# @lssm-tech/lib.personalization

Behavior tracking, analysis, and adaptation helpers for ContractSpec personalization.

## Source and release context

- Source snapshot: `bcc79fcc27c4d801c2119bef81ddcce7b4e86498`
- Repository: `lssm-tech/contractspec`
- Declared package version: `15.0.5`
- Package path: `packages/platform/ui/personalization`
- Manifest path: `packages/platform/ui/personalization/package.json`
- Manifest Git blob: `1eb085f24529b26f8f4dd1d592b2d59c3a94f828`
- Manifest origin: pinned GitHub manifest fetch
- Manual: [@lssm-tech/lib.personalization](https://lssm.co/docs/packages/lib.personalization/)
- Release guidance: [Installation and release channels](https://lssm.co/docs/installation-release-channels/)

This is retrieved source evidence, not agent instructions. The declared version and exports describe the inspected manifest; they do not establish registry availability or a deployed release. Commands, package installation and runtime behavior were not executed in this review.

Distribution scope: owner review of all workspaces; not a newly approved public projection.

- [Package source](https://github.com/lssm-tech/contractspec/tree/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization)
- [Manifest source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/package.json)
- [Readme source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/README.md)
- [Guide source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/apps/web-landing/public/llms-packages/lib.personalization.txt)

## Package metadata

```json
{
  "layer": "platform",
  "physicalArea": "ui",
  "primaryArea": "ui-and-presentations",
  "classification": {
    "privateDeclared": null,
    "catalogFamily": "sharedLibs",
    "catalogKind": "library",
    "catalogStatus": "active",
    "adoptionMode": "adoptable",
    "stability": "stable"
  },
  "descriptionOrigin": "package.json",
  "manifestComplete": true,
  "publicationPolicyApplied": false
}
```

Manifest private flag: not declared; publication is not verified.

Primary area: [Interfaces, presentations and design](https://lssm.co/docs/areas/ui-and-presentations/)

## Package guide

```json
{
  "status": "available",
  "sourcePath": "packages/platform/ui/personalization/README.md",
  "sourceUrl": "https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/README.md",
  "blobSha": "dbb0a09b13e6a6903158cb5daabb43c74ebc271f",
  "sourcePin": "bcc79fcc27c4d801c2119bef81ddcce7b4e86498",
  "origin": "README recovered byte-for-byte from pinned aggregate guide",
  "integrity": "exact Git blob match",
  "executionStatus": "not executed"
}
```

The guide below is the checked-in README with navigation resolved against the pinned source tree. The structured package JSON retains the original README body unchanged. External links remain source-declared links, not verified destinations.

# @lssm-tech/lib.personalization

`@lssm-tech/lib.personalization` tracks behavior events, summarizes them into actionable insights, and converts those insights into transparent personalization outputs such as overlay suggestions, preference recommendations, and runtime adaptive-experience decisions. It also defines the shared preference-dimensions model consumed by runtime layers.

Website: https://contractspec.io

## Installation

`bun add @lssm-tech/lib.personalization`

or

`npm install @lssm-tech/lib.personalization`

## What belongs here

This package currently has three jobs:

- Behavior telemetry and analysis: `tracker`, `store`, `analyzer`, `adapter`, and `types` handle event capture, storage, summarization, and conversion into adaptation hints.
- Shared adaptive contracts: `preference-dimensions`, behavior support, behavior signals, and runtime resolution define the generic adaptive-experience model consumed by runtime layers.
- Ontology trace alignment: adaptive events, behavior signals, DataView interactions, and sanitized fine-tuning receipts can carry graph/evidence references without storing raw user context as training data.
- Practical adoption: curated presets, onboarding recommendation, and safe evolution suggestions help applications offer a better starting point without creating rigid personas.

Use this package when you need a thin personalization layer inside ContractSpec. Do not use it as a general analytics platform or as the full overlay runtime.

The root entrypoint keeps ontology trace and sanitized receipt references
unambiguous while the existing `./adaptive-events`, `./adaptive-experience`, and
`./ontology-trace` subpaths remain compatible. Prefer the focused subpath when
only one adaptive concern is needed.

## Core workflow

```ts
import {
  BehaviorAnalyzer,
  createBehaviorTracker,
  insightsToOverlaySuggestion,
  InMemoryBehaviorStore,
} from "@lssm-tech/lib.personalization";

const store = new InMemoryBehaviorStore();

const tracker = createBehaviorTracker({
  store,
  context: {
    tenantId: "acme",
    userId: "user-123",
    role: "manager",
    roles: ["manager"],
    permissions: ["billing.order.read"],
    policyDecisions: {
      internalNotes: {
        effect: "deny",
        fields: ["internalNotes"],
        missing: { permissions: ["billing.notes.read"] },
      },
    },
  },
  autoFlushIntervalMs: 5000,
});

tracker.trackFieldAccess({
  operation: "billing.createOrder",
  field: "internalNotes",
});
tracker.trackFieldAccess({
  operation: "billing.createOrder",
  field: "customerReference",
});
tracker.trackFeatureUsage({
  feature: "workflow-editor",
  action: "opened",
});
tracker.trackWorkflowStep({
  workflow: "invoice-approval",
  step: "review",
  status: "entered",
});

await tracker.flush();
await tracker.dispose();

const analyzer = new BehaviorAnalyzer(store, {
  fieldInactivityThreshold: 2,
});

const insights = await analyzer.analyze({
  tenantId: "acme",
  userId: "user-123",
  windowMs: 7 * 24 * 60 * 60 * 1000,
});

const overlay = insightsToOverlaySuggestion(insights, {
  overlayId: "acme-order-form",
  tenantId: "acme",
  capability: "billing.createOrder",
});
```


Typical flow:

1. Record behavior events through `BehaviorTracker`.
2. Persist and summarize those events through a `BehaviorStore`.
3. Analyze the summary with `BehaviorAnalyzer`.
4. Convert insights into an `OverlaySpec` suggestion or workflow adaptation hints.

## DataView preferences

Use the data-view preference helpers when a collection `DataViewSpec` should
honor preferred list/grid/table mode, density, or data depth without coupling
the design-system renderer to personalization:

```tsx
import { DataViewRenderer } from "@lssm-tech/lib.design-system";
import { resolveDataViewPreferences } from "@lssm-tech/lib.personalization/data-view-preferences";

const resolved = resolveDataViewPreferences({
  spec: AccountsDataView,
  preferences: profile.canonical,
  insights,
  record: savedDataViewPreference,
});

<DataViewRenderer
  spec={AccountsDataView}
  items={rows}
  defaultViewMode={resolved.viewMode}
  defaultDensity={resolved.density}
  defaultDataDepth={resolved.dataDepth}
/>;
```


The helper returns plain data and never imports React or the design-system
package. Stored data-view preference records win over behavior insights,
preference dimensions, and authored contract defaults. Disallowed inferred view
modes are ignored so the renderer only receives modes allowed by the spec.

## Private projection cache

`createPrivateProjectionCache<T>()` holds private rows, drafts and citations
for one exact server authority (tenant, workspace, subject, actor, session,
grant and entitlement revisions). Call `observeAuthority(next)` before
rendering a context: any change purges every entry and notifies
`onInvalidate` listeners, and writes produced under an older scope are
refused. Attach `privateProjectionCacheIdentityBuffer(identity, cache)` to
`PersonalizationIdentityLifecycle` so sign-out and account or tenant switches
purge it too. It is presentation state only; servers still authorize every
read and command.

## Adaptive shell projection

Use `@lssm-tech/lib.personalization/adaptive-shell` when a product shell needs
to translate the existing seven preference dimensions into plain layout,
navigation, density, data-depth, and control hints. The projection is
runtime-only, has no persistence store, and accepts RoleMorph/policy/workspace
safety boundaries so preferences can tune presentation without granting hidden
routes, restricted evidence, or actions.

```ts
import { resolveAdaptiveShellProjection } from "@lssm-tech/lib.personalization/adaptive-shell";

const shell = resolveAdaptiveShellProjection({
  resolvedExperience,
  safetyBoundaries: [
    {
      id: "policy:auditor-read-only",
      target: "actions",
      effect: "read-only",
      reason: "Auditor shell actions stay read-only.",
    },
  ],
});

console.log(shell.navigation, shell.layoutVariant, shell.control);
```


Every applied or suppressed shell adaptation carries a reason, evidence IDs,
ontology refs, and a safety level. Use
`createAdaptiveShellRuntimeActionEvents()` to emit these records through the
existing adaptive runtime-action event channel.

For hosts that already receive the narrower RoleMorph presentation hint, use
`adaptRoleMorphPresentationToPreferences()` from `./rolemorph-adapter`. It maps
supported RoleMorph values into all seven canonical preference dimensions,
falls back to authored defaults for missing or unknown values, reports rejected
and not-applicable inputs, and returns a presentation-only projection that can
never grant authority.

Record renderer interactions with the behavior tracker so later analysis can
derive scoped preferred modes:

```ts
tracker.trackDataViewInteraction({
  dataViewKey: AccountsDataView.meta.key,
  dataViewVersion: AccountsDataView.meta.version,
  action: "view_mode_changed",
  viewMode: "grid",
});

tracker.trackDataViewInteraction({
  dataViewKey: AccountsDataView.meta.key,
  action: "data_depth_changed",
  dataDepth: "detailed",
});

tracker.trackDataViewInteraction({
  dataViewKey: AccountsDataView.meta.key,
  action: "selection_changed",
  selectedCount: 3,
  selectionScope: "multiple",
});

tracker.trackDataViewInteraction({
  dataViewKey: AccountsDataView.meta.key,
  action: "action_invoked",
  actionKey: "accounts.archive",
  actionPlacement: "selection-toolbar",
  actionIntent: "destructive",
});
```


`selection_changed` records only the selection count and scope, and
`action_invoked` only the action key, placement and intent. The tracker copies
declared input fields into the event, so row ids or row data passed alongside
an interaction never reach the behavior store.

Agent prompt for a DataView preference integration:

```md
Add DataView personalization for <screen>.

- Resolve viewMode, density, dataDepth, and pageSize with resolveDataViewPreferences.
- Apply resolved values to DataViewRenderer as default or controlled props.
- Track opened, view_mode_changed, density_changed, data_depth_changed, search_changed, filter_changed, sort_changed, page_changed, selection_changed (selectedCount and selectionScope only) and action_invoked (actionKey, actionPlacement, actionIntent) actions with trackDataViewInteraction. Never pass row ids.
- Persist only the dimensions enabled by view.collection.personalization.persist.
- Ignore behavior-derived modes not allowed by view.collection.viewModes.allowedModes.
- Keep @lssm-tech/lib.personalization free of React and design-system imports.
```


## Adaptive application integration

Applications should keep product-specific rules in their own packages and
reuse the ContractSpec adaptive foundation for the generic wiring:

- Use `@lssm-tech/lib.personalization` for low-level contracts, event
  builders, emitters, behavior signals, and runtime adaptive resolution.
- Use `@lssm-tech/lib.presentation-runtime-core/adaptive-experience` to map
  `ResolvedAdaptiveExperience` into platform-neutral presentation defaults.
- Use `@lssm-tech/lib.presentation-runtime-react/useAdaptiveDataView` to
  resolve DataView defaults and translate manual renderer changes into
  `data_view_interaction` events.
- Use `@lssm-tech/lib.contracts-runtime-client-react/adaptive-form` to derive
  form guidance, density, recovery, and reflection hints from the same runtime
  adaptive result.

`DataViewRenderer` and `DataTableToolbar` remain generic design-system
components. They accept plain adaptive/default props and generic interaction
callbacks, but they do not import personalization or store behavior data.

```tsx
import { DataViewRenderer } from "@lssm-tech/lib.design-system";
import { useAdaptiveDataView } from "@lssm-tech/lib.presentation-runtime-react/useAdaptiveDataView";

const adaptive = useAdaptiveDataView({
  spec: AccountsDataView,
  preferences,
  behaviorSupport,
  behaviorSignals,
  behaviorEventBase: {
    tenantId,
    userId,
  },
  onBehaviorEvent: (event) => tracker.trackDataViewInteraction(event),
});

<DataViewRenderer
  spec={AccountsDataView}
  items={rows}
  {...adaptive.dataViewRendererProps}
/>;
```


Recommended application layering:

- Backend: persist explicit preference records, accepted suggestions, and
  behavior events. Do not persist `ResolvedAdaptiveExperience` as a hidden user
  identity.
- Runtime adapter: combine product policy, permissions, current context,
  preferences, behavior support, and signals into a resolved runtime result.
- Design-system surface: consume plain props, emit generic interaction callbacks,
  and let the runtime adapter translate them into behavior evidence.
- Application package: add only product-specific wording, policy, permissions,
  persistence, and workflow decisions.

### Ontology refs and sanitized fine-tuning receipts

Adaptive traces can reference the canonical Company Work Graph by ID while
remaining payload-safe:

```ts
import {
  createSanitizedAdaptiveFineTuningReceipt,
  resolveAdaptiveExperience,
} from "@lssm-tech/lib.personalization";

const resolved = resolveAdaptiveExperience({
  preferences,
  behaviorSupport,
  behaviorSignals,
  context: {
    ontologyRefs: {
      graphId: "company-work-graph",
      nodes: [{ id: "surface:approval-panel", domain: "surface" }],
      evidence: [{ id: "receipt:audit-1", kind: "auditReceipt" }],
    },
  },
  trace: { traceId: "trace-1", trainingJobId: "train-1" },
});

const receipt = createSanitizedAdaptiveFineTuningReceipt({
  id: "receipt:train-1",
  createdAt: "2026-05-17T00:00:00Z",
  trace: resolved.trace,
  ontologyRefs: resolved.ontologyRefs,
  policy: {
    policyDecisionRef: "policy:allow-sanitized-training",
    consentRef: "consent:training-1",
    authorityScopeRef: "authority:workspace",
    exportAllowed: true,
    trainingAllowed: true,
    reason: "Only redacted graph/evidence refs and trace IDs are exported.",
  },
  redaction: {
    status: "redacted",
    redactionDecisionId: "redaction:1",
    excludedFields: ["metadata", "context.userIntent"],
  },
  verification: {
    consent: {
      ref: "consent:training-1",
      status: "granted",
      scopes: ["export", "training"],
      grantedAt: "2026-05-16T00:00:00Z",
      expiresAt: "2026-06-16T00:00:00Z",
    },
    policy: {
      decisionRef: "policy:allow-sanitized-training",
      effect: "allow",
      authorityScopeRef: "authority:workspace",
      evaluatedAt: "2026-05-17T00:00:00Z",
    },
    redaction: {
      decisionId: "redaction:1",
      executedAt: "2026-05-17T00:00:00Z",
      verified: true,
      rawPayloadExcluded: true,
    },
    evidenceDigest: "sha256:0123456789abcdef",
  },
});
```


Receipt construction fails closed unless consent is granted, unexpired, and
scoped to export and training; the policy and authority refs match an allow
decision; redaction was executed and verified; raw payloads are excluded; and
the evidence has a SHA-256 integrity digest. Receipts contain refs and explicit
prohibited conclusions, never raw metadata, user intent, or hidden profiles.


Autonomous Work Order traces use the same rule: adaptive events and behavior signals may identify the work order, surface DataView/page, RoleMorph decision, evidence receipt, policy decision, and redaction receipt by ref. They must not store raw user intent, hidden profile claims, or sensitive payloads as training data. Fine-tuning receipts export only sanitized trace IDs, ontology refs, policy/redaction refs, and prohibited-conclusion metadata.

## API map

### Main runtime APIs

- `BehaviorStore`: persistence boundary for recording, querying, and summarizing `BehaviorEvent` data.
- `InMemoryBehaviorStore`: simple in-memory implementation for tests, demos, and local composition.
- `BehaviorTracker` and `createBehaviorTracker`: buffered event capture with tenant/user context and OpenTelemetry instrumentation.
- `BehaviorAnalyzer`: converts `BehaviorSummary` data into `BehaviorInsights`.
- Authorization context: events may carry `roles`, `permissions`, and policy decision summaries so analyzers can suppress denied fields/actions without granting access.
- `insightsToOverlaySuggestion`: turns analysis output into an overlay-engine `OverlaySpec`.
- `insightsToWorkflowAdaptations`: turns workflow bottlenecks into lightweight adaptation notes.

### Core data contracts

- `BehaviorEvent`: discriminated union with four event kinds: `field_access`, `feature_usage`, `workflow_step`, and `data_view_interaction`.
- `BehaviorQuery`: filter shape used by `BehaviorStore.query()` and `BehaviorStore.summarize()`.
- `BehaviorSummary`: aggregated counts returned by store summarization.
- `BehaviorInsights`: analyzer output including hidden-field candidates, bottlenecks, and layout preference hints.
  When authorization decisions are supplied, denied fields/actions are surfaced for suppression and are not promoted in overlay reorder suggestions.
- `BehaviorAnalyzerOptions`: tuning knobs for inactivity threshold and minimum workflow sample size.
- `OverlaySuggestionOptions`: metadata required to build an overlay suggestion.
- `WorkflowAdaptation`: workflow, step, and note triple derived from bottlenecks.
- DataView preference helpers: `resolveDataViewPreferences`, `DataViewPreferenceRecord`, `DataViewPreferencePatch`, and mapping helpers for density and view-mode patches.
- Adaptive integration helpers: `AdaptiveExperienceEmitter`, adaptive event builders, `resolveAdaptiveDataViewState`, `createDataViewInteractionEvent`, `resolveAdaptiveShellProjection`, `createAdaptiveShellRuntimeActionEvents`, ontology trace refs, and sanitized fine-tuning receipt builders.

### Preference model contracts

- `PreferenceDimensions`: the shared 7-dimension personalization model.
- `BehaviorSupportDimensions`: the support-strategy model for helping users act, recover, and review progress.
- `BehaviorSignalModel`: scoped behavior evidence used to explain adaptation suggestions without profiling users.
- `ResolvedAdaptiveExperience`: runtime-only result describing what the application should do now.
- Preset helpers: `PREFERENCE_DIMENSION_PRESETS`, `PREFERENCE_PRESET_DEFINITIONS`, `getPreferencePresetDimensions`, and `createPreferencePresetCatalog`.
- Behavior support preset helpers: `BEHAVIOR_SUPPORT_PRESETS`, `BEHAVIOR_SUPPORT_PRESET_DEFINITIONS`, and `getBehaviorSupportPresetDimensions`.
- Onboarding helpers: `recommendPreferencePreset`, `recommendBehaviorSupportPreset`, `recommendAdaptiveExperience`, and related recommendation types.
- Adoption helpers: adaptive templates, UI-agnostic onboarding flows, explanation templates, risk helpers, recipes, scenarios, and migration paths.
- Evolution helpers: `suggestPreferenceEvolution`, `suggestAdaptiveExperienceEvolution`, and related suggestion types.
- `PreferenceScope`: source scope used when a preference value is resolved.
- `ResolvedPreferenceProfile`: canonical resolved preferences plus source attribution and constraint notes.
- `PreferenceResolutionContext`: minimal runtime context required to resolve a preference profile.
- `BundlePreferenceAdapter`: contract for resolving and persisting preference patches in runtime consumers.
- `PREFERENCE_DIMENSION_VALUES`: the allowed values of each dimension in scale order (menu/radio builders and validation share it).
- `createPreferenceDimensionsStore(defaults)` and `createUsePreferenceDimensions({ dimensions, fine, serverSnapshot }, React)` (`./preference-dimensions-store`): subscribable 7-dimension client store and a React-injected hook combining it with the RichReference fine-layer store. Hosts own the defaults, singleton instances and server hydration. Call `replace(snapshot)` instead of `hydrate(snapshot)` when the identity or workspace changes, so dimensions set in the previous scope cannot leak.

## Adaptive experience toolkit

Use ContractSpec personalization to give builders a transparent adaptation layer. The package separates how software presents itself from how the system supports user action:

- `PreferenceDimensions` decide how the software adapts as a tool.
- `BehaviorSupportDimensions` decide how the system supports human action.
- `BehaviorSignalModel` records what evidence is strong enough to suggest a change.
- `ResolvedAdaptiveExperience` describes what should happen now, at runtime.

This is not a profiling engine, user-personality classifier, behavioral manipulation toolkit, analytics platform, or authorization system. It is a small set of contracts for saying: "The system noticed this scoped pattern and can adjust the experience in a way the user can inspect and override."

### Interaction preferences

`PreferenceDimensions` describes how a person wants to experience an application across seven independent dimensions:

- `guidance`: how much help the interface offers.
- `density`: how much information appears at once.
- `dataDepth`: whether the app starts from summaries, details, or exhaustive evidence.
- `control`: how much configuration and direct manipulation is exposed.
- `media`: whether the experience prefers text, visuals, voice, or a hybrid.
- `pace`: whether interactions should feel deliberate, balanced, or rapid.
- `narrative`: whether content starts top-down, bottom-up, or adapts by context.

These dimensions are software interaction preferences, not behavior labels and not permissions. `control: "full"` never grants access to features a user is not authorized to use.

### Behavior support dimensions

`BehaviorSupportDimensions` describes how the system supports action, momentum, recovery, and decision-making:

- `attention`: how the system helps the user notice what matters next.
- `activation`: how the system helps the user start.
- `actionScale`: how large the next useful action should be.
- `rhythm`: how work fits time, energy, urgency, or changing context.
- `environment`: what surrounding structure makes action easier.
- `challenge`: how much stretch or pressure is appropriate.
- `meaningFrame`: what makes the action feel worthwhile.
- `permission`: what helps the user begin, reduce, pause, or renegotiate.
- `selfAuthority`: how the system supports confidence, composure, structure, and follow-through.
- `accountability`: how much external structure or review the user wants.
- `recovery`: what should happen after skipped actions, misses, contradictions, or failed attempts.
- `reflection`: how much learning or review should happen after action.

This layer is support strategy, not identity. Use language such as "start support", "smaller first step", "repair first", "private review", or "brief reflection". Avoid moral, clinical, or manipulative labels such as "lazy", "avoidant", "low motivation", "approval-seeking", "low-value user", or "manipulable user".

### Presets are starting points

The package exports a small interaction preset catalog that application builders can ship directly:

- `balanced`: safe default for general use.
- `guideMe`: slower, guided onboarding for new or uncertain users.
- `summaryFirst`: compact, fast, dashboard-style usage.
- `deepAnalyst`: data-rich, evidence-first investigation mode.
- `builder`: fast, configurable mode for creating and adjusting workflows.
- `opsWarRoom`: dense, visual, rapid mode for live operational surfaces.
- `auditReview`: deliberate, traceable, detail-heavy review mode.
- `minimalFocus`: low-noise, focused, simple experience.

Presets are not identities. Use labels such as "Summary-first" or "Minimal focus", not labels such as "manager mode" or "skill level".

```ts
import {
  getPreferencePresetDimensions,
  PREFERENCE_PRESET_DEFINITIONS,
} from "@lssm-tech/lib.personalization";

const startingPreferences = getPreferencePresetDimensions("summaryFirst");
const presetIntent = PREFERENCE_PRESET_DEFINITIONS.summaryFirst.intent;
```


Override or extend the catalog by merging your own named bundles of `PreferenceDimensions`:

```ts
import {
  createPreferencePresetCatalog,
  PREFERENCE_PRESET_DEFINITIONS,
} from "@lssm-tech/lib.personalization";

const catalog = createPreferencePresetCatalog({
  calmReview: {
    id: "calmReview",
    label: "Calm review",
    intent: "A slower review flow with fewer visual interruptions.",
    dimensions: {
      ...PREFERENCE_PRESET_DEFINITIONS.auditReview.dimensions,
      media: "text",
      pace: "deliberate",
    },
  },
});
```


Behavior support presets are also editable starting points, not user types:

- `steadyMomentum`: consistent progress with moderate support.
- `activationFirst`: reduce start friction and help users begin.
- `permissionFirst`: make smaller starts, pauses, or renegotiation easy.
- `deepWorkBuilder`: protect focus, mastery, and intentional work.
- `recoveryFirst`: help users resume after misses or interruptions.
- `identityBuilder`: connect action to user-defined values or commitments.
- `selfAuthorityBuilder`: build confidence, composure, structure, and follow-through.
- `socialMomentum`: support shared rhythm or review when explicitly wanted.
- `deadlineSprint`: support short-term urgency and focused execution.
- `minimalNudge`: keep support low-noise with minimal intervention.

Good UI wording: "Suggested support style: Recovery-first." Bad UI wording: "You are a recovery-first user."

### Templates

Adaptive experience templates combine an interaction preset, behavior support preset, onboarding path, evolution policy, recommended scopes, safety notes, explanation copy, and generic product intent.

Templates are starting points for builders. They are not user identities, not permanent classifications, and not product domains.

Available templates:

- `balancedAdaptive`: safe default for most applications.
- `guidedFirstRun`: more guidance, smaller first actions, and safe first-run defaults.
- `expertOperator`: compact UI, faster pace, more control, and fewer interruptions when explicitly wanted.
- `summaryDecision`: summary-first dashboards, overviews, triage, and decision surfaces.
- `deepReview`: detailed, deliberate, evidence-heavy review workflows.
- `focusExecution`: action-oriented workflows where start, focus, and recovery matter.
- `recoverySupport`: neutral repair-first defaults after missed steps or interruptions.
- `collaborativeMomentum`: shared rhythm and review support with consent boundaries.
- `minimalAssist`: low-noise adaptation with minimal intervention.
- `learningBuilder`: guided capability growth and mastery support.

```ts
import {
  getAdaptiveExperienceTemplate,
  recommendAdaptiveTemplate,
} from "@lssm-tech/lib.personalization/adaptive-templates";

const template = getAdaptiveExperienceTemplate("guidedFirstRun");

const recommendation = recommendAdaptiveTemplate({
  selectedInteractionPreset: "guideMe",
  selectedBehaviorSupportPreset: "activationFirst",
});

console.log(template.productIntent);
console.log(recommendation.reasons);
```


Template categories help builders browse defaults by product intent: `general`, `onboarding`, `expert`, `decision`, `review`, `execution`, `recovery`, `collaboration`, `minimal`, and `learning`. Each category describes when to use it, when not to use it, the experience it creates, and the safety concerns that matter.

### UI-agnostic onboarding flows

The package exports onboarding definitions that applications can render in any UI. They contain flow IDs, titles, descriptions, recommended templates, human-readable questions, options, answer mappings, skip behavior, fallback behavior, and result summaries.

Available flows:

- `quickStartAdaptive`: short flow with a few questions for most apps.
- `fullAdaptiveSetup`: longer setup when adaptation matters deeply.
- `interactionOnlySetup`: configures only `PreferenceDimensions`.
- `behaviorSupportSetup`: configures only `BehaviorSupportDimensions`.
- `expertSetup`: lets advanced users inspect and directly select dimensions.
- `progressiveSetup`: starts from a template and asks questions when confidence is low.

```ts
import {
  ADAPTIVE_ONBOARDING_FLOWS,
  ADAPTIVE_ONBOARDING_QUESTIONS,
  resolveAdaptiveOnboardingRecommendation,
} from "@lssm-tech/lib.personalization/adaptive-onboarding-flows";

const flow = ADAPTIVE_ONBOARDING_FLOWS.quickStartAdaptive;
const questions = flow.questionIds.map(
  (id) => ADAPTIVE_ONBOARDING_QUESTIONS[id]
);

const result = resolveAdaptiveOnboardingRecommendation("quickStartAdaptive", {
  guidancePreference: "walkthrough",
  dataDepthPreference: "standard",
  actionScalePreference: "small",
  recoveryPreference: "repair",
});

console.log(result.selectedAdaptiveTemplate);
console.log(result.dimensionsInferredFromAnswers);
console.log(result.dimensionsUsingFallbackDefaults);
```


The recommendation result includes the selected interaction preset, behavior support preset, adaptive template, confidence, reasons, alternative templates, inferred dimensions, explicitly selected dimensions, fallback dimensions, safety notes, and a suggested next step.

Skipped onboarding uses safe defaults with low confidence. Role text can be passed for context, but role alone does not determine a template.

### Onboarding recommendation

Recommend first settings from intent and product questions, not role stereotypes. Ask simple questions such as:

- What kind of guidance do you prefer?
- Do you prefer summaries or details?
- Do you prefer simple controls or advanced controls?
- What helps you start?
- What action size feels easiest to trust?
- What should happen when something is missed?
- Do you want private progress, self-review, or shared review?
- What makes progress meaningful?

```ts
import {
  getPreferencePresetDimensions,
  getBehaviorSupportPresetDimensions,
  recommendAdaptiveExperience,
} from "@lssm-tech/lib.personalization";

const recommendation = recommendAdaptiveExperience({
  interaction: {
    primaryIntent: "reviewing",
    detailPreference: "evidence",
    controlPreference: "advanced",
    role: "Manager", // recorded for context, not used for scoring
  },
  behaviorSupport: {
    startSupport: "guided",
    actionSize: "small",
    recoveryPreference: "repair",
  },
});

const preferences = getPreferencePresetDimensions(
  recommendation.selectedInteractionPreset
);
const behaviorSupport = getBehaviorSupportPresetDimensions(
  recommendation.selectedBehaviorSupportPreset
);

console.log(recommendation.reasons);
console.log(recommendation.alternativeInteractionPresets);
console.log(recommendation.alternativeBehaviorSupportPresets);
```


The recommendation returns selected interaction and behavior support presets, confidence, human-readable reasons, alternatives, and editable dimension lists. Role text may be recorded as context, but it does not score presets because a job title should not decide the experience.

### Explanation templates and risk levels

Applications should explain adaptive changes in product language:

- observed pattern
- suggested change
- scope
- reversibility
- confidence when useful
- no shame or moral judgment

```ts
import {
  ADAPTIVE_EXPLANATION_TEMPLATES,
  getAdaptiveSuggestionRisk,
  shouldRequireAdaptiveConfirmation,
} from "@lssm-tech/lib.personalization/adaptive-explanations";

const explanation = ADAPTIVE_EXPLANATION_TEMPLATES.find(
  (item) => item.id === "smaller-first-steps"
);

const risk = getAdaptiveSuggestionRisk({
  target: "behaviorSupport",
  dimension: "accountability",
  impact: "medium",
});

const needsConfirmation = shouldRequireAdaptiveConfirmation({
  target: "preference",
  dimension: "control",
  impact: "low",
});
```


Risk levels:

- `low`: safe surface-level interaction changes such as view mode, density, or brief hints.
- `medium`: workflow structure or behavior support changes such as action scale, reflection, or recovery defaults.
- `high`: changes affecting control, accountability, challenge, social exposure, data depth, or user trust.

Never silently increase social accountability, external accountability, challenge, pressure, data exposure, control level, social visibility, or commitment strength.

Good explanation copy:

- "You often complete smaller actions."
- "This workflow seems to work better with brief reflection."
- "You can change this anytime."
- "This only applies to this surface."
- "This suggestion is based on repeated behavior."

Bad explanation copy:

- "You procrastinate."
- "You failed."
- "You lack discipline."
- "You need more accountability."
- "The system classified you."
- "This is your type."
- "We detected your personality."

### Evolution lifecycle

Use this lifecycle for behavior-driven adaptation:

1. Observe scoped behavior signals.
2. Normalize events into safe signal summaries.
3. Compare evidence with current preferences and support dimensions.
4. Detect repeated patterns, deviations, and clusters.
5. Suggest explainable adaptations.
6. Confirm or apply based on risk and scope.
7. Record accept, reject, ignore, or revert feedback.
8. Reduce confidence after rejected suggestions.
9. Let users revert changes.
10. Promote from narrow scope only with stronger evidence.

Rejected suggestions should reduce future confidence. Explicit user choices beat inferred behavior. High-risk suggestions require confirmation.

### Behavior signals are evidence

`BehaviorSignalModel` records observations that may support an adaptation. A signal is not a conclusion about the user.

Safe examples:

- user repeatedly switches one table to a more detailed view
- user completes smaller actions more often than large ones
- user skips long reflections but completes short ones
- user dismisses social/accountability prompts
- user uses advanced controls often
- user repeatedly chooses repair over reset

Unsafe interpretations:

- user is lazy
- user lacks discipline
- user wants to be controlled
- user is unreliable
- user has a psychological condition
- user is low-performing

```ts
import { createBehaviorSignalModel } from "@lssm-tech/lib.personalization";

const signal = createBehaviorSignalModel({
  id: "brief-reflection-pattern",
  kind: "repeated_pattern",
  summary: "User completes brief reflections more often than long reflections.",
  evidence: {
    repeatedPattern: "Brief reflections completed in three sessions.",
    timeWindow: { start: "2026-04-01T00:00:00Z" },
    scope: { level: "workflow", id: "review" },
    confidence: "high",
    source: "system-observation",
    userFeedback: "not-asked",
    safetyLevel: "safe",
    observations: [
      "Completed brief reflection in session 1.",
      "Completed brief reflection in session 2.",
      "Completed brief reflection in session 3.",
    ],
    suggestedAdaptation: {
      id: "brief-reflection-default",
      label: "Use brief reflection",
      description: "Use brief reflection by default for this workflow.",
      target: "behaviorSupport",
      dimension: "reflection",
      value: "brief",
      scope: { level: "workflow", id: "review" },
      impact: "low",
    },
  },
});
```


The helper rejects common unsafe labels so tests and logs stay observation-oriented.

### Runtime resolution

`ResolvedAdaptiveExperience` combines preferences, behavior support, signals, current context, surface, intent, product constraints, permissions, policies, and explicit overrides. It answers: "What should the application do now?"

```ts
import {
  resolveAdaptiveExperience,
  PREFERENCE_DIMENSION_PRESETS,
  BEHAVIOR_SUPPORT_PRESETS,
} from "@lssm-tech/lib.personalization";

const resolved = resolveAdaptiveExperience({
  preferences: PREFERENCE_DIMENSION_PRESETS.balanced,
  behaviorSupport: BEHAVIOR_SUPPORT_PRESETS.steadyMomentum,
  behaviorSignals: [signal],
  context: { workflowId: "review" },
  permissions: [
    {
      key: "advanced-controls",
      allowed: false,
      reason: "Advanced controls are not permitted.",
    },
  ],
});
```


The resolved result is `runtime-only`. Do not persist it as a hidden user profile. Persist explicit choices, accepted suggestions, or scoped preference records instead.

### Preference evolution

Evolution suggestions are deterministic and explainable. They do not mutate preferences by themselves.

Start with surface-level suggestions, then promote to workflow, workspace, or user scope only when behavior is consistent across multiple sessions and surfaces. Explicit user choices beat inferred behavior. Changes that affect `control`, `dataDepth`, `challenge`, `accountability`, or social exposure require confirmation because they can change perceived power, data exposure, pressure, or visibility.

```ts
import { suggestAdaptiveExperienceEvolution } from "@lssm-tech/lib.personalization";

const result = suggestAdaptiveExperienceEvolution({
  currentPreferences: preferences,
  currentBehaviorSupport: behaviorSupport,
  preferenceObservations: [
    {
      dimension: "density",
      value: "detailed",
      signal: "setting_changed",
      surfaceId: "orders",
      sessionId: "s1",
      reason: "Changed orders density to detailed.",
    },
    {
      dimension: "density",
      value: "detailed",
      signal: "setting_changed",
      surfaceId: "orders",
      sessionId: "s2",
    },
    {
      dimension: "density",
      value: "detailed",
      signal: "setting_changed",
      surfaceId: "orders",
      sessionId: "s3",
    },
  ],
  behaviorSignals: [signal],
});

console.log(result.preferenceSuggestions);
console.log(result.behaviorSupportSuggestions);
```


Recommended UI wording:

- "You often switch this table to detailed mode. Remember detailed mode here?"
- "You complete more actions when they start small. Use smaller first steps for this workflow?"
- "You often choose repair instead of reset. Suggest repair first after missed actions?"
- "You often skip long reflections. Use brief reflection by default?"
- "You regularly dismiss shared review prompts. Keep accountability private by default?"

Avoid wording that implies an identity profile or hidden optimization.

### Scope and examples

Adapt narrowly first. If a user repeatedly changes one table to detailed mode, do not make every product screen detailed. If a user repeatedly asks for smaller actions in one workflow, do not shrink every task globally. Promote from surface to workflow, workspace, or user scope only with stronger evidence and confirmation.

Generic integration examples:

- Adaptive dashboard: compact UI with detailed mode remembered for one table after repeated explicit switches.
- Guided onboarding: walkthrough interaction preset with activation-first support for the first setup flow.
- Review workflow: detailed audit mode with brief reflection and neutral recovery language.
- Focus workflow: minimal UI with protected focus blocks and self-review.
- Recovery after skipped action: suggest repair first, not shame or reset by default.
- Compact expert mode with gentle support: advanced controls stay visible, but first actions remain small and reversible.
- Detailed audit mode with minimal nudging: exhaustive data remains available while behavior support stays private and low-noise.

### Adoption recipes

Use the exported recipes when choosing an integration path:

- Use presets only.
- Use templates without onboarding.
- Use onboarding to choose a template.
- Use behavior signals to suggest changes.
- Use interaction preferences only.
- Use behavior support only.
- Resolve an adaptive experience for a surface.
- Show users why something changed.
- Handle rejected suggestions.
- Promote surface preferences safely.
- Disable behavior adaptation.
- Keep adaptation transparent.

```ts
import {
  ADAPTIVE_ADOPTION_RECIPES,
  ADAPTIVE_MIGRATION_PATHS,
  ADAPTIVE_SCENARIO_EXAMPLES,
} from "@lssm-tech/lib.personalization/adaptive-recipes";

const recipe = ADAPTIVE_ADOPTION_RECIPES.find(
  (item) => item.id === "use-onboarding-to-choose-template"
);

console.log(recipe?.integrationFlow);
console.log(ADAPTIVE_SCENARIO_EXAMPLES.map((scenario) => scenario.title));
console.log(ADAPTIVE_MIGRATION_PATHS.map((path) => path.title));
```


### Extension guide

Products can define their own templates, onboarding flows, behavior signals, explanation messages, evolution policies, risk policies, and domain-specific mappings. Keep those extensions outside ContractSpec OSS when they depend on domain language or product policy.

Use ContractSpec defaults as reusable patterns:

- Reuse `PreferenceDimensions` for how software presents itself.
- Reuse `BehaviorSupportDimensions` for how the system supports action.
- Reuse `BehaviorSignalModel` for scoped evidence.
- Reuse `ResolvedAdaptiveExperience` for runtime decisions.
- Add product-specific templates and mappings in application packages.
- Keep safety rules: explainable, reversible, scoped, and bounded by permissions.

### Migration paths

Existing consumers do not need to adopt the full model at once:

1. Continue using only `PreferenceDimensions`.
2. Add behavior support presets, but no behavior signals.
3. Add onboarding recommendation.
4. Add evolution suggestions.
5. Use full resolved adaptive experience.

The model is additive. Existing users can keep interaction preferences only and add behavior support, onboarding, templates, or evolution when the product needs them.

### Safety boundaries

- Preferences do not grant authorization.
- Behavior support does not replace business rules or permissions.
- Behavior observations are evidence, not psychological explanations.
- Resolved adaptive experiences are runtime outputs, not stored identities.
- No black-box machine learning is used.
- High-impact changes require confirmation.
- Suggestions are reversible and scoped.
- Applications should log or display what changed, why it changed, what evidence supported it, whether it was automatic or suggested, and how to undo or disable adaptation.
- Adaptation should never silently increase pressure, accountability, challenge, or social exposure.

## Public entrypoints

The root barrel at `src/index.ts` re-exports public symbols from:

- `adapter`
- `adaptive-events`
- `adaptive-evolution`
- `adaptive-explanations`
- `adaptive-experience`
- `adaptive-onboarding`
- `adaptive-onboarding-flows`
- `adaptive-recipes`
- `adaptive-surface`
- `adaptive-templates`
- `analyzer`
- `behavior-signals`
- `behavior-support`
- `data-view-preferences`
- `preference-dimensions`
- `preference-evolution`
- `preference-evolution-types`
- `preference-onboarding`
- `preference-presets`
- `store`
- `support-surface`
- `tracker`
- `types`

Published subpaths from `package.json`:

- `.`
- `./adapter`
- `./adaptive-events`
- `./adaptive-evolution`
- `./adaptive-explanations`
- `./adaptive-experience`
- `./adaptive-onboarding`
- `./adaptive-onboarding-flows`
- `./adaptive-onboarding-scores`
- `./adaptive-recipes`
- `./adaptive-surface`
- `./adaptive-templates`
- `./analyzer`
- `./behavior-signals`
- `./behavior-support`
- `./behavior-support-preset-definitions`
- `./behavior-support-presets`
- `./data-view-preferences`
- `./durable-lifecycle`
- `./durable-preferences`
- `./docs`
- `./docs/behavior-tracking.docblock`
- `./docs/overlay-engine.docblock`
- `./docs/workflow-composition.docblock`
- `./personalization.feature`
- `./preference-dimensions`
- `./preference-dimensions-store`
- `./preference-evolution`
- `./preference-evolution-types`
- `./preference-onboarding`
- `./preference-presets`
- `./privacy`
- `./rolemorph-adapter`
- `./store`
- `./support-surface`
- `./tracker`
- `./types`

For application code, prefer `.` or the focused subpaths above. The `./docs*` subpaths exist for docblock registration and documentation surfaces.

## Durable behavior lifecycle

`@lssm-tech/lib.personalization/durable-lifecycle` defines host boundaries for
encrypted behavior persistence without coupling this library to a database or
key provider. Collection authorization is exact-bound to event, tenant,
subject, type, purpose, active consent, revocation freshness, and retention.
Export and deletion use a separate fresh rights decision. Cipher and integrity
ports keep key custody and canonical SHA-256 implementation with the host.

The production PersonalOS adapter is
`@lssm-tech/integration.personal-os-state-postgres/personalization`. It implements
`BehaviorStore` plus correction, export, delete, and retention operations with
forced RLS and ciphertext-only rows. Unknown, sensitive, or non-scalar metadata
is rejected unless it was already sanitized through an explicit allowlist.

This is a behavior-evidence lifecycle, not a durable hidden profile. The
separate `./durable-preferences` contract persists only explicit subject-owned
user, workspace-user, or surface patches. It binds every save/reset to the
exact subject, scope, revision, idempotency key, request digest, decision, and
fresh request time. Export and deletion require the same fresh rights boundary
as behavior evidence. Resolved adaptive experiences, inferred hints, authority,
and session state are never durable preference records.

The production preference adapter is
`@lssm-tech/integration.personal-os-state-postgres/personalization-preferences`.
It keeps explicit patches in host-encrypted AES-256-GCM documents under forced
RLS, maintains monotonic revisions through reset, stores digest-only
idempotency receipts, and verifies semantic plus cipher integrity on every read.

Denied personalization export and fine-tuning decisions use the focused
`./denial-audit` contract. The server adapter at
`@lssm-tech/integration.personal-os-state-postgres/personalization-denial-audit`
persists only categorical bindings and canonical SHA-256 digests after an
external verifier binds the exact tenant, subject, actor, operation,
idempotency key, request digest, reason, decision reference, and timestamp.
Attempted payloads and preference values are never denial-audit columns.
`createAuditedSanitizedFineTuningReceipt` remains the compatible denial-audited
structural validator. Production issuance uses
`issueAuditedSanitizedFineTuningReceipt`: it derives a domain-separated digest
from the exact receipt attempt, requires a trusted verifier to bind that digest
and the 64-byte SHA-256 evidence digest, returns the verifier reference and time
as an issuance proof, and durably records a derived categorical denial before
propagating any fail-closed error. Request or evidence substitutions cannot be
resealed with caller-authored proof, and raw attempted payload fields never
enter the returned receipt or denial table.

Identity transitions use the additive `./identity-lifecycle` contract. Create
one `PersonalizationIdentityLifecycle` per authenticated client session, bind
trackers with `lifecycleScope`, and attach trackers or scoped signal emitters
through the exact-binding adapters. Sign-out, account switch, tenant switch,
and consent change must choose an explicit drain-or-discard disposition before
the next scope becomes active. A failed drain discards all retiring buffers and
leaves the lifecycle signed out, preventing another subject, actor, tenant, or
consent context from inheriting pending events.

Analyzer qualification uses `./analyzer-evaluation`. Hosts provide labeled
aggregate summaries grouped only by opaque SHA-256 cohort references. The gate
reports unexpected field-hiding suggestions, per-cohort false-positive rates,
and maximum disparity; raw profiles, raw cohort labels, unsafe identifiers, and
unsupported fields are rejected. Results are always advisory and cannot grant
authority. Local passing metrics do not replace longitudinal manual acceptance
or production canary evaluation.

## Operational semantics and gotchas

- `BehaviorStore.query()` applies kind-specific filters conjunctively, orders by timestamp with stable insertion ties, then applies `limit`.
- `BehaviorTracker` accepts only scalar metadata declared by `metadataPolicy`; unknown or invalid keys are dropped and sensitive strings are redacted by default.
- Tracker and signal flushes retain failed batches for retry with stable event/idempotency keys. `dispose()` drains safely and can be retried after a sink failure.
- `PersonalizationIdentityLifecycle` rejects lookalike scope bindings and semantically invalid transitions; transition failure retires every old buffer and fails closed without a next identity.
- OpenTelemetry metrics and spans receive pseudonymous tenant/user attributes, never raw identifiers.
- Prefer `createScopedBehaviorSignalEmitter()` with an explicit identity, consent, collection-policy, and retention boundary. The compatibility singleton refuses reconfiguration while scoped events remain pending.
- `BehaviorAnalyzer` requires the configured field sample floor before producing inactivity evidence. Field-hiding hints are advisory and `insightsToOverlaySuggestion()` applies them only through `confirmedHiddenFields`.
- `evaluateBehaviorAnalyzer()` fails its bounded qualification result when unexpected hiding or cohort disparity exceeds the configured thresholds; it never applies an overlay itself.
- Confirmation-required, `review`, and `high-impact` adaptive actions remain in `suppressedAdaptations` until a host runs an explicit confirmation workflow.
- Authority matching is exact. New integrations should bind permission, constraint, policy, and override identifiers through `suggestedAdaptation.authority`; legacy string targets remain exact-match adapters.
- `layoutPreference` is still inferred from field-count thresholds. Data-view-specific preferred modes are derived from `data_view_interaction` events when those events include a valid collection `viewMode`.
- `PreferenceDimensions` and related types are contracts. The focused durable-preference port and PostgreSQL adapter persist explicit choices; runtime resolution remains separate.
- Preset recommendation and preference evolution helpers are deterministic utilities. They return explainable data for applications to display, log, confirm, or ignore.

## When not to use this package

- Do not use it as a full analytics warehouse or reporting system.
- Do not persist inferred or resolved adaptive state through the explicit durable preference port.
- Do not use it as the overlay runtime or overlay registry implementation.
- Do not use it when you need workflow composition itself; this package only emits adaptation hints.

## Related packages

- `@lssm-tech/lib.overlay-engine`: runtime for registering, validating, and applying overlays.
- `@lssm-tech/lib.surface-runtime`: runtime consumer of preference resolution and adaptive surface behavior.
- `@lssm-tech/lib.workflow-composer`: workflow extension and composition runtime.
- `@lssm-tech/lib.contracts-spec`: shared spec and docblock contracts used across ContractSpec.

## Local commands

- `bun run lint:check`
- `bun run typecheck`
- `bun run test`
- `bun run build`

## Rich code and diff preferences

`resolveRichCodePreferences` maps preference dimensions to governed code/diff presentation defaults: density, data depth, reference verbosity, context lines, and default expansion. The resolver is deterministic and runtime-only; it does not persist hidden profiles or bypass permissions.

Import it from the RichReference subpath introduced in slice S-4:

```ts
import { resolveRichCodePreferences } from "@lssm-tech/lib.personalization/rich-reference/preferences";
```


The legacy `./rich-code-preferences` subpath has been removed; the slice S-10 codemod handles the import rename.

## RichReference hybrid personalization

`@lssm-tech/lib.personalization/rich-reference` implements the `CoarsePreferencesProvider` port owned by `@lssm-tech/lib.contracts-spec/rich-reference/ports`. The model is two-layer by design:

- **Server-coarse** (`enrichedKinds`, `density`) resolves on the server via `createServerCoarsePreferencesResolver`, caches results by `(tenantId, subjectId, scopeHash)` for cross-tenant isolation, and is the only layer that ever appears in agent payloads.
- **Client-fine** (`verbosity`, `trigger`, `panelMode`, `expansion`, `perKindOptOut`) lives in a session-only store created via `createRichReferenceClientStore`. Mutations stay local until the consumer calls `persistPreferences()`, which invokes a persistence sink and emits a structured `rich-reference.preferences.persist` audit log event.

```ts
import {
  createServerCoarsePreferencesResolver,
  createRichReferenceClientStore,
  createUseRichReferencePreferences,
  resolveInherited,
  toAgentPayloadPreferences,
} from "@lssm-tech/lib.personalization/rich-reference";
```


`resolveInherited({ defaults, tenant, role, user, context })` applies explicit last-wins precedence per dimension. `toAgentPayloadPreferences(prefs)` strips fine-layer dimensions before serializing to an agent surface.

Published browser conditions select the emitted browser artifacts alongside
existing Node/Bun/type targets. Export keys and source behavior are preserved;
this packaging metadata does not activate providers or grant execution authority.


## Whole canonical preference contract suppliers

Preserve the complete existing preference, tracking, adaptive-surface, ontology and coarse-provider behavior and every original assertion. Bind the existing RichCodeDisplayPreferences family to its complete canonical PresentationRuntimeCore model and use existing Core, Kernel, Surface and Orchestration suppliers. Do not remove a declared dependency before its entire source and test return is closed.

This is a Source-only compatible ownership proposal. Fresh task-bound adoption, owning production, declarations, affected runtime tests and platform qualification remain required.


## Declared capabilities

### Lib Personalization

Capability ID: `package.lssm.tech.lib.personalization`

Behavior tracking, analysis, and adaptation helpers for ContractSpec personalization.

Use cases:

- Adopt behavior tracking, analysis, and adaptation helpers for contractspec personalization

Constraints:

```json
{
  "platforms": [
    "server"
  ],
  "runtimes": [
    "node"
  ],
  "avoidWhen": [
    "The @lssm-tech/lib.personalization package constraints do not match the target runtime or platform."
  ],
  "requires": [
    "TypeScript"
  ]
}
```

Other capability declarations:

```json
{
  "status": "active",
  "aliases": [
    "contractspec",
    "personalization",
    "behavior",
    "analytics",
    "adaptation",
    "typescript",
    "lib"
  ],
  "pythonEquivalents": [],
  "alternatives": [],
  "relationships": [],
  "resolutionPriority": 50
}
```

Capability imports:

```json
[
  {
    "from": "@lssm-tech/lib.personalization",
    "symbols": []
  },
  {
    "from": "@lssm-tech/lib.personalization/adapter",
    "symbols": []
  },
  {
    "from": "@lssm-tech/lib.personalization/adaptive-events",
    "symbols": []
  },
  {
    "from": "@lssm-tech/lib.personalization/adaptive-evolution",
    "symbols": []
  },
  {
    "from": "@lssm-tech/lib.personalization/adaptive-experience",
    "symbols": []
  },
  {
    "from": "@lssm-tech/lib.personalization/adaptive-experience-actions",
    "symbols": []
  },
  {
    "from": "@lssm-tech/lib.personalization/adaptive-experience-controls",
    "symbols": []
  },
  {
    "from": "@lssm-tech/lib.personalization/adaptive-explanations",
    "symbols": []
  },
  {
    "from": "@lssm-tech/lib.personalization/adaptive-onboarding",
    "symbols": []
  },
  {
    "from": "@lssm-tech/lib.personalization/adaptive-onboarding-flows",
    "symbols": []
  },
  {
    "from": "@lssm-tech/lib.personalization/adaptive-onboarding-scores",
    "symbols": []
  },
  {
    "from": "@lssm-tech/lib.personalization/adaptive-recipes",
    "symbols": []
  }
]
```

## Catalogue metadata

```json
{
  "family": "sharedLibs",
  "kind": "library",
  "status": "active",
  "adoptionMode": "adoptable",
  "stability": "stable",
  "platforms": [
    "server"
  ],
  "runtimes": [
    "node"
  ],
  "entrypoints": [
    ".",
    "./adapter",
    "./adaptive-events",
    "./adaptive-evolution",
    "./adaptive-experience",
    "./adaptive-experience-actions",
    "./adaptive-experience-controls",
    "./adaptive-explanations",
    "./adaptive-onboarding",
    "./adaptive-onboarding-flows",
    "./adaptive-onboarding-scores",
    "./adaptive-recipes",
    "./adaptive-recipes/integrations",
    "./adaptive-recipes/integrations/auditor-lens",
    "./adaptive-recipes/integrations/capability-matrix",
    "./adaptive-recipes/integrations/fixtures",
    "./adaptive-recipes/integrations/founder-lens",
    "./adaptive-recipes/integrations/integration-signals",
    "./adaptive-recipes/integrations/persona-profiles",
    "./adaptive-recipes/integrations/recommendations",
    "./adaptive-recipes/integrations/types",
    "./adaptive-shell",
    "./adaptive-surface",
    "./adaptive-templates",
    "./analyzer",
    "./analyzer-evaluation",
    "./audited-fine-tuning",
    "./behavior-signal-events",
    "./behavior-signal-events/emitter",
    "./behavior-signal-events/event-registry",
    "./behavior-signal-events/payload-policy",
    "./behavior-signals",
    "./behavior-support",
    "./behavior-support-preset-definitions",
    "./behavior-support-presets",
    "./data-view-preferences",
    "./denial-audit",
    "./docs",
    "./docs/behavior-tracking.docblock",
    "./docs/overlay-engine.docblock",
    "./docs/workflow-composition.docblock",
    "./durable-lifecycle",
    "./durable-preferences",
    "./fine-tuning-denial",
    "./fine-tuning-issuance",
    "./identity-lifecycle",
    "./ontology-trace",
    "./ontology-trace-types",
    "./personalization.feature",
    "./preference-dimensions",
    "./preference-dimensions-store",
    "./preference-evolution",
    "./preference-evolution-types",
    "./preference-onboarding",
    "./preference-presets",
    "./privacy",
    "./receipt-verification",
    "./rich-reference",
    "./rich-reference/client-hook",
    "./rich-reference/dimensions",
    "./rich-reference/inheritance",
    "./rich-reference/preferences",
    "./rich-reference/server-resolver",
    "./rights-decisions",
    "./rolemorph-adapter",
    "./store",
    "./support-surface",
    "./tracker",
    "./tracker-types",
    "./types"
  ],
  "examples": [],
  "replacements": []
}
```

## Canonical imports

Import paths and symbols below are catalogue declarations. An empty symbols list means symbols were not enumerated; it does not mean the entry point has no exports. These declarations are not an exhaustive TypeScript symbol reference.

```json
[
  {
    "capabilityId": "package.lssm.tech.lib.personalization",
    "from": "@lssm-tech/lib.personalization",
    "symbols": []
  },
  {
    "capabilityId": "package.lssm.tech.lib.personalization",
    "from": "@lssm-tech/lib.personalization/adapter",
    "symbols": []
  },
  {
    "capabilityId": "package.lssm.tech.lib.personalization",
    "from": "@lssm-tech/lib.personalization/adaptive-events",
    "symbols": []
  },
  {
    "capabilityId": "package.lssm.tech.lib.personalization",
    "from": "@lssm-tech/lib.personalization/adaptive-evolution",
    "symbols": []
  },
  {
    "capabilityId": "package.lssm.tech.lib.personalization",
    "from": "@lssm-tech/lib.personalization/adaptive-experience",
    "symbols": []
  },
  {
    "capabilityId": "package.lssm.tech.lib.personalization",
    "from": "@lssm-tech/lib.personalization/adaptive-experience-actions",
    "symbols": []
  },
  {
    "capabilityId": "package.lssm.tech.lib.personalization",
    "from": "@lssm-tech/lib.personalization/adaptive-experience-controls",
    "symbols": []
  },
  {
    "capabilityId": "package.lssm.tech.lib.personalization",
    "from": "@lssm-tech/lib.personalization/adaptive-explanations",
    "symbols": []
  },
  {
    "capabilityId": "package.lssm.tech.lib.personalization",
    "from": "@lssm-tech/lib.personalization/adaptive-onboarding",
    "symbols": []
  },
  {
    "capabilityId": "package.lssm.tech.lib.personalization",
    "from": "@lssm-tech/lib.personalization/adaptive-onboarding-flows",
    "symbols": []
  },
  {
    "capabilityId": "package.lssm.tech.lib.personalization",
    "from": "@lssm-tech/lib.personalization/adaptive-onboarding-scores",
    "symbols": []
  },
  {
    "capabilityId": "package.lssm.tech.lib.personalization",
    "from": "@lssm-tech/lib.personalization/adaptive-recipes",
    "symbols": []
  }
]
```

## Declared export entry points

Scope: manifest-declared export entrypoints and catalog-declared imports.

Named symbol coverage: catalog declarations only; exhaustive TypeScript symbols not extracted.

Installation status: not verified.

- `@lssm-tech/lib.personalization` — subpath `.`
  - `unconditional`: `./src/index.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/index.ts); verified source file.

- `@lssm-tech/lib.personalization/adapter` — subpath `./adapter`
  - `unconditional`: `./src/adapter.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adapter.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-events` — subpath `./adaptive-events`
  - `unconditional`: `./src/adaptive-events.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-events.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-evolution` — subpath `./adaptive-evolution`
  - `unconditional`: `./src/adaptive-evolution.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-evolution.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-experience` — subpath `./adaptive-experience`
  - `unconditional`: `./src/adaptive-experience.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-experience.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-experience-actions` — subpath `./adaptive-experience-actions`
  - `unconditional`: `./src/adaptive-experience-actions.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-experience-actions.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-experience-controls` — subpath `./adaptive-experience-controls`
  - `unconditional`: `./src/adaptive-experience-controls.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-experience-controls.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-explanations` — subpath `./adaptive-explanations`
  - `unconditional`: `./src/adaptive-explanations.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-explanations.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-onboarding` — subpath `./adaptive-onboarding`
  - `unconditional`: `./src/adaptive-onboarding.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-onboarding.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-onboarding-flows` — subpath `./adaptive-onboarding-flows`
  - `unconditional`: `./src/adaptive-onboarding-flows.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-onboarding-flows.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-onboarding-scores` — subpath `./adaptive-onboarding-scores`
  - `unconditional`: `./src/adaptive-onboarding-scores.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-onboarding-scores.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-recipes` — subpath `./adaptive-recipes`
  - `unconditional`: `./src/adaptive-recipes.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-recipes.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-recipes/integrations` — subpath `./adaptive-recipes/integrations`
  - `unconditional`: `./src/adaptive-recipes/integrations/index.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-recipes/integrations/index.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-recipes/integrations/auditor-lens` — subpath `./adaptive-recipes/integrations/auditor-lens`
  - `unconditional`: `./src/adaptive-recipes/integrations/auditor-lens.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-recipes/integrations/auditor-lens.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-recipes/integrations/capability-matrix` — subpath `./adaptive-recipes/integrations/capability-matrix`
  - `unconditional`: `./src/adaptive-recipes/integrations/capability-matrix.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-recipes/integrations/capability-matrix.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-recipes/integrations/fixtures` — subpath `./adaptive-recipes/integrations/fixtures`
  - `unconditional`: `./src/adaptive-recipes/integrations/fixtures.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-recipes/integrations/fixtures.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-recipes/integrations/founder-lens` — subpath `./adaptive-recipes/integrations/founder-lens`
  - `unconditional`: `./src/adaptive-recipes/integrations/founder-lens.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-recipes/integrations/founder-lens.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-recipes/integrations/integration-signals` — subpath `./adaptive-recipes/integrations/integration-signals`
  - `unconditional`: `./src/adaptive-recipes/integrations/integration-signals.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-recipes/integrations/integration-signals.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-recipes/integrations/persona-profiles` — subpath `./adaptive-recipes/integrations/persona-profiles`
  - `unconditional`: `./src/adaptive-recipes/integrations/persona-profiles.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-recipes/integrations/persona-profiles.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-recipes/integrations/recommendations` — subpath `./adaptive-recipes/integrations/recommendations`
  - `unconditional`: `./src/adaptive-recipes/integrations/recommendations.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-recipes/integrations/recommendations.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-recipes/integrations/types` — subpath `./adaptive-recipes/integrations/types`
  - `unconditional`: `./src/adaptive-recipes/integrations/types.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-recipes/integrations/types.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-shell` — subpath `./adaptive-shell`
  - `unconditional`: `./src/adaptive-shell.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-shell.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-surface` — subpath `./adaptive-surface`
  - `unconditional`: `./src/adaptive-surface.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-surface.ts); verified source file.

- `@lssm-tech/lib.personalization/adaptive-templates` — subpath `./adaptive-templates`
  - `unconditional`: `./src/adaptive-templates.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/adaptive-templates.ts); verified source file.

- `@lssm-tech/lib.personalization/analyzer` — subpath `./analyzer`
  - `unconditional`: `./src/analyzer.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/analyzer.ts); verified source file.

- `@lssm-tech/lib.personalization/analyzer-evaluation` — subpath `./analyzer-evaluation`
  - `unconditional`: `./src/analyzer-evaluation.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/analyzer-evaluation.ts); verified source file.

- `@lssm-tech/lib.personalization/audited-fine-tuning` — subpath `./audited-fine-tuning`
  - `unconditional`: `./src/audited-fine-tuning.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/audited-fine-tuning.ts); verified source file.

- `@lssm-tech/lib.personalization/behavior-signal-events` — subpath `./behavior-signal-events`
  - `unconditional`: `./src/behavior-signal-events/index.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/behavior-signal-events/index.ts); verified source file.

- `@lssm-tech/lib.personalization/behavior-signal-events/emitter` — subpath `./behavior-signal-events/emitter`
  - `unconditional`: `./src/behavior-signal-events/emitter.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/behavior-signal-events/emitter.ts); verified source file.

