@floomhq/skills 1.0.2 → 1.1.0

package/dist/index.js

@@ -2352,12 +2352,170 @@ var init_skill_package = __esm({
   }
 });
 
-// ../shared/src/contract/index.ts
+// ../shared/src/contract/catalog-install.ts
 import { z as z2 } from "zod";
-var CONTRACT_ERROR_CODES, ContractErrorCodeSchema, RequestIdSchema, IsoDateTimeSchema, IdSchema, SlugSchema, EmailSchema, Sha256Schema, VersionSeqSchema, UrlSchema, ErrorDetailSchema, ErrorEnvelopeSchema, UserSchema, WorkspaceSchema, MeResponseSchema, WorkspaceCreateRequestSchema, WorkspaceCreateResponseSchema, MemberSchema, MembersListResponseSchema, InviteStatusSchema, InviteCreateRequestSchema, InviteSchema, InviteCreateResponseSchema, InviteLinkRotateResponseSchema, InvitesListResponseSchema, InviteAcceptResponseSchema, TargetSchema, VersionRefSchema, PersonNameSchema, PersonNameEmailSchema, FileMetadataSchema, FileTreeEntrySchema, FileDownloadSchema, FileCopySchema, FileActionSchema, TextFileContentSchema, SafeExtractionSchema, BinaryMetadataSchema, NonTextFileContentSchema, FileContentSchema, SkillsListItemSchema, SkillsListResponseSchema, VersionHistoryItemSchema, SkillDetailResponseSchema, SkillVersionReadResponseSchema, ShareCreateRequestSchema, ShareCreateResponseSchema, PublicShareGetResponseSchema, DeviceSessionStateSchema, DeviceSessionResponseSchema, DeviceSessionActionResponseSchema, CliLibraryStateSchema, CliLibraryTargetQuerySchema, CliLibrarySkillSchema, CliLibraryResponseSchema, LocalManifestSkillSchema, LocalManifestSchema, ContractDecisionChecklistItemSchema, AGENT_TARGETS, AgentTargetSyncSchema, AgentMachineSchema, AgentsListResponseSchema, ActivityEventSchema, ActivityFeedResponseSchema, SkillSyncTargetEntrySchema, SkillSyncMachineSchema, SkillSyncStateResponseSchema;
+var UuidSchema, Sha256Schema, IsoDateTimeSchema, HexTokenSchema, Ed25519PublicKeySchema, Ed25519SignatureSchema, CATALOG_UPGRADE_FREEZES_AT, CatalogInstallAgentSchema, CatalogInstallMethodSchema, CatalogInstallOsSchema, CatalogInstallScopeSchema, CatalogInstallEnvironmentSchema, CatalogInstallerIdentitySchema, CatalogInstallerSupportCellSchema, CatalogInstallDurationBaselineSchema, CatalogUpgradeQualificationRuleSchema, CatalogInstallChallengeRequestSchema, CatalogInstallChallengeResponseSchema, CatalogInstallNonceRequestSchema, CatalogInstallNonceResponseSchema, CatalogInstallReceiptRequestSchema, CatalogUpgradeDispositionSchema, CatalogInstallReceiptResponseSchema;
+var init_catalog_install = __esm({
+  "../shared/src/contract/catalog-install.ts"() {
+    "use strict";
+    UuidSchema = z2.string().uuid();
+    Sha256Schema = z2.string().regex(/^[a-f0-9]{64}$/);
+    IsoDateTimeSchema = z2.string().datetime({ offset: true });
+    HexTokenSchema = z2.string().regex(/^[a-f0-9]{64}$/);
+    Ed25519PublicKeySchema = z2.string().regex(/^[A-Za-z0-9+/]{43}=$/);
+    Ed25519SignatureSchema = z2.string().regex(/^[A-Za-z0-9+/]{86}==$/);
+    CATALOG_UPGRADE_FREEZES_AT = "2026-09-30T23:59:59.999999Z";
+    CatalogInstallAgentSchema = z2.enum([
+      "claude",
+      "codex",
+      "cursor",
+      "gemini",
+      "opencode"
+    ]);
+    CatalogInstallMethodSchema = z2.enum(["cli", "npx", "mcp"]);
+    CatalogInstallOsSchema = z2.enum(["darwin", "linux", "windows"]);
+    CatalogInstallScopeSchema = z2.enum(["global", "project"]);
+    CatalogInstallEnvironmentSchema = z2.enum([
+      "production",
+      "preview",
+      "staging",
+      "ci",
+      "platform_test",
+      "floom_owned"
+    ]);
+    CatalogInstallerIdentitySchema = z2.object({
+      name: z2.string().regex(/^[a-z0-9][a-z0-9._-]{0,63}$/),
+      version: z2.string().regex(/^[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?$/),
+      artifact_sha256: Sha256Schema
+    }).strict();
+    CatalogInstallerSupportCellSchema = z2.object({
+      installer: CatalogInstallerIdentitySchema,
+      agent: CatalogInstallAgentSchema,
+      target_os: CatalogInstallOsSchema,
+      install_scope: CatalogInstallScopeSchema,
+      install_method: CatalogInstallMethodSchema,
+      support_status: z2.enum(["U", "S"]),
+      valid_from: IsoDateTimeSchema,
+      valid_until: IsoDateTimeSchema,
+      evidence_manifest_sha256: Sha256Schema
+    }).strict();
+    CatalogInstallDurationBaselineSchema = z2.object({
+      baseline_version: z2.string().regex(/^[a-z0-9][a-z0-9._-]{0,63}$/),
+      cell: CatalogInstallerSupportCellSchema,
+      sample_count: z2.number().int().min(100),
+      p01_duration_ms: z2.number().int().positive(),
+      corpus_sha256: Sha256Schema,
+      evidence_manifest_sha256: Sha256Schema,
+      excludes_warm_cache: z2.literal(true)
+    }).strict();
+    CatalogUpgradeQualificationRuleSchema = z2.object({
+      version: z2.string().regex(/^[a-z0-9][a-z0-9._-]{0,63}$/),
+      rule_hash: Sha256Schema,
+      source_sha256: Sha256Schema,
+      configuration_sha256: Sha256Schema,
+      reconciliation_query_sha256: Sha256Schema,
+      installer_registry_version: z2.string().min(1).max(64),
+      goal_count: z2.literal(1e5),
+      freezes_at: z2.literal(CATALOG_UPGRADE_FREEZES_AT)
+    }).strict();
+    CatalogInstallChallengeRequestSchema = z2.object({
+      release_id: UuidSchema,
+      agent: CatalogInstallAgentSchema,
+      install_method: CatalogInstallMethodSchema,
+      installer: CatalogInstallerIdentitySchema,
+      target_os: CatalogInstallOsSchema,
+      install_scope: CatalogInstallScopeSchema,
+      environment: CatalogInstallEnvironmentSchema,
+      installation_public_key: Ed25519PublicKeySchema,
+      attribution_token: z2.string().min(32).max(256).nullable()
+    }).strict();
+    CatalogInstallChallengeResponseSchema = z2.object({
+      challenge_id: UuidSchema,
+      challenge_token: HexTokenSchema,
+      proof_payload: z2.string().startsWith("floom-install-challenge-v2|"),
+      server_manifest_sha256: Sha256Schema,
+      expires_at: IsoDateTimeSchema
+    }).strict();
+    CatalogInstallNonceRequestSchema = z2.object({
+      challenge_id: UuidSchema,
+      challenge_token: HexTokenSchema,
+      installer_attestation_signature: Ed25519SignatureSchema,
+      installation_proof_signature: Ed25519SignatureSchema
+    }).strict();
+    CatalogInstallNonceResponseSchema = z2.object({
+      nonce_id: UuidSchema,
+      nonce_token: HexTokenSchema,
+      installer_session_id: UuidSchema,
+      installer_session_token: HexTokenSchema,
+      release_id: UuidSchema,
+      content_sha256: Sha256Schema,
+      server_manifest_sha256: Sha256Schema,
+      agent: CatalogInstallAgentSchema,
+      install_method: CatalogInstallMethodSchema,
+      installer: CatalogInstallerIdentitySchema,
+      target_os: CatalogInstallOsSchema,
+      install_scope: CatalogInstallScopeSchema,
+      environment: CatalogInstallEnvironmentSchema,
+      qualification_rule_id: UuidSchema,
+      registry_version_id: UuidSchema,
+      expires_at: IsoDateTimeSchema
+    }).strict();
+    CatalogInstallReceiptRequestSchema = z2.object({
+      receipt_id: UuidSchema,
+      nonce_id: UuidSchema,
+      nonce_token: HexTokenSchema,
+      installer_session_id: UuidSchema,
+      installer_session_token: HexTokenSchema,
+      release_id: UuidSchema,
+      content_sha256: Sha256Schema,
+      manifest_sha256: Sha256Schema,
+      agent: CatalogInstallAgentSchema,
+      install_method: CatalogInstallMethodSchema,
+      installer: CatalogInstallerIdentitySchema,
+      target_os: CatalogInstallOsSchema,
+      install_scope: CatalogInstallScopeSchema,
+      environment: CatalogInstallEnvironmentSchema,
+      started_at: IsoDateTimeSchema,
+      completed_at: IsoDateTimeSchema,
+      result: z2.enum(["success", "failure"]),
+      qualification_rule_id: UuidSchema,
+      registry_version_id: UuidSchema,
+      installation_public_key: Ed25519PublicKeySchema,
+      installation_signature: Ed25519SignatureSchema
+    }).strict().superRefine((receipt, context) => {
+      if (Date.parse(receipt.completed_at) < Date.parse(receipt.started_at)) {
+        context.addIssue({
+          code: z2.ZodIssueCode.custom,
+          path: ["completed_at"],
+          message: "completed_at must not precede started_at"
+        });
+      }
+    });
+    CatalogUpgradeDispositionSchema = z2.enum([
+      "qualified",
+      "duplicate",
+      "excluded",
+      "quarantined",
+      "released",
+      "exclude_abuse",
+      "continue_quarantine"
+    ]);
+    CatalogInstallReceiptResponseSchema = z2.object({
+      receipt_id: UuidSchema,
+      disposition: CatalogUpgradeDispositionSchema,
+      reason_code: z2.string().min(1).max(120),
+      rule_version: z2.string().min(1).max(64)
+    }).strict();
+  }
+});
+
+// ../shared/src/contract/index.ts
+import { z as z3 } from "zod";
+var CONTRACT_ERROR_CODES, ContractErrorCodeSchema, RequestIdSchema, IsoDateTimeSchema2, IdSchema, SlugSchema, EmailSchema, Sha256Schema2, VersionSeqSchema, UrlSchema, ErrorDetailSchema, ErrorEnvelopeSchema, UserSchema, WorkspaceSchema, MeResponseSchema, WorkspaceCreateRequestSchema, WorkspaceCreateResponseSchema, MemberSchema, MembersListResponseSchema, InviteStatusSchema, InviteCreateRequestSchema, InviteSchema, InviteCreateResponseSchema, InviteLinkRotateResponseSchema, InvitesListResponseSchema, InviteAcceptResponseSchema, TargetSchema, VersionRefSchema, PersonNameSchema, PersonNameEmailSchema, FileMetadataSchema, FileTreeEntrySchema, FileDownloadSchema, FileCopySchema, FileActionSchema, TextFileContentSchema, SafeExtractionSchema, BinaryMetadataSchema, NonTextFileContentSchema, FileContentSchema, SkillsListItemSchema, SkillsListResponseSchema, VersionHistoryItemSchema, SkillDetailResponseSchema, SkillVersionReadResponseSchema, ShareCreateRequestSchema, ShareCreateResponseSchema, PublicShareGetResponseSchema, DeviceSessionStateSchema, DeviceSessionResponseSchema, DeviceSessionActionResponseSchema, CliLibraryStateSchema, CliLibraryTargetQuerySchema, CliLibrarySkillSchema, CliLibraryResponseSchema, LocalManifestSkillSchema, LocalManifestSchema, ContractDecisionChecklistItemSchema, AGENT_TARGETS, AgentTargetSyncSchema, AgentMachineSchema, AgentsListResponseSchema, ActivityEventSchema, ActivityFeedResponseSchema, SkillSyncTargetEntrySchema, SkillSyncMachineSchema, SkillSyncStateResponseSchema;
 var init_contract = __esm({
   "../shared/src/contract/index.ts"() {
     "use strict";
+    init_catalog_install();
     CONTRACT_ERROR_CODES = [
       "UNAUTHENTICATED",
       "FORBIDDEN",
@@ -2365,6 +2523,7 @@ var init_contract = __esm({
       "VALIDATION_FAILED",
       "CONFLICT",
       "RATE_LIMITED",
+      "SERVICE_UNAVAILABLE",
       "INTERNAL",
       "WORKSPACE_REQUIRED",
       "WORKSPACE_ALREADY_EXISTS",
@@ -2382,270 +2541,270 @@ var init_contract = __esm({
       "UNSAFE_FILE_PATH",
       "SKILL_MARKDOWN_REQUIRED"
     ];
-    ContractErrorCodeSchema = z2.enum(CONTRACT_ERROR_CODES);
-    RequestIdSchema = z2.string().min(1);
-    IsoDateTimeSchema = z2.string().datetime({ offset: true });
-    IdSchema = z2.string().uuid();
-    SlugSchema = z2.string().min(1).max(80).regex(/^(?=.{1,80}$)[a-z0-9]+(?:-[a-z0-9]+)*$/);
-    EmailSchema = z2.string().email().max(320);
-    Sha256Schema = z2.string().regex(/^[a-f0-9]{64}$/);
-    VersionSeqSchema = z2.number().int().positive();
-    UrlSchema = z2.string().url();
-    ErrorDetailSchema = z2.object({
+    ContractErrorCodeSchema = z3.enum(CONTRACT_ERROR_CODES);
+    RequestIdSchema = z3.string().min(1);
+    IsoDateTimeSchema2 = z3.string().datetime({ offset: true });
+    IdSchema = z3.string().uuid();
+    SlugSchema = z3.string().min(1).max(80).regex(/^(?=.{1,80}$)[a-z0-9]+(?:-[a-z0-9]+)*$/);
+    EmailSchema = z3.string().email().max(320);
+    Sha256Schema2 = z3.string().regex(/^[a-f0-9]{64}$/);
+    VersionSeqSchema = z3.number().int().positive();
+    UrlSchema = z3.string().url();
+    ErrorDetailSchema = z3.object({
       code: ContractErrorCodeSchema,
-      message: z2.string().min(1),
+      message: z3.string().min(1),
       request_id: RequestIdSchema
-    }).catchall(z2.unknown());
-    ErrorEnvelopeSchema = z2.object({
+    }).catchall(z3.unknown());
+    ErrorEnvelopeSchema = z3.object({
       error: ErrorDetailSchema
     }).strict();
-    UserSchema = z2.object({
+    UserSchema = z3.object({
       id: IdSchema,
       email: EmailSchema,
-      name: z2.string().min(1),
+      name: z3.string().min(1),
       avatar_url: UrlSchema.nullable()
     }).strict();
-    WorkspaceSchema = z2.object({
+    WorkspaceSchema = z3.object({
       id: IdSchema,
       slug: SlugSchema,
-      name: z2.string().min(1).max(120)
+      name: z3.string().min(1).max(120)
     }).strict();
-    MeResponseSchema = z2.object({
+    MeResponseSchema = z3.object({
       user: UserSchema,
       workspace: WorkspaceSchema.nullable()
     }).strict();
-    WorkspaceCreateRequestSchema = z2.object({
-      name: z2.string().trim().min(1).max(120)
+    WorkspaceCreateRequestSchema = z3.object({
+      name: z3.string().trim().min(1).max(120)
     }).strict();
-    WorkspaceCreateResponseSchema = z2.object({
+    WorkspaceCreateResponseSchema = z3.object({
       workspace: WorkspaceSchema
     }).strict();
-    MemberSchema = z2.object({
-      name: z2.string().min(1),
+    MemberSchema = z3.object({
+      name: z3.string().min(1),
       email: EmailSchema,
-      joined_at: IsoDateTimeSchema
+      joined_at: IsoDateTimeSchema2
     }).strict();
-    MembersListResponseSchema = z2.object({
+    MembersListResponseSchema = z3.object({
       workspace: WorkspaceSchema,
-      members: z2.array(MemberSchema),
-      total: z2.number().int().nonnegative()
+      members: z3.array(MemberSchema),
+      total: z3.number().int().nonnegative()
     }).strict();
-    InviteStatusSchema = z2.enum([
+    InviteStatusSchema = z3.enum([
       "pending",
       "accepted",
       "revoked",
       "expired"
     ]);
-    InviteCreateRequestSchema = z2.object({
+    InviteCreateRequestSchema = z3.object({
       email: EmailSchema
     }).strict();
-    InviteSchema = z2.object({
+    InviteSchema = z3.object({
       email: EmailSchema,
       status: InviteStatusSchema,
-      expires_at: IsoDateTimeSchema,
-      created_at: IsoDateTimeSchema
+      expires_at: IsoDateTimeSchema2,
+      created_at: IsoDateTimeSchema2
     }).strict();
-    InviteCreateResponseSchema = z2.object({
+    InviteCreateResponseSchema = z3.object({
       invite: InviteSchema,
       accept_url: UrlSchema
     }).strict();
-    InviteLinkRotateResponseSchema = z2.object({
+    InviteLinkRotateResponseSchema = z3.object({
       invite: InviteSchema,
       accept_url: UrlSchema
     }).strict();
-    InvitesListResponseSchema = z2.object({
-      invites: z2.array(InviteSchema),
-      total: z2.number().int().nonnegative()
+    InvitesListResponseSchema = z3.object({
+      invites: z3.array(InviteSchema),
+      total: z3.number().int().nonnegative()
     }).strict();
-    InviteAcceptResponseSchema = z2.object({
+    InviteAcceptResponseSchema = z3.object({
       invite: InviteSchema.extend({
-        status: z2.literal("accepted"),
-        accepted_at: IsoDateTimeSchema
+        status: z3.literal("accepted"),
+        accepted_at: IsoDateTimeSchema2
       }),
       workspace: WorkspaceSchema
     }).strict();
-    TargetSchema = z2.enum([
+    TargetSchema = z3.enum([
       "claude",
       "codex",
       "cursor",
       "gemini",
       "opencode"
     ]);
-    VersionRefSchema = z2.object({
+    VersionRefSchema = z3.object({
       version_seq: VersionSeqSchema,
-      display: z2.string().regex(/^v[1-9][0-9]*$/)
+      display: z3.string().regex(/^v[1-9][0-9]*$/)
     }).strict().superRefine((value, context) => {
       if (value.display !== `v${value.version_seq}`) {
         context.addIssue({
-          code: z2.ZodIssueCode.custom,
+          code: z3.ZodIssueCode.custom,
           message: "display must equal v${version_seq}",
           path: ["display"]
         });
       }
     });
-    PersonNameSchema = z2.object({
-      name: z2.string().min(1)
+    PersonNameSchema = z3.object({
+      name: z3.string().min(1)
     }).strict();
     PersonNameEmailSchema = PersonNameSchema.extend({
       email: EmailSchema
     }).strict();
-    FileMetadataSchema = z2.object({
-      path: z2.string().min(1).max(512),
-      size_bytes: z2.number().int().nonnegative(),
-      size: z2.number().int().nonnegative(),
-      sha256: Sha256Schema,
-      mime: z2.string().min(1)
+    FileMetadataSchema = z3.object({
+      path: z3.string().min(1).max(512),
+      size_bytes: z3.number().int().nonnegative(),
+      size: z3.number().int().nonnegative(),
+      sha256: Sha256Schema2,
+      mime: z3.string().min(1)
     }).strict();
-    FileTreeEntrySchema = z2.object({
-      path: z2.string().min(1).max(512),
-      kind: z2.enum(["directory", "file"]),
-      parent_path: z2.string().max(512).nullable(),
-      depth: z2.number().int().nonnegative(),
-      size_bytes: z2.number().int().nonnegative().nullable()
+    FileTreeEntrySchema = z3.object({
+      path: z3.string().min(1).max(512),
+      kind: z3.enum(["directory", "file"]),
+      parent_path: z3.string().max(512).nullable(),
+      depth: z3.number().int().nonnegative(),
+      size_bytes: z3.number().int().nonnegative().nullable()
     }).strict();
-    FileDownloadSchema = z2.object({
-      available: z2.boolean(),
+    FileDownloadSchema = z3.object({
+      available: z3.boolean(),
       url: UrlSchema.nullable(),
-      filename: z2.string().min(1).nullable(),
-      expires_at: IsoDateTimeSchema.nullable()
+      filename: z3.string().min(1).nullable(),
+      expires_at: IsoDateTimeSchema2.nullable()
     }).strict();
-    FileCopySchema = z2.object({
-      available: z2.boolean(),
-      source: z2.enum(["content_text", "safe_extraction", "none"])
+    FileCopySchema = z3.object({
+      available: z3.boolean(),
+      source: z3.enum(["content_text", "safe_extraction", "none"])
     }).strict();
-    FileActionSchema = z2.object({
+    FileActionSchema = z3.object({
       copy: FileCopySchema,
       download: FileDownloadSchema
     }).strict();
     TextFileContentSchema = FileMetadataSchema.extend({
-      mode: z2.literal("text"),
-      content_text: z2.string(),
-      safe_extraction: z2.null(),
-      binary: z2.null(),
+      mode: z3.literal("text"),
+      content_text: z3.string(),
+      safe_extraction: z3.null(),
+      binary: z3.null(),
       actions: FileActionSchema
     }).strict();
-    SafeExtractionSchema = z2.object({
-      status: z2.enum(["available", "truncated", "unsupported"]),
-      text_preview: z2.string().nullable(),
-      reason: z2.string().min(1).nullable()
+    SafeExtractionSchema = z3.object({
+      status: z3.enum(["available", "truncated", "unsupported"]),
+      text_preview: z3.string().nullable(),
+      reason: z3.string().min(1).nullable()
     }).strict();
-    BinaryMetadataSchema = z2.object({
-      filename: z2.string().min(1),
-      size_bytes: z2.number().int().nonnegative(),
-      sha256: Sha256Schema,
-      mime: z2.string().min(1),
+    BinaryMetadataSchema = z3.object({
+      filename: z3.string().min(1),
+      size_bytes: z3.number().int().nonnegative(),
+      sha256: Sha256Schema2,
+      mime: z3.string().min(1),
       download_url: UrlSchema.nullable()
     }).strict();
     NonTextFileContentSchema = FileMetadataSchema.extend({
-      mode: z2.literal("non_text"),
-      content_text: z2.null(),
+      mode: z3.literal("non_text"),
+      content_text: z3.null(),
       safe_extraction: SafeExtractionSchema,
       binary: BinaryMetadataSchema,
       actions: FileActionSchema
     }).strict();
-    FileContentSchema = z2.discriminatedUnion("mode", [
+    FileContentSchema = z3.discriminatedUnion("mode", [
       TextFileContentSchema,
       NonTextFileContentSchema
     ]);
-    SkillsListItemSchema = z2.object({
+    SkillsListItemSchema = z3.object({
       slug: SlugSchema,
-      title: z2.string().min(1),
-      description: z2.string(),
-      icon: z2.string().min(1).nullable().optional(),
+      title: z3.string().min(1),
+      description: z3.string(),
+      icon: z3.string().min(1).nullable().optional(),
       latest_version: VersionRefSchema,
-      updated_at: IsoDateTimeSchema,
+      updated_at: IsoDateTimeSchema2,
       updated_by: PersonNameSchema
     }).strict();
-    SkillsListResponseSchema = z2.object({
-      skills: z2.array(SkillsListItemSchema),
-      total: z2.number().int().nonnegative(),
-      order: z2.literal("updated_desc"),
-      search: z2.object({
-        mode: z2.literal("client_side_only"),
-        server_search: z2.literal(false),
-        query_param: z2.null()
+    SkillsListResponseSchema = z3.object({
+      skills: z3.array(SkillsListItemSchema),
+      total: z3.number().int().nonnegative(),
+      order: z3.literal("updated_desc"),
+      search: z3.object({
+        mode: z3.literal("client_side_only"),
+        server_search: z3.literal(false),
+        query_param: z3.null()
       }).strict(),
-      pagination: z2.null()
+      pagination: z3.null()
     }).strict();
-    VersionHistoryItemSchema = z2.object({
+    VersionHistoryItemSchema = z3.object({
       version_seq: VersionSeqSchema,
-      display: z2.string().regex(/^v[1-9][0-9]*$/),
-      created_at: IsoDateTimeSchema,
+      display: z3.string().regex(/^v[1-9][0-9]*$/),
+      created_at: IsoDateTimeSchema2,
       created_by: PersonNameSchema,
-      changelog: z2.string().nullable().optional()
+      changelog: z3.string().nullable().optional()
     }).strict().superRefine((value, context) => {
       if (value.display !== `v${value.version_seq}`) {
         context.addIssue({
-          code: z2.ZodIssueCode.custom,
+          code: z3.ZodIssueCode.custom,
           message: "display must equal v${version_seq}",
           path: ["display"]
         });
       }
     });
-    SkillDetailResponseSchema = z2.object({
-      skill: z2.object({
+    SkillDetailResponseSchema = z3.object({
+      skill: z3.object({
         slug: SlugSchema,
-        title: z2.string().min(1),
-        description: z2.string(),
+        title: z3.string().min(1),
+        description: z3.string(),
         owner: PersonNameEmailSchema,
-        created_at: IsoDateTimeSchema,
-        license: z2.string().nullable().optional(),
-        min_floom: z2.string().nullable().optional(),
+        created_at: IsoDateTimeSchema2,
+        license: z3.string().nullable().optional(),
+        min_floom: z3.string().nullable().optional(),
         latest: VersionRefSchema,
-        works_with: z2.array(TargetSchema),
-        files: z2.array(FileMetadataSchema),
-        versions: z2.array(VersionHistoryItemSchema)
+        works_with: z3.array(TargetSchema),
+        files: z3.array(FileMetadataSchema),
+        versions: z3.array(VersionHistoryItemSchema)
       }).strict()
     }).strict();
-    SkillVersionReadResponseSchema = z2.object({
-      skill: z2.object({
+    SkillVersionReadResponseSchema = z3.object({
+      skill: z3.object({
         slug: SlugSchema,
-        title: z2.string().min(1),
-        description: z2.string()
+        title: z3.string().min(1),
+        description: z3.string()
       }).strict(),
       version: VersionHistoryItemSchema,
-      files: z2.array(FileMetadataSchema),
-      tree: z2.array(FileTreeEntrySchema),
+      files: z3.array(FileMetadataSchema),
+      tree: z3.array(FileTreeEntrySchema),
       selected_file: FileContentSchema.nullable(),
-      file_contents: z2.array(FileContentSchema)
+      file_contents: z3.array(FileContentSchema)
     }).strict();
-    ShareCreateRequestSchema = z2.object({}).strict();
-    ShareCreateResponseSchema = z2.object({
+    ShareCreateRequestSchema = z3.object({}).strict();
+    ShareCreateResponseSchema = z3.object({
       url: UrlSchema,
-      token: z2.string().min(32)
+      token: z3.string().min(32)
     }).strict();
-    PublicShareGetResponseSchema = z2.object({
-      skill: z2.object({
-        title: z2.string().min(1),
-        description: z2.string(),
+    PublicShareGetResponseSchema = z3.object({
+      skill: z3.object({
+        title: z3.string().min(1),
+        description: z3.string(),
         owner: PersonNameSchema,
         version: VersionRefSchema
       }).strict(),
-      files: z2.array(FileMetadataSchema),
-      tree: z2.array(FileTreeEntrySchema),
+      files: z3.array(FileMetadataSchema),
+      tree: z3.array(FileTreeEntrySchema),
       selected_file: FileContentSchema.nullable(),
-      file_contents: z2.array(FileContentSchema),
-      license: z2.string().nullable().optional()
+      file_contents: z3.array(FileContentSchema),
+      license: z3.string().nullable().optional()
     }).strict();
-    DeviceSessionStateSchema = z2.enum([
+    DeviceSessionStateSchema = z3.enum([
       "pending",
       "approved",
       "denied",
       "expired"
     ]);
-    DeviceSessionResponseSchema = z2.object({
+    DeviceSessionResponseSchema = z3.object({
       state: DeviceSessionStateSchema,
-      device: z2.object({
-        label: z2.string().min(1),
-        location: z2.string().min(1).nullable().optional(),
-        client: z2.string().min(1),
-        first_seen: IsoDateTimeSchema
+      device: z3.object({
+        label: z3.string().min(1),
+        location: z3.string().min(1).nullable().optional(),
+        client: z3.string().min(1),
+        first_seen: IsoDateTimeSchema2
       }).strict()
     }).strict();
-    DeviceSessionActionResponseSchema = z2.object({
+    DeviceSessionActionResponseSchema = z3.object({
       state: DeviceSessionStateSchema
     }).strict();
-    CliLibraryStateSchema = z2.enum([
+    CliLibraryStateSchema = z3.enum([
       "active",
       "stale",
       "missing",
@@ -2653,90 +2812,1015 @@ var init_contract = __esm({
       "conflict",
       "unsupported_target"
     ]);
-    CliLibraryTargetQuerySchema = z2.object({
+    CliLibraryTargetQuerySchema = z3.object({
       target: TargetSchema
     }).strict();
-    CliLibrarySkillSchema = z2.object({
+    CliLibrarySkillSchema = z3.object({
       slug: SlugSchema,
-      title: z2.string().min(1),
-      description: z2.string(),
+      title: z3.string().min(1),
+      description: z3.string(),
       version: VersionRefSchema,
-      hash: Sha256Schema,
+      hash: Sha256Schema2,
       state: CliLibraryStateSchema,
-      files: z2.array(FileContentSchema)
+      files: z3.array(FileContentSchema)
     }).strict();
-    CliLibraryResponseSchema = z2.object({
+    CliLibraryResponseSchema = z3.object({
       workspace: WorkspaceSchema,
       target: TargetSchema,
-      generated_at: IsoDateTimeSchema,
-      manifest_schema_version: z2.literal(1),
-      hash_basis: z2.literal("workspace_slug:skill_slug:version_seq:file_sha256"),
-      full_hash: Sha256Schema,
-      states: z2.array(CliLibraryStateSchema),
-      skills: z2.array(CliLibrarySkillSchema)
+      generated_at: IsoDateTimeSchema2,
+      manifest_schema_version: z3.literal(1),
+      hash_basis: z3.literal("workspace_slug:skill_slug:version_seq:file_sha256"),
+      full_hash: Sha256Schema2,
+      states: z3.array(CliLibraryStateSchema),
+      skills: z3.array(CliLibrarySkillSchema)
     }).strict();
-    LocalManifestSkillSchema = z2.object({
+    LocalManifestSkillSchema = z3.object({
       slug: SlugSchema,
       version_seq: VersionSeqSchema,
-      hash: Sha256Schema,
+      hash: Sha256Schema2,
       state: CliLibraryStateSchema,
-      installed_paths: z2.array(z2.string().min(1))
+      installed_paths: z3.array(z3.string().min(1))
     }).strict();
-    LocalManifestSchema = z2.object({
-      manifest_schema_version: z2.literal(1),
+    LocalManifestSchema = z3.object({
+      manifest_schema_version: z3.literal(1),
       target: TargetSchema,
       workspace_slug: SlugSchema,
-      full_hash: Sha256Schema,
-      hash_basis: z2.literal("workspace_slug:skill_slug:version_seq:file_sha256"),
-      installed_at: IsoDateTimeSchema,
-      backup_path: z2.string().min(1).nullable(),
-      skills: z2.array(LocalManifestSkillSchema)
+      full_hash: Sha256Schema2,
+      hash_basis: z3.literal("workspace_slug:skill_slug:version_seq:file_sha256"),
+      installed_at: IsoDateTimeSchema2,
+      backup_path: z3.string().min(1).nullable(),
+      skills: z3.array(LocalManifestSkillSchema)
     }).strict();
-    ContractDecisionChecklistItemSchema = z2.object({
-      id: z2.string().min(1),
-      title: z2.string().min(1),
-      locked: z2.literal(true)
+    ContractDecisionChecklistItemSchema = z3.object({
+      id: z3.string().min(1),
+      title: z3.string().min(1),
+      locked: z3.literal(true)
     }).strict();
     AGENT_TARGETS = ["claude", "codex", "cursor", "gemini", "opencode"];
-    AgentTargetSyncSchema = z2.object({
-      last_pulled_at: IsoDateTimeSchema.nullable()
+    AgentTargetSyncSchema = z3.object({
+      last_pulled_at: IsoDateTimeSchema2.nullable()
     }).strict();
-    AgentMachineSchema = z2.object({
-      machine_id: z2.string().uuid(),
-      machine_label: z2.string().min(1),
-      last_seen_at: IsoDateTimeSchema,
-      target_sync: z2.record(z2.enum(AGENT_TARGETS), AgentTargetSyncSchema)
+    AgentMachineSchema = z3.object({
+      machine_id: z3.string().uuid(),
+      machine_label: z3.string().min(1),
+      last_seen_at: IsoDateTimeSchema2,
+      target_sync: z3.record(z3.enum(AGENT_TARGETS), AgentTargetSyncSchema)
     }).strict();
-    AgentsListResponseSchema = z2.object({
-      machines: z2.array(AgentMachineSchema),
-      total: z2.number().int().nonnegative()
+    AgentsListResponseSchema = z3.object({
+      machines: z3.array(AgentMachineSchema),
+      total: z3.number().int().nonnegative()
     }).strict();
-    ActivityEventSchema = z2.object({
+    ActivityEventSchema = z3.object({
       id: IdSchema,
-      event_name: z2.enum(["signup", "workspace_create", "push", "pull", "share_create", "skill_delete"]),
-      source: z2.enum(["web", "cli", "api"]),
-      target: z2.enum(AGENT_TARGETS).nullable(),
-      skill_slug: z2.string().nullable(),
-      created_at: IsoDateTimeSchema
+      event_name: z3.enum(["signup", "workspace_create", "push", "pull", "share_create", "skill_delete"]),
+      source: z3.enum(["web", "cli", "api"]),
+      target: z3.enum(AGENT_TARGETS).nullable(),
+      skill_slug: z3.string().nullable(),
+      created_at: IsoDateTimeSchema2
     }).strict();
-    ActivityFeedResponseSchema = z2.object({
-      events: z2.array(ActivityEventSchema),
-      total: z2.number().int().nonnegative()
+    ActivityFeedResponseSchema = z3.object({
+      events: z3.array(ActivityEventSchema),
+      total: z3.number().int().nonnegative()
     }).strict();
-    SkillSyncTargetEntrySchema = z2.object({
+    SkillSyncTargetEntrySchema = z3.object({
       target: TargetSchema,
-      last_pulled_at: IsoDateTimeSchema
+      last_pulled_at: IsoDateTimeSchema2
     }).strict();
-    SkillSyncMachineSchema = z2.object({
+    SkillSyncMachineSchema = z3.object({
       machine_id: IdSchema,
-      machine_label: z2.string().min(1),
-      targets: z2.array(SkillSyncTargetEntrySchema)
+      machine_label: z3.string().min(1),
+      targets: z3.array(SkillSyncTargetEntrySchema)
+    }).strict();
+    SkillSyncStateResponseSchema = z3.object({
+      machines: z3.array(SkillSyncMachineSchema),
+      total_machines: z3.number().int().nonnegative(),
+      total_targets_synced: z3.number().int().nonnegative()
+    }).strict();
+  }
+});
+
+// ../shared/src/catalog.ts
+import { z as z4 } from "zod";
+var CatalogSlugSchema, CatalogPublicationStateSchema, CatalogProfileTypeSchema, CatalogSourceSchema, CatalogSourceRevisionSchema, CatalogProfileSchema, CatalogPersonSchema, CatalogCompanySchema, CatalogSkillSchema, CatalogReleaseSchema, CatalogStackSchema, CatalogStackVersionSchema, CatalogTaxonomyAxisSchema, CatalogAssignmentSourceSchema, CatalogEvidenceClassSchema, CatalogSkillLabelSchema, CatalogCompatibilitySchema, CatalogPermissionSchema, CatalogEvidenceEventSchema, CatalogRightsEventSchema, CatalogTrustAssertionSchema, CatalogTrustAssertionEventSchema;
+var init_catalog = __esm({
+  "../shared/src/catalog.ts"() {
+    "use strict";
+    init_contract();
+    CatalogSlugSchema = SlugSchema.refine((slug) => slug.length >= 3, {
+      message: "catalog slugs must contain at least three characters"
+    });
+    CatalogPublicationStateSchema = z4.enum([
+      "draft",
+      "review",
+      "published",
+      "withdrawn"
+    ]);
+    CatalogProfileTypeSchema = z4.enum(["person", "company"]);
+    CatalogSourceSchema = z4.object({
+      id: IdSchema,
+      source_type: z4.enum(["repository", "registry", "url", "manual"]),
+      canonical_url: UrlSchema.nullable(),
+      external_key: z4.string().trim().min(1).max(500).nullable(),
+      display_name: z4.string().trim().min(1).max(200),
+      license_expression: z4.string().trim().min(1).max(500).nullable(),
+      source_state: z4.enum(["active", "withdrawn", "unavailable"]),
+      observed_at: IsoDateTimeSchema2
+    }).strict().superRefine((source, context) => {
+      if (source.canonical_url === null && source.external_key === null) {
+        context.addIssue({
+          code: z4.ZodIssueCode.custom,
+          path: ["canonical_url"],
+          message: "a canonical URL or external key is required"
+        });
+      }
+    });
+    CatalogSourceRevisionSchema = z4.object({
+      id: IdSchema,
+      source_id: IdSchema,
+      revision_key: z4.string().trim().min(1).max(500),
+      content_sha256: Sha256Schema2.nullable(),
+      source_updated_at: IsoDateTimeSchema2.nullable(),
+      observed_at: IsoDateTimeSchema2,
+      metadata: z4.record(z4.unknown())
+    }).strict();
+    CatalogProfileSchema = z4.object({
+      id: IdSchema,
+      profile_type: CatalogProfileTypeSchema,
+      handle: CatalogSlugSchema,
+      display_name: z4.string().trim().min(1).max(200),
+      summary: z4.string().max(2e3).nullable(),
+      avatar_url: UrlSchema.nullable(),
+      canonical_source_revision_id: IdSchema,
+      publication_state: CatalogPublicationStateSchema,
+      published_at: IsoDateTimeSchema2.nullable(),
+      withdrawn_at: IsoDateTimeSchema2.nullable()
+    }).strict().superRefine((profile, context) => {
+      if (profile.publication_state === "published" && profile.published_at === null) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["published_at"], message: "published Profiles require published_at" });
+      }
+      if (profile.publication_state === "withdrawn" && profile.withdrawn_at === null) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["withdrawn_at"], message: "withdrawn Profiles require withdrawn_at" });
+      }
+    });
+    CatalogPersonSchema = z4.object({
+      profile_id: IdSchema,
+      public_name: z4.string().trim().min(1).max(200),
+      headline: z4.string().max(500).nullable()
+    }).strict();
+    CatalogCompanySchema = z4.object({
+      profile_id: IdSchema,
+      legal_name: z4.string().trim().min(1).max(300).nullable(),
+      website_url: UrlSchema.nullable(),
+      is_publisher: z4.boolean()
+    }).strict();
+    CatalogSkillSchema = z4.object({
+      id: IdSchema,
+      slug: CatalogSlugSchema,
+      title: z4.string().trim().min(1).max(200),
+      summary: z4.string().max(2e3).nullable(),
+      outcome: z4.string().max(2e3).nullable(),
+      canonical_source_id: IdSchema,
+      primary_creator_profile_id: IdSchema.nullable(),
+      publisher_profile_id: IdSchema.nullable(),
+      distribution_skill_id: IdSchema.nullable(),
+      distribution_workspace_id: IdSchema.nullable(),
+      canonical_release_id: IdSchema.nullable(),
+      publication_state: CatalogPublicationStateSchema,
+      published_at: IsoDateTimeSchema2.nullable(),
+      withdrawn_at: IsoDateTimeSchema2.nullable()
+    }).strict().superRefine((skill, context) => {
+      if (skill.publication_state === "published") {
+        for (const key of ["publisher_profile_id", "distribution_skill_id", "distribution_workspace_id", "canonical_release_id", "published_at"]) {
+          if (skill[key] === null) context.addIssue({ code: z4.ZodIssueCode.custom, path: [key], message: `published Skills require ${key}` });
+        }
+      }
+      if (skill.publication_state === "withdrawn" && skill.withdrawn_at === null) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["withdrawn_at"], message: "withdrawn Skills require withdrawn_at" });
+      }
+    });
+    CatalogReleaseSchema = z4.object({
+      id: IdSchema,
+      skill_id: IdSchema,
+      source_revision_id: IdSchema,
+      private_skill_version_id: IdSchema.nullable(),
+      version: z4.string().trim().min(1).max(120),
+      content_sha256: Sha256Schema2,
+      publication_state: CatalogPublicationStateSchema,
+      published_at: IsoDateTimeSchema2.nullable(),
+      withdrawn_at: IsoDateTimeSchema2.nullable()
+    }).strict().superRefine((release2, context) => {
+      if (release2.publication_state === "published" && (release2.published_at === null || release2.private_skill_version_id === null)) {
+        context.addIssue({
+          code: z4.ZodIssueCode.custom,
+          path: ["published_at"],
+          message: "published releases require published_at and an immutable private Skill version"
+        });
+      }
+      if (release2.publication_state === "withdrawn" && release2.withdrawn_at === null) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["withdrawn_at"], message: "withdrawn Releases require withdrawn_at" });
+      }
+    });
+    CatalogStackSchema = z4.object({
+      id: IdSchema,
+      slug: CatalogSlugSchema,
+      title: z4.string().trim().min(1).max(200),
+      summary: z4.string().max(2e3).nullable(),
+      curator_profile_id: IdSchema,
+      canonical_stack_version_id: IdSchema.nullable(),
+      publication_state: CatalogPublicationStateSchema,
+      published_at: IsoDateTimeSchema2.nullable(),
+      withdrawn_at: IsoDateTimeSchema2.nullable()
+    }).strict().superRefine((stack, context) => {
+      if (stack.publication_state === "published" && (stack.canonical_stack_version_id === null || stack.published_at === null)) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["canonical_stack_version_id"], message: "published Stacks require a canonical version and published_at" });
+      }
+      if (stack.publication_state === "withdrawn" && stack.withdrawn_at === null) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["withdrawn_at"], message: "withdrawn Stacks require withdrawn_at" });
+      }
+    });
+    CatalogStackVersionSchema = z4.object({
+      id: IdSchema,
+      stack_id: IdSchema,
+      version_seq: z4.number().int().positive(),
+      rationale: z4.string().trim().min(1).max(4e3),
+      source_revision_id: IdSchema.nullable(),
+      publication_state: CatalogPublicationStateSchema,
+      published_at: IsoDateTimeSchema2.nullable(),
+      withdrawn_at: IsoDateTimeSchema2.nullable()
+    }).strict().superRefine((version, context) => {
+      if (version.publication_state === "published" && version.published_at === null) {
+        context.addIssue({
+          code: z4.ZodIssueCode.custom,
+          path: ["published_at"],
+          message: "published Stack versions require published_at"
+        });
+      }
+      if (version.publication_state === "published" && version.source_revision_id === null) {
+        context.addIssue({
+          code: z4.ZodIssueCode.custom,
+          path: ["source_revision_id"],
+          message: "published Stack versions require a source revision"
+        });
+      }
+      if (version.publication_state === "withdrawn" && version.withdrawn_at === null) {
+        context.addIssue({
+          code: z4.ZodIssueCode.custom,
+          path: ["withdrawn_at"],
+          message: "withdrawn Stack versions require withdrawn_at"
+        });
+      }
+    });
+    CatalogTaxonomyAxisSchema = z4.enum([
+      "capability",
+      "task",
+      "domain",
+      "workflow_stage",
+      "input",
+      "output",
+      "audience",
+      "modality",
+      "runtime",
+      "integration"
+    ]);
+    CatalogAssignmentSourceSchema = z4.enum([
+      "imported",
+      "publisher",
+      "model_assisted",
+      "reviewer",
+      "floom"
+    ]);
+    CatalogEvidenceClassSchema = z4.enum([
+      "declared_fact",
+      "inferred_assertion",
+      "observed_evidence"
+    ]);
+    CatalogSkillLabelSchema = z4.object({
+      skill_id: IdSchema,
+      release_id: IdSchema.nullable(),
+      source_revision_id: IdSchema.nullable(),
+      label_id: IdSchema,
+      axis: CatalogTaxonomyAxisSchema,
+      taxonomy_version_id: IdSchema,
+      label_role: z4.enum(["primary", "secondary"]),
+      assignment_source: CatalogAssignmentSourceSchema,
+      evidence_class: CatalogEvidenceClassSchema,
+      confidence: z4.number().min(0).max(1).nullable(),
+      classifier_version: z4.string().min(1).nullable(),
+      prompt_version: z4.string().min(1).nullable(),
+      input_content_sha256: Sha256Schema2.nullable(),
+      reviewer_id: IdSchema.nullable(),
+      reviewed_at: IsoDateTimeSchema2.nullable()
+    }).strict().superRefine((assignment, context) => {
+      if (assignment.release_id === null === (assignment.source_revision_id === null)) {
+        context.addIssue({
+          code: z4.ZodIssueCode.custom,
+          path: ["release_id"],
+          message: "exactly one release_id or source_revision_id is required"
+        });
+      }
+      if (assignment.label_role === "primary" && !["capability", "task"].includes(assignment.axis)) {
+        context.addIssue({
+          code: z4.ZodIssueCode.custom,
+          path: ["label_role"],
+          message: "only capability and task labels can be primary"
+        });
+      }
+      if (assignment.assignment_source === "model_assisted") {
+        const hasModelProvenance = assignment.evidence_class === "inferred_assertion" && assignment.confidence !== null && assignment.classifier_version !== null && assignment.prompt_version !== null && assignment.input_content_sha256 !== null;
+        if (!hasModelProvenance) {
+          context.addIssue({
+            code: z4.ZodIssueCode.custom,
+            path: ["assignment_source"],
+            message: "model-assisted labels require complete inference provenance"
+          });
+        }
+      }
+      if (assignment.reviewer_id !== null && assignment.reviewed_at === null) {
+        context.addIssue({
+          code: z4.ZodIssueCode.custom,
+          path: ["reviewed_at"],
+          message: "reviewed labels require reviewed_at"
+        });
+      }
+    });
+    CatalogCompatibilitySchema = z4.object({
+      release_id: IdSchema,
+      target_type: z4.enum(["runtime", "integration", "operating_system", "tool"]),
+      target_slug: z4.string().regex(/^[a-z0-9][a-z0-9._-]{0,79}$/),
+      compatibility_state: z4.enum(["unknown", "supported", "unsupported", "verified"]),
+      install_method: z4.string().min(1).max(120).nullable(),
+      evidence_id: IdSchema.nullable(),
+      verified_at: IsoDateTimeSchema2.nullable()
+    }).strict().superRefine((compatibility, context) => {
+      if (compatibility.compatibility_state === "verified" && (compatibility.evidence_id === null || compatibility.verified_at === null)) {
+        context.addIssue({
+          code: z4.ZodIssueCode.custom,
+          path: ["compatibility_state"],
+          message: "verified compatibility requires evidence and verified_at"
+        });
+      }
+    });
+    CatalogPermissionSchema = z4.object({
+      release_id: IdSchema,
+      permission_key: z4.string().regex(/^[a-z][a-z0-9._-]{1,79}$/),
+      access_mode: z4.enum(["read", "write", "execute", "send"]),
+      required: z4.boolean(),
+      approval_mode: z4.enum(["none", "per_action", "session", "external"]),
+      data_sensitivity: z4.enum(["public", "internal", "confidential", "restricted"]),
+      description: z4.string().max(2e3).nullable(),
+      evidence_id: IdSchema.nullable()
+    }).strict();
+    CatalogEvidenceEventSchema = z4.object({
+      id: IdSchema,
+      evidence_id: IdSchema,
+      event_type: z4.enum(["recorded", "published", "withdrawn"]),
+      prior_event_id: IdSchema.nullable(),
+      actor_id: IdSchema.nullable(),
+      reason: z4.string().trim().min(1).max(2e3).nullable(),
+      occurred_at: IsoDateTimeSchema2
+    }).strict().superRefine((event, context) => {
+      if (event.event_type === "recorded" && event.prior_event_id !== null) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["prior_event_id"], message: "recorded is the root event" });
+      }
+      if (event.event_type !== "recorded" && event.prior_event_id === null) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["prior_event_id"], message: "non-root evidence events require prior_event_id" });
+      }
+      if (event.event_type === "withdrawn" && event.reason === null) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["reason"], message: "withdrawal requires a reason" });
+      }
+    });
+    CatalogRightsEventSchema = z4.object({
+      id: IdSchema,
+      release_id: IdSchema,
+      event_type: z4.enum(["grant", "supersession", "withdrawal", "expiry"]),
+      rights_state: z4.enum(["allowed", "restricted", "prohibited", "withdrawn", "expired"]),
+      rights_basis: z4.enum(["license", "direct_permission", "public_domain", "ownership"]).nullable(),
+      scopes: z4.array(z4.enum(["distribution", "redistribution", "display", "evaluation"])).min(0),
+      evidence_id: IdSchema,
+      prior_event_id: IdSchema.nullable(),
+      effective_at: IsoDateTimeSchema2,
+      expires_at: IsoDateTimeSchema2.nullable()
+    }).strict().superRefine((rights, context) => {
+      const grantsRights = ["grant", "supersession"].includes(rights.event_type);
+      if (grantsRights && (rights.rights_basis === null || rights.scopes.length === 0)) {
+        context.addIssue({
+          code: z4.ZodIssueCode.custom,
+          path: ["rights_basis"],
+          message: "grant and supersession require a basis and explicit scopes"
+        });
+      }
+      if (!grantsRights && (rights.rights_basis !== null || rights.scopes.length !== 0)) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["scopes"], message: "withdrawal and expiry do not grant scopes" });
+      }
+      if (rights.event_type === "grant" && rights.prior_event_id !== null) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["prior_event_id"], message: "grant is the root rights event" });
+      }
+      if (rights.event_type !== "grant" && rights.prior_event_id === null) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["prior_event_id"], message: "non-root rights events require prior_event_id" });
+      }
+      const expectedState = rights.event_type === "withdrawal" ? "withdrawn" : rights.event_type === "expiry" ? "expired" : null;
+      if (expectedState !== null && rights.rights_state !== expectedState) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["rights_state"], message: `${rights.event_type} requires ${expectedState}` });
+      }
+      if (grantsRights && !["allowed", "restricted", "prohibited"].includes(rights.rights_state)) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["rights_state"], message: "granting events require an asserted rights state" });
+      }
+      if (rights.expires_at !== null && Date.parse(rights.expires_at) <= Date.parse(rights.effective_at)) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["expires_at"], message: "rights expiry must follow its effective time" });
+      }
+    });
+    CatalogTrustAssertionSchema = z4.object({
+      id: IdSchema,
+      assertion_type: z4.enum(["signed_by", "tested", "evaluated", "recommended"]),
+      profile_id: IdSchema.nullable(),
+      skill_id: IdSchema.nullable(),
+      release_id: IdSchema.nullable(),
+      release_content_sha256: Sha256Schema2.nullable(),
+      issuer_profile_id: IdSchema,
+      issuer_verification_evidence_id: IdSchema.nullable(),
+      issuer_identity_verification_record_id: IdSchema.nullable(),
+      evidence_id: IdSchema,
+      install_evidence_id: IdSchema.nullable(),
+      agent: z4.string().trim().min(1).max(120).nullable(),
+      runtime: z4.string().trim().min(1).max(120).nullable(),
+      test_name: z4.string().trim().min(1).max(200).nullable(),
+      eval_suite: z4.string().trim().min(1).max(200).nullable(),
+      eval_suite_version: z4.string().trim().min(1).max(120).nullable(),
+      result: z4.string().trim().min(1).max(500).nullable(),
+      score: z4.number().finite().nullable(),
+      recommendation_statement: z4.string().trim().min(1).max(2e3).nullable(),
+      asserted_at: IsoDateTimeSchema2,
+      proposed_by: IdSchema,
+      public_explanation: z4.string().trim().min(1).max(2e3)
+    }).strict().superRefine((assertion, context) => {
+      if ([assertion.profile_id, assertion.skill_id, assertion.release_id].filter((value) => value !== null).length !== 1) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["release_id"], message: "exactly one Trust subject is required" });
+      }
+      const releaseBound = ["signed_by", "tested", "evaluated"].includes(assertion.assertion_type);
+      if (releaseBound && (assertion.release_id === null || assertion.release_content_sha256 === null)) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["release_id"], message: "release-bound Trust requires exact Release and hash" });
+      }
+      if (assertion.assertion_type === "signed_by" && (assertion.issuer_verification_evidence_id === null || assertion.issuer_identity_verification_record_id === null)) {
+        context.addIssue({
+          code: z4.ZodIssueCode.custom,
+          path: ["issuer_identity_verification_record_id"],
+          message: "Signed by requires verified issuer evidence and an active Identity Verification Record"
+        });
+      }
+      if (assertion.assertion_type === "tested" && (assertion.install_evidence_id === null || assertion.agent === null || assertion.runtime === null || assertion.test_name === null || assertion.result !== "passed")) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["result"], message: "Tested requires agent, runtime, named smoke test, and passed result" });
+      }
+      if (assertion.assertion_type === "evaluated" && (assertion.eval_suite === null || assertion.eval_suite_version === null || assertion.result === null)) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["eval_suite"], message: "Evaluated requires named versioned suite and result" });
+      }
+      if (assertion.assertion_type === "recommended" && assertion.recommendation_statement === null) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["recommendation_statement"], message: "Recommended requires an explicit statement" });
+      }
+    });
+    CatalogTrustAssertionEventSchema = z4.object({
+      id: IdSchema,
+      assertion_id: IdSchema,
+      status: z4.enum(["draft", "active", "disputed", "suspended", "withdrawn", "expired"]),
+      prior_event_id: IdSchema.nullable(),
+      reviewer_id: IdSchema.nullable(),
+      review_method: z4.string().trim().min(1).max(500).nullable(),
+      reason: z4.string().trim().min(1).max(2e3).nullable(),
+      occurred_at: IsoDateTimeSchema2
+    }).strict().superRefine((event, context) => {
+      if (event.status === "draft" && event.prior_event_id !== null) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["prior_event_id"], message: "draft is the root Trust event" });
+      }
+      if (event.status !== "draft" && event.prior_event_id === null) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["prior_event_id"], message: "non-draft Trust events require prior_event_id" });
+      }
+      if (event.status === "active" && (event.reviewer_id === null || event.review_method === null)) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["reviewer_id"], message: "active Trust requires review evidence" });
+      }
+      if (["disputed", "suspended", "withdrawn", "expired"].includes(event.status) && event.reason === null) {
+        context.addIssue({ code: z4.ZodIssueCode.custom, path: ["reason"], message: `${event.status} requires a reason` });
+      }
+    });
+  }
+});
+
+// ../shared/src/catalog-trust.ts
+import { z as z5 } from "zod";
+function addUtcMonthsClamped(value, months) {
+  const source = new Date(value);
+  const result = new Date(source);
+  const day = result.getUTCDate();
+  result.setUTCDate(1);
+  result.setUTCMonth(result.getUTCMonth() + months);
+  const finalDay = new Date(Date.UTC(result.getUTCFullYear(), result.getUTCMonth() + 1, 0)).getUTCDate();
+  result.setUTCDate(Math.min(day, finalDay));
+  return result.getTime();
+}
+var CatalogContractAuthoritySchema, CatalogProfileClaimIntentSchema, CatalogProfileClaimRequestStateSchema, CatalogProfileControlStateSchema, CatalogIdentityVerificationRequestStateSchema, CatalogIdentityVerificationRecordStateSchema, CatalogGovernanceScopeSchema, CatalogMethodVersionStateSchema, Ed25519PublicKeySchema2, Ed25519SignatureSchema2, CatalogTrustAuthorityRootSchema, CatalogTrustReviewerAssignmentSchema, CatalogTrustReviewerAssignmentEventSchema, CatalogMethodVersionBaseSchema, CatalogProfileClaimMethodVersionSchema, CatalogIdentityVerificationMethodVersionSchema, CatalogMethodVersionEventSchema, CatalogProfileClaimChallengeSchema, CatalogProfileClaimRequestSchema, CatalogProfileClaimEvidenceReferenceSchema, CatalogWorkflowEventBaseSchema, CatalogProfileClaimRequestEventSchema, CatalogProfileControlEventSchema, CatalogProfileControlSchema, CatalogIdentityVerificationRequestSchema, CatalogIdentityVerificationRequestEventSchema, CatalogIdentityEvidenceReferenceSchema, CatalogIdentityVerificationChallengeSchema, CatalogIdentityVerificationResultSchema, CatalogPrivateEvidenceRetentionEventSchema, CatalogPrivateEvidenceLegalHoldEventSchema, CatalogPrivateEvidenceDeletionReceiptSchema, CatalogIdentityVerificationRecordSchema, CatalogIdentityVerificationRecordEventSchema;
+var init_catalog_trust = __esm({
+  "../shared/src/catalog-trust.ts"() {
+    "use strict";
+    init_contract();
+    CatalogContractAuthoritySchema = z5.literal(
+      "agent_proposed_reviewer_verified"
+    );
+    CatalogProfileClaimIntentSchema = z5.enum([
+      "initial",
+      "reclaim",
+      "transfer"
+    ]);
+    CatalogProfileClaimRequestStateSchema = z5.enum([
+      "claim_requested",
+      "challenge_issued",
+      "proof_submitted",
+      "under_review",
+      "approved",
+      "rejected",
+      "expired",
+      "withdrawn",
+      "superseded"
+    ]);
+    CatalogProfileControlStateSchema = z5.enum([
+      "active",
+      "disputed",
+      "transferred",
+      "withdrawn",
+      "expired"
+    ]);
+    CatalogIdentityVerificationRequestStateSchema = z5.enum([
+      "verification_requested",
+      "challenge_issued",
+      "proof_submitted",
+      "under_review",
+      "approved",
+      "rejected",
+      "expired",
+      "withdrawn",
+      "superseded"
+    ]);
+    CatalogIdentityVerificationRecordStateSchema = z5.enum([
+      "active",
+      "suspended",
+      "revoked",
+      "expired"
+    ]);
+    CatalogGovernanceScopeSchema = z5.literal("catalog_trust_governance");
+    CatalogMethodVersionStateSchema = z5.enum(["proposed", "active", "retired"]);
+    Ed25519PublicKeySchema2 = z5.string().regex(/^[A-Za-z0-9+/]{43}=$/);
+    Ed25519SignatureSchema2 = z5.string().regex(/^[A-Za-z0-9+/]{86}==$/);
+    CatalogTrustAuthorityRootSchema = z5.object({
+      id: IdSchema,
+      authority_scope: CatalogGovernanceScopeSchema,
+      authority_reference: z5.string().trim().min(1).max(2e3),
+      authority_sha256: Sha256Schema2,
+      anchor_key_id: z5.string().regex(/^[a-z0-9][a-z0-9._:-]{0,119}$/),
+      authority_public_key: Ed25519PublicKeySchema2,
+      anchor_signature: Ed25519SignatureSchema2,
+      active_from: IsoDateTimeSchema2,
+      created_at: IsoDateTimeSchema2
+    }).strict();
+    CatalogTrustReviewerAssignmentSchema = z5.object({
+      id: IdSchema,
+      authority_root_id: IdSchema,
+      authority_scope: CatalogGovernanceScopeSchema,
+      reviewer_id: IdSchema,
+      assignment_role: z5.enum(["trust_reviewer", "backup_trust_reviewer"]),
+      appointed_by: IdSchema,
+      authority_reference: z5.string().trim().min(1).max(2e3),
+      authority_sha256: Sha256Schema2,
+      valid_from: IsoDateTimeSchema2,
+      valid_until: IsoDateTimeSchema2,
+      current_state: z5.enum(["active", "revoked", "expired"]),
+      terminal_at: IsoDateTimeSchema2.nullable(),
+      created_at: IsoDateTimeSchema2
+    }).strict().superRefine((assignment, context) => {
+      if (assignment.reviewer_id === assignment.appointed_by) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["appointed_by"], message: "reviewers cannot appoint themselves" });
+      }
+      if (Date.parse(assignment.valid_until) <= Date.parse(assignment.valid_from)) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["valid_until"], message: "valid_until must follow valid_from" });
+      }
+      if (Date.parse(assignment.valid_until) > Date.parse(assignment.valid_from) + 365 * 24 * 60 * 60 * 1e3) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["valid_until"], message: "assignment exceeds its one-year bound" });
+      }
+      const terminal = assignment.current_state !== "active";
+      if (terminal !== (assignment.terminal_at !== null)) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["terminal_at"], message: "terminal_at must match assignment state" });
+      }
+    });
+    CatalogTrustReviewerAssignmentEventSchema = z5.object({
+      id: IdSchema,
+      assignment_id: IdSchema,
+      state: z5.enum(["active", "revoked", "expired"]),
+      prior_event_id: IdSchema.nullable(),
+      actor_id: IdSchema,
+      authority_root_id: IdSchema,
+      reason: z5.string().trim().min(1).max(2e3),
+      occurred_at: IsoDateTimeSchema2,
+      created_at: IsoDateTimeSchema2
+    }).strict().superRefine((event, context) => {
+      if (event.state === "active" !== (event.prior_event_id === null)) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["prior_event_id"], message: "assignment history begins once with active" });
+      }
+    });
+    CatalogMethodVersionBaseSchema = z5.object({
+      id: IdSchema,
+      version: z5.string().trim().min(1).max(120),
+      contract_authority: CatalogContractAuthoritySchema,
+      configuration_sha256: Sha256Schema2,
+      activated_at: IsoDateTimeSchema2.nullable(),
+      retired_at: IsoDateTimeSchema2.nullable(),
+      proposed_by: IdSchema,
+      reviewed_by: IdSchema.nullable(),
+      current_state: CatalogMethodVersionStateSchema,
+      created_at: IsoDateTimeSchema2
+    }).strict();
+    CatalogProfileClaimMethodVersionSchema = CatalogMethodVersionBaseSchema.extend({
+      method: z5.enum(["corporate_domain_email", "operator_direct_relationship"])
+    }).superRefine((method, context) => {
+      if (method.reviewed_by !== null && method.proposed_by === method.reviewed_by) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["reviewed_by"], message: "method review must be independent" });
+      }
+      if (method.retired_at !== null && method.activated_at !== null && Date.parse(method.retired_at) <= Date.parse(method.activated_at)) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["retired_at"], message: "retired_at must follow activated_at" });
+      }
+      const validState = method.current_state === "proposed" && method.activated_at === null && method.retired_at === null && method.reviewed_by === null || method.current_state === "active" && method.activated_at !== null && method.retired_at === null && method.reviewed_by !== null || method.current_state === "retired" && method.activated_at !== null && method.retired_at !== null && method.reviewed_by !== null;
+      if (!validState) context.addIssue({ code: z5.ZodIssueCode.custom, path: ["current_state"], message: "method lifecycle fields are inconsistent" });
+    });
+    CatalogIdentityVerificationMethodVersionSchema = CatalogMethodVersionBaseSchema.extend({
+      subject_kind: z5.enum(["person", "publisher"])
+    }).superRefine((method, context) => {
+      if (method.reviewed_by !== null && method.proposed_by === method.reviewed_by) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["reviewed_by"], message: "method review must be independent" });
+      }
+      if (method.retired_at !== null && method.activated_at !== null && Date.parse(method.retired_at) <= Date.parse(method.activated_at)) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["retired_at"], message: "retired_at must follow activated_at" });
+      }
+      const validState = method.current_state === "proposed" && method.activated_at === null && method.retired_at === null && method.reviewed_by === null || method.current_state === "active" && method.activated_at !== null && method.retired_at === null && method.reviewed_by !== null || method.current_state === "retired" && method.activated_at !== null && method.retired_at !== null && method.reviewed_by !== null;
+      if (!validState) context.addIssue({ code: z5.ZodIssueCode.custom, path: ["current_state"], message: "method lifecycle fields are inconsistent" });
+    });
+    CatalogMethodVersionEventSchema = z5.object({
+      id: IdSchema,
+      method_version_id: IdSchema,
+      state: CatalogMethodVersionStateSchema,
+      prior_event_id: IdSchema.nullable(),
+      actor_id: IdSchema,
+      reviewer_id: IdSchema.nullable(),
+      reason: z5.string().trim().min(1).max(2e3),
+      occurred_at: IsoDateTimeSchema2,
+      created_at: IsoDateTimeSchema2
+    }).strict().superRefine((event, context) => {
+      if (event.state === "proposed" !== (event.prior_event_id === null)) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["prior_event_id"], message: "method history begins once with proposed" });
+      }
+      if (event.state !== "proposed" && (event.reviewer_id === null || event.actor_id !== event.reviewer_id)) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["reviewer_id"], message: "method decisions require the acting reviewer" });
+      }
+    });
+    CatalogProfileClaimChallengeSchema = z5.object({
+      id: IdSchema,
+      claim_request_id: IdSchema,
+      challenge_secret_hash: Sha256Schema2,
+      binding_sha256: Sha256Schema2,
+      issued_at: IsoDateTimeSchema2,
+      expires_at: IsoDateTimeSchema2,
+      consumed_at: IsoDateTimeSchema2.nullable(),
+      purge_after: IsoDateTimeSchema2,
+      created_at: IsoDateTimeSchema2
+    }).strict().superRefine((challenge, context) => {
+      const issued = Date.parse(challenge.issued_at);
+      if (Date.parse(challenge.expires_at) !== issued + 30 * 60 * 1e3) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["expires_at"], message: "challenge expires exactly 30 minutes after issuance" });
+      }
+      if (Date.parse(challenge.purge_after) !== issued + 30 * 24 * 60 * 60 * 1e3) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["purge_after"], message: "challenge purges exactly 30 days after issuance" });
+      }
+      if (challenge.consumed_at !== null) {
+        const consumed = Date.parse(challenge.consumed_at);
+        if (consumed < issued || consumed > Date.parse(challenge.expires_at)) {
+          context.addIssue({ code: z5.ZodIssueCode.custom, path: ["consumed_at"], message: "consumption must occur during challenge validity" });
+        }
+      }
+    });
+    CatalogProfileClaimRequestSchema = z5.object({
+      id: IdSchema,
+      profile_id: IdSchema,
+      claimant_user_id: IdSchema,
+      proposed_controller_user_id: IdSchema,
+      intent: CatalogProfileClaimIntentSchema,
+      actor_capacity: z5.enum([
+        "person",
+        "company_representative",
+        "publisher_representative"
+      ]),
+      method_version_id: IdSchema,
+      prior_profile_control_id: IdSchema.nullable(),
+      transfer_authorization_type: z5.enum(["controller_consent", "dispute_resolution"]).nullable(),
+      transfer_authorization_sha256: Sha256Schema2.nullable(),
+      transfer_consent_event_id: IdSchema.nullable(),
+      transfer_dispute_record_id: IdSchema.nullable(),
+      current_state: CatalogProfileClaimRequestStateSchema,
+      created_at: IsoDateTimeSchema2,
+      terminal_at: IsoDateTimeSchema2.nullable()
+    }).strict().superRefine((request, context) => {
+      const terminal = ["approved", "rejected", "expired", "withdrawn", "superseded"].includes(
+        request.current_state
+      );
+      if (terminal !== (request.terminal_at !== null)) {
+        context.addIssue({
+          code: z5.ZodIssueCode.custom,
+          path: ["terminal_at"],
+          message: "terminal_at must match terminal Claim Request state"
+        });
+      }
+      const transferFields = [
+        request.prior_profile_control_id,
+        request.transfer_authorization_type,
+        request.transfer_authorization_sha256
+      ];
+      if (request.intent === "transfer" && transferFields.some((value) => value === null) || request.intent !== "transfer" && transferFields.some((value) => value !== null)) {
+        context.addIssue({
+          code: z5.ZodIssueCode.custom,
+          path: ["intent"],
+          message: "transfer bindings are required only for transfer requests"
+        });
+      }
+      const recordBindings = [request.transfer_consent_event_id, request.transfer_dispute_record_id];
+      if (request.intent !== "transfer" && recordBindings.some((value) => value !== null)) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["intent"], message: "authorization records belong only to transfers" });
+      }
+      if (request.intent === "transfer") {
+        const consent = request.transfer_authorization_type === "controller_consent";
+        if (consent && (request.transfer_consent_event_id === null || request.transfer_dispute_record_id !== null) || !consent && (request.transfer_consent_event_id !== null || request.transfer_dispute_record_id === null)) {
+          context.addIssue({ code: z5.ZodIssueCode.custom, path: ["transfer_authorization_type"], message: "transfer authorization must bind exactly one matching record" });
+        }
+      }
+    });
+    CatalogProfileClaimEvidenceReferenceSchema = z5.object({
+      id: IdSchema,
+      claim_request_id: IdSchema,
+      evidence_class: z5.enum([
+        "corporate_domain_control",
+        "authenticated_channel",
+        "corroborating_relationship",
+        "reviewer_evidence",
+        "malformed_proof"
+      ]),
+      private_reference: z5.string().regex(/^private:\/\/[^\s]+$/).max(2e3),
+      reference_sha256: Sha256Schema2,
+      submitted_by: IdSchema,
+      created_at: IsoDateTimeSchema2,
+      purge_after: IsoDateTimeSchema2,
+      purge_claimed_at: IsoDateTimeSchema2.nullable(),
+      purge_claim_token: IdSchema.nullable(),
+      purge_attempt_count: z5.number().int().nonnegative()
+    }).strict().superRefine((evidence, context) => {
+      const created = new Date(evidence.created_at);
+      const maximum = new Date(created);
+      if (evidence.evidence_class === "malformed_proof") maximum.setUTCDate(maximum.getUTCDate() + 7);
+      else maximum.setTime(addUtcMonthsClamped(evidence.created_at, 24));
+      if (Date.parse(evidence.purge_after) < created.getTime() + 24 * 60 * 60 * 1e3) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["purge_after"], message: "retention is below its one-day floor" });
+      }
+      if (Date.parse(evidence.purge_after) > maximum.getTime()) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["purge_after"], message: "retention exceeds its evidence-class bound" });
+      }
+      if (evidence.purge_claimed_at === null !== (evidence.purge_claim_token === null)) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["purge_claim_token"], message: "purge claim time and token must be paired" });
+      }
+    });
+    CatalogWorkflowEventBaseSchema = z5.object({
+      id: IdSchema,
+      prior_event_id: IdSchema.nullable(),
+      actor_id: IdSchema,
+      reviewer_id: IdSchema.nullable(),
+      evidence_manifest_sha256: Sha256Schema2.nullable(),
+      reason: z5.string().trim().min(1).max(2e3).nullable(),
+      occurred_at: IsoDateTimeSchema2,
+      created_at: IsoDateTimeSchema2
     }).strict();
