@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2026 Fractal Synapse Labs LCA PBC
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -1,86 +1,8 @@
 # `@treeseed/sdk`
 
-`@treeseed/sdk` is the main programmatic interface for Treeseed content, control-plane state, and graph-first AI context retrieval.
+`@treeseed/sdk` is TreeSeed's portable contract and remote API package. It gives API, CLI, Agent, browser, and external integrations one versioned description of the control plane and typed conduits to remote TreeSeed and TreeDX services.
 
-For most consumers, the right entrypoint is `AgentSdk`.
-
-Use the SDK when you are writing automation, services, scripts, agents, or package internals that need Treeseed data, graph, workflow, config, reconciliation, hosting, package, or TreeDX integration primitives. Use the CLI when you want an operator command. Use Admin when you want a browser UI. Use API when you need the deployed backend service. Use UI when you need reusable components.
-
-## How SDK Fits With Treeseed
-
-The SDK is the shared platform substrate used by:
-
-- `@treeseed/core` for site runtime, content, plugin, and hosting integration
-- `@treeseed/admin` for admin contracts, view models, API facades, and platform primitives
-- `@treeseed/api` for backend contracts, reconciliation, operation state, and shared data models
-- `@treeseed/cli` for workflow, config, hosting, release, and reconciliation commands
-- `@treeseed/agent` for provider runtime consumption of shared contracts
-- root `@treeseed/market` for tenant config, content, and hosted workflow integration
-
-The SDK is not a UI package, admin portal, backend server, CLI parser, capacity-provider runtime, AgentKernel runtime, or ecommerce implementation. See the root [Package Ownership](../../docs/package-ownership.md) guide for the full system map.
-
-## Which Surface Should I Use?
-
-Treeseed exposes three public SDK surfaces, but they are not peers:
-
-| Surface | Role | Use It For |
-| --- | --- | --- |
-| `AgentSdk` | Primary | application code, workers, scripts, API handlers, graph-first context retrieval |
-| `ScopedAgentSdk` | Operational | agent-runtime code that must enforce model permissions and inject actor identity |
-| `ContentGraphRuntime` | Advanced | low-level graph-only integrations that want the graph engine without the rest of the SDK |
-
-If you are unsure, use `AgentSdk`.
-
-## Major Capability Groups
-
-`AgentSdk` covers five main areas:
-
-- generic model reads and mutations across content-backed models and the static-hub D1 form store
-- operational runtime state such as messages, runs, cursors, and leases
-- control-plane orchestration for work days, tasks, task events, graph runs, and reports
-- provider-neutral capacity and assignment contracts for allocation sets, project agent classes, kernel policy/profile, capacity envelopes, provider sessions, assignments, mode runs, reservations, estimates, checkpoints, and usage actuals
-- hosting graph compilation, deployment readiness, live hosted-service checks, Treeseed runner smoke helpers, and verification cache support for Treeseed workflows
-- graph-first context retrieval through `parseGraphDsl()`, `resolveSeeds()`, `queryGraph()`, and `buildContextPack()`
-- agent scoping through `scopeForAgent()`
-
-## Workflow And Hosting Support
-
-The SDK owns the shared implementation behind the fail-fast `trsd` deployment workflow.
-It also owns the canonical reconciliation platform for desired-state infrastructure. See the root workspace `docs/reconciliation-platform.md` for the full contract.
-
-Current workflow-support exports include:
-
-```ts
-import {
-  collectTreeseedDeploymentReadiness,
-  collectTreeseedLiveHostedServiceChecks,
-  formatTreeseedReadinessReport,
-  runTreeseedOperationsRunnerSmoke,
-} from '@treeseed/sdk/workflow-support';
-```
-
-These helpers are used by:
-
-- `trsd ready <local|staging|prod>`
-- `trsd hosting plan|apply|verify --environment <env> --service <id>`
-- `trsd audit hosting --environment <env> --live`
-- `trsd doctor --live --hosted-services`
-- `trsd operations smoke --environment <env> --service operationsRunner`
-- `trsd stage --verify action|local|none`
-- `trsd release --verify-deployed-resources`
-
-`trsd stage` is branch/ref promotion. It merges `staging` down into the feature branch, runs local proof by default, promotes exact verified refs to staging, and leaves hosted CI/CD/provider repair to the staging release workflow. Hosted reconciliation and live deployed-resource verification remain owned by hosting, release, and explicit verification commands.
-
-For the API app, the expected hosted backend services are the API service, indexed Treeseed operations runner, PostgreSQL, and public TreeDX federation nodes owned by `packages/api`. The root web app remains a web UI and `/v1/*` proxy/client surface, with admin routes contributed by `@treeseed/admin` and visual primitives contributed by `@treeseed/ui`.
-
-Reconciliation guarantees:
-
-- command surfaces compile desired resources before provider mutation
-- cached state can locate resources but live observation proves readiness
-- hosted apply cannot report `ok: true` when live postconditions fail
-- adapter reports use `desiredGraph`, `observedGraph`, `stateGraph`, `diff`, `actions`, `postconditions`, `blockedDrift`, `providerLimitations`, `liveVerification`, and `ok`
-
-Agent capacity architecture is documented in the root workspace [Agent Capacity Implementation Roadmap](../../docs/agent-capacity-implementation-roadmap.md) and [Agent Capacity Domain Model](../../docs/agent-capacity-domain-model.md). SDK owns the portable contracts only; API owns durable coordination records and `@treeseed/agent` owns runtime execution.
+The SDK does not own control-plane persistence, scheduling, repository mutation, content publication, deployment, provider runtimes, or server-side business workflows. Those implementations belong to the API or their dedicated runtime packages.
 
 ## Install
 