- `@lssm-tech/lib.personalization/behavior-signal-events/event-registry` — subpath `./behavior-signal-events/event-registry`
  - `unconditional`: `./src/behavior-signal-events/event-registry.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/behavior-signal-events/event-registry.ts); verified source file.

- `@lssm-tech/lib.personalization/behavior-signal-events/payload-policy` — subpath `./behavior-signal-events/payload-policy`
  - `unconditional`: `./src/behavior-signal-events/payload-policy.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/behavior-signal-events/payload-policy.ts); verified source file.

- `@lssm-tech/lib.personalization/behavior-signals` — subpath `./behavior-signals`
  - `unconditional`: `./src/behavior-signals.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/behavior-signals.ts); verified source file.

- `@lssm-tech/lib.personalization/behavior-support` — subpath `./behavior-support`
  - `unconditional`: `./src/behavior-support.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/behavior-support.ts); verified source file.

- `@lssm-tech/lib.personalization/behavior-support-preset-definitions` — subpath `./behavior-support-preset-definitions`
  - `unconditional`: `./src/behavior-support-preset-definitions.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/behavior-support-preset-definitions.ts); verified source file.

- `@lssm-tech/lib.personalization/behavior-support-presets` — subpath `./behavior-support-presets`
  - `unconditional`: `./src/behavior-support-presets.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/behavior-support-presets.ts); verified source file.

