@knpkv/control-center 0.1.0

package/dist/server/domain/readiness/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../../../src/domain/readiness/model.ts"],"names":[],"mappings":"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"}

package/dist/server/domain/readiness/policy.d.ts

@@ -0,0 +1,73 @@
+import type { UtcTimestamp } from "../utcTimestamp.js";
+import type { ReadinessEvidenceReference, ReadinessFactDefinition, ReadinessFactEvaluation, ReadinessFactObservation, ReadinessFactResult, ReadinessFinding, ReadinessFindingCode, ReadinessSourceSummary, ReadinessStages, ReadinessVerdict } from "./model.js";
+/** Locale-independent ordering used by canonical readiness records and digests. */
+export declare const compareReadinessText: (left: string, right: string) => number;
+/** Sorted unique string-like values for deterministic assessment material. */
+export declare const sortedReadinessUnique: <Value extends string>(values: ReadonlyArray<Value>) => Array<Value>;
+/** Whether definitions form the complete provider-neutral V1 delivery policy. */
+export declare const readinessDefinitionsShapeIsV1: (definitions: ReadonlyArray<ReadinessFactDefinition>) => boolean;
+/** Whether definitions and observations form a complete V1 delivery policy shape. */
+export declare const readinessPolicyShapeIsV1: (definitions: ReadonlyArray<ReadinessFactDefinition>, observations: ReadonlyArray<ReadinessFactObservation>) => boolean;
+/** Whether one exact evidence dependency is current enough for a verdict. */
+export declare const readinessEvidenceIsCurrent: (evidence: ReadinessEvidenceReference) => boolean;
+/** Whether every evidence dependency of an observed fact is current and valid. */
+export declare const readinessObservationIsCurrent: (observation: ReadinessFactObservation) => boolean;
+/** Whether a normalized observation is semantically positive. */
+export declare const readinessObservationIsPositive: (observation: ReadinessFactObservation) => boolean;
+/** Machine-readable explicit-failure reason, independent of freshness. */
+export declare const readinessFailureCode: (observation: ReadinessFactObservation) => ReadinessFindingCode | null;
+/** Machine-readable non-positive reason for one normalized observation. */
+export declare const readinessNonPositiveCode: (observation: ReadinessFactObservation) => ReadinessFindingCode | null;
+/** Whether this observation represents active build or check work. */
+export declare const readinessObservationIsDeliveryActivity: (definition: ReadinessFactDefinition, observation: ReadinessFactObservation | null) => boolean;
+/** Canonical semantic result retained for one fact evaluation. */
+export declare const readinessFactResult: (definition: ReadinessFactDefinition, observation: ReadinessFactObservation | null) => ReadinessFactResult;
+/** Stable sort/deduplication key for readiness findings. */
+export declare const readinessFindingKey: (finding: ReadinessFinding) => string;
+/** Exact blocker, warning, and gap sets implied by retained fact evaluations. */
+export declare const deriveReadinessFindings: (facts: ReadonlyArray<ReadinessFactEvaluation>, complete: boolean) => {
+    readonly blockers: Array<ReadinessFinding>;
+    readonly warnings: Array<ReadinessFinding>;
+    readonly gaps: Array<ReadinessFinding>;
+};
+/** Exact worst-state summaries for plugin evidence retained by facts. */
+export declare const deriveReadinessSourceSummaries: (facts: ReadonlyArray<ReadinessFactEvaluation>) => Array<ReadinessSourceSummary>;
+/** Earliest evidence freshness boundary retained by one environment assessment. */
+export declare const deriveReadinessNextEvaluationAt: (facts: ReadonlyArray<ReadinessFactEvaluation>) => UtcTimestamp | null;
+/** Derive the exact three delivery stages from canonical fact evaluations. */
+export declare const deriveReadinessStages: (facts: ReadonlyArray<ReadinessFactEvaluation>) => ReadinessStages;
+/** Derive the canonical verdict from facts, findings, and exact stage state. */
+export declare const deriveEnvironmentReadinessVerdict: (input: {
+    readonly blockers: ReadonlyArray<ReadinessFinding>;
+    readonly facts: ReadonlyArray<ReadinessFactEvaluation>;
+    readonly gaps: ReadonlyArray<ReadinessFinding>;
+    readonly stages: ReadinessStages;
+}) => ReadinessVerdict;
+type ReleaseEnvironmentReadiness = {
+    readonly blockers: ReadonlyArray<ReadinessFinding>;
+    readonly environmentId: string;
+    readonly gaps: ReadonlyArray<ReadinessFinding>;
+    readonly nextEvaluationAt: UtcTimestamp | null;
+    readonly sourceFreshness: ReadonlyArray<ReadinessSourceSummary>;
+    readonly stages: ReadinessStages;
+    readonly verdict: ReadinessVerdict;
+    readonly warnings: ReadonlyArray<ReadinessFinding>;
+};
+/** Exact merged findings implied by retained environment summaries. */
+export declare const deriveReleaseReadinessFindings: (environments: ReadonlyArray<ReleaseEnvironmentReadiness>) => {
+    readonly blockers: Array<ReadinessFinding>;
+    readonly warnings: Array<ReadinessFinding>;
+    readonly gaps: Array<ReadinessFinding>;
+};
+/** Exact worst-state source summaries implied by retained environments. */
+export declare const deriveReleaseReadinessSourceSummaries: (environments: ReadonlyArray<ReleaseEnvironmentReadiness>) => Array<ReadinessSourceSummary>;
+/** Earliest child freshness boundary implied by retained environments. */
+export declare const deriveReleaseReadinessNextEvaluationAt: (environments: ReadonlyArray<ReleaseEnvironmentReadiness>) => UtcTimestamp | null;
+/** Exact three-stage roll-up implied by retained environment summaries. */
+export declare const deriveReleaseReadinessStages: (environments: ReadonlyArray<ReleaseEnvironmentReadiness>) => ReadinessStages;
+/** Canonical cross-environment precedence for release readiness. */
+export declare const deriveReleaseReadinessVerdict: (environments: ReadonlyArray<ReleaseEnvironmentReadiness>) => ReadinessVerdict;
+/** Structural equality for canonical stage records without serialization shortcuts. */
+export declare const readinessStagesAreEqual: (left: ReadinessStages, right: ReadinessStages) => boolean;
+export {};
+//# sourceMappingURL=policy.d.ts.map