-    SkillSyncStateResponseSchema = z2.object({
-      machines: z2.array(SkillSyncMachineSchema),
-      total_machines: z2.number().int().nonnegative(),
-      total_targets_synced: z2.number().int().nonnegative()
+    CatalogProfileClaimRequestEventSchema = CatalogWorkflowEventBaseSchema.extend({
+      claim_request_id: IdSchema,
+      state: CatalogProfileClaimRequestStateSchema
+    }).superRefine((event, context) => {
+      if (event.state === "claim_requested" !== (event.prior_event_id === null)) {
+        context.addIssue({
+          code: z5.ZodIssueCode.custom,
+          path: ["prior_event_id"],
+          message: "only claim_requested is a root event"
+        });
+      }
+      if (["rejected", "expired", "withdrawn", "superseded"].includes(event.state) && event.reason === null) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["reason"], message: `${event.state} requires a reason` });
+      }
+    });
+    CatalogProfileControlEventSchema = CatalogWorkflowEventBaseSchema.extend({
+      profile_control_id: IdSchema,
+      state: CatalogProfileControlStateSchema
+    }).superRefine((event, context) => {
+      if (event.prior_event_id === null && event.state !== "active") {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["prior_event_id"], message: "Profile Control history must begin with active" });
+      }
+      if (event.state !== "active" && event.reason === null) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["reason"], message: `${event.state} requires a reason` });
+      }
+    });
+    CatalogProfileControlSchema = z5.object({
+      id: IdSchema,
+      profile_id: IdSchema,
+      controller_user_id: IdSchema,
+      claim_request_id: IdSchema,
+      current_state: CatalogProfileControlStateSchema,
+      next_recheck_at: IsoDateTimeSchema2,
+      created_at: IsoDateTimeSchema2,
+      terminal_at: IsoDateTimeSchema2.nullable()
+    }).strict().superRefine((control, context) => {
+      const terminal = ["transferred", "withdrawn", "expired"].includes(control.current_state);
+      if (terminal !== (control.terminal_at !== null)) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["terminal_at"], message: "terminal_at must match terminal Profile Control state" });
+      }
+    });
+    CatalogIdentityVerificationRequestSchema = z5.object({
+      id: IdSchema,
+      profile_id: IdSchema,
+      profile_control_id: IdSchema,
+      claimant_user_id: IdSchema,
+      evidence_proposer_id: IdSchema,
+      subject_kind: z5.enum(["person", "publisher"]),
+      method_version_id: IdSchema,
+      current_state: CatalogIdentityVerificationRequestStateSchema,
+      created_at: IsoDateTimeSchema2,
+      terminal_at: IsoDateTimeSchema2.nullable()
+    }).strict().superRefine((request, context) => {
+      const terminal = ["approved", "rejected", "expired", "withdrawn", "superseded"].includes(request.current_state);
+      if (terminal !== (request.terminal_at !== null)) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["terminal_at"], message: "terminal_at must match terminal Identity Request state" });
+      }
+    });
+    CatalogIdentityVerificationRequestEventSchema = CatalogWorkflowEventBaseSchema.extend({
+      identity_verification_request_id: IdSchema,
+      state: CatalogIdentityVerificationRequestStateSchema
+    }).superRefine((event, context) => {
+      if (event.state === "verification_requested" !== (event.prior_event_id === null)) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["prior_event_id"], message: "only verification_requested is a root event" });
+      }
+      if (["rejected", "expired", "withdrawn", "superseded"].includes(event.state) && event.reason === null) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["reason"], message: `${event.state} requires a reason` });
+      }
+    });
+    CatalogIdentityEvidenceReferenceSchema = z5.object({
+      id: IdSchema,
+      identity_verification_request_id: IdSchema,
+      evidence_kind: z5.enum([
+        "government_photo_id",
+        "live_face_match",
+        "controlled_domain",
+        "publishing_account",
+        "derived_match",
+        "reviewer_evidence"
+      ]),
+      private_reference: z5.string().regex(/^private:\/\/[^\s]+$/).max(2e3),
+      reference_sha256: Sha256Schema2,
+      derived_result: z5.string().trim().min(1).max(2e3).nullable(),
+      submitted_by: IdSchema,
+      created_at: IsoDateTimeSchema2,
+      purge_after: IsoDateTimeSchema2,
+      purge_claimed_at: IsoDateTimeSchema2.nullable(),
+      purge_claim_token: IdSchema.nullable(),
+      purge_attempt_count: z5.number().int().nonnegative()
+    }).strict().superRefine((evidence, context) => {
+      const created = new Date(evidence.created_at);
+      const maximum = new Date(created);
+      if (["government_photo_id", "live_face_match"].includes(evidence.evidence_kind)) {
+        maximum.setUTCDate(maximum.getUTCDate() + 30);
+      } else {
+        maximum.setTime(addUtcMonthsClamped(evidence.created_at, 24));
+      }
+      if (Date.parse(evidence.purge_after) < created.getTime() + 24 * 60 * 60 * 1e3) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["purge_after"], message: "retention is below its one-day floor" });
+      }
+      if (Date.parse(evidence.purge_after) > maximum.getTime()) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["purge_after"], message: "retention exceeds its evidence-kind bound" });
+      }
+      if (evidence.purge_claimed_at === null !== (evidence.purge_claim_token === null)) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["purge_claim_token"], message: "purge claim time and token must be paired" });
+      }
+    });
+    CatalogIdentityVerificationChallengeSchema = z5.object({
+      id: IdSchema,
+      identity_verification_request_id: IdSchema,
+      subject_kind: z5.enum(["person", "publisher"]),
+      challenge_secret_hash: Sha256Schema2,
+      binding_sha256: Sha256Schema2,
+      issued_by: IdSchema,
+      issued_at: IsoDateTimeSchema2,
+      expires_at: IsoDateTimeSchema2,
+      consumed_at: IsoDateTimeSchema2.nullable(),
+      purge_after: IsoDateTimeSchema2,
+      created_at: IsoDateTimeSchema2
+    }).strict().superRefine((challenge, context) => {
+      const issued = Date.parse(challenge.issued_at);
+      if (Date.parse(challenge.expires_at) !== issued + 30 * 60 * 1e3) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["expires_at"], message: "identity challenge expires after exactly 30 minutes" });
+      }
+      if (Date.parse(challenge.purge_after) !== issued + 30 * 24 * 60 * 60 * 1e3) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["purge_after"], message: "identity challenge retention is exactly 30 days" });
+      }
+      if (challenge.consumed_at !== null) {
+        const consumed = Date.parse(challenge.consumed_at);
+        if (consumed < issued || consumed > Date.parse(challenge.expires_at)) {
+          context.addIssue({ code: z5.ZodIssueCode.custom, path: ["consumed_at"], message: "challenge consumption must occur before expiry" });
+        }
+      }
+    });
+    CatalogIdentityVerificationResultSchema = z5.object({
+      id: IdSchema,
+      identity_verification_request_id: IdSchema,
+      challenge_id: IdSchema,
+      result_kind: z5.enum(["identity_match", "liveness", "domain_control", "publishing_account_control"]),
+      outcome: z5.enum(["match", "mismatch", "inconclusive"]),
+      private_attestation_reference: z5.string().regex(/^private:\/\/[^\s]+$/).max(2e3),
+      attestation_sha256: Sha256Schema2,
+      recorded_by: IdSchema,
+      recorded_at: IsoDateTimeSchema2
     }).strict();