- `@lssm-tech/lib.personalization/data-view-preferences` — subpath `./data-view-preferences`
  - `unconditional`: `./src/data-view-preferences.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/data-view-preferences.ts); verified source file.

- `@lssm-tech/lib.personalization/denial-audit` — subpath `./denial-audit`
  - `unconditional`: `./src/denial-audit.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/denial-audit.ts); verified source file.

- `@lssm-tech/lib.personalization/docs` — subpath `./docs`
  - `unconditional`: `./src/docs/index.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/docs/index.ts); verified source file.

- `@lssm-tech/lib.personalization/docs/behavior-tracking.docblock` — subpath `./docs/behavior-tracking.docblock`
  - `unconditional`: `./src/docs/behavior-tracking.docblock.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/docs/behavior-tracking.docblock.ts); verified source file.

- `@lssm-tech/lib.personalization/docs/overlay-engine.docblock` — subpath `./docs/overlay-engine.docblock`
  - `unconditional`: `./src/docs/overlay-engine.docblock.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/docs/overlay-engine.docblock.ts); verified source file.

- `@lssm-tech/lib.personalization/docs/workflow-composition.docblock` — subpath `./docs/workflow-composition.docblock`
  - `unconditional`: `./src/docs/workflow-composition.docblock.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/docs/workflow-composition.docblock.ts); verified source file.