package/dist/server/domain/readiness/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../../../../src/domain/readiness/policy.ts"],"names":[],"mappings":"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"}

package/dist/server/domain/readiness/rollup.d.ts

@@ -0,0 +1,6 @@
+import type { EnvironmentReadinessAssessment, ReleaseReadinessAssessment, ReleaseReadinessRollupInput } from "./model.js";
+/** Exact compact projection retained when an environment is rolled into a release. */
+export declare const summarizeEnvironmentReadiness: (assessment: EnvironmentReadinessAssessment) => ReleaseReadinessAssessment["environments"][number];
+/** Pure deterministic roll-up of current target-environment assessments. */
+export declare const rollUpReleaseReadiness: (input: ReleaseReadinessRollupInput) => ReleaseReadinessAssessment;
+//# sourceMappingURL=rollup.d.ts.map

package/dist/server/domain/readiness/rollup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollup.d.ts","sourceRoot":"","sources":["../../../../src/domain/readiness/rollup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,8BAA8B,EAC9B,0BAA0B,EAC1B,2BAA2B,EAC5B,MAAM,YAAY,CAAA;AAWnB,sFAAsF;AACtF,eAAO,MAAM,6BAA6B,GACxC,YAAY,8BAA8B,KACzC,0BAA0B,CAAC,cAAc,CAAC,CAAC,MAAM,CAclD,CAAA;AAEF,4EAA4E;AAC5E,eAAO,MAAM,sBAAsB,GACjC,OAAO,2BAA2B,KACjC,0BAwCF,CAAA"}

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