+    CatalogPrivateEvidenceRetentionEventSchema = z5.object({
+      id: IdSchema,
+      evidence_table: z5.enum(["catalog_profile_claim_evidence_references", "catalog_identity_evidence_references"]),
+      evidence_id: IdSchema,
+      lifecycle_table: z5.enum(["catalog_profile_claim_request_events", "catalog_identity_verification_request_events", "catalog_profile_control_events", "catalog_identity_verification_record_events"]),
+      lifecycle_event_id: IdSchema,
+      retention_policy: z5.enum(["malformed_7d", "sensitive_30d", "workflow_24m"]),
+      purge_after: IsoDateTimeSchema2,
+      prior_event_id: IdSchema.nullable(),
+      occurred_at: IsoDateTimeSchema2,
+      created_at: IsoDateTimeSchema2
+    }).strict();
+    CatalogPrivateEvidenceLegalHoldEventSchema = z5.object({
+      id: IdSchema,
+      evidence_table: z5.enum(["catalog_profile_claim_evidence_references", "catalog_identity_evidence_references"]),
+      evidence_id: IdSchema,
+      action: z5.enum(["placed", "released"]),
+      prior_event_id: IdSchema.nullable(),
+      actor_id: IdSchema,
+      reviewer_id: IdSchema,
+      reason: z5.string().trim().min(1).max(2e3),
+      occurred_at: IsoDateTimeSchema2,
+      created_at: IsoDateTimeSchema2
+    }).strict().superRefine((event, context) => {
+      if (event.actor_id === event.reviewer_id) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["reviewer_id"], message: "legal hold review must be independent" });
+      }
+      if (event.action === "placed" !== (event.prior_event_id === null)) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["prior_event_id"], message: "hold placement is the root and release is its successor" });
+      }
+    });
+    CatalogPrivateEvidenceDeletionReceiptSchema = z5.object({
+      id: IdSchema,
+      evidence_table: z5.enum(["catalog_profile_claim_evidence_references", "catalog_identity_evidence_references"]),
+      evidence_id: IdSchema,
+      claim_token: IdSchema,
+      private_reference_sha256: Sha256Schema2,
+      storage_receipt_reference: z5.string().regex(/^storage:\/\/[^\s]+$/).max(2e3),
+      storage_receipt_sha256: Sha256Schema2,
+      acknowledged_by: IdSchema,
+      storage_deleted_at: IsoDateTimeSchema2,
+      created_at: IsoDateTimeSchema2
+    }).strict();
+    CatalogIdentityVerificationRecordSchema = z5.object({
+      id: IdSchema,
+      identity_verification_request_id: IdSchema,
+      profile_id: IdSchema,
+      profile_control_id: IdSchema,
+      subject_kind: z5.enum(["person", "publisher"]),
+      method_version_id: IdSchema,
+      derived_evidence_sha256: Sha256Schema2,
+      current_state: CatalogIdentityVerificationRecordStateSchema,
+      created_at: IsoDateTimeSchema2,
+      terminal_at: IsoDateTimeSchema2.nullable()
+    }).strict().superRefine((record, context) => {
+      const terminal = ["revoked", "expired"].includes(record.current_state);
+      if (terminal !== (record.terminal_at !== null)) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["terminal_at"], message: "terminal_at must match terminal Identity Record state" });
+      }
+    });
+    CatalogIdentityVerificationRecordEventSchema = z5.object({
+      id: IdSchema,
+      identity_verification_record_id: IdSchema,
+      state: CatalogIdentityVerificationRecordStateSchema,
+      prior_event_id: IdSchema.nullable(),
+      actor_id: IdSchema,
+      reviewer_id: IdSchema.nullable(),
+      reason: z5.string().trim().min(1).max(2e3).nullable(),
+      occurred_at: IsoDateTimeSchema2,
+      created_at: IsoDateTimeSchema2
+    }).strict().superRefine((event, context) => {
+      if (event.state === "active" !== (event.prior_event_id === null)) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["prior_event_id"], message: "only the initial active state is a root event" });
+      }
+      if (event.state !== "active" && event.reason === null) {
+        context.addIssue({ code: z5.ZodIssueCode.custom, path: ["reason"], message: `${event.state} requires a reason` });
+      }
+    });
   }
 });
 