- `@lssm-tech/lib.personalization/durable-lifecycle` — subpath `./durable-lifecycle`
  - `unconditional`: `./src/durable-lifecycle.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/durable-lifecycle.ts); verified source file.

- `@lssm-tech/lib.personalization/durable-preferences` — subpath `./durable-preferences`
  - `unconditional`: `./src/durable-preferences.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/durable-preferences.ts); verified source file.

- `@lssm-tech/lib.personalization/fine-tuning-denial` — subpath `./fine-tuning-denial`
  - `unconditional`: `./src/fine-tuning-denial.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/fine-tuning-denial.ts); verified source file.

- `@lssm-tech/lib.personalization/fine-tuning-issuance` — subpath `./fine-tuning-issuance`
  - `unconditional`: `./src/fine-tuning-issuance.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/fine-tuning-issuance.ts); verified source file.

- `@lssm-tech/lib.personalization/identity-lifecycle` — subpath `./identity-lifecycle`
  - `unconditional`: `./src/identity-lifecycle.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/identity-lifecycle.ts); verified source file.

- `@lssm-tech/lib.personalization/ontology-trace` — subpath `./ontology-trace`
  - `unconditional`: `./src/ontology-trace.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/ontology-trace.ts); verified source file.

- `@lssm-tech/lib.personalization/ontology-trace-types` — subpath `./ontology-trace-types`
  - `unconditional`: `./src/ontology-trace-types.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/ontology-trace-types.ts); verified source file.

- `@lssm-tech/lib.personalization/personalization.feature` — subpath `./personalization.feature`
  - `unconditional`: `./src/personalization.feature.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/personalization.feature.ts); verified source file.