@@ -0,0 +1,97 @@
+import * as Schema from "effect/Schema";
+/** Explicit decision proposed for an incomplete delivery relationship. */
+export declare const RelationshipRepairDisposition: Schema.Literals<readonly ["link", "verify", "reject"]>;
+/** Decoded relationship-repair disposition. */
+export type RelationshipRepairDisposition = typeof RelationshipRepairDisposition.Type;
+/** Bounded human-readable justification stored with a repair proposal. */
+export declare const RelationshipRepairRationale: Schema.String;
+/** Decoded relationship-repair rationale. */
+export type RelationshipRepairRationale = typeof RelationshipRepairRationale.Type;
+/** Authenticated origin retained for proposal review and later audit. */
+export declare const RelationshipRepairProposalOrigin: Schema.Struct<{
+    readonly actor: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"human", {
+        readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+    }>, Schema.TaggedStruct<"agent", {
+        readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+    }>]>;
+    readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+}>;
+/** Decoded relationship-repair proposal origin. */
+export type RelationshipRepairProposalOrigin = typeof RelationshipRepairProposalOrigin.Type;
+/** Final reviewer decision over one exact proposal. */
+export declare const RelationshipRepairReviewDecision: Schema.Literals<readonly ["approved", "rejected"]>;
+/** Decoded relationship-repair review decision. */
+export type RelationshipRepairReviewDecision = typeof RelationshipRepairReviewDecision.Type;
+/** Immutable review evidence retained with a finalized proposal. */
+export declare const RelationshipRepairReview: Schema.Struct<{
+    readonly reviewId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairReviewId">;
+    readonly decision: Schema.Literals<readonly ["approved", "rejected"]>;
+    readonly rationale: Schema.String;
+    readonly origin: Schema.Struct<{
+        readonly actor: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"human", {
+            readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+        }>, Schema.TaggedStruct<"agent", {
+            readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+        }>]>;
+        readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+    }>;
+    readonly reviewedAt: Schema.DateTimeUtcFromString;
+}>;
+/** Decoded relationship-repair review. */
+export type RelationshipRepairReview = typeof RelationshipRepairReview.Type;
+/** Immutable evidence that one approved proposal appended an exact ledger revision. */
+export declare const RelationshipRepairApplication: Schema.Struct<{
+    readonly proposalId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairProposalId">;
+    readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+    readonly appliedRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+    readonly origin: Schema.Struct<{
+        readonly actor: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"human", {
+            readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+        }>, Schema.TaggedStruct<"agent", {
+            readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+        }>]>;
+        readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+    }>;
+    readonly appliedAt: Schema.DateTimeUtcFromString;
+}>;
+/** Decoded relationship-repair application evidence. */
+export type RelationshipRepairApplication = typeof RelationshipRepairApplication.Type;
+/** Durable proposal bound to one exact immutable relationship revision. */
+export declare const RelationshipRepairProposal: Schema.Struct<{
+    readonly schemaVersion: Schema.Literal<2>;
+    readonly proposalId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairProposalId">;
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+    readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+    readonly environmentId: Schema.NullOr<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">>;
+    readonly relationshipId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipId">;
+    readonly expectedRevision: Schema.brand<Schema.Int, "LedgerRevision">;
+    readonly disposition: Schema.Literals<readonly ["link", "verify", "reject"]>;
+    readonly rationale: Schema.String;
+    readonly origin: Schema.Struct<{
+        readonly actor: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"human", {
+            readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+        }>, Schema.TaggedStruct<"agent", {
+            readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+        }>]>;
+        readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+    }>;
+    readonly status: Schema.Literals<readonly ["pending", "approved", "rejected"]>;
+    readonly proposedAt: Schema.DateTimeUtcFromString;
+    readonly review: Schema.NullOr<Schema.Struct<{
+        readonly reviewId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RelationshipRepairReviewId">;
+        readonly decision: Schema.Literals<readonly ["approved", "rejected"]>;
+        readonly rationale: Schema.String;
+        readonly origin: Schema.Struct<{
+            readonly actor: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"human", {
+                readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+            }>, Schema.TaggedStruct<"agent", {
+                readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+            }>]>;
+            readonly sessionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "SessionId">;
+        }>;
+        readonly reviewedAt: Schema.DateTimeUtcFromString;
+    }>>;
+}>;
+/** Decoded durable relationship-repair proposal. */
+export type RelationshipRepairProposal = typeof RelationshipRepairProposal.Type;
+//# sourceMappingURL=relationshipRepair.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"relationshipRepair.d.ts","sourceRoot":"","sources":["../../../src/domain/relationshipRepair.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAevC,0EAA0E;AAC1E,eAAO,MAAM,6BAA6B,wDAAgD,CAAA;AAE1F,+CAA+C;AAC/C,MAAM,MAAM,6BAA6B,GAAG,OAAO,6BAA6B,CAAC,IAAI,CAAA;AAErF,0EAA0E;AAC1E,eAAO,MAAM,2BAA2B,eAIiB,CAAA;AAEzD,6CAA6C;AAC7C,MAAM,MAAM,2BAA2B,GAAG,OAAO,2BAA2B,CAAC,IAAI,CAAA;AAEjF,yEAAyE;AACzE,eAAO,MAAM,gCAAgC;;;;;;;EAG3C,CAAA;AAEF,mDAAmD;AACnD,MAAM,MAAM,gCAAgC,GAAG,OAAO,gCAAgC,CAAC,IAAI,CAAA;AAE3F,uDAAuD;AACvD,eAAO,MAAM,gCAAgC,oDAA4C,CAAA;AAEzF,mDAAmD;AACnD,MAAM,MAAM,gCAAgC,GAAG,OAAO,gCAAgC,CAAC,IAAI,CAAA;AAE3F,oEAAoE;AACpE,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;EAMkB,CAAA;AAEvD,0CAA0C;AAC1C,MAAM,MAAM,wBAAwB,GAAG,OAAO,wBAAwB,CAAC,IAAI,CAAA;AAE3E,uFAAuF;AACvF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;EAMkB,CAAA;AAE5D,wDAAwD;AACxD,MAAM,MAAM,6BAA6B,GAAG,OAAO,6BAA6B,CAAC,IAAI,CAAA;AAErF,2EAA2E;AAC3E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAckB,CAAA;AAEzD,oDAAoD;AACpD,MAAM,MAAM,0BAA0B,GAAG,OAAO,0BAA0B,CAAC,IAAI,CAAA"}

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