@@ -2751,6 +3835,8 @@ var init_src = __esm({
     init_install_targets();
     init_security_scan();
     init_skill_package();
+    init_catalog();
+    init_catalog_trust();
     init_contract();
   }
 });
@@ -3070,8 +4156,8 @@ import { mkdir as mkdir2, readFile as readFile3, writeFile, chmod } from "node:f
 
 // src/lib/invocation.ts
 var NPX_HINTS = ["_npx", "npm-cache/_npx", "npm-cache\\_npx", ".npm/_npx"];
-var NPX_INVOCATION = "npx -y @floomhq/floom";
-var GLOBAL_INVOCATION = "floom";
+var NPX_INVOCATION = "npx -y @floomhq/skills";
+var GLOBAL_INVOCATION = "floom-skills";
 var cached = null;
 function detect() {
   const override = process.env.FLOOM_INVOKED_AS;
@@ -3089,16 +4175,16 @@ function cliInvocation() {
   return cached;
 }
 function cliCmd(cmd) {
-  const stripped = cmd.startsWith("floom ") ? cmd.slice("floom ".length) : cmd;
+  const stripped = cmd.startsWith("floom-skills ") ? cmd.slice("floom-skills ".length) : cmd.startsWith("floom ") ? cmd.slice("floom ".length) : cmd;
   return `${cliInvocation()} ${stripped}`;
 }
 
 // src/config.ts
 var CONFIG_DIR = join3(homedir2(), ".floom");
 var AUTH_FILE = join3(CONFIG_DIR, "auth.json");
-var DEFAULT_APP_URL = "https://floom.dev";
-var DEFAULT_API_URL = "https://floom.dev/api/v1";
-var TRUSTED_API_HOSTS = /* @__PURE__ */ new Set(["floom.dev", "try.floom.dev"]);
+var DEFAULT_APP_URL = "https://skills.floom.dev";
+var DEFAULT_API_URL = "https://skills.floom.dev/api/v1";
+var TRUSTED_API_HOSTS = /* @__PURE__ */ new Set(["skills.floom.dev"]);
 var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1"]);
 function devModeEnabled() {
   const v = process.env.FLOOM_DEV;
@@ -3112,7 +4198,7 @@ function isTrustedApiUrl(apiUrl) {
       return url.protocol === "https:";
     }
     if (LOOPBACK_HOSTS.has(url.hostname) && devModeEnabled()) {
-      return true;
+      return url.protocol === "http:" || url.protocol === "https:";
     }
     return false;
   } catch {
@@ -3149,13 +4235,13 @@ async function readRawAuth() {
         `Cannot read your Floom auth file (permission denied).
   Fix: chmod 600 ~/.floom/auth.json
   Or re-authenticate: ${cliCmd("login")}
-  More help: https://floom.dev/docs#troubleshooting`
+  More help: https://skills.floom.dev/docs#troubleshooting`
       );
     }
     throw new Error(
       `Cannot read your Floom auth file.
   Run: ${cliCmd("login")}
-  More help: https://floom.dev/docs#troubleshooting`
+  More help: https://skills.floom.dev/docs#troubleshooting`
     );
   }
   try {
@@ -3164,7 +4250,7 @@ async function readRawAuth() {
     throw new Error(
       `Your Floom auth file is corrupted.
   Run: ${cliCmd("login")} to generate a fresh one.
-  More help: https://floom.dev/docs#troubleshooting`
+  More help: https://skills.floom.dev/docs#troubleshooting`
     );
   }
 }
