@konitif/workbench 0.285.3 → 0.285.5

package/README.md

@@ -17,6 +17,8 @@ npm install @konitif/workbench
 - Project preflight and repository-quality contracts.
 - Explicit workspace persistence, synchronization and surface ports.
 - Content-addressed workspace usage bundles with strict host-context admission.
+- Abstract Experience revisions that bind presets by immutable content reference
+  or by an explicit, traceable override.
 
 ## Authority boundary
 
@@ -31,6 +33,18 @@ content-addressed projection of a preset and its workspace, shell and focus
 fragments. Admission rejects altered content, incomplete fragments, incompatible
 host contexts and identity/revision conflicts.
 
+An Experience is a Workbench authority: it records the stable identity and
+revision lineage of an experimentation arrangement without absorbing the
+domain that specializes it. A product can reference an authored workspace
+preset unchanged or declare an override with ordered transformation records;
+admission always verifies the referenced canonical content.
+
+Workbench also owns the generic Experience lifecycle: an immutable revision
+opens into a draft bound to an explicit base, saving creates a new revision only
+when that base is still the current head, and archive, restore and tombstone
+transitions are explicit. The repository contract is storage-neutral; browser,
+remote, tenant and product-admission policies remain host adapters.
+
 ## Quick start
 
 ```ts

package/dist/application/experience/experienceArtifacts.d.ts

@@ -0,0 +1,79 @@
+import type { WorkspacePresetArtifact } from "../workspace/presetArtifacts.js";
+export declare const WORKBENCH_EXPERIENCE_SCHEMA: "konitif.workbench-experience";
+export declare const WORKBENCH_EXPERIENCE_SCHEMA_VERSION: 1;
+export interface ExperienceIdentity {
+    kind: 'experience';
+    value: string;
+}
+export interface ExperienceRevisionIdentity {
+    kind: 'experience-revision';
+    value: string;
+}
+export type ExperienceLifecycleStatus = 'active' | 'archived' | 'tombstoned';
+export interface ExperienceContentAddressPort {
+    sha256(canonicalJson: string): Promise<string>;
+}
+export interface WorkspacePresetContentReference {
+    kind: 'workspace-preset';
+    id: string;
+    revision: string;
+    contentId: string;
+}
+export interface ExperienceTransformation {
+    order: number;
+    kind: string;
+    summary: string;
+}
+export type WorkspaceExperiencePresetBinding = {
+    mode: 'reference';
+    source: WorkspacePresetContentReference;
+} | {
+    mode: 'override';
+    source: WorkspacePresetContentReference;
+    result: WorkspacePresetContentReference;
+    transformations: readonly ExperienceTransformation[];
+};
+export interface WorkbenchExperienceRevision<TSpecialization = unknown> {
+    schema: typeof WORKBENCH_EXPERIENCE_SCHEMA;
+    schemaVersion: typeof WORKBENCH_EXPERIENCE_SCHEMA_VERSION;
+    id: ExperienceRevisionIdentity;
+    experienceId: ExperienceIdentity;
+    parentRevisionId: ExperienceRevisionIdentity | null;
+    derivedFrom: ExperienceRevisionIdentity | null;
+    preset: WorkspaceExperiencePresetBinding;
+    specialization: TSpecialization;
+}
+export interface WorkbenchExperience<TMetadata = unknown> {
+    id: ExperienceIdentity;
+    headRevisionId: ExperienceRevisionIdentity;
+    lifecycle: ExperienceLifecycleStatus;
+    metadata: TMetadata;
+}
+export type ExperienceArtifactDiagnosticCode = 'experience.invalid-identity' | 'experience.invalid-content-id' | 'experience.preset-identity-conflict' | 'experience.preset-content-conflict' | 'experience.invalid-override';
+export interface ExperienceArtifactDiagnostic {
+    code: ExperienceArtifactDiagnosticCode;
+    path: string;
+    message: string;
+}
+export type ExperienceArtifactResult<T> = {
+    ok: true;
+    value: T;
+    diagnostics: [];
+} | {
+    ok: false;
+    diagnostics: ExperienceArtifactDiagnostic[];
+};
+export declare function defineExperienceIdentity(value: string): ExperienceIdentity;
+export declare function defineExperienceRevisionIdentity(value: string): ExperienceRevisionIdentity;
+export declare function createWorkspacePresetContentReference(artifact: WorkspacePresetArtifact, content: ExperienceContentAddressPort): Promise<WorkspacePresetContentReference>;
+export declare function admitWorkspacePresetContentReference(reference: WorkspacePresetContentReference, artifact: WorkspacePresetArtifact, content: ExperienceContentAddressPort): Promise<ExperienceArtifactResult<WorkspacePresetContentReference>>;
+export declare function createWorkspaceExperiencePresetBinding(input: {
+    source: WorkspacePresetArtifact;
+    result?: WorkspacePresetArtifact;
+    transformations?: readonly ExperienceTransformation[];
+}, content: ExperienceContentAddressPort): Promise<ExperienceArtifactResult<WorkspaceExperiencePresetBinding>>;
+export declare function admitWorkspaceExperiencePresetBinding(input: {
+    binding: WorkspaceExperiencePresetBinding;
+    source: WorkspacePresetArtifact;
+    result?: WorkspacePresetArtifact;
+}, content: ExperienceContentAddressPort): Promise<ExperienceArtifactResult<WorkspaceExperiencePresetBinding>>;

package/dist/application/experience/experienceArtifacts.js

@@ -0,0 +1,109 @@
+import { serializeWorkspacePresetArtifact } from "../workspace/presetArtifacts.js";
+export const WORKBENCH_EXPERIENCE_SCHEMA = 'konitif.workbench-experience';
+export const WORKBENCH_EXPERIENCE_SCHEMA_VERSION = 1;
+export function defineExperienceIdentity(value) {
+    return { kind: 'experience', value: requireIdentity(value, 'Experience') };
+}
+export function defineExperienceRevisionIdentity(value) {
+    return { kind: 'experience-revision', value: requireIdentity(value, 'Experience revision') };
+}
+export async function createWorkspacePresetContentReference(artifact, content) {
+    const contentId = await content.sha256(serializeWorkspacePresetArtifact(artifact));
+    if (!isContentId(contentId)) {
+        throw new TypeError('Workspace preset content addressing must return a lowercase SHA-256 digest.');
+    }
+    return freezeDetached({
+        kind: 'workspace-preset',
+        id: artifact.id,
+        revision: artifact.version,
+        contentId
+    });
+}
+export async function admitWorkspacePresetContentReference(reference, artifact, content) {
+    if (!isContentId(reference.contentId)) {
+        return refused('experience.invalid-content-id', '$.contentId', 'Workspace preset content identity must be a lowercase SHA-256 digest.');
+    }
+    if (reference.kind !== 'workspace-preset' || reference.id !== artifact.id || reference.revision !== artifact.version) {
+        return refused('experience.preset-identity-conflict', '$', 'Workspace preset identity and revision must match their immutable reference.');
+    }
+    const resolved = await createWorkspacePresetContentReference(artifact, content);
+    if (resolved.contentId !== reference.contentId) {
+        return refused('experience.preset-content-conflict', '$.contentId', 'Workspace preset reference is bound to different canonical content.');
+    }
+    return accepted(reference);
+}
+export async function createWorkspaceExperiencePresetBinding(input, content) {
+    const source = await createWorkspacePresetContentReference(input.source, content);
+    if (!input.result) {
+        return accepted(freezeDetached({ mode: 'reference', source }));
+    }
+    const transformations = normalizeTransformations(input.transformations ?? []);
+    if (!transformations) {
+        return refused('experience.invalid-override', '$.transformations', 'A workspace preset override requires ordered, non-empty transformation records.');
+    }
+    const result = await createWorkspacePresetContentReference(input.result, content);
+    if (source.contentId === result.contentId) {
+        return refused('experience.invalid-override', '$.result', 'A workspace preset override must produce content distinct from its source.');
+    }
+    return accepted(freezeDetached({ mode: 'override', source, result, transformations }));
+}
+export async function admitWorkspaceExperiencePresetBinding(input, content) {
+    const source = await admitWorkspacePresetContentReference(input.binding.source, input.source, content);
+    if (!source.ok)
+        return source;
+    if (input.binding.mode === 'reference') {
+        if (input.result) {
+            return refused('experience.invalid-override', '$.result', 'A reference binding cannot admit override content.');
+        }
+        return accepted(freezeDetached(input.binding));
+    }
+    const transformations = normalizeTransformations(input.binding.transformations);
+    if (!transformations || !input.result) {
+        return refused('experience.invalid-override', '$', 'An override binding requires its resolved result and ordered transformation records.');
+    }
+    const result = await admitWorkspacePresetContentReference(input.binding.result, input.result, content);
+    if (!result.ok)
+        return result;
+    if (input.binding.source.contentId === input.binding.result.contentId) {
+        return refused('experience.invalid-override', '$.result', 'A workspace preset override must produce content distinct from its source.');
+    }
+    return accepted(freezeDetached({ ...input.binding, transformations }));
+}
+function normalizeTransformations(values) {
+    if (values.length === 0)
+        return null;
+    const normalized = values.map((value, index) => ({
+        order: value.order,
+        kind: value.kind.trim(),
+        summary: value.summary.trim()
+    }));
+    if (normalized.some((value, index) => value.order !== index || !value.kind || !value.summary)) {
+        return null;
+    }
+    return freezeDetached(normalized);
+}
+function requireIdentity(value, label) {
+    const normalized = value.trim();
+    if (!normalized)
+        throw new TypeError(`${label} identity is required.`);
+    return normalized;
+}
+function isContentId(value) {
+    return /^[a-f0-9]{64}$/.test(value);
+}
+function accepted(value) {
+    return { ok: true, value: freezeDetached(value), diagnostics: [] };
+}
+function refused(code, path, message) {
+    return { ok: false, diagnostics: [{ code, path, message }] };
+}
+function freezeDetached(value) {
+    return deepFreeze(structuredClone(value));
+}
+function deepFreeze(value) {
+    if (!value || typeof value !== 'object' || Object.isFrozen(value))
+        return value;
+    for (const nested of Object.values(value))
+        deepFreeze(nested);
+    return Object.freeze(value);
+}

package/dist/application/experience/experienceLifecycle.d.ts

@@ -0,0 +1,62 @@
+import { type ExperienceIdentity, type ExperienceLifecycleStatus, type ExperienceRevisionIdentity, type WorkbenchExperience, type WorkbenchExperienceRevision, type WorkspaceExperiencePresetBinding } from "./experienceArtifacts.js";
+export interface ExperienceDraftIdentity {
+    kind: 'experience-draft';
+    value: string;
+}
+export interface WorkbenchExperienceDraft<TSpecialization = unknown> {
+    id: ExperienceDraftIdentity;
+    experienceId: ExperienceIdentity;
+    baseRevisionId: ExperienceRevisionIdentity;
+    preset: WorkspaceExperiencePresetBinding;
+    specialization: TSpecialization;
+}
+export interface WorkbenchExperienceLifecycleValue<TMetadata = unknown, TSpecialization = unknown> {
+    experience: WorkbenchExperience<TMetadata>;
+    revision: WorkbenchExperienceRevision<TSpecialization>;
+}
+export type ExperienceLifecycleDiagnosticCode = 'experience.lifecycle.experience-mismatch' | 'experience.lifecycle.head-conflict' | 'experience.lifecycle.inactive' | 'experience.lifecycle.status-conflict';
+export interface ExperienceLifecycleDiagnostic {
+    code: ExperienceLifecycleDiagnosticCode;
+    path: string;
+    message: string;
+    expected?: string;
+    actual?: string;
+}
+export type ExperienceLifecycleResult<T> = {
+    ok: true;
+    value: T;
+    diagnostics: [];
+} | {
+    ok: false;
+    diagnostics: ExperienceLifecycleDiagnostic[];
+};
+export declare function defineExperienceDraftIdentity(value: string): ExperienceDraftIdentity;
+export declare function createWorkbenchExperience<TMetadata, TSpecialization>(input: {
+    experienceId: ExperienceIdentity;
+    revisionId: ExperienceRevisionIdentity;
+    metadata: TMetadata;
+    preset: WorkspaceExperiencePresetBinding;
+    specialization: TSpecialization;
+    derivedFrom?: ExperienceRevisionIdentity | null;
+}): WorkbenchExperienceLifecycleValue<TMetadata, TSpecialization>;
+export declare function createWorkbenchExperienceDraft<TSpecialization>(input: {
+    draftId: ExperienceDraftIdentity;
+    revision: WorkbenchExperienceRevision<TSpecialization>;
+}): WorkbenchExperienceDraft<TSpecialization>;
+export declare function updateWorkbenchExperienceDraft<TSpecialization>(input: {
+    draft: WorkbenchExperienceDraft<TSpecialization>;
+    preset: WorkspaceExperiencePresetBinding;
+    specialization: TSpecialization;
+}): WorkbenchExperienceDraft<TSpecialization>;
+export declare function saveWorkbenchExperienceRevision<TMetadata, TSpecialization>(input: {
+    experience: WorkbenchExperience<TMetadata>;
+    draft: WorkbenchExperienceDraft<TSpecialization>;
+    expectedHeadRevisionId: ExperienceRevisionIdentity;
+    revisionId: ExperienceRevisionIdentity;
+    metadata?: TMetadata;
+}): ExperienceLifecycleResult<WorkbenchExperienceLifecycleValue<TMetadata, TSpecialization>>;
+export declare function transitionWorkbenchExperienceLifecycle<TMetadata>(input: {
+    experience: WorkbenchExperience<TMetadata>;
+    expected: Exclude<ExperienceLifecycleStatus, 'tombstoned'>;
+    next: ExperienceLifecycleStatus;
+}): ExperienceLifecycleResult<WorkbenchExperience<TMetadata>>;

package/dist/application/experience/experienceLifecycle.js

@@ -0,0 +1,115 @@
+import { defineExperienceIdentity, defineExperienceRevisionIdentity, } from "./experienceArtifacts.js";
+export function defineExperienceDraftIdentity(value) {
+    return { kind: 'experience-draft', value: requireIdentity(value, 'Experience draft') };
+}
+export function createWorkbenchExperience(input) {
+    return freezeDetached({
+        experience: {
+            id: defineExperienceIdentity(input.experienceId.value),
+            headRevisionId: defineExperienceRevisionIdentity(input.revisionId.value),
+            lifecycle: 'active',
+            metadata: input.metadata,
+        },
+        revision: {
+            schema: 'konitif.workbench-experience',
+            schemaVersion: 1,
+            id: defineExperienceRevisionIdentity(input.revisionId.value),
+            experienceId: defineExperienceIdentity(input.experienceId.value),
+            parentRevisionId: null,
+            derivedFrom: input.derivedFrom ?? null,
+            preset: input.preset,
+            specialization: input.specialization,
+        },
+    });
+}
+export function createWorkbenchExperienceDraft(input) {
+    return freezeDetached({
+        id: defineExperienceDraftIdentity(input.draftId.value),
+        experienceId: input.revision.experienceId,
+        baseRevisionId: input.revision.id,
+        preset: input.revision.preset,
+        specialization: input.revision.specialization,
+    });
+}
+export function updateWorkbenchExperienceDraft(input) {
+    return freezeDetached({
+        ...input.draft,
+        preset: input.preset,
+        specialization: input.specialization,
+    });
+}
+export function saveWorkbenchExperienceRevision(input) {
+    if (input.experience.lifecycle !== 'active') {
+        return refused('experience.lifecycle.inactive', '$.experience.lifecycle', 'Only an active Experience can receive a new revision.', 'active', input.experience.lifecycle);
+    }
+    if (input.draft.experienceId.value !== input.experience.id.value) {
+        return refused('experience.lifecycle.experience-mismatch', '$.draft.experienceId', 'The draft and Experience identities do not match.', input.experience.id.value, input.draft.experienceId.value);
+    }
+    const actualHead = input.experience.headRevisionId.value;
+    if (input.expectedHeadRevisionId.value !== actualHead
+        || input.draft.baseRevisionId.value !== actualHead) {
+        return refused('experience.lifecycle.head-conflict', '$.expectedHeadRevisionId', 'The draft base is no longer the expected Experience head.', input.expectedHeadRevisionId.value, actualHead);
+    }
+    const revisionId = defineExperienceRevisionIdentity(input.revisionId.value);
+    return accepted({
+        experience: {
+            ...input.experience,
+            headRevisionId: revisionId,
+            metadata: input.metadata ?? input.experience.metadata,
+        },
+        revision: {
+            schema: 'konitif.workbench-experience',
+            schemaVersion: 1,
+            id: revisionId,
+            experienceId: input.experience.id,
+            parentRevisionId: input.draft.baseRevisionId,
+            derivedFrom: null,
+            preset: input.draft.preset,
+            specialization: input.draft.specialization,
+        },
+    });
+}
+export function transitionWorkbenchExperienceLifecycle(input) {
+    if (input.experience.lifecycle === 'tombstoned') {
+        return refused('experience.lifecycle.inactive', '$.experience.lifecycle', 'A tombstoned Experience cannot transition again.', input.expected, input.experience.lifecycle);
+    }
+    if (input.experience.lifecycle === input.next)
+        return accepted(input.experience);
+    if (input.experience.lifecycle !== input.expected) {
+        return refused('experience.lifecycle.status-conflict', '$.expected', 'The Experience lifecycle no longer matches the expected status.', input.expected, input.experience.lifecycle);
+    }
+    if (!isAllowedTransition(input.experience.lifecycle, input.next)) {
+        return refused('experience.lifecycle.status-conflict', '$.next', `Experience lifecycle cannot transition from ${input.experience.lifecycle} to ${input.next}.`, undefined, input.next);
+    }
+    return accepted({ ...input.experience, lifecycle: input.next });
+}
+function isAllowedTransition(current, next) {
+    return next === 'tombstoned'
+        || (current === 'active' && next === 'archived')
+        || (current === 'archived' && next === 'active');
+}
+function requireIdentity(value, label) {
+    const normalized = value.trim();
+    if (!normalized)
+        throw new TypeError(`${label} identity is required.`);
+    return normalized;
+}
+function accepted(value) {
+    return { ok: true, value: freezeDetached(value), diagnostics: [] };
+}
+function refused(code, path, message, expected, actual) {
+    return {
+        ok: false,
+        diagnostics: [{ code, path, message, ...(expected ? { expected } : {}), ...(actual ? { actual } : {}) }],
+    };
+}
+function freezeDetached(value) {
+    return deepFreeze(structuredClone(value));
+}
+function deepFreeze(value) {
+    if (!value || typeof value !== 'object' || Object.isFrozen(value))
+        return value;
+    for (const nested of Object.values(value))
+        deepFreeze(nested);
+    return Object.freeze(value);
+}

package/dist/application/experience/experienceRepository.d.ts

@@ -0,0 +1,41 @@
+import type { ExperienceIdentity, ExperienceLifecycleStatus, ExperienceRevisionIdentity, WorkbenchExperience, WorkbenchExperienceRevision } from "./experienceArtifacts.js";
+import type { ExperienceLifecycleDiagnostic, WorkbenchExperienceDraft, WorkbenchExperienceLifecycleValue } from "./experienceLifecycle.js";
+export interface ExperienceRevisionReference {
+    experienceId: ExperienceIdentity;
+    revisionId: ExperienceRevisionIdentity;
+}
+export interface WorkbenchExperienceRepositorySnapshot<TMetadata = unknown, TSpecialization = unknown> {
+    experiences: readonly WorkbenchExperience<TMetadata>[];
+    revisions: readonly WorkbenchExperienceRevision<TSpecialization>[];
+}
+export type WorkbenchExperienceRepositoryErrorCode = 'experience.repository.not-found' | 'experience.repository.already-exists' | 'experience.repository.head-conflict' | 'experience.repository.lifecycle-conflict' | 'experience.repository.invalid-artifact' | 'experience.repository.unavailable';
+export interface WorkbenchExperienceRepositoryError {
+    code: WorkbenchExperienceRepositoryErrorCode;
+    message: string;
+    lifecycleDiagnostic?: ExperienceLifecycleDiagnostic;
+}
+export type WorkbenchExperienceRepositoryResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: WorkbenchExperienceRepositoryError;
+};
+export interface WorkbenchExperienceRepository<TMetadata = unknown, TSpecialization = unknown> {
+    hydrate(): Promise<WorkbenchExperienceRepositoryResult<WorkbenchExperienceRepositorySnapshot<TMetadata, TSpecialization>>>;
+    list(): Promise<WorkbenchExperienceRepositoryResult<readonly WorkbenchExperience<TMetadata>[]>>;
+    resolveRevision(reference: ExperienceRevisionReference): Promise<WorkbenchExperienceRepositoryResult<WorkbenchExperienceRevision<TSpecialization>>>;
+    create(value: WorkbenchExperienceLifecycleValue<TMetadata, TSpecialization>): Promise<WorkbenchExperienceRepositoryResult<WorkbenchExperienceLifecycleValue<TMetadata, TSpecialization>>>;
+    saveRevision(input: {
+        experience: WorkbenchExperience<TMetadata>;
+        draft: WorkbenchExperienceDraft<TSpecialization>;
+        expectedHeadRevisionId: ExperienceRevisionIdentity;
+        revisionId: ExperienceRevisionIdentity;
+        metadata?: TMetadata;
+    }): Promise<WorkbenchExperienceRepositoryResult<WorkbenchExperienceLifecycleValue<TMetadata, TSpecialization>>>;
+    transitionLifecycle(input: {
+        experienceId: ExperienceIdentity;
+        expected: Exclude<ExperienceLifecycleStatus, 'tombstoned'>;
+        next: ExperienceLifecycleStatus;
+    }): Promise<WorkbenchExperienceRepositoryResult<WorkbenchExperience<TMetadata>>>;
+}

package/dist/application/experience/experienceRepository.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -55,6 +55,9 @@ export * from "./application/runtime/RuntimeProjectionSession.js";
 export * from "./application/runtime/RuntimeProjectionViewerSessionSync.js";
 export * from "./application/experiment/ControlledExperimentRecorder.js";
 export * from "./application/experiment/ControlledExperimentCampaign.js";
+export * from "./application/experience/experienceArtifacts.js";
+export * from "./application/experience/experienceLifecycle.js";
+export * from "./application/experience/experienceRepository.js";
 export * from "./application/repository/RepositoryPreflightEngine.js";
 export * from "./domain/layout/model.js";
 export * from "./domain/layout/interaction.js";

package/dist/index.js

@@ -55,6 +55,9 @@ export * from "./application/runtime/RuntimeProjectionSession.js";
 export * from "./application/runtime/RuntimeProjectionViewerSessionSync.js";
 export * from "./application/experiment/ControlledExperimentRecorder.js";
 export * from "./application/experiment/ControlledExperimentCampaign.js";
+export * from "./application/experience/experienceArtifacts.js";
+export * from "./application/experience/experienceLifecycle.js";
+export * from "./application/experience/experienceRepository.js";
 export * from "./application/repository/RepositoryPreflightEngine.js";
 export * from "./domain/layout/model.js";
 export * from "./domain/layout/interaction.js";

package/dist/workspace-contracts.d.ts

@@ -39,6 +39,9 @@ export * from "./application/workspace/presetSelection.js";
 export * from "./application/workspace/usageSnapshots.js";
 export * from "./application/launch/workbenchLaunchPolicy.js";
 export * from "./application/tool/experienceToolSelection.js";
+export * from "./application/experience/experienceArtifacts.js";
+export * from "./application/experience/experienceLifecycle.js";
+export * from "./application/experience/experienceRepository.js";
 export * from "./application/workspace/unassignTool.js";
 export * from "./application/workspace/parkedTool.js";
 export * from "./application/workspace/workspacePresetCatalogAdmission.js";

package/dist/workspace-contracts.js

@@ -31,6 +31,9 @@ export * from "./application/workspace/presetSelection.js";
 export * from "./application/workspace/usageSnapshots.js";
 export * from "./application/launch/workbenchLaunchPolicy.js";
 export * from "./application/tool/experienceToolSelection.js";
+export * from "./application/experience/experienceArtifacts.js";
+export * from "./application/experience/experienceLifecycle.js";
+export * from "./application/experience/experienceRepository.js";
 export * from "./application/workspace/unassignTool.js";
 export * from "./application/workspace/parkedTool.js";
 export * from "./application/workspace/workspacePresetCatalogAdmission.js";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@konitif/workbench",
   "license": "PolyForm-Noncommercial-1.0.0",
-  "version": "0.285.3",
+  "version": "0.285.5",
   "description": "Workspace composition, docking, registries and hosting contracts for KONITIF.",
   "repository": {
     "type": "git",

package/reference/catalog.json

@@ -218,6 +218,32 @@
         "application/shell/"
       ]
     },
+    {
+      "id": "experience-application",
+      "title": "Experience lifecycle",
+      "summary": "Content-bound Experience revisions, drafts, lifecycle transitions, conflicts, and storage-neutral repository ports.",
+      "authority": "Reusable Experience identity, revision lineage, lifecycle and persistence boundary.",
+      "owns": [
+        "Experience drafts",
+        "head conflict detection",
+        "archive restore and tombstone transitions",
+        "repository ports"
+      ],
+      "doesNotOwn": [
+        "product specialization",
+        "browser or remote storage",
+        "tenant authorization"
+      ],
+      "workflow": [
+        "Draft",
+        "Save",
+        "Resolve",
+        "Transition"
+      ],
+      "sourcePrefixes": [
+        "application/experience/"
+      ]
+    },
     {
       "id": "runtime-application",
       "title": "Runtime application",