@@ -0,0 +1,191 @@
+import * as Schema from "effect/Schema";
+/** Human-readable service name retained independently of provider identity. */
+export declare const ReleaseServiceName: Schema.brand<Schema.String, "ReleaseServiceName">;
+/** Decoded release service name. */
+export type ReleaseServiceName = typeof ReleaseServiceName.Type;
+/** Provider-neutral release version or immutable release label. */
+export declare const ReleaseVersion: Schema.brand<Schema.String, "ReleaseVersion">;
+/** Decoded release version. */
+export type ReleaseVersion = typeof ReleaseVersion.Type;
+/** Lifecycle of the release aggregate, separate from readiness and pipeline state. */
+export declare const ReleaseLifecycle: Schema.Literals<readonly ["assembling", "candidate", "deploying", "released", "cancelled"]>;
+/** Decoded release lifecycle. */
+export type ReleaseLifecycle = typeof ReleaseLifecycle.Type;
+/**
+ * Foundational release aggregate. Readiness, evidence, stages, and delivery
+ * relationships extend this record in their owning slices.
+ */
+export declare const Release: Schema.Struct<{
+    readonly createdAt: Schema.DateTimeUtcFromString;
+    readonly freshness: Schema.toTaggedUnion<"_tag", readonly [Schema.Struct<{
+        readonly _tag: Schema.tag<"current">;
+        readonly pluginHealth: Schema.Union<readonly [Schema.TaggedStruct<"healthy", {
+            readonly checkedAt: Schema.DateTimeUtcFromString;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"degraded">;
+            readonly checkedAt: Schema.DateTimeUtcFromString;
+            readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+            readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly safeMessage: Schema.String;
+        }>]>;
+        readonly provenance: Schema.Union<readonly [Schema.TaggedStruct<"provider", {
+            readonly sourceRevision: Schema.Struct<{
+                readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                readonly revision: Schema.brand<Schema.String, "Revision">;
+                readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+            }>;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"cache">;
+            readonly cachedAt: Schema.DateTimeUtcFromString;
+            readonly sourceRevision: Schema.Struct<{
+                readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                readonly revision: Schema.brand<Schema.String, "Revision">;
+                readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+            }>;
+        }>]>;
+        readonly sourceObservedAt: Schema.DateTimeUtcFromString;
+        readonly staleAfterSeconds: Schema.Int;
+        readonly synchronizedAt: Schema.DateTimeUtcFromString;
+        readonly evaluatedAt: Schema.optional<Schema.DateTimeUtcFromString>;
+    }>, Schema.Struct<{
+        readonly _tag: Schema.tag<"stale">;
+        readonly pluginHealth: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"healthy", {
+            readonly checkedAt: Schema.DateTimeUtcFromString;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"degraded">;
+            readonly checkedAt: Schema.DateTimeUtcFromString;
+            readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+            readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly safeMessage: Schema.String;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"unavailable">;
+            readonly checkedAt: Schema.DateTimeUtcFromString;
+            readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+            readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly safeMessage: Schema.String;
+        }>, Schema.TaggedStruct<"disabled", {
+            readonly checkedAt: Schema.DateTimeUtcFromString;
+        }>]>;
+        readonly provenance: Schema.Struct<{
+            readonly _tag: Schema.tag<"cache">;
+            readonly cachedAt: Schema.DateTimeUtcFromString;
+            readonly sourceRevision: Schema.Struct<{
+                readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+                readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+                readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+                readonly revision: Schema.brand<Schema.String, "Revision">;
+                readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+                readonly firstObservedAt: Schema.DateTimeUtcFromString;
+                readonly lastObservedAt: Schema.DateTimeUtcFromString;
+                readonly synchronizedAt: Schema.DateTimeUtcFromString;
+                readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+            }>;
+        }>;
+        readonly sourceObservedAt: Schema.DateTimeUtcFromString;
+        readonly staleAfterSeconds: Schema.Int;
+        readonly synchronizedAt: Schema.DateTimeUtcFromString;
+        readonly evaluatedAt: Schema.optional<Schema.DateTimeUtcFromString>;
+    }>, Schema.TaggedStruct<"missing", {
+        readonly pluginHealth: Schema.TaggedStruct<"healthy", {
+            readonly checkedAt: Schema.DateTimeUtcFromString;
+        }>;
+        readonly provenance: Schema.TaggedStruct<"none", {
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+        }>;
+        readonly sourceObservedAt: Schema.Null;
+        readonly staleAfterSeconds: Schema.Int;
+        readonly synchronizedAt: Schema.DateTimeUtcFromString;
+    }>, Schema.TaggedStruct<"unavailable", {
+        readonly pluginHealth: Schema.Union<readonly [Schema.Struct<{
+            readonly _tag: Schema.tag<"unavailable">;
+            readonly checkedAt: Schema.DateTimeUtcFromString;
+            readonly failureClass: Schema.Literals<readonly ["authentication", "authorization", "rate-limit", "timeout", "malformed-response", "outage", "unknown"]>;
+            readonly retryAt: Schema.NullOr<Schema.DateTimeUtcFromString>;
+            readonly safeMessage: Schema.String;
+        }>, Schema.TaggedStruct<"disabled", {
+            readonly checkedAt: Schema.DateTimeUtcFromString;
+        }>]>;
+        readonly provenance: Schema.TaggedStruct<"none", {
+            readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+        }>;
+        readonly sourceObservedAt: Schema.Null;
+        readonly staleAfterSeconds: Schema.Int;
+        readonly synchronizedAt: Schema.Null;
+    }>]>;
+    readonly id: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+    readonly lifecycle: Schema.Literals<readonly ["assembling", "candidate", "deploying", "released", "cancelled"]>;
+    readonly relay: Schema.Struct<{
+        readonly algorithm: Schema.Literal<"relay/v1">;
+        readonly codename: Schema.TemplateLiteral<readonly [Schema.Literals<readonly ["Amber", "Azure", "Copper", "Ember", "Golden", "Lunar", "Moss", "Nova", "Quiet", "Silver", "Solar", "Tidal", "Velvet", "Verdant", "Wild", "Winter"]>, " ", Schema.Literals<readonly ["Anchor", "Beacon", "Bridge", "Comet", "Finch", "Fork", "Gate", "Grove", "Harbor", "Orbit", "Pulse", "Reef", "Relay", "Spark", "Wave", "Willow"]>]>;
+        readonly symbolIndices: Schema.Tuple<readonly [Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>, Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>, Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>]>;
+    }>;
+    readonly roleAssignments: Schema.$Array<Schema.Struct<{
+        readonly actor: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"human", {
+            readonly personId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PersonId">;
+        }>, Schema.TaggedStruct<"agent", {
+            readonly agentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "AgentId">;
+        }>]>;
+        readonly assignmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "RoleAssignmentId">;
+        readonly lifecycle: Schema.toTaggedUnion<"_tag", readonly [Schema.TaggedStruct<"active", {
+            readonly assignedAt: Schema.DateTimeUtcFromString;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"ended">;
+            readonly assignedAt: Schema.DateTimeUtcFromString;
+            readonly endedAt: Schema.DateTimeUtcFromString;
+        }>, Schema.Struct<{
+            readonly _tag: Schema.tag<"revoked">;
+            readonly assignedAt: Schema.DateTimeUtcFromString;
+            readonly revokedAt: Schema.DateTimeUtcFromString;
+        }>]>;
+        readonly role: Schema.Literals<readonly ["workspace-owner", "workspace-approver", "release-owner", "release-approver", "change-owner", "issue-owner", "issue-assignee", "page-owner", "author", "contributor", "reviewer", "operator", "deployment-approver", "merge-approver", "watcher"]>;
+        readonly scope: Schema.TaggedUnion<{
+            readonly release: Schema.TaggedStruct<"release", {
+                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            }>;
+            readonly environment: Schema.TaggedStruct<"environment", {
+                readonly environmentId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">;
+                readonly releaseId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "ReleaseId">;
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            }>;
+            readonly entity: Schema.TaggedStruct<"entity", {
+                readonly entityId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EntityId">;
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            }>;
+            readonly workspace: Schema.TaggedStruct<"workspace", {
+                readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+            }>;
+        }>;
+    }>>;
+    readonly serviceName: Schema.brand<Schema.String, "ReleaseServiceName">;
+    readonly sourceRevisions: Schema.$Array<Schema.Struct<{
+        readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+        readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+        readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+        readonly revision: Schema.brand<Schema.String, "Revision">;
+        readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+        readonly firstObservedAt: Schema.DateTimeUtcFromString;
+        readonly lastObservedAt: Schema.DateTimeUtcFromString;
+        readonly synchronizedAt: Schema.DateTimeUtcFromString;
+        readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+    }>>;
+    readonly targetEnvironmentIds: Schema.$Array<Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "EnvironmentId">>;
+    readonly updatedAt: Schema.DateTimeUtcFromString;
+    readonly version: Schema.brand<Schema.String, "ReleaseVersion">;
+    readonly workspaceId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "WorkspaceId">;
+}>;
+/** Decoded foundational release aggregate. */
+export type Release = typeof Release.Type;
+//# sourceMappingURL=release.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"release.d.ts","sourceRoot":"","sources":["../../../src/domain/release.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAQvC,+EAA+E;AAC/E,eAAO,MAAM,kBAAkB,mDAIW,CAAA;AAE1C,oCAAoC;AACpC,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC,IAAI,CAAA;AAE/D,mEAAmE;AACnE,eAAO,MAAM,cAAc,+CAIW,CAAA;AAEtC,+BAA+B;AAC/B,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;AAEvD,sFAAsF;AACtF,eAAO,MAAM,gBAAgB,6FAM3B,CAAA;AAEF,iCAAiC;AACjC,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,IAAI,CAAA;AAsB3D;;;GAGG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiEiB,CAAA;AAErC,8CAA8C;AAC9C,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA"}

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