@@ -3193,7 +4279,11 @@ function getApiUrl() {
   return DEFAULT_API_URL;
 }
 function getAppUrl() {
-  return process.env.FLOOM_APP_URL ?? DEFAULT_APP_URL;
+  const configured = process.env.FLOOM_APP_URL?.trim();
+  if (!configured) return DEFAULT_APP_URL;
+  const normalized = trustedApiUrlOrDefault(`${configured.replace(/\/$/, "")}/api/v1`);
+  if (normalized === DEFAULT_API_URL) return DEFAULT_APP_URL;
+  return normalized.replace(/\/api\/v1$/, "");
 }
 function getApiBaseUrls(preferred) {
   const explicitApiUrl = process.env.FLOOM_API_URL?.trim();
@@ -3287,7 +4377,7 @@ async function getMachineIdentity() {
 }
 
 // src/version.ts
-var VERSION = "1.0.2";
+var VERSION = "1.1.0";
 
 // src/api-client.ts
 var DEFAULT_TIMEOUT_MS = 2e4;
@@ -3334,7 +4424,7 @@ async function readLimitedText(res, limitBytes = MAX_ERROR_BODY_BYTES) {
   return truncated ? `${text}
 [truncated]` : text;
 }
-var HELP = "https://floom.dev/docs#troubleshooting";
+var HELP = "https://skills.floom.dev/docs#troubleshooting";
 function friendlyApiErrorMessage(code, raw, status) {
   if (code === "AUTH_REQUIRED" || code === "TOKEN_INVALID" || status === 401) {
     return `Not signed in.
@@ -3361,7 +4451,7 @@ function friendlyApiErrorMessage(code, raw, status) {
   }
   if (code === "CLI_VERSION_TOO_OLD") {
     return `Your CLI is out of date.
-  Run: npm i -g @floomhq/floom@latest
+  Run: npm i -g @floomhq/skills@latest
   More help: ${HELP}`;
   }
   if (code === "FILE_TOO_LARGE" || code === "BUNDLE_TOO_LARGE") {
@@ -3382,7 +4472,7 @@ async function api(path, opts = {}) {
       "AUTH_REQUIRED",
       `Not signed in.
   Run: ${cliCmd("login")}
-  More help: https://floom.dev/docs#troubleshooting`
+  More help: https://skills.floom.dev/docs#troubleshooting`
     );
   }
   let lastError = null;
@@ -3416,9 +4506,9 @@ async function api(path, opts = {}) {
     } catch (e) {
       lastError = new FloomError(
         "INTERNAL_ERROR",
-        `Cannot reach Floom (${base}): ${e.message}
+        `Cannot reach Floom Skills (${base}): ${e.message}
   Check your internet connection or firewall. If on a corporate network, you may need to set a proxy: npm config set proxy http://...
-  More help: https://floom.dev/docs#troubleshooting`,
+  More help: https://skills.floom.dev/docs#troubleshooting`,
         { apiUrl: base }
       );
       continue;
@@ -3606,7 +4696,7 @@ Fix: replace the link with the real file contents:
 
 (or move the target file under the skill folder if it lives elsewhere)
 
-More help: https://floom.dev/docs#skill-folder-rules`
+More help: https://skills.floom.dev/docs#skill-folder-rules`
         );
       }
       if (entry.isDirectory()) {
@@ -3772,7 +4862,7 @@ async function loginCommand() {
         ]);
         if (cliCmd("login").startsWith("npx ")) {
           log.blank();
-          log.info("  Tip: install once with  npm i -g @floomhq/floom  and just type `floom` after that.");
+          log.info("  Tip: install once with  npm i -g @floomhq/skills  and just type `floom-skills` after that.");
         }
         return;
       }