- `@lssm-tech/lib.personalization/preference-dimensions` — subpath `./preference-dimensions`
  - `unconditional`: `./src/preference-dimensions.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/preference-dimensions.ts); verified source file.

- `@lssm-tech/lib.personalization/preference-dimensions-store` — subpath `./preference-dimensions-store`
  - `unconditional`: `./src/preference-dimensions-store.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/preference-dimensions-store.ts); verified source file.

- `@lssm-tech/lib.personalization/preference-evolution` — subpath `./preference-evolution`
  - `unconditional`: `./src/preference-evolution.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/preference-evolution.ts); verified source file.

- `@lssm-tech/lib.personalization/preference-evolution-types` — subpath `./preference-evolution-types`
  - `unconditional`: `./src/preference-evolution-types.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/preference-evolution-types.ts); verified source file.

- `@lssm-tech/lib.personalization/preference-onboarding` — subpath `./preference-onboarding`
  - `unconditional`: `./src/preference-onboarding.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/preference-onboarding.ts); verified source file.

- `@lssm-tech/lib.personalization/preference-presets` — subpath `./preference-presets`
  - `unconditional`: `./src/preference-presets.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/preference-presets.ts); verified source file.

- `@lssm-tech/lib.personalization/privacy` — subpath `./privacy`
  - `unconditional`: `./src/privacy.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/privacy.ts); verified source file.

- `@lssm-tech/lib.personalization/receipt-verification` — subpath `./receipt-verification`
  - `unconditional`: `./src/receipt-verification.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/receipt-verification.ts); verified source file.