@@ -0,0 +1,44 @@
+import { Schema } from "effect";
+import type { ReleaseId } from "./identifiers.js";
+/** Canonical persisted algorithm label for the current Release Relay projection. */
+export declare const RELEASE_RELAY_ALGORITHM = "relay/v1";
+/** Explicit v1 alias retained beside the versioned catalog constants. */
+export declare const RELEASE_RELAY_V1_ALGORITHM = "relay/v1";
+/** Frozen adjective catalog whose order is part of the relay/v1 contract. */
+export declare const RELEASE_RELAY_V1_ADJECTIVES: readonly ["Amber", "Azure", "Copper", "Ember", "Golden", "Lunar", "Moss", "Nova", "Quiet", "Silver", "Solar", "Tidal", "Velvet", "Verdant", "Wild", "Winter"];
+/** Frozen noun catalog whose order is part of the relay/v1 contract. */
+export declare const RELEASE_RELAY_V1_NOUNS: readonly ["Anchor", "Beacon", "Bridge", "Comet", "Finch", "Fork", "Gate", "Grove", "Harbor", "Orbit", "Pulse", "Reef", "Relay", "Spark", "Wave", "Willow"];
+/** Schema for the relay/v1 algorithm discriminator. */
+export declare const ReleaseRelayAlgorithm: Schema.Literal<"relay/v1">;
+/** Persisted relay/v1 adjective. */
+export declare const ReleaseRelayAdjective: Schema.Literals<readonly ["Amber", "Azure", "Copper", "Ember", "Golden", "Lunar", "Moss", "Nova", "Quiet", "Silver", "Solar", "Tidal", "Velvet", "Verdant", "Wild", "Winter"]>;
+/** Persisted relay/v1 noun. */
+export declare const ReleaseRelayNoun: Schema.Literals<readonly ["Anchor", "Beacon", "Bridge", "Comet", "Finch", "Fork", "Gate", "Grove", "Harbor", "Orbit", "Pulse", "Reef", "Relay", "Spark", "Wave", "Willow"]>;
+/** Persisted relay/v1 codename assembled from the frozen catalogs. */
+export declare const ReleaseRelayCodename: Schema.TemplateLiteral<readonly [Schema.Literals<readonly ["Amber", "Azure", "Copper", "Ember", "Golden", "Lunar", "Moss", "Nova", "Quiet", "Silver", "Solar", "Tidal", "Velvet", "Verdant", "Wild", "Winter"]>, " ", Schema.Literals<readonly ["Anchor", "Beacon", "Bridge", "Comet", "Finch", "Fork", "Gate", "Grove", "Harbor", "Orbit", "Pulse", "Reef", "Relay", "Spark", "Wave", "Willow"]>]>;
+/** Closed index into rly's separately versioned 16-symbol presentation catalog. */
+export declare const ReleaseRelaySymbolIndex: Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>;
+/** Decoded relay/v1 symbol index. */
+export type ReleaseRelaySymbolIndex = typeof ReleaseRelaySymbolIndex.Type;
+/** Exactly three distinct persisted indices into the release-symbol catalog. */
+export declare const ReleaseRelaySymbolIndices: Schema.Tuple<readonly [Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>, Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>, Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>]>;
+/** Decoded three-symbol relay projection. */
+export type ReleaseRelaySymbolIndices = typeof ReleaseRelaySymbolIndices.Type;
+/** Versioned, persisted Release Relay identity owned by the Control Center domain. */
+export declare const ReleaseRelayProjection: Schema.Struct<{
+    readonly algorithm: Schema.Literal<"relay/v1">;
+    readonly codename: Schema.TemplateLiteral<readonly [Schema.Literals<readonly ["Amber", "Azure", "Copper", "Ember", "Golden", "Lunar", "Moss", "Nova", "Quiet", "Silver", "Solar", "Tidal", "Velvet", "Verdant", "Wild", "Winter"]>, " ", Schema.Literals<readonly ["Anchor", "Beacon", "Bridge", "Comet", "Finch", "Fork", "Gate", "Grove", "Harbor", "Orbit", "Pulse", "Reef", "Relay", "Spark", "Wave", "Willow"]>]>;
+    readonly symbolIndices: Schema.Tuple<readonly [Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>, Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>, Schema.Literals<readonly [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]>]>;
+}>;
+/** Decoded versioned Release Relay projection. */
+export type ReleaseRelayProjection = typeof ReleaseRelayProjection.Type;
+/**
+ * Derive the stable relay/v1 projection for one canonical immutable release identifier.
+ *
+ * relay/v1 applies unsigned 32-bit FNV-1a to the ASCII domains
+ * `relay/v1|adjective|<release-id>`, `relay/v1|noun|<release-id>`, and
+ * `relay/v1|symbol/<position>|<release-id>`. Symbol hashes select ranks from the
+ * remaining 16, 15, then 14 indices, making distinctness constructive.
+ */
+export declare const deriveReleaseRelay: (releaseId: ReleaseId) => ReleaseRelayProjection;
+//# sourceMappingURL=releaseRelay.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"releaseRelay.d.ts","sourceRoot":"","sources":["../../../src/domain/releaseRelay.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAEjD,oFAAoF;AACpF,eAAO,MAAM,uBAAuB,aAAa,CAAA;AAEjD,yEAAyE;AACzE,eAAO,MAAM,0BAA0B,aAA0B,CAAA;AAwBjE,6EAA6E;AAC7E,eAAO,MAAM,2BAA2B,+JAiBtC,CAAA;AAEF,wEAAwE;AACxE,eAAO,MAAM,sBAAsB,4JAiBjC,CAAA;AAEF,uDAAuD;AACvD,eAAO,MAAM,qBAAqB,4BAA0C,CAAA;AAE5E,oCAAoC;AACpC,eAAO,MAAM,qBAAqB,gLAA+C,CAAA;AAEjF,+BAA+B;AAC/B,eAAO,MAAM,gBAAgB,6KAA0C,CAAA;AAEvE,sEAAsE;AACtE,eAAO,MAAM,oBAAoB,qYAAyE,CAAA;AAE1G,mFAAmF;AACnF,eAAO,MAAM,uBAAuB,kFAA0E,CAAA;AAE9G,qCAAqC;AACrC,MAAM,MAAM,uBAAuB,GAAG,OAAO,uBAAuB,CAAC,IAAI,CAAA;AAEzE,gFAAgF;AAChF,eAAO,MAAM,yBAAyB,+QAI0C,CAAA;AAEhF,6CAA6C;AAC7C,MAAM,MAAM,yBAAyB,GAAG,OAAO,yBAAyB,CAAC,IAAI,CAAA;AAE7E,sFAAsF;AACtF,eAAO,MAAM,sBAAsB;;;;EAIjC,CAAA;AAEF,kDAAkD;AAClD,MAAM,MAAM,sBAAsB,GAAG,OAAO,sBAAsB,CAAC,IAAI,CAAA;AA2GvE;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,GAAI,WAAW,SAAS,KAAG,sBAWzD,CAAA"}

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