@@ -3793,7 +4883,7 @@ async function loginCommand() {
   log.err("Login timed out \u2014 the browser window expired.");
   printNext([
     { command: cliCmd("login"), description: "try again" },
-    { command: "More help: https://floom.dev/docs#troubleshooting" }
+    { command: "More help: https://skills.floom.dev/docs#troubleshooting" }
   ]);
   process.exitCode = 1;
 }
@@ -3817,7 +4907,7 @@ async function logoutCommand(opts = {}, deps = {}) {
         remoteRevokeFailed = true;
         process.exitCode = 1;
         log.err(
-          "Local session cleared. Other devices are still authenticated.\nSign in at https://floom.dev/settings to revoke other sessions from the web."
+          "Local session cleared. Other devices are still authenticated.\nSign in at https://skills.floom.dev/settings to revoke other sessions from the web."
         );
       } else {
         log.warn(`Remote session revoke failed: ${error.message}`);
@@ -3940,7 +5030,7 @@ async function accountCommand(opts = {}) {
 init_src();
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z as z3 } from "zod";
+import { z as z6 } from "zod";
 
 // src/commands/sync-engine.ts
 init_src();
@@ -4011,9 +5101,9 @@ async function readManifest(root) {
     if (err.code === "ENOENT") return null;
     if (error instanceof SyntaxError || error instanceof ZodError) {
       throw new Error(
-        `Corrupted manifest at ${manifestPath(root)}. Remove that file or run floom pull after backing up local edits.
-  Run: rm ${manifestPath(root)} && npx -y @floomhq/floom pull
-  More help: https://floom.dev/docs#troubleshooting`
+        `Corrupted manifest at ${manifestPath(root)}. Remove that file or run floom-skills pull after backing up local edits.
+  Run: rm ${manifestPath(root)} && npx -y @floomhq/skills pull
+  More help: https://skills.floom.dev/docs#troubleshooting`
       );
     }
     throw error;
@@ -4476,7 +5566,7 @@ function createMcpServer(deps = {}) {
     {
       title: "Floom Search Skills",
       description: "Search the authenticated workspace skill library by keyword. Returns matching skills with title and description.",
-      inputSchema: { query: z3.string().describe("Search query string") },
+      inputSchema: { query: z6.string().describe("Search query string") },
       annotations: {
         readOnlyHint: true,
         destructiveHint: false,
@@ -4502,7 +5592,7 @@ function createMcpServer(deps = {}) {
           query,
           status: "error",
           message: err.message,
-          hint: "Run: npx -y @floomhq/floom login"
+          hint: "Run: npx -y @floomhq/skills login"
         });
       }
     }
@@ -4512,7 +5602,7 @@ function createMcpServer(deps = {}) {
     {
       title: "Floom Get Skill",
       description: "Fetch full skill detail (body, files, version history) for a given skill slug from the workspace.",
-      inputSchema: { slug: z3.string().describe("Skill slug, e.g. 'brand-voice'") },
+      inputSchema: { slug: z6.string().describe("Skill slug, e.g. 'brand-voice'") },
       annotations: {
         readOnlyHint: true,
         destructiveHint: false,
@@ -4538,7 +5628,7 @@ function createMcpServer(deps = {}) {
           slug,
           status: "error",
           message: err.message,
-          hint: "Run: npx -y @floomhq/floom login"
+          hint: "Run: npx -y @floomhq/skills login"
         });
       }
     }
@@ -4549,8 +5639,8 @@ function createMcpServer(deps = {}) {
       title: "Floom Send Feedback",
       description: "Send feedback, a feature request, or a bug report to the Floom team.",
       inputSchema: {
-        message: z3.string().describe("Feedback message"),
-        type: z3.enum(["feedback", "bug", "feature"]).default("feedback").describe("Type of feedback")
+        message: z6.string().describe("Feedback message"),
+        type: z6.enum(["feedback", "bug", "feature"]).default("feedback").describe("Type of feedback")
       },
       annotations: {
         readOnlyHint: false,
@@ -4590,10 +5680,10 @@ async function mcpCommand() {
 This command is launched by your AI agent, not run directly.
 
 Add this to your agent's MCP configuration:
-  {"command":"npx","args":["-y","@floomhq/floom","mcp"]}
+  {"command":"npx","args":["-y","@floomhq/skills","mcp"]}
 
 Claude Code users can instead run:
-  claude mcp add floom -- npx -y @floomhq/floom mcp
+  claude mcp add floom -- npx -y @floomhq/skills mcp
 
 Press Ctrl+C to stop.
 `
@@ -5004,7 +6094,7 @@ async function pushExplicitPath(pathArg, options, pushApi, authed) {
   if (!await hasSkillMd(folder)) {
     if (!json) {
       log.err(`No SKILL.md at the root of ${pathArg}.`);
-      log.info("  Every skill folder needs a SKILL.md at its root. See: https://floom.dev/docs#concept");
+      log.info("  Every skill folder needs a SKILL.md at its root. See: https://skills.floom.dev/docs#concept");
     }
     process.exitCode = 2;
     return;
@@ -5486,7 +6576,7 @@ async function pullCommand(skillArg, rawOpts = {}) {
         log.blank();
         log.info(`Or use: ${cliCmd("pull --agent claude")}`);
         log.blank();
-        log.info("More help: https://floom.dev/docs#agents");
+        log.info("More help: https://skills.floom.dev/docs#agents");
       }
       process.exitCode = 1;
       return;
@@ -5817,7 +6907,7 @@ function printPreview(plan) {
       log.err(`    Keep your local version:  ${cliCmd(`push <${skill.slug}-dir>`)}`);
     }
     log.err("Your local copy is always backed up to .floom/backups/ first.");
-    log.err("More: https://floom.dev/docs#conflicts");
+    log.err("More: https://skills.floom.dev/docs#conflicts");
   }
 }
 async function defaultConfirmProceed() {
@@ -6042,7 +7132,7 @@ async function syncCommand(rawOpts = {}, deps = {}) {
       } else {
         log.err("No agents detected \u2014 install Claude, Codex, Cursor, Gemini, or OpenCode, then re-run.");
         log.info("Floom syncs into one of: Claude, Codex, Cursor, Gemini, OpenCode.");
-        log.info("More: https://floom.dev/docs#agents");
+        log.info("More: https://skills.floom.dev/docs#agents");
       }
       process.exitCode = 1;
       return;
@@ -6329,7 +7419,7 @@ async function statusCommand(rawOpts = {}) {
       log.info("If someone sent you a shared skill:");
       log.command(cliCmd("install <link>"));
       log.blank();
-      log.info("More help: https://floom.dev/docs#agents");
+      log.info("More help: https://skills.floom.dev/docs#agents");
     }
     process.exitCode = 1;
     return;
@@ -6619,19 +7709,28 @@ init_prompt();
 var TOKEN_RE = /^fls_[A-Za-z0-9_-]{32,}$/;
 var SAFE_SLUG_RE2 = /^(?=.{1,80}$)[a-z0-9]+(?:-[a-z0-9]+)*$/;
 var MAX_DECODED_FILE_BYTES2 = 2 * 1024 * 1024;
-function parseToken(input) {
+function trustedCatalogOrigin(url) {
+  if (url.protocol === "https:") return true;
+  const dev = process.env.FLOOM_DEV;
+  const devMode = dev === "1" || dev === "true";
+  return devMode && url.protocol === "http:" && (url.hostname === "127.0.0.1" || url.hostname === "localhost");
+}
+function parseInstallSource(input) {
   const trimmed = input.trim();
-  if (TOKEN_RE.test(trimmed)) return trimmed;
+  if (TOKEN_RE.test(trimmed)) return { kind: "share", token: trimmed };
+  let url;
   try {
-    const url = new URL(trimmed);
-    const parts = url.pathname.split("/").filter(Boolean);
-    if (parts.length >= 2 && parts[parts.length - 2] === "s") {
-      const candidate = parts[parts.length - 1];
-      if (candidate && TOKEN_RE.test(candidate)) return candidate;
-    }
-    const last = parts[parts.length - 1];
-    if (last && TOKEN_RE.test(last)) return last;
+    url = new URL(trimmed);
   } catch {
+    return null;
+  }
+  const parts = url.pathname.split("/").filter(Boolean);
+  const last = parts[parts.length - 1];
+  const parent = parts.length >= 2 ? parts[parts.length - 2] : null;
+  if (parent === "s" && last && TOKEN_RE.test(last)) return { kind: "share", token: last };
+  if (last && TOKEN_RE.test(last)) return { kind: "share", token: last };
+  if (parent === "skills" && last && SAFE_SLUG_RE2.test(last) && trustedCatalogOrigin(url)) {
+    return { kind: "catalog", origin: url.origin, slug: last };
   }
   return null;
 }
@@ -6666,9 +7765,9 @@ function bytesForShareFile(file) {
 function derivedSlug(title) {
   return title.toLowerCase().replace(/[^a-z0-9 -]/g, "").trim().replace(/\s+/g, "-").replace(/-+/g, "-").slice(0, 80).replace(/^-+|-+$/g, "") || "shared-skill";
 }
-async function fetchPublicShare(token) {
-  const apiBase = getAppUrl().replace(/\/$/, "");
-  const url = `${apiBase}/api/v1/share/${encodeURIComponent(token)}`;
+async function fetchInstallSource(source) {
+  const url = source.kind === "share" ? `${getAppUrl().replace(/\/$/, "")}/api/v1/share/${encodeURIComponent(source.token)}` : `${source.origin}/api/v1/catalog/install/skills/${encodeURIComponent(source.slug)}`;
+  const notFoundMessage = source.kind === "share" ? "Share link not found or has been revoked." : "Install link not found or has been withdrawn.";
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), 3e4);
   let res;
@@ -6681,7 +7780,7 @@ async function fetchPublicShare(token) {
     clearTimeout(timer);
   }
   if (res.status === 404) {
-    throw new FloomError("SKILL_NOT_FOUND", "Share link not found or has been revoked.");
+    throw new FloomError("SKILL_NOT_FOUND", notFoundMessage);
   }
   if (!res.ok) throw new Error(`Floom API returned HTTP ${res.status}. Try again in a moment.`);
   let json;
@@ -6763,17 +7862,18 @@ async function installCommand(input, rawOpts = {}) {
     throw error;
   }
   const json = flags.json;
-  const token = parseToken(input);
-  if (!token) {
+  const source = parseInstallSource(input);
+  if (!source) {
     if (!json) {
-      log.err("That doesn't look like a Floom share link. It should look like: https://floom.dev/s/fls_xxx");
+      log.err("That doesn't look like a Floom share link. It must look like: https://skills.floom.dev/s/fls_xxx");
+      log.info("A public catalog Skill page also works: https://<catalog host>/skills/<slug>");
     }
     process.exitCode = 2;
     return;
   }
   let shareData;
   try {
-    shareData = await fetchPublicShare(token);
+    shareData = await fetchInstallSource(source);
   } catch (e) {
     if (!json) {
       log.err(e instanceof FloomError ? e.message : e.message);
@@ -6798,7 +7898,7 @@ async function installCommand(input, rawOpts = {}) {
       log.info("Floom can install shared skills into Claude, Codex, Cursor, Gemini, or OpenCode.");
       log.info("Install one of those agents, then run this command again.");
       log.blank();
-      log.info("More help: https://floom.dev/docs#agents");
+      log.info("More help: https://skills.floom.dev/docs#agents");
     }
     process.exitCode = 1;
     return;
@@ -7005,7 +8105,7 @@ description: TODO: Use when the user needs help with [specific task, workflow, o
 <!--
 This file teaches your AI agent when and how to use the skill.
 Keep it practical: triggers, rules, examples, and done criteria.
-See: https://floom.dev/docs/skills
+See: https://skills.floom.dev/docs/skills
 -->
 
 Use this skill when:
@@ -7250,7 +8350,7 @@ function npmLatest() {
   return new Promise((resolveP) => {
     let child;
     try {
-      child = spawn3("npm", ["view", "@floomhq/floom", "version"], { stdio: ["ignore", "pipe", "ignore"] });
+      child = spawn3("npm", ["view", "@floomhq/skills", "version"], { stdio: ["ignore", "pipe", "ignore"] });
     } catch {
       resolveP(null);
       return;
@@ -7303,7 +8403,7 @@ async function doctorCommand(opts = {}) {
     }
   }
   if (authOk) {
-    checks.push({ name: "api", status: "pass", message: "https://floom.dev reachable", fix: null });
+    checks.push({ name: "api", status: "pass", message: "https://skills.floom.dev reachable", fix: null });
   } else {
     checks.push({ name: "api", status: "warn", message: "skipped \u2014 sign in first", fix: cliCmd("login") });
   }
@@ -7370,11 +8470,11 @@ async function doctorCommand(opts = {}) {
   }
   const latest = await npmLatest();
   if (!latest) {
-    checks.push({ name: "version", status: "warn", message: `@floomhq/floom ${VERSION}; latest version unreachable`, fix: null });
+    checks.push({ name: "version", status: "warn", message: `@floomhq/skills ${VERSION}; latest version unreachable`, fix: null });
   } else if (significantlyOutdated(VERSION, latest)) {
-    checks.push({ name: "version", status: "warn", message: `@floomhq/floom ${VERSION} installed, latest is ${latest}`, fix: "npx -y @floomhq/floom@latest" });
+    checks.push({ name: "version", status: "warn", message: `@floomhq/skills ${VERSION} installed, latest is ${latest}`, fix: "npx -y @floomhq/skills@latest" });
   } else {
-    checks.push({ name: "version", status: "pass", message: `@floomhq/floom ${VERSION} is current`, fix: null });
+    checks.push({ name: "version", status: "pass", message: `@floomhq/skills ${VERSION} is current`, fix: null });
   }
   const failures = checks.filter((c) => c.status === "fail");
   const warnings = checks.filter((c) => c.status === "warn");
@@ -8119,8 +9219,8 @@ var COMMON_FLAGS = `Common flags
   --no-secret-check  with push, skip the pre-publish secret scan`;
 function printGroupedHelp() {
   const out2 = process.stdout;
-  out2.write("\n" + chalk7.bold("Usage: floom [command]") + "\n\n");
-  out2.write(`  ${chalk7.cyan.bold("floom")}              your dashboard \u2014 Library and agent status at a glance
+  out2.write("\n" + chalk7.bold("Usage: floom-skills [command]") + "\n\n");
+  out2.write(`  ${chalk7.cyan.bold("floom-skills")}       your dashboard \u2014 Library and agent status at a glance
 `);
   const allNames = GROUPS.flatMap((g) => g.rows.map((r) => r.name));
   const width = Math.max(...allNames.map((n) => n.length), 14);
@@ -8133,7 +9233,7 @@ function printGroupedHelp() {
     }
   }
   out2.write("\n" + COMMON_FLAGS + "\n");
-  out2.write("\n" + chalk7.dim("More help: https://floom.dev/docs") + "\n");
+  out2.write("\n" + chalk7.dim("More help: https://skills.floom.dev/docs") + "\n");
 }
 
 // src/index.ts
@@ -8144,7 +9244,7 @@ function aliasNotice(oldName, newName) {
   log.notice(`"${oldName}" is now "${newName}" \u2014 both work for now.`);
 }
 var program = new Command();
-program.name("floom").description("Floom: one shared skill library, synced across every AI agent.").version(VERSION).addHelpCommand(false).helpOption("-h, --help", "show grouped help").allowExcessArguments(true).showSuggestionAfterError(true).showHelpAfterError(false);
+program.name("floom-skills").description("Floom Skills: publish, install, sync, and share AI agent skills.").version(VERSION).addHelpCommand(false).helpOption("-h, --help", "show grouped help").allowExcessArguments(true).showSuggestionAfterError(true).showHelpAfterError(false);
 program.helpInformation = function helpInformation() {
   printGroupedHelp();
   return "";
@@ -8159,8 +9259,8 @@ program.action(async (_opts, cmd) => {
     log.err(`unknown command: ${unknown}`);
     const knownNames = program.commands.map((c) => c.name());
     const suggestion = closestCommand(unknown, knownNames);
-    if (suggestion) log.info(`Did you mean: floom ${suggestion}?`);
-    log.info("Run: floom --help");
+    if (suggestion) log.info(`Did you mean: floom-skills ${suggestion}?`);
+    log.info("Run: floom-skills --help");
     process.exitCode = 2;
     return;
   }