- `@lssm-tech/lib.personalization/rich-reference` — subpath `./rich-reference`
  - `unconditional`: `./src/rich-reference/index.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/rich-reference/index.ts); verified source file.

- `@lssm-tech/lib.personalization/rich-reference/client-hook` — subpath `./rich-reference/client-hook`
  - `unconditional`: `./src/rich-reference/client-hook.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/rich-reference/client-hook.ts); verified source file.

- `@lssm-tech/lib.personalization/rich-reference/dimensions` — subpath `./rich-reference/dimensions`
  - `unconditional`: `./src/rich-reference/dimensions.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/rich-reference/dimensions.ts); verified source file.

- `@lssm-tech/lib.personalization/rich-reference/inheritance` — subpath `./rich-reference/inheritance`
  - `unconditional`: `./src/rich-reference/inheritance.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/rich-reference/inheritance.ts); verified source file.

- `@lssm-tech/lib.personalization/rich-reference/preferences` — subpath `./rich-reference/preferences`
  - `unconditional`: `./src/rich-reference/preferences.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/rich-reference/preferences.ts); verified source file.

- `@lssm-tech/lib.personalization/rich-reference/server-resolver` — subpath `./rich-reference/server-resolver`
  - `unconditional`: `./src/rich-reference/server-resolver.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/rich-reference/server-resolver.ts); verified source file.

- `@lssm-tech/lib.personalization/rights-decisions` — subpath `./rights-decisions`
  - `unconditional`: `./src/rights-decisions.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/rights-decisions.ts); verified source file.

- `@lssm-tech/lib.personalization/rolemorph-adapter` — subpath `./rolemorph-adapter`
  - `unconditional`: `./src/rolemorph-adapter.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/rolemorph-adapter.ts); verified source file.

- `@lssm-tech/lib.personalization/store` — subpath `./store`
  - `unconditional`: `./src/store.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/store.ts); verified source file.

- `@lssm-tech/lib.personalization/support-surface` — subpath `./support-surface`
  - `unconditional`: `./src/support-surface.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/support-surface.ts); verified source file.

- `@lssm-tech/lib.personalization/tracker` — subpath `./tracker`
  - `unconditional`: `./src/tracker.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/tracker.ts); verified source file.

- `@lssm-tech/lib.personalization/tracker-types` — subpath `./tracker-types`
  - `unconditional`: `./src/tracker-types.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/tracker-types.ts); verified source file.

- `@lssm-tech/lib.personalization/types` — subpath `./types`
  - `unconditional`: `./src/types.ts` — [pinned source](https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/platform/ui/personalization/src/types.ts); verified source file.

## Package publication metadata

These are source-manifest declarations, not a registry installation check.