@@ -88,313 +10,65 @@ Agent capacity architecture is documented in the root workspace [Agent Capacity
 npm install @treeseed/sdk
 ```
 
-Consumer contract:
-
-- Node `>=22`
-- ESM package
-- import from the package root or documented subpath exports
-
-## Quickstart
-
-```ts
-import { AgentSdk } from '@treeseed/sdk/sdk';
-
-const sdk = new AgentSdk({
-  repoRoot: '/absolute/path/to/your-site',
-});
-```
+Requirements: Node.js 22 or newer and ESM.
 
-Use `AgentSdk.createLocal()` when you want the local static-hub D1 form store:
+## Control-plane API
 
 ```ts
-import { AgentSdk } from '@treeseed/sdk/sdk';
+import {
+  ControlPlaneClient,
+  defaultLocalControlPlaneServer,
+} from '@treeseed/sdk/control-plane-client';
 
-const sdk = AgentSdk.createLocal({
-  repoRoot: '/absolute/path/to/your-site',
-  databaseName: 'treeseed-local',
-  persistTo: '.wrangler/state/v3/d1',
+const client = new ControlPlaneClient({
+  profile: defaultLocalControlPlaneServer(),
+  accessToken: process.env.TREESEED_ACCESS_TOKEN,
 });
-```
-
-## TreeDX Content Repository
-
-TreeDX is the generic repository service used by Treeseed when TreeDX service configuration is available. The SDK is the Treeseed integration and client layer: it configures the TreeDX portfolio, maps Treeseed model registry behavior onto generic repository/ref/path/frontmatter/body/query requests, and keeps product semantics outside TreeDX. The API package may host public TreeDX federation nodes as part of backend reconciliation.
-
-Project site code and optional project repositories remain local filesystem/git
-workspace concerns by default. Use `contentRepository: { adapter: 'local' }` or
-`AgentSdk.createLocal()` for explicit local content behavior.
-
-See [TreeDX Content Repository](./docs/treedx-content-repository.md).
-
-## Preferred Graph Workflow
-
-The preferred graph API for new integrations is:
-
-1. `parseGraphDsl()`
-2. `queryGraph()`
-3. `buildContextPack()`
-
-Example:
-
-```ts
-import { AgentSdk } from '@treeseed/sdk/sdk';
-
-const sdk = new AgentSdk();
-const parsed = await sdk.parseGraphDsl(
-  'ctx "queue api" for implement in /knowledge via implements,references depth 1 budget 4000 as full',
-);
-
-if (!parsed.ok || !parsed.query) {
-  throw new Error(parsed.errors.join('; '));
-}
-
-const graph = await sdk.queryGraph(parsed.query);
-const pack = await sdk.buildContextPack(parsed.query);
-```
-
-The public `ctx` syntax is:
 
-```text
-ctx <target>
-  [for <focus>]
-  [in <scope>]
-  [via <relation[,relation...]>]
-  [depth <0-3>]
-  [where <filter-expression>]
-  [limit <n>]
-  [budget <tokens>]
-  [as <list|brief|full|map>]
+const health = await client.call({ method: 'GET', path: '/v1/health' });
 ```
 
-The old `key=value` graph DSL is no longer supported.
-
-## TreeDX Remote Repository Mode
-
-TreeDX support is opt-in. Local SDK behavior remains the default.
+The client provides typed operation dispatch, RFC 9457 problem handling, OAuth device and refresh flows, server-profile normalization, idempotency keys, optimistic-concurrency headers, and request cancellation. Generated operation bindings come from the versioned operation catalog; the generic `call` method accepts only the public REST path shape. Token and profile persistence belong to the consuming CLI, application, or host credential store.
 
-Use the low-level TreeDX client when you want direct repository, workspace, query, graph, registry, or context calls:
+## TreeDX API
 
 ```ts
-import { TreeDxClient } from '@treeseed/sdk/treedx';
+import { TreeDxClient } from '@treeseed/sdk/treedx/client';
 
 const treeDx = new TreeDxClient({
-  baseUrl: 'http://localhost:4000',
+  baseUrl: 'http://127.0.0.1:4000',
   token: process.env.TREEDX_TOKEN,
   repoId: 'repo_123',
 });
 
-const whoami = await treeDx.whoami();
-const file = await treeDx.readRepositoryFile({
-  path: 'docs/readme.md',
-  parseFrontmatter: true,
-});
+const result = await treeDx.searchRepositoryFiles({ query: 'release' });
 ```
 
-`AgentSdk` can delegate content-backed model and graph calls to TreeDX when configured explicitly:
-
-```ts
-import { AgentSdk, TreeDxClient } from '@treeseed/sdk';
-
-const treeDx = new TreeDxClient({
-  baseUrl: 'http://localhost:4000',
-  token: process.env.TREEDX_TOKEN,
-  repoId: 'repo_123',
-});
+TreeDX remains a remote service. Its client and transport types are retained here so consumers do not duplicate protocol code.
 
-const sdk = new AgentSdk({
-  repoRoot: process.cwd(),
-  treeDx: {
-    enabled: true,
-    client: treeDx,
-    repoId: 'repo_123',
-    defaultRef: 'refs/heads/main',
-  },
-});
+## Public boundaries
 
-const docs = await sdk.search({
-  model: 'knowledge',
-  filters: [{ field: 'status', op: 'eq', value: 'published' }],
-});
-```
+The package intentionally exposes only:
 
-TreeDX mode keeps TreeSeed model semantics in the SDK model registry. TreeDX receives generic repository/ref/path/frontmatter/body/query requests and returns generic repository/file/query/graph results.
+- standards and semantic-compatibility contracts for TypeScript, OpenAPI, and MCP;
+- the control-plane operation catalog and human-centered command/workday contracts;
+- control-plane, TreeDX, and capacity-provider remote clients;
+- portable account, knowledge, feedback, content, agent, capacity, provider, secret-capability, and graph request contracts;
+- deterministic validation that belongs to those wire contracts.
 
-TreeDX auth, policy, audit, and federation helpers are available on the same client:
+There is no root catch-all export. Import a documented subpath so ownership and compatibility remain explicit.
 
-```ts
-const mode = await treeDx.authMode();
-const scope = await treeDx.effectiveScope({ repoId: 'repo_123' });
-
-await treeDx.putCapabilityGrant({
-  actorId: 'actor_agent',
-  tenantId: 'tenant_demo',
-  repoIds: ['repo_123'],
-  capabilities: ['files:read', 'files:search'],
-  refs: ['refs/heads/main'],
-  paths: ['docs/**'],
-});
-
-const audit = await treeDx.listAuditEvents({
-  repoId: 'repo_123',
-  eventType: 'repo.query_executed',
-  limit: 25,
-});
-
-const plan = await treeDx.planFederatedQuery({
-  repoIds: ['repo_123'],
-  capabilities: ['files:search'],
-  paths: { repo_123: ['docs/**'] },
-});
-
-const search = await treeDx.federatedSearch({
-  repoIds: ['repo_123'],
-  refs: { repo_123: 'refs/heads/main' },
-  paths: { repo_123: ['docs/**'] },
-  query: 'release',
-  includeErrors: true,
-});
-```
-
-Federation planning performs scope reduction before execution. The SDK delegates global execution to TreeDX instead of fanning out across every node and filtering locally.
-
-Snapshot, artifact, mirror sync, and migration helpers are also available on `TreeDxClient`:
-
-```ts
-const snapshot = await treeDx.buildSnapshot({
-  ref: 'refs/heads/main',
-  kind: 'repository_snapshot',
-  paths: ['docs/**'],
-  includeGraph: true,
-});
-
-const artifact = await treeDx.exportArtifact({
-  snapshotId: snapshot.snapshotId,
-});
-
-const download = await treeDx.downloadArtifact({
-  snapshotId: snapshot.snapshotId,
-});
-
-await treeDx.syncMirror({
-  mirrorId: 'mirror_123',
-  remoteName: 'origin',
-});
-
-await treeDx.createMigration({
-  targetNodeId: 'node_mirror',
-  mode: 'primary_transfer',
-  planOnly: true,
-  requireMirrorSynced: false,
-});
-
-await treeDx.ready();
-await treeDx.deepHealth();
-await treeDx.metrics();
-```
-
-`downloadArtifact()` returns an `ArrayBuffer` plus content type, filename, checksum, and snapshot headers. These APIs are generic TreeDX repository operations; TreeSeed package or release semantics are not encoded in TreeDX.
-
-Mocked end-to-end TreeDX contract tests prove the SDK can drive the TreeDX repository loop without an agent-side clone when `contentPathMap` is supplied:
+## Verification
 
 ```bash
-npx vitest run --config ./vitest.config.ts test/utils/treedx-e2e-contract.test.ts
-```
-
-The optional live contract command reports `not configured` and exits
-successfully unless all of these are set:
-
-```text
-TREEDX_LIVE_URL
-TREEDX_LIVE_TOKEN
-TREEDX_LIVE_REPO_ID
-```
-
-## Capacity Scheduling Contracts
-
-The SDK owns the provider-neutral capacity runtime helpers used by the agent manager, workers, and market control plane. These helpers keep work estimation separate from provider cost by normalizing `taskSignature + executionProfileId` estimates, then routing against grants, provider lanes, quality requirements, quota/congestion pressure, attention/context saturation, utility, predictive reserve, and hybrid execution metadata.
-
-Capacity records remain metadata-compatible: advanced scheduling data lives in task payload JSON, routing decision candidates/scores, reservation metadata, capacity plan metadata, checkpoint artifacts, and usage actual metadata. Missing metadata is neutral, so older callers continue to use the credit-only behavior.
-
-## Shared Fixture Support
-
-SDK also owns the shared fixture support model used across the Treeseed workspace.
-
-That support layer is responsible for:
-
-- resolving the canonical shared fixture in `.fixtures/treeseed-fixtures`
-- preparing fixture-local package visibility for package-scoped verification
-- linking real workspace or installed packages into the fixture runtime when available
-- providing the canonical `contracts-only` Agent shim used by packages such as `core` during isolated verification
-
-The shared fixture is an integrated Treeseed project, but package verification remains package-scoped. SDK owns the tooling that lets other packages validate their own slice of that project without mutating the fixture itself.
-
-## Advanced Graph Methods
-
-The SDK also exposes lower-level graph primitives such as:
-
-- `searchFiles()`
-- `searchSections()`
-- `searchEntities()`
-- `getGraphNode()`
-- `getNeighbors()`
-- `followReferences()`
-- `getBacklinks()`
-- `getRelated()`
-- `getSubgraph()`
-- `refreshGraph()`
-
-These remain public, but they are considered advanced tools. Prefer the graph-first context workflow above unless you specifically need raw lexical search or raw traversal primitives.
-
-## `ScopedAgentSdk`
-
-Use `scopeForAgent()` when code must enforce an agent’s declared permissions:
-
-```ts
-const scoped = sdk.scopeForAgent({
-  slug: 'guide-agent',
-  permissions: [
-    { model: 'knowledge', operations: ['get', 'read', 'search'] },
-    { model: 'message', operations: ['create'] },
-  ],
-});
+npm test
+npm run verify:direct
 ```
 
-`ScopedAgentSdk` is intended for manager/worker and agent-runtime code. It is not the default application entrypoint.
-
-## `ContentGraphRuntime`
-
-`ContentGraphRuntime` is still exported, but it is an advanced graph runtime:
-
-- it powers the graph subsystem behind `AgentSdk`
-- it is useful when you want only graph behavior
-- it is not the recommended starting point for most applications
-
-## Reference Docs
-
-- [SDK Interface Reference](../../src/content/knowledge/sdk/interface-reference.mdx)
-- [Graph API Guide](../../src/content/knowledge/sdk/graph-api-guide.mdx)
-- [ctx Query Language](../../src/content/knowledge/sdk/ctx-query-language.mdx)
-- [How ctx Works](../../src/content/knowledge/sdk/ctx-query-engine.mdx)
-
-## Other Public Capabilities
-
-The package also exports:
+The release gate builds only the package export closure, verifies deterministic contract artifacts, checks the packed public boundary, and runs the focused contract/client suite. Removed implementation and lifecycle suites are not executed.
 
-- workflow helpers such as `TreeseedWorkflowSdk`
-- remote and queue clients such as `RemoteTreeseedClient`, `CloudflareQueuePullClient`, and `CloudflareQueuePushClient`
-- model registry, field, and filter utilities
-- plugin/runtime types and helpers
+## Versioning
 
-For package work:
+Contract removals, input or output narrowing, scope escalation, risk escalation, and incompatible REST or MCP surface changes are breaking. Compatible additions require a minor version; contract-preserving repairs require a patch. Prerelease consumers pin an exact immutable version.
 
-```bash
-npm install
-npm run build
-npm test
-```
-
-For fixture-specific work:
-
-```bash
-npm run fixtures:check
-```
+License: Apache-2.0.

package/dist/accounts/account-contracts.d.ts

@@ -0,0 +1,170 @@
+export type AuthAvailabilityStatus = 'empty' | 'invalid' | 'reserved' | 'taken' | 'available' | 'throttled' | 'error';
+export interface AuthAvailabilityResult {
+    value: string;
+    available: boolean;
+    status: AuthAvailabilityStatus;
+    message: string;
+    retryAfterSeconds?: number;
+}
+export type AuthProviderId = 'github' | 'google' | 'microsoft' | 'apple';
+export interface AuthProviderCapability {
+    id: AuthProviderId;
+    label: string;
+}
+export interface WebAuthenticationResult {
+    accessToken: string;
+    refreshToken?: string | null;
+    tokenType: 'Bearer';
+    expiresAt: string;
+    expiresInSeconds: number;
+    principal: ApiPrincipal;
+}
+export interface CredentialRegistrationRequest {
+    firstName: string;
+    lastName: string;
+    username: string;
+    email: string;
+    password: string;
+    returnTo?: string;
+    inviteToken?: string;
+}
+export interface CredentialRegistrationResult extends Partial<WebAuthenticationResult> {
+    confirmationRequired?: boolean;
+    confirmationToken?: string;
+}
+export interface UsernameClaimResult extends WebAuthenticationResult {
+    username: string;
+}
+export type ReauthenticationAction = 'password_change' | 'account_delete';
+export interface ReauthenticationGrant {
+    grantId: string;
+    action: ReauthenticationAction;
+    expiresInSeconds: number;
+}
+export interface AccountMutationResult {
+    changed?: boolean;
+    deleted?: boolean;
+    id?: string;
+    status?: 'updated' | 'revoked' | 'already-revoked' | 'not-found';
+}
+export interface AccountEmailAddress {
+    id: string;
+    email: string;
+    status: 'pending' | 'verified';
+    isPrimary: boolean;
+    verificationRequestedAt?: string | null;
+    verifiedAt?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface AccountEmailMutationResult {
+    emailAddress: AccountEmailAddress;
+    verificationSent?: boolean;
+    confirmationToken?: string;
+}
+export interface AccountIdentity {
+    id: string;
+    username: string;
+    displayName: string;
+    firstName?: string | null;
+    lastName?: string | null;
+    image?: string | null;
+    headline?: string | null;
+    profileSummary?: string | null;
+    location?: string | null;
+    website?: string | null;
+    expertise?: string[];
+    hasCredential: boolean;
+    emails: AccountEmailAddress[];
+    providers: Array<{
+        id: string;
+        provider: string;
+        email?: string | null;
+        linkedAt: string;
+        canUnlink: boolean;
+    }>;
+}
+export interface AccountPreferences {
+    timeZone: string;
+    realTimeUpdates: boolean;
+    realTimePollingIntervalSeconds: 2 | 5 | 15 | 30;
+}
+export type AccountPreferencesUpdate = Partial<AccountPreferences>;
+export interface AccountWebSession {
+    id: string;
+    provider: string;
+    expiresAt: string;
+    revokedAt?: string | null;
+    authenticatedAt: string;
+    lastSeenAt?: string | null;
+    ipAddress?: string | null;
+    userAgent?: string | null;
+    current: boolean;
+}
+export interface AccountDeletionBlocker {
+    code: 'platform_admin' | 'team_owner';
+    message: string;
+    teamId?: string;
+    teamSlug?: string;
+    teamName?: string;
+}
+export declare const NOTIFICATION_EMAIL_CADENCES: readonly ["immediate", "daily", "weekly"];
+export type NotificationEmailCadence = typeof NOTIFICATION_EMAIL_CADENCES[number];
+export interface NotificationContentCapability {
+    id: string;
+    label: string;
+    description: string;
+    eventTypes: string[];
+}
+export declare const NOTIFICATION_CONTENT_CAPABILITIES: readonly NotificationContentCapability[];
+export interface NotificationProjectOverride {
+    projectId: string;
+    contentTypes: string[];
+}
+export interface NotificationProject {
+    id: string;
+    slug: string;
+    name?: string | null;
+}
+export interface NotificationPreferences {
+    emailCadence: NotificationEmailCadence;
+    globalContentTypes: string[];
+    projectOverrides: NotificationProjectOverride[];
+}
+export interface AccountNotification {
+    id: string;
+    eventType: string;
+    contentType: string;
+    projectId: string;
+    title: string;
+    summary?: string | null;
+    targetUrl: string;
+    createdAt: string;
+    readAt?: string | null;
+}
+export interface PersonalThemePaletteMode {
+    canvas: string;
+    surface: string;
+    text: string;
+    accent: string;
+}
+export interface PersonalThemePalette {
+    light: PersonalThemePaletteMode;
+    dark: PersonalThemePaletteMode;
+}
+export interface PersonalThemeDraft {
+    name: string;
+    baseScheme: string;
+    palette: PersonalThemePalette;
+}
+export interface PersonalTheme extends PersonalThemeDraft {
+    id: string;
+    schemeId: string;
+    compilerVersion: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare const PERSONAL_THEME_COMPILER_VERSION = 1;
+export declare function normalizeNotificationPreferences(input: Partial<NotificationPreferences> | null | undefined): NotificationPreferences;
+export declare function isValidPersonalThemeDraft(input: unknown): input is PersonalThemeDraft;
+import type { ApiPrincipal } from '../operator-contracts/oauth.js';

package/dist/accounts/account-contracts.js

@@ -0,0 +1,33 @@
+const NOTIFICATION_EMAIL_CADENCES = ["immediate", "daily", "weekly"];
+const NOTIFICATION_CONTENT_CAPABILITIES = [
+  { id: "objectives", label: "Objectives", description: "Strategic objectives and changes to their status.", eventTypes: ["content.objective.published"] },
+  { id: "questions", label: "Questions", description: "New research questions and published answers.", eventTypes: ["content.question.published"] },
+  { id: "notes", label: "Notes", description: "Linked observations, feedback, and implementation notes.", eventTypes: ["content.note.published"] },
+  { id: "proposals", label: "Proposals", description: "New proposals and material proposal updates.", eventTypes: ["content.proposal.published"] },
+  { id: "decisions", label: "Decisions", description: "Accepted, rejected, deferred, or superseded decisions.", eventTypes: ["content.decision.published"] },
+  { id: "agents", label: "Agents", description: "Project agent definition changes.", eventTypes: ["content.agent.published"] }
+];
+const PERSONAL_THEME_COMPILER_VERSION = 1;
+function normalizeNotificationPreferences(input) {
+  const allowed = new Set(NOTIFICATION_CONTENT_CAPABILITIES.map((entry) => entry.id));
+  const cadence = NOTIFICATION_EMAIL_CADENCES.includes(input?.emailCadence) ? input?.emailCadence : "daily";
+  const normalizeTypes = (values) => Array.isArray(values) ? [...new Set(values.filter((value) => typeof value === "string" && allowed.has(value)))].sort() : [];
+  return {
+    emailCadence: cadence,
+    globalContentTypes: normalizeTypes(input?.globalContentTypes),
+    projectOverrides: Array.isArray(input?.projectOverrides) ? input.projectOverrides.filter((entry) => Boolean(entry && typeof entry.projectId === "string" && entry.projectId.trim())).map((entry) => ({ projectId: entry.projectId.trim(), contentTypes: normalizeTypes(entry.contentTypes) })).sort((left, right) => left.projectId.localeCompare(right.projectId)) : []
+  };
+}
+function isValidPersonalThemeDraft(input) {
+  if (!input || typeof input !== "object") return false;
+  const draft = input;
+  const color = (value) => typeof value === "string" && /^#[0-9a-f]{6}$/iu.test(value);
+  return typeof draft.name === "string" && draft.name.trim().length >= 2 && draft.name.trim().length <= 60 && typeof draft.baseScheme === "string" && Boolean(draft.baseScheme.trim()) && Boolean(draft.palette?.light && draft.palette?.dark) && ["canvas", "surface", "text", "accent"].every((key) => color(draft.palette.light[key]) && color(draft.palette.dark[key]));
+}
+export {
+  NOTIFICATION_CONTENT_CAPABILITIES,
+  NOTIFICATION_EMAIL_CADENCES,
+  PERSONAL_THEME_COMPILER_VERSION,
+  isValidPersonalThemeDraft,
+  normalizeNotificationPreferences
+};