@@ -0,0 +1,39 @@
+import { Schema } from "effect";
+/** Stable persisted provider names, independent of package abbreviations. */
+export declare const ProviderId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+/** Decoded plugin-provider identifier. */
+export type ProviderId = typeof ProviderId.Type;
+/** Opaque immutable identifier assigned to an object by its source provider. */
+export declare const VendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+/** Decoded source-provider object identifier. */
+export type VendorImmutableId = typeof VendorImmutableId.Type;
+/** Opaque source-provider revision, version, digest, or ETag. */
+export declare const Revision: Schema.brand<Schema.String, "Revision">;
+/** Decoded source-provider revision. */
+export type Revision = typeof Revision.Type;
+/** Positive version of the normalization schema used for a source record. */
+export declare const NormalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+/** Decoded normalization-schema version. */
+export type NormalizationSchemaVersion = typeof NormalizationSchemaVersion.Type;
+/** Safe navigable URL for an exact provider object, without embedded credentials. */
+export declare const SourceUrl: Schema.decodeTo<Schema.URL, Schema.String, never, never>;
+/** Decoded safe source URL. */
+export type SourceUrl = typeof SourceUrl.Type;
+/**
+ * Immutable provenance needed to reconcile a normalized record with the exact
+ * provider object and revision from which it was derived.
+ */
+export declare const SourceRevision: Schema.Struct<{
+    readonly providerId: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+    readonly pluginConnectionId: Schema.brand<Schema.decodeTo<Schema.String, Schema.String, never, never>, "PluginConnectionId">;
+    readonly vendorImmutableId: Schema.brand<Schema.String, "VendorImmutableId">;
+    readonly revision: Schema.brand<Schema.String, "Revision">;
+    readonly sourceUrl: Schema.Union<readonly [Schema.decodeTo<Schema.URL, Schema.String, never, never>, Schema.Null]>;
+    readonly firstObservedAt: Schema.DateTimeUtcFromString;
+    readonly lastObservedAt: Schema.DateTimeUtcFromString;
+    readonly synchronizedAt: Schema.DateTimeUtcFromString;
+    readonly normalizationSchemaVersion: Schema.brand<Schema.Number, "NormalizationSchemaVersion">;
+}>;
+/** Decoded source-revision provenance. */
+export type SourceRevision = typeof SourceRevision.Type;
+//# sourceMappingURL=sourceRevision.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sourceRevision.d.ts","sourceRoot":"","sources":["../../../src/domain/sourceRevision.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,MAAM,EAAwB,MAAM,QAAQ,CAAA;AAa/D,6EAA6E;AAC7E,eAAO,MAAM,UAAU,4FAMkB,CAAA;AAEzC,0CAA0C;AAC1C,MAAM,MAAM,UAAU,GAAG,OAAO,UAAU,CAAC,IAAI,CAAA;AAE/C,gFAAgF;AAChF,eAAO,MAAM,iBAAiB,kDAAmE,CAAA;AAEjG,iDAAiD;AACjD,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC,IAAI,CAAA;AAE7D,iEAAiE;AACjE,eAAO,MAAM,QAAQ,yCAA0D,CAAA;AAE/E,wCAAwC;AACxC,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C,6EAA6E;AAC7E,eAAO,MAAM,0BAA0B,2DAGW,CAAA;AAElD,4CAA4C;AAC5C,MAAM,MAAM,0BAA0B,GAAG,OAAO,0BAA0B,CAAC,IAAI,CAAA;AAgB/E,qFAAqF;AACrF,eAAO,MAAM,SAAS,0DAYrB,CAAA;AAED,+BAA+B;AAC/B,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA;AAE7C;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;EAgCkB,CAAA;AAE7C,0CAA0C;AAC1C,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA"}

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