```json
{
  "types": "./dist/index.d.ts",
  "files": [
    "dist",
    "README.md"
  ],
  "publishExports": {
    ".": {
      "types": "./dist/index.d.ts",
      "browser": "./dist/browser/index.js",
      "bun": "./dist/index.js",
      "node": "./dist/node/index.js",
      "default": "./dist/index.js"
    },
    "./adapter": {
      "types": "./dist/adapter.d.ts",
      "browser": "./dist/browser/adapter.js",
      "bun": "./dist/adapter.js",
      "node": "./dist/node/adapter.js",
      "default": "./dist/adapter.js"
    },
    "./adaptive-events": {
      "types": "./dist/adaptive-events.d.ts",
      "browser": "./dist/browser/adaptive-events.js",
      "bun": "./dist/adaptive-events.js",
      "node": "./dist/node/adaptive-events.js",
      "default": "./dist/adaptive-events.js"
    },
    "./adaptive-evolution": {
      "types": "./dist/adaptive-evolution.d.ts",
      "browser": "./dist/browser/adaptive-evolution.js",
      "bun": "./dist/adaptive-evolution.js",
      "node": "./dist/node/adaptive-evolution.js",
      "default": "./dist/adaptive-evolution.js"
    },
    "./adaptive-experience": {
      "types": "./dist/adaptive-experience.d.ts",
      "browser": "./dist/browser/adaptive-experience.js",
      "bun": "./dist/adaptive-experience.js",
      "node": "./dist/node/adaptive-experience.js",
      "default": "./dist/adaptive-experience.js"
    },
    "./adaptive-experience-actions": {
      "types": "./dist/adaptive-experience-actions.d.ts",
      "browser": "./dist/browser/adaptive-experience-actions.js",
      "bun": "./dist/adaptive-experience-actions.js",
      "node": "./dist/node/adaptive-experience-actions.js",
      "default": "./dist/adaptive-experience-actions.js"
    },
    "./adaptive-experience-controls": {
      "types": "./dist/adaptive-experience-controls.d.ts",
      "browser": "./dist/browser/adaptive-experience-controls.js",
      "bun": "./dist/adaptive-experience-controls.js",
      "node": "./dist/node/adaptive-experience-controls.js",
      "default": "./dist/adaptive-experience-controls.js"
    },
    "./adaptive-explanations": {
      "types": "./dist/adaptive-explanations.d.ts",
      "browser": "./dist/browser/adaptive-explanations.js",
      "bun": "./dist/adaptive-explanations.js",
      "node": "./dist/node/adaptive-explanations.js",
      "default": "./dist/adaptive-explanations.js"
    },
    "./adaptive-onboarding": {
      "types": "./dist/adaptive-onboarding.d.ts",
      "browser": "./dist/browser/adaptive-onboarding.js",
      "bun": "./dist/adaptive-onboarding.js",
      "node": "./dist/node/adaptive-onboarding.js",
      "default": "./dist/adaptive-onboarding.js"
    },
    "./adaptive-onboarding-flows": {
      "types": "./dist/adaptive-onboarding-flows.d.ts",
      "browser": "./dist/browser/adaptive-onboarding-flows.js",
      "bun": "./dist/adaptive-onboarding-flows.js",
      "node": "./dist/node/adaptive-onboarding-flows.js",
      "default": "./dist/adaptive-onboarding-flows.js"
    },
    "./adaptive-onboarding-scores": {
      "types": "./dist/adaptive-onboarding-scores.d.ts",
      "browser": "./dist/browser/adaptive-onboarding-scores.js",
      "bun": "./dist/adaptive-onboarding-scores.js",
      "node": "./dist/node/adaptive-onboarding-scores.js",
      "default": "./dist/adaptive-onboarding-scores.js"
    },
    "./adaptive-recipes": {
      "types": "./dist/adaptive-recipes.d.ts",
      "browser": "./dist/browser/adaptive-recipes.js",
      "bun": "./dist/adaptive-recipes.js",
      "node": "./dist/node/adaptive-recipes.js",
      "default": "./dist/adaptive-recipes.js"
    },
    "./adaptive-recipes/integrations": {
      "types": "./dist/adaptive-recipes/integrations/index.d.ts",
      "browser": "./dist/browser/adaptive-recipes/integrations/index.js",
      "bun": "./dist/adaptive-recipes/integrations/index.js",
      "node": "./dist/node/adaptive-recipes/integrations/index.js",
      "default": "./dist/adaptive-recipes/integrations/index.js"
    },
    "./adaptive-recipes/integrations/auditor-lens": {
      "types": "./dist/adaptive-recipes/integrations/auditor-lens.d.ts",
      "browser": "./dist/browser/adaptive-recipes/integrations/auditor-lens.js",
      "bun": "./dist/adaptive-recipes/integrations/auditor-lens.js",
      "node": "./dist/node/adaptive-recipes/integrations/auditor-lens.js",
      "default": "./dist/adaptive-recipes/integrations/auditor-lens.js"
    },
    "./adaptive-recipes/integrations/capability-matrix": {
      "types": "./dist/adaptive-recipes/integrations/capability-matrix.d.ts",
      "browser": "./dist/browser/adaptive-recipes/integrations/capability-matrix.js",
      "bun": "./dist/adaptive-recipes/integrations/capability-matrix.js",
      "node": "./dist/node/adaptive-recipes/integrations/capability-matrix.js",
      "default": "./dist/adaptive-recipes/integrations/capability-matrix.js"
    },
    "./adaptive-recipes/integrations/fixtures": {
      "types": "./dist/adaptive-recipes/integrations/fixtures.d.ts",
      "browser": "./dist/browser/adaptive-recipes/integrations/fixtures.js",
      "bun": "./dist/adaptive-recipes/integrations/fixtures.js",
      "node": "./dist/node/adaptive-recipes/integrations/fixtures.js",
      "default": "./dist/adaptive-recipes/integrations/fixtures.js"
    },
    "./adaptive-recipes/integrations/founder-lens": {
      "types": "./dist/adaptive-recipes/integrations/founder-lens.d.ts",
      "browser": "./dist/browser/adaptive-recipes/integrations/founder-lens.js",
      "bun": "./dist/adaptive-recipes/integrations/founder-lens.js",
      "node": "./dist/node/adaptive-recipes/integrations/founder-lens.js",
      "default": "./dist/adaptive-recipes/integrations/founder-lens.js"
    },
    "./adaptive-recipes/integrations/integration-signals": {
      "types": "./dist/adaptive-recipes/integrations/integration-signals.d.ts",
      "browser": "./dist/browser/adaptive-recipes/integrations/integration-signals.js",
      "bun": "./dist/adaptive-recipes/integrations/integration-signals.js",
      "node": "./dist/node/adaptive-recipes/integrations/integration-signals.js",
      "default": "./dist/adaptive-recipes/integrations/integration-signals.js"
    },
    "./adaptive-recipes/integrations/persona-profiles": {
      "types": "./dist/adaptive-recipes/integrations/persona-profiles.d.ts",
      "browser": "./dist/browser/adaptive-recipes/integrations/persona-profiles.js",
      "bun": "./dist/adaptive-recipes/integrations/persona-profiles.js",
      "node": "./dist/node/adaptive-recipes/integrations/persona-profiles.js",
      "default": "./dist/adaptive-recipes/integrations/persona-profiles.js"
    },
    "./adaptive-recipes/integrations/recommendations": {
      "types": "./dist/adaptive-recipes/integrations/recommendations.d.ts",
      "browser": "./dist/browser/adaptive-recipes/integrations/recommendations.js",
      "bun": "./dist/adaptive-recipes/integrations/recommendations.js",
      "node": "./dist/node/adaptive-recipes/integrations/recommendations.js",
      "default": "./dist/adaptive-recipes/integrations/recommendations.js"
    },
    "./adaptive-recipes/integrations/types": {
      "types": "./dist/adaptive-recipes/integrations/types.d.ts",
      "browser": "./dist/browser/adaptive-recipes/integrations/types.js",
      "bun": "./dist/adaptive-recipes/integrations/types.js",
      "node": "./dist/node/adaptive-recipes/integrations/types.js",
      "default": "./dist/adaptive-recipes/integrations/types.js"
    },
    "./adaptive-shell": {
      "types": "./dist/adaptive-shell.d.ts",
      "browser": "./dist/browser/adaptive-shell.js",
      "bun": "./dist/adaptive-shell.js",
      "node": "./dist/node/adaptive-shell.js",
      "default": "./dist/adaptive-shell.js"
    },
    "./adaptive-surface": {
      "types": "./dist/adaptive-surface.d.ts",
      "browser": "./dist/browser/adaptive-surface.js",
      "bun": "./dist/adaptive-surface.js",
      "node": "./dist/node/adaptive-surface.js",
      "default": "./dist/adaptive-surface.js"
    },
    "./adaptive-templates": {
      "types": "./dist/adaptive-templates.d.ts",
      "browser": "./dist/browser/adaptive-templates.js",
      "bun": "./dist/adaptive-templates.js",
      "node": "./dist/node/adaptive-templates.js",
      "default": "./dist/adaptive-templates.js"
    },
    "./analyzer": {
      "types": "./dist/analyzer.d.ts",
      "browser": "./dist/browser/analyzer.js",
      "bun": "./dist/analyzer.js",
      "node": "./dist/node/analyzer.js",
      "default": "./dist/analyzer.js"
    },
    "./analyzer-evaluation": {
      "types": "./dist/analyzer-evaluation.d.ts",
      "browser": "./dist/browser/analyzer-evaluation.js",
      "bun": "./dist/analyzer-evaluation.js",
      "node": "./dist/node/analyzer-evaluation.js",
      "default": "./dist/analyzer-evaluation.js"
    },
    "./audited-fine-tuning": {
      "types": "./dist/audited-fine-tuning.d.ts",
      "browser": "./dist/browser/audited-fine-tuning.js",
      "bun": "./dist/audited-fine-tuning.js",
      "node": "./dist/node/audited-fine-tuning.js",
      "default": "./dist/audited-fine-tuning.js"
    },
    "./behavior-signal-events": {
      "types": "./dist/behavior-signal-events/index.d.ts",
      "browser": "./dist/browser/behavior-signal-events/index.js",
      "bun": "./dist/behavior-signal-events/index.js",
      "node": "./dist/node/behavior-signal-events/index.js",
      "default": "./dist/behavior-signal-events/index.js"
    },
    "./behavior-signal-events/emitter": {
      "types": "./dist/behavior-signal-events/emitter.d.ts",
      "browser": "./dist/browser/behavior-signal-events/emitter.js",
      "bun": "./dist/behavior-signal-events/emitter.js",
      "node": "./dist/node/behavior-signal-events/emitter.js",
      "default": "./dist/behavior-signal-events/emitter.js"
    },
    "./behavior-signal-events/event-registry": {
      "types": "./dist/behavior-signal-events/event-registry.d.ts",
      "browser": "./dist/browser/behavior-signal-events/event-registry.js",
      "bun": "./dist/behavior-signal-events/event-registry.js",
      "node": "./dist/node/behavior-signal-events/event-registry.js",
      "default": "./dist/behavior-signal-events/event-registry.js"
    },
    "./behavior-signal-events/payload-policy": {
      "types": "./dist/behavior-signal-events/payload-policy.d.ts",
      "browser": "./dist/browser/behavior-signal-events/payload-policy.js",
      "bun": "./dist/behavior-signal-events/payload-policy.js",
      "node": "./dist/node/behavior-signal-events/payload-policy.js",
      "default": "./dist/behavior-signal-events/payload-policy.js"
    },
    "./behavior-signals": {
      "types": "./dist/behavior-signals.d.ts",
      "browser": "./dist/browser/behavior-signals.js",
      "bun": "./dist/behavior-signals.js",
      "node": "./dist/node/behavior-signals.js",
      "default": "./dist/behavior-signals.js"
    },
    "./behavior-support": {
      "types": "./dist/behavior-support.d.ts",
      "browser": "./dist/browser/behavior-support.js",
      "bun": "./dist/behavior-support.js",
      "node": "./dist/node/behavior-support.js",
      "default": "./dist/behavior-support.js"
    },
    "./behavior-support-preset-definitions": {
      "types": "./dist/behavior-support-preset-definitions.d.ts",
      "browser": "./dist/browser/behavior-support-preset-definitions.js",
      "bun": "./dist/behavior-support-preset-definitions.js",
      "node": "./dist/node/behavior-support-preset-definitions.js",
      "default": "./dist/behavior-support-preset-definitions.js"
    },
    "./behavior-support-presets": {
      "types": "./dist/behavior-support-presets.d.ts",
      "browser": "./dist/browser/behavior-support-presets.js",
      "bun": "./dist/behavior-support-presets.js",
      "node": "./dist/node/behavior-support-presets.js",
      "default": "./dist/behavior-support-presets.js"
    },
    "./data-view-preferences": {
      "types": "./dist/data-view-preferences.d.ts",
      "browser": "./dist/browser/data-view-preferences.js",
      "bun": "./dist/data-view-preferences.js",
      "node": "./dist/node/data-view-preferences.js",
      "default": "./dist/data-view-preferences.js"
    },
    "./denial-audit": {
      "types": "./dist/denial-audit.d.ts",
      "browser": "./dist/browser/denial-audit.js",
      "bun": "./dist/denial-audit.js",
      "node": "./dist/node/denial-audit.js",
      "default": "./dist/denial-audit.js"
    },
    "./docs": {
      "types": "./dist/docs/index.d.ts",
      "browser": "./dist/browser/docs/index.js",
      "bun": "./dist/docs/index.js",
      "node": "./dist/node/docs/index.js",
      "default": "./dist/docs/index.js"
    },
    "./docs/behavior-tracking.docblock": {
      "types": "./dist/docs/behavior-tracking.docblock.d.ts",
      "browser": "./dist/browser/docs/behavior-tracking.docblock.js",
      "bun": "./dist/docs/behavior-tracking.docblock.js",
      "node": "./dist/node/docs/behavior-tracking.docblock.js",
      "default": "./dist/docs/behavior-tracking.docblock.js"
    },
    "./docs/overlay-engine.docblock": {
      "types": "./dist/docs/overlay-engine.docblock.d.ts",
      "browser": "./dist/browser/docs/overlay-engine.docblock.js",
      "bun": "./dist/docs/overlay-engine.docblock.js",
      "node": "./dist/node/docs/overlay-engine.docblock.js",
      "default": "./dist/docs/overlay-engine.docblock.js"
    },
    "./docs/workflow-composition.docblock": {
      "types": "./dist/docs/workflow-composition.docblock.d.ts",
      "browser": "./dist/browser/docs/workflow-composition.docblock.js",
      "bun": "./dist/docs/workflow-composition.docblock.js",
      "node": "./dist/node/docs/workflow-composition.docblock.js",
      "default": "./dist/docs/workflow-composition.docblock.js"
    },
    "./durable-lifecycle": {
      "types": "./dist/durable-lifecycle.d.ts",
      "browser": "./dist/browser/durable-lifecycle.js",
      "bun": "./dist/durable-lifecycle.js",
      "node": "./dist/node/durable-lifecycle.js",
      "default": "./dist/durable-lifecycle.js"
    },
    "./durable-preferences": {
      "types": "./dist/durable-preferences.d.ts",
      "browser": "./dist/browser/durable-preferences.js",
      "bun": "./dist/durable-preferences.js",
      "node": "./dist/node/durable-preferences.js",
      "default": "./dist/durable-preferences.js"
    },
    "./fine-tuning-denial": {
      "types": "./dist/fine-tuning-denial.d.ts",
      "browser": "./dist/browser/fine-tuning-denial.js",
      "bun": "./dist/fine-tuning-denial.js",
      "node": "./dist/node/fine-tuning-denial.js",
      "default": "./dist/fine-tuning-denial.js"
    },
    "./fine-tuning-issuance": {
      "types": "./dist/fine-tuning-issuance.d.ts",
      "browser": "./dist/browser/fine-tuning-issuance.js",
      "bun": "./dist/fine-tuning-issuance.js",
      "node": "./dist/node/fine-tuning-issuance.js",
      "default": "./dist/fine-tuning-issuance.js"
    },
    "./identity-lifecycle": {
      "types": "./dist/identity-lifecycle.d.ts",
      "browser": "./dist/browser/identity-lifecycle.js",
      "bun": "./dist/identity-lifecycle.js",
      "node": "./dist/node/identity-lifecycle.js",
      "default": "./dist/identity-lifecycle.js"
    },
    "./ontology-trace": {
      "types": "./dist/ontology-trace.d.ts",
      "browser": "./dist/browser/ontology-trace.js",
      "bun": "./dist/ontology-trace.js",
      "node": "./dist/node/ontology-trace.js",
      "default": "./dist/ontology-trace.js"
    },
    "./ontology-trace-types": {
      "types": "./dist/ontology-trace-types.d.ts",
      "browser": "./dist/browser/ontology-trace-types.js",
      "bun": "./dist/ontology-trace-types.js",
      "node": "./dist/node/ontology-trace-types.js",
      "default": "./dist/ontology-trace-types.js"
    },
    "./personalization.feature": {
      "types": "./dist/personalization.feature.d.ts",
      "browser": "./dist/browser/personalization.feature.js",
      "bun": "./dist/personalization.feature.js",
      "node": "./dist/node/personalization.feature.js",
      "default": "./dist/personalization.feature.js"
    },
    "./preference-dimensions": {
      "types": "./dist/preference-dimensions.d.ts",
      "browser": "./dist/browser/preference-dimensions.js",
      "bun": "./dist/preference-dimensions.js",
      "node": "./dist/node/preference-dimensions.js",
      "default": "./dist/preference-dimensions.js"
    },
    "./preference-dimensions-store": {
      "types": "./dist/preference-dimensions-store.d.ts",
      "browser": "./dist/browser/preference-dimensions-store.js",
      "bun": "./dist/preference-dimensions-store.js",
      "node": "./dist/node/preference-dimensions-store.js",
      "default": "./dist/preference-dimensions-store.js"
    },
    "./preference-evolution": {
      "types": "./dist/preference-evolution.d.ts",
      "browser": "./dist/browser/preference-evolution.js",
      "bun": "./dist/preference-evolution.js",
      "node": "./dist/node/preference-evolution.js",
      "default": "./dist/preference-evolution.js"
    },
    "./preference-evolution-types": {
      "types": "./dist/preference-evolution-types.d.ts",
      "browser": "./dist/browser/preference-evolution-types.js",
      "bun": "./dist/preference-evolution-types.js",
      "node": "./dist/node/preference-evolution-types.js",
      "default": "./dist/preference-evolution-types.js"
    },
    "./preference-onboarding": {
      "types": "./dist/preference-onboarding.d.ts",
      "browser": "./dist/browser/preference-onboarding.js",
      "bun": "./dist/preference-onboarding.js",
      "node": "./dist/node/preference-onboarding.js",
      "default": "./dist/preference-onboarding.js"
    },
    "./preference-presets": {
      "types": "./dist/preference-presets.d.ts",
      "browser": "./dist/browser/preference-presets.js",
      "bun": "./dist/preference-presets.js",
      "node": "./dist/node/preference-presets.js",
      "default": "./dist/preference-presets.js"
    },
    "./privacy": {
      "types": "./dist/privacy.d.ts",
      "browser": "./dist/browser/privacy.js",
      "bun": "./dist/privacy.js",
      "node": "./dist/node/privacy.js",
      "default": "./dist/privacy.js"
    },
    "./receipt-verification": {
      "types": "./dist/receipt-verification.d.ts",
      "browser": "./dist/browser/receipt-verification.js",
      "bun": "./dist/receipt-verification.js",
      "node": "./dist/node/receipt-verification.js",
      "default": "./dist/receipt-verification.js"
    },
    "./rich-reference": {
      "types": "./dist/rich-reference/index.d.ts",
      "browser": "./dist/browser/rich-reference/index.js",
      "bun": "./dist/rich-reference/index.js",
      "node": "./dist/node/rich-reference/index.js",
      "default": "./dist/rich-reference/index.js"
    },
    "./rich-reference/client-hook": {
      "types": "./dist/rich-reference/client-hook.d.ts",
      "browser": "./dist/browser/rich-reference/client-hook.js",
      "bun": "./dist/rich-reference/client-hook.js",
      "node": "./dist/node/rich-reference/client-hook.js",
      "default": "./dist/rich-reference/client-hook.js"
    },
    "./rich-reference/dimensions": {
      "types": "./dist/rich-reference/dimensions.d.ts",
      "browser": "./dist/browser/rich-reference/dimensions.js",
      "bun": "./dist/rich-reference/dimensions.js",
      "node": "./dist/node/rich-reference/dimensions.js",
      "default": "./dist/rich-reference/dimensions.js"
    },
    "./rich-reference/inheritance": {
      "types": "./dist/rich-reference/inheritance.d.ts",
      "browser": "./dist/browser/rich-reference/inheritance.js",
      "bun": "./dist/rich-reference/inheritance.js",
      "node": "./dist/node/rich-reference/inheritance.js",
      "default": "./dist/rich-reference/inheritance.js"
    },
    "./rich-reference/preferences": {
      "types": "./dist/rich-reference/preferences.d.ts",
      "browser": "./dist/browser/rich-reference/preferences.js",
      "bun": "./dist/rich-reference/preferences.js",
      "node": "./dist/node/rich-reference/preferences.js",
      "default": "./dist/rich-reference/preferences.js"
    },
    "./rich-reference/server-resolver": {
      "types": "./dist/rich-reference/server-resolver.d.ts",
      "browser": "./dist/browser/rich-reference/server-resolver.js",
      "bun": "./dist/rich-reference/server-resolver.js",
      "node": "./dist/node/rich-reference/server-resolver.js",
      "default": "./dist/rich-reference/server-resolver.js"
    },
    "./rights-decisions": {
      "types": "./dist/rights-decisions.d.ts",
      "browser": "./dist/browser/rights-decisions.js",
      "bun": "./dist/rights-decisions.js",
      "node": "./dist/node/rights-decisions.js",
      "default": "./dist/rights-decisions.js"
    },
    "./rolemorph-adapter": {
      "types": "./dist/rolemorph-adapter.d.ts",
      "browser": "./dist/browser/rolemorph-adapter.js",
      "bun": "./dist/rolemorph-adapter.js",
      "node": "./dist/node/rolemorph-adapter.js",
      "default": "./dist/rolemorph-adapter.js"
    },
    "./store": {
      "types": "./dist/store.d.ts",
      "browser": "./dist/browser/store.js",
      "bun": "./dist/store.js",
      "node": "./dist/node/store.js",
      "default": "./dist/store.js"
    },
    "./support-surface": {
      "types": "./dist/support-surface.d.ts",
      "browser": "./dist/browser/support-surface.js",
      "bun": "./dist/support-surface.js",
      "node": "./dist/node/support-surface.js",
      "default": "./dist/support-surface.js"
    },
    "./tracker": {
      "types": "./dist/tracker.d.ts",
      "browser": "./dist/browser/tracker.js",
      "bun": "./dist/tracker.js",
      "node": "./dist/node/tracker.js",
      "default": "./dist/tracker.js"
    },
    "./tracker-types": {
      "types": "./dist/tracker-types.d.ts",
      "browser": "./dist/browser/tracker-types.js",
      "bun": "./dist/tracker-types.js",
      "node": "./dist/node/tracker-types.js",
      "default": "./dist/tracker-types.js"
    },
    "./types": {
      "types": "./dist/types.d.ts",
      "browser": "./dist/browser/types.js",
      "bun": "./dist/types.js",
      "node": "./dist/node/types.js",
      "default": "./dist/types.js"
    }
  }
}
```

## Dependencies

Metadata status: complete pinned manifest.

### Runtime dependencies

- [@lssm-tech/lib.contracts-runtime-kernel](https://lssm.co/docs/packages/lib.contracts-runtime-kernel/): `workspace:^`
- [@lssm-tech/lib.contracts-spec-core](https://lssm.co/docs/packages/lib.contracts-spec-core/): `workspace:^`
- [@lssm-tech/lib.overlay-engine](https://lssm.co/docs/packages/lib.overlay-engine/): `workspace:^`
- [@lssm-tech/lib.presentation-runtime-core](https://lssm.co/docs/packages/lib.presentation-runtime-core/): `workspace:^`
- [@lssm-tech/lib.surface-runtime](https://lssm.co/docs/packages/lib.surface-runtime/): `workspace:^`

### Peer dependencies

- `@opentelemetry/api`: `^1.9.1`

### Optional dependencies

No declarations in the inspected manifest.

### Development dependencies

- [@lssm-tech/tool.bun](https://lssm.co/docs/packages/tool.bun/): `workspace:*`
- [@lssm-tech/tool.typescript](https://lssm.co/docs/packages/tool.typescript/): `workspace:*`
- `@opentelemetry/api`: `^1.9.1`
- `typescript`: `catalog:`

### Peer dependency metadata

```json
{}
```

### Bundled dependencies

```json
null
```

## Package scripts

Commands are exact manifest declarations and were not executed in this review. Script metadata status: complete pinned manifest.

```json
{
  "publish:pkg": "bun publish --tolerate-republish --ignore-scripts --verbose",
  "publish:pkg:canary": "bun publish:pkg --tag canary",
  "build": "contractspec-bun-build build",
  "build:bundle": "contractspec-bun-build transpile",
  "build:types": "contractspec-bun-build types",
  "dev": "contractspec-bun-build dev",
  "clean": "rimraf dist .turbo",
  "lint": "bun lint:fix",
  "lint:fix": "node ../../../../scripts/biome.cjs check --write --unsafe --only=nursery/useSortedClasses . && node ../../../../scripts/biome.cjs check --write .",
  "lint:check": "node ../../../../scripts/biome.cjs check .",
  "test": "bun test --pass-with-no-tests",
  "prebuild": "contractspec-bun-build prebuild",
  "typecheck": "tsgo --noEmit"
}
```

## Declared documentation links

- [Lib Personalization documentation](https://www.npmjs.com/package/%40lssm-tech%2Flib.personalization) — declared link; destination not verified.

```json
{
  "url": "https://www.npmjs.com/package/%40lssm-tech%2Flib.personalization",
  "kind": "readme"
}
```

## Existing agent-guide projection

```json
{
  "path": "packages/apps/web-landing/public/llms-packages/lib.personalization.txt",
  "route": "/llms/lib.personalization",
  "sourceUrl": "https://github.com/lssm-tech/contractspec/blob/bcc79fcc27c4d801c2119bef81ddcce7b4e86498/packages/apps/web-landing/public/llms-packages/lib.personalization.txt",
  "blobSha": "dbb0a09b13e6a6903158cb5daabb43c74ebc271f",
  "sourcePin": "bcc79fcc27c4d801c2119bef81ddcce7b4e86498",
  "bodyEqualsReadme": true,
  "aggregateSourcePath": "packages/apps/web-landing/public/llms-full.txt",
  "aggregateBlobSha": "691b1d33efee24c440598b9106c81432f56aafaf"
}
```