@@ -0,0 +1,105 @@
+import * as Schema from "effect/Schema";
+/** Actor classes that can contribute durable activity to a workspace Timeline. */
+export declare const TimelineActorKind: Schema.Literals<readonly ["agent", "human", "plugin", "system"]>;
+/** Decoded Timeline actor class. */
+export type TimelineActorKind = typeof TimelineActorKind.Type;
+/** Durable source streams merged by the Timeline projection. */
+export declare const TimelineSourceKind: Schema.Literals<readonly ["action", "plugin-sync", "relationship", "system"]>;
+/** Decoded Timeline source stream. */
+export type TimelineSourceKind = typeof TimelineSourceKind.Type;
+/** Connected provider identity retained when a durable event has provenance. */
+export declare const TimelineService: Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>;
+/** Decoded connected provider identity. */
+export type TimelineService = typeof TimelineService.Type;
+/** Stable cursor for newest-first Timeline pagination. */
+export declare const TimelineCursor: Schema.Struct<{
+    readonly eventKey: Schema.String;
+    readonly occurredAt: Schema.DateTimeUtcFromString;
+}>;
+/** Decoded stable Timeline cursor. */
+export type TimelineCursor = typeof TimelineCursor.Type;
+/** Default-redacted, human-readable event from one durable workspace source. */
+export declare const TimelineEvent: Schema.Struct<{
+    readonly eventKey: Schema.String;
+    readonly occurredAt: Schema.DateTimeUtcFromString;
+    readonly actor: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["agent", "human", "plugin", "system"]>;
+        readonly label: Schema.String;
+    }>;
+    readonly sourceKind: Schema.Literals<readonly ["action", "plugin-sync", "relationship", "system"]>;
+    readonly service: Schema.NullOr<Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>>;
+    readonly eventType: Schema.String;
+    readonly title: Schema.String;
+    readonly href: Schema.NullOr<Schema.String>;
+}>;
+/** Decoded Timeline event. */
+export type TimelineEvent = typeof TimelineEvent.Type;
+/** Owner-visible durable identifiers for one exact Timeline event. */
+export declare const TimelineEventIdentifiers: Schema.Struct<{
+    readonly actorId: Schema.NullOr<Schema.String>;
+    readonly actionId: Schema.NullOr<Schema.String>;
+    readonly relationshipId: Schema.NullOr<Schema.String>;
+    readonly pluginConnectionId: Schema.NullOr<Schema.String>;
+    readonly releaseId: Schema.NullOr<Schema.String>;
+    readonly entityId: Schema.NullOr<Schema.String>;
+}>;
+/** Decoded owner-visible Timeline identifiers. */
+export type TimelineEventIdentifiers = typeof TimelineEventIdentifiers.Type;
+/** Owner-visible reference to the local agent job attributable to an event. */
+export declare const TimelineAgentJobDetail: Schema.Struct<{
+    readonly jobId: Schema.String;
+}>;
+/** Decoded Timeline agent-job reference. */
+export type TimelineAgentJobDetail = typeof TimelineAgentJobDetail.Type;
+/** Deliberate owner-only expansion of one otherwise redacted Timeline event. */
+export declare const TimelineEventDetail: Schema.Struct<{
+    readonly event: Schema.Struct<{
+        readonly eventKey: Schema.String;
+        readonly occurredAt: Schema.DateTimeUtcFromString;
+        readonly actor: Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["agent", "human", "plugin", "system"]>;
+            readonly label: Schema.String;
+        }>;
+        readonly sourceKind: Schema.Literals<readonly ["action", "plugin-sync", "relationship", "system"]>;
+        readonly service: Schema.NullOr<Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>>;
+        readonly eventType: Schema.String;
+        readonly title: Schema.String;
+        readonly href: Schema.NullOr<Schema.String>;
+    }>;
+    readonly identifiers: Schema.Struct<{
+        readonly actorId: Schema.NullOr<Schema.String>;
+        readonly actionId: Schema.NullOr<Schema.String>;
+        readonly relationshipId: Schema.NullOr<Schema.String>;
+        readonly pluginConnectionId: Schema.NullOr<Schema.String>;
+        readonly releaseId: Schema.NullOr<Schema.String>;
+        readonly entityId: Schema.NullOr<Schema.String>;
+    }>;
+    readonly agentJob: Schema.NullOr<Schema.Struct<{
+        readonly jobId: Schema.String;
+    }>>;
+}>;
+/** Decoded owner-only Timeline event expansion. */
+export type TimelineEventDetail = typeof TimelineEventDetail.Type;
+/** One bounded Timeline page. */
+export declare const TimelinePage: Schema.Struct<{
+    readonly events: Schema.$Array<Schema.Struct<{
+        readonly eventKey: Schema.String;
+        readonly occurredAt: Schema.DateTimeUtcFromString;
+        readonly actor: Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["agent", "human", "plugin", "system"]>;
+            readonly label: Schema.String;
+        }>;
+        readonly sourceKind: Schema.Literals<readonly ["action", "plugin-sync", "relationship", "system"]>;
+        readonly service: Schema.NullOr<Schema.Literals<readonly ["codecommit", "codepipeline", "jira", "confluence", "clockify"]>>;
+        readonly eventType: Schema.String;
+        readonly title: Schema.String;
+        readonly href: Schema.NullOr<Schema.String>;
+    }>>;
+    readonly nextCursor: Schema.NullOr<Schema.Struct<{
+        readonly eventKey: Schema.String;
+        readonly occurredAt: Schema.DateTimeUtcFromString;
+    }>>;
+}>;
+/** Decoded bounded Timeline page. */
+export type TimelinePage = typeof TimelinePage.Type;
+//# sourceMappingURL=timeline.d.ts.map