@bendyline/gezel-catalog 1.0.6 → 1.1.0

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import { CatalogKind, CatalogItemSummary, CatalogItemDetail, CatalogItemVersionInfo, CraftbookTestSpec, ToolsetCategory, ToolsetManifest } from '@bendyline/gezel';
+import { CatalogKind, CatalogItemSummary, CatalogItemDetail, CatalogItemVersionInfo, CraftbookTestSpec, ToolsetCategory, CraftbookDoc, NewCraftbookStep, CraftbookStepWritableOutputMedium, CraftbookStepOutputMedium, ToolsetManifest } from '@bendyline/gezel';
+import { z } from 'zod';
 
 /**
  * ─ CatalogSource ───────────────────────────────────────────────────
@@ -43,7 +44,7 @@ interface CatalogSource {
     readItemFile(kind: CatalogKind, id: string, relPath: string, version?: string): Promise<Buffer | null>;
     /**
      * Optional: every file under an item's folder as item-relative paths. Only
-     * on-disk sources implement it (used by the `.gzl` exporter); synthetic
+     * on-disk sources implement it (used by the `.gezapp` exporter); synthetic
      * sources (builtin toolsets) omit it.
      */
     listItemFiles?(kind: CatalogKind, id: string): Promise<string[]>;
@@ -122,7 +123,7 @@ declare class BundledSource implements CatalogSource {
     /**
      * Every file under an item's folder, as item-relative paths (e.g.
      * `manifest.json`, `versions/1.0.0/pages/gallery/index.html`), sorted. Used
-     * by the `.gzl` exporter to pack an item verbatim — pages, seeds, and all
+     * by the `.gezapp` exporter to pack an item verbatim — pages, seeds, and all
      * assets, not just the ones the manifest names. Read each back with
      * `readItemFile(kind, id, relPath)` (no version → item-relative). Empty when
      * the item folder is missing.
@@ -172,9 +173,11 @@ declare class BundledSource implements CatalogSource {
  *
  *   1. BuiltinToolsetsSource — synthetic groups for our in-process MCP
  *      server. Tools we ship and own.
- *   2. BundledSource — pre-reviewed third-party catalog shipped with
+ *   2. InstalledAiAppsSource — active `.gezapp` packages mounted as units.
+ *   3. LocalCatalogSource — manually authored/imported user content.
+ *   4. BundledSource — pre-reviewed third-party catalog shipped with
  *      the app (`data/`). Hand-curated.
- *   3. CommunitySource — auto-imported entries from the upstream MCP
+ *   5. CommunitySource — auto-imported entries from the upstream MCP
  *      registry (`data/community/`). Permissively-licensed only;
  *      treated as a second tier that the UI can label distinctly.
  *
@@ -185,9 +188,9 @@ declare class CatalogService {
     private readonly contentRootProvider;
     /**
      * @param sources explicit source list (replaces the defaults entirely).
-     * @param opts.localRoot a GEZEL_HOME to read user-installed / `.gzl`-imported
-     *   catalog items from (project types + gezel roles). Appended just ahead of
-     *   the bundled tier so a user's imported item shadows a same-id bundled one.
+     * @param opts.localRoot a GEZEL_HOME to read user-installed catalog items and
+     *   mounted `.gezapp` packages from. Both sit ahead of the bundled tier so a
+     *   user's installed item shadows a same-id bundled one.
      * @param opts.contentRoot dynamic gilde content root for the default
      *   bundled + community tiers, re-read on every disk access. The live
      *   gilde update mechanism flips it without reconstructing this service
@@ -217,7 +220,7 @@ declare class CatalogService {
         label: string;
     }>;
     /**
-     * Merged listing across sources. Items from earlier sources (bundled)
+     * Merged listing across sources. Items from earlier sources
      * shadow later sources (remote) on id collision.
      */
     list(kind: CatalogKind): Promise<CatalogItemSummary[]>;
@@ -288,6 +291,29 @@ declare class LocalCatalogSource extends BundledSource {
     listItemFiles(kind: CatalogKind, id: string): Promise<string[]>;
 }
 
+/**
+ * Dynamic catalog source over the active `.gezapp` registry. Package versions
+ * stay mounted as units under `~/.gezel/ai-apps/`; the importer never flattens
+ * their files into the generic local catalog, so provenance and uninstall
+ * remain tractable.
+ */
+declare class InstalledAiAppsSource implements CatalogSource {
+    private readonly home;
+    private readonly gezelVersion?;
+    readonly id = "installed-ai-apps";
+    readonly label = "AI Apps";
+    constructor(home: string, gezelVersion?: string | undefined);
+    listKinds(): Promise<CatalogKind[]>;
+    list(kind: CatalogKind): Promise<CatalogItemSummary[]>;
+    get(kind: CatalogKind, id: string, version?: string): Promise<CatalogItemDetail | null>;
+    listVersions(kind: CatalogKind, id: string): Promise<CatalogItemVersionInfo[]>;
+    readItemFile(kind: CatalogKind, id: string, relPath: string, version?: string): Promise<Buffer | null>;
+    listItemFiles(kind: CatalogKind, id: string): Promise<string[]>;
+    private registry;
+    private sources;
+    private rescope;
+}
+
 /**
  * Categorize a toolset by its identity-manifest fields. The order of
  * checks matches the priority order of `RULES` above.
@@ -304,6 +330,58 @@ declare function categorizeToolset(input: {
     maintainerName?: string;
 }): ToolsetCategory;
 
+/** Resolve the authored blueprint's primary result drawer without prompt inference. */
+declare function outputMediumForCraftbookBlueprint(step: NewCraftbookStep): CraftbookStepOutputMedium;
+/**
+ * Every output surface the authored step procedure requires after applying
+ * the same inference used to persist generated policies. Runtime consumers
+ * use this as a compatibility floor for tasks embedded from an older catalog
+ * whose generated `additionalOutputMedia` predates the current detector.
+ */
+declare function outputMediaForCraftbookBlueprint(step: NewCraftbookStep): ReadonlySet<CraftbookStepWritableOutputMedium>;
+/**
+ * Add deterministic subtractive policies to every top-level and fanout step.
+ * Existing authored denials are preserved; generated defaults only add
+ * groups for which the procedure carries no positive signal.
+ */
+declare function applyDefaultCraftbookStepPolicies(doc: CraftbookDoc): CraftbookDoc;
+
+/**
+ * The gilde `schemas/` payload, defined once and consumed twice: the
+ * `export-gilde-schemas` script writes it into a gilde checkout, and
+ * `gilde-schema-freshness.test.ts` diffs it against the gilde this build
+ * actually resolves.
+ *
+ * The two consumers resolve gilde differently on purpose. The script
+ * writes to the sibling checkout (`GILDE_DIR`) because that is what you
+ * PR; the test reads the RESOLVED package (`gildePackageRoot()`) because
+ * that is what gezel ships against. With `pnpm link:gilde` they are the
+ * same tree; without it, the test is checking the pinned tarball.
+ *
+ * Why the test exists: gilde's `build-index` normalizes every manifest
+ * through these committed JSON Schemas, and a property the schema does
+ * not declare is dropped from the published `index.json` — which is the
+ * fast path `BundledSource` reads at runtime. So a core schema field
+ * added without re-exporting does not fail anywhere; it is silently
+ * erased from shipped content. Three craftbooks were shipping that way
+ * (`pull-request-review` lost `corpusCoverage.artifact`,
+ * `powerpoint-deck` lost `markdownHeadingsMatch.outlineArtifact`,
+ * `invoice-run` lost `spawn.overArtifact`) before anyone noticed.
+ */
+
+/**
+ * `unrepresentable` stays at its default ('throw') so a future transform
+ * in a published schema fails loudly here instead of silently weakening
+ * gilde validation.
+ */
+declare function renderSchema(filename: string, schema: z.ZodType): string;
+/**
+ * Every file the gilde `schemas/` directory should contain, as exact
+ * file contents. Byte-for-byte what the exporter writes, so a test can
+ * compare against the committed copies without reimplementing anything.
+ */
+declare function renderGildeSchemaFiles(): Array<[filename: string, content: string]>;
+
 /**
  * ─ Built-in toolsets ────────────────────────────────────────────────
  *
@@ -485,10 +563,10 @@ declare function validateGildeContentUpgrade(opts: {
 /**
  * Tiny Hugging Face Hub API client used by catalog tooling.
  *
- * Scope: enough to list the files in a model repo and extract their
- * sha256 + size for manifest generation. Not a general-purpose HF SDK —
- * we don't need authentication, dataset endpoints, model cards, or
- * downloads (the install path has its own streaming downloader).
+ * Scope: enough to list the files in a model or dataset repo and extract
+ * their sha256 + size for manifest generation. Not a general-purpose HF SDK —
+ * we don't need authentication, model cards, or downloads (the install path
+ * has its own streaming downloader).
  *
  * The Hub publishes file metadata at `/api/models/<repo>/tree/<rev>`.
  * Each entry looks like:
@@ -521,9 +599,13 @@ interface HfFileEntry {
     /** True when the sha came from `lfs.oid` (a real sha256). */
     lfsBacked: boolean;
 }
+/** Hub repository kind; the API path differs (`/api/models/` vs `/api/datasets/`). */
+type HfRepoType = 'model' | 'dataset';
 interface FetchTreeOptions {
     /** Branch / tag / commit. Defaults to `main`. */
     rev?: string;
+    /** Defaults to `model`. Knowledge catalogs live in dataset repos. */
+    repoType?: HfRepoType;
     /** Test seam — defaults to global fetch. */
     fetchImpl?: typeof fetch;
 }
@@ -545,6 +627,7 @@ declare function fetchHuggingfaceTree(repo: string, opts?: FetchTreeOptions): Pr
  */
 declare function fetchHuggingfaceCommit(repo: string, opts?: {
     rev?: string;
+    repoType?: HfRepoType;
     fetchImpl?: typeof fetch;
 }): Promise<string>;
 /**
@@ -560,4 +643,4 @@ declare function totalSize(files: ReadonlyArray<HfFileEntry>): number;
  */
 declare function selectMlxInstallFiles(files: ReadonlyArray<HfFileEntry>): HfFileEntry[];
 
-export { BUILTIN_TOOLSETS, BUILTIN_TOOL_TO_GROUP, type BuiltinToolsetGroup, BuiltinToolsetsSource, BundledSource, type BundledSourceOptions, CatalogService, type CatalogSource, CommunitySource, type FetchTreeOptions, GILDE_PACKAGE_NAME, type GildeContentRegression, type GildeContentValidation, type GildeReleaseInfo, type HfFileEntry, LocalCatalogSource, builtinCatalogId, categorizeToolset, compareRelease, extractNpmPackageTarball, fetchGildeReleases, fetchHuggingfaceCommit, fetchHuggingfaceTree, getBuiltinToolset, gildeDataDir, gildePackageRoot, installNpmPackageToolset, isGildeReleaseVersion, pickGildePatchUpdate, publishStagedNpmInstall, recoverInterruptedNpmInstall, selectMlxInstallFiles, stageGildeVersion, totalSize, validateGildeContentUpgrade, validateNpmArchiveEntry, verifyTarballSha256 };
+export { BUILTIN_TOOLSETS, BUILTIN_TOOL_TO_GROUP, type BuiltinToolsetGroup, BuiltinToolsetsSource, BundledSource, type BundledSourceOptions, CatalogService, type CatalogSource, CommunitySource, type FetchTreeOptions, GILDE_PACKAGE_NAME, type GildeContentRegression, type GildeContentValidation, type GildeReleaseInfo, type HfFileEntry, InstalledAiAppsSource, LocalCatalogSource, applyDefaultCraftbookStepPolicies, builtinCatalogId, categorizeToolset, compareRelease, extractNpmPackageTarball, fetchGildeReleases, fetchHuggingfaceCommit, fetchHuggingfaceTree, getBuiltinToolset, gildeDataDir, gildePackageRoot, installNpmPackageToolset, isGildeReleaseVersion, outputMediaForCraftbookBlueprint, outputMediumForCraftbookBlueprint, pickGildePatchUpdate, publishStagedNpmInstall, recoverInterruptedNpmInstall, renderGildeSchemaFiles, renderSchema, selectMlxInstallFiles, stageGildeVersion, totalSize, validateGildeContentUpgrade, validateNpmArchiveEntry, verifyTarballSha256 };

package/dist/index.js

@@ -33,6 +33,8 @@ var BUILTIN_TOOLSET_ICONS = {
   tasks: `<svg ${SVG_ATTRS}><rect x="3" y="4" width="6" height="6" rx="1"/><path d="M4.5 7L6 8.5 8 5.5"/><rect x="3" y="14" width="6" height="6" rx="1"/><path d="M12 7h9M12 17h9"/></svg>`,
   // Three connected nodes — a small team.
   "team-management": `<svg ${SVG_ATTRS}><circle cx="12" cy="6" r="2.5"/><circle cx="6" cy="17" r="2.5"/><circle cx="18" cy="17" r="2.5"/><path d="M10.5 8L7.5 14.5M13.5 8l3 6.5M8.5 17h7"/></svg>`,
+  // A closed shipping box — a packaged app bundle.
+  "ai-apps": `<svg ${SVG_ATTRS}><path d="M21 8L12 3 3 8v8l9 5 9-5V8z"/><path d="M3 8l9 5 9-5"/><path d="M7.5 5.5l9 5"/></svg>`,
   // Terminal-like frame with a prompt arrow.
   "code-execution": `<svg ${SVG_ATTRS}><rect x="3" y="4" width="18" height="16" rx="2"/><path d="M7 10l3 2-3 2M13 14h4"/></svg>`,
   // Browser window + a tiny pointer.
@@ -61,8 +63,8 @@ var BUILTIN_TOOLSETS = [
   {
     id: "memory",
     name: "Memory",
-    description: "Persistent notes a gezel can search, recall, and write back. Backed by the gezel's per-day memory files plus a vector index.",
-    tools: ["search_memory", "save_memory", "list_memories"]
+    description: "Search indexed project knowledge through one unified surface, plus persistent notes a gezel can recall and write back. The generic search spans workspace content, artifacts, project/gezel memory, and shared documents.",
+    tools: ["search", "search_memory", "save_memory", "list_memories"]
   },
   {
     id: "workspace-fs-read",
@@ -168,6 +170,12 @@ var BUILTIN_TOOLSETS = [
     description: "Project-scoped read-write outputs (reports, scratch files, scripts a gezel produces, and large outputs auto-saved by tools that exceed the inline cap).",
     tools: ["list_artifacts", "read_artifact", "write_artifact", "grep_artifact"]
   },
+  {
+    id: "data-tables",
+    name: "Data Tables",
+    description: "Read a project's mirrored data tables with SQL. `list_tables` shows what is there, `describe_table` explains a table's columns and units, and `query_table` runs one read-only query and returns the answer \u2014 never the underlying rows, which is what lets a table be far larger than the context window.",
+    tools: ["list_tables", "describe_table", "query_table"]
+  },
   {
     id: "tasks",
     name: "Task Management",
@@ -243,8 +251,6 @@ var BUILTIN_TOOLSETS = [
       "list_project_types",
       "apply_project_type",
       "start_project_from_type",
-      "export_project_type",
-      "import_project_type",
       "list_project_gezels",
       "add_gezel_to_project",
       "remove_gezel_from_project",
@@ -253,6 +259,12 @@ var BUILTIN_TOOLSETS = [
       "disable_suggested_work"
     ]
   },
+  {
+    id: "ai-apps",
+    name: "AI Apps",
+    description: "Package a configured project into a shareable .gezapp bundle and install one back. Deliberately in no role default: this is a distribution chore the user drives from Settings or the `gezel app` CLI, not something a gezel reaches for mid-conversation. Install it on a gezel whose actual job is publishing app bundles.",
+    tools: ["export_ai_app", "import_ai_app"]
+  },
   {
     id: "audio",
     name: "Audio",
@@ -303,8 +315,14 @@ var BUILTIN_TOOLSETS = [
   {
     id: "web",
     name: "Web Access",
-    description: "Search the web (when a keyed backend like Brave is configured) or Wikipedia, fetch URL contents, and find interactive elements on a browser-controlled page (after a Playwright navigate / click / type). `web_search` only registers when a real keyed backend is configured; `wikipedia_search` only registers for non-cloud models (cloud models already have Wikipedia in training).",
-    tools: ["web_search", "wikipedia_search", "fetch_url", "browser_find_page_element"]
+    description: "Search the web (when a keyed backend like Brave is configured) or Wikipedia, fetch URL contents, and find interactive elements on a browser-controlled page (after a Playwright navigate / click / type). `web_search` only registers when a real keyed backend is configured; `wikipedia_search` / `wikipedia_read` only register for non-cloud models (cloud models already have Wikipedia in training). Wikipedia search results arrive with article lead text already included, so reading a result does not need a follow-up fetch.",
+    tools: [
+      "web_search",
+      "wikipedia_search",
+      "wikipedia_read",
+      "fetch_url",
+      "browser_find_page_element"
+    ]
   },
   {
     id: "images",
@@ -480,6 +498,7 @@ import {
   GEZEL_CONTENT_COMPAT,
   GezelTemplateVersionManifestSchema,
   ImageModelVersionManifestSchema,
+  KnowledgeCatalogVersionManifestSchema,
   ProjectTypeVersionManifestSchema,
   ToolsetVersionManifestSchema,
   VideoModelVersionManifestSchema,
@@ -501,7 +520,8 @@ var KINDS = [
   "connector-type",
   "chat-model",
   "image-model",
-  "video-model"
+  "video-model",
+  "knowledge-catalog"
 ];
 var KIND_DIR = {
   toolset: "toolsets",
@@ -511,7 +531,8 @@ var KIND_DIR = {
   "connector-type": "connector-types",
   "chat-model": "chat-models",
   "image-model": "image-models",
-  "video-model": "video-models"
+  "video-model": "video-models",
+  "knowledge-catalog": "knowledge-catalogs"
 };
 function shardPrefix(id) {
   return id.slice(0, 2).toLowerCase();
@@ -718,7 +739,7 @@ var BundledSource = class {
   /**
    * Every file under an item's folder, as item-relative paths (e.g.
    * `manifest.json`, `versions/1.0.0/pages/gallery/index.html`), sorted. Used
-   * by the `.gzl` exporter to pack an item verbatim — pages, seeds, and all
+   * by the `.gezapp` exporter to pack an item verbatim — pages, seeds, and all
    * assets, not just the ones the manifest names. Read each back with
    * `readItemFile(kind, id, relPath)` (no version → item-relative). Empty when
    * the item folder is missing.
@@ -1005,6 +1026,7 @@ function craftbookManifestFromDoc(identity, doc, version, availableVersions) {
     version,
     releasedAt: doc.releasedAt,
     role: identity.role,
+    ...identity.category ? { category: identity.category } : {},
     ...identity.workflow ? { workflow: identity.workflow } : {},
     // The prose lives inline on the doc (`description`) — there is no
     // separate about.md file to point at. `get()` surfaces it directly.
@@ -1020,11 +1042,15 @@ function craftbookManifestFromDoc(identity, doc, version, availableVersions) {
     ...doc.paramSchema ? { paramSchema: doc.paramSchema } : {},
     ...doc.command ? { command: doc.command } : {},
     ...doc.requirements ? { requirements: doc.requirements } : {},
+    ...doc.recommends ? { recommends: doc.recommends } : {},
     ...doc.runModes ? { runModes: doc.runModes } : {},
     ...doc.toolsets ? { toolsets: doc.toolsets } : {},
+    ...doc.commands ? { commands: doc.commands } : {},
     ...doc.connectors ? { connectors: doc.connectors } : {},
     ...doc.hooks ? { hooks: doc.hooks } : {},
     ...doc.spawn ? { spawn: doc.spawn } : {},
+    ...doc.diffpackCapable ? { diffpackCapable: true } : {},
+    ...doc.capabilityFloor ? { capabilityFloor: doc.capabilityFloor } : {},
     availableVersions
   };
 }
@@ -1065,6 +1091,10 @@ function parseVersionPayload(kind, raw) {
       const p2 = VideoModelVersionManifestSchema.parse(raw);
       return { ...p2, __kind: "video-model" };
     }
+    if (kind === "knowledge-catalog") {
+      const p2 = KnowledgeCatalogVersionManifestSchema.parse(raw);
+      return { ...p2, __kind: "knowledge-catalog" };
+    }
     const p = ImageModelVersionManifestSchema.parse(raw);
     return { ...p, __kind: "image-model" };
   } catch {
@@ -1111,6 +1141,7 @@ function mergeIdentityAndVersion(kind, identity, version, availableVersions) {
       version: version.version,
       releasedAt: version.releasedAt,
       role: identity.role,
+      ...identity.category ? { category: identity.category } : {},
       ...identity.workflow ? { workflow: identity.workflow } : {},
       about: version.about,
       steps: version.steps,
@@ -1125,6 +1156,7 @@ function mergeIdentityAndVersion(kind, identity, version, availableVersions) {
       ...version.paramSchema ? { paramSchema: version.paramSchema } : {},
       ...version.command ? { command: version.command } : {},
       ...version.requirements ? { requirements: version.requirements } : {},
+      ...version.recommends ? { recommends: version.recommends } : {},
       ...version.runModes ? { runModes: version.runModes } : {},
       ...version.toolsets ? { toolsets: version.toolsets } : {},
       ...version.connectors ? { connectors: version.connectors } : {},
@@ -1304,6 +1336,43 @@ function mergeIdentityAndVersion(kind, identity, version, availableVersions) {
       availableVersions
     };
   }
+  if (kind === "knowledge-catalog" && identity.kind === "knowledge-catalog" && version.__kind === "knowledge-catalog") {
+    return {
+      schemaVersion: 1,
+      kind: "knowledge-catalog",
+      id: identity.id,
+      name: identity.name,
+      description: identity.description,
+      tags: identity.tags,
+      maintainer: identity.maintainer,
+      ...identity.logo !== void 0 ? { logo: identity.logo } : {},
+      ...identity.license !== void 0 ? { license: identity.license } : {},
+      ...identity.licenseClass !== void 0 ? { licenseClass: identity.licenseClass } : {},
+      ...identity.licenseShortName !== void 0 ? { licenseShortName: identity.licenseShortName } : {},
+      ...identity.licenseUrl !== void 0 ? { licenseUrl: identity.licenseUrl } : {},
+      ...identity.recoScore !== void 0 ? { recoScore: identity.recoScore } : {},
+      ...minGezelVersion !== void 0 ? { minGezelVersion } : {},
+      publisherId: identity.publisherId,
+      language: identity.language,
+      ...identity.category ? { category: identity.category } : {},
+      ...identity.upstream !== void 0 ? { upstream: identity.upstream } : {},
+      version: version.version,
+      releasedAt: version.releasedAt,
+      formatVersion: version.formatVersion,
+      huggingface: version.huggingface,
+      sha256: version.sha256,
+      archiveBytes: version.archiveBytes,
+      uncompressedBytes: version.uncompressedBytes,
+      documents: version.documents,
+      chunks: version.chunks,
+      embeddingProfile: version.embeddingProfile,
+      topics: version.topics,
+      ...version.sourceSnapshot ? { sourceSnapshot: version.sourceSnapshot } : {},
+      ...version.parquet ? { parquet: version.parquet } : {},
+      ...version.notes !== void 0 ? { notes: version.notes } : {},
+      availableVersions
+    };
+  }
   if (kind === "video-model" && identity.kind === "video-model" && version.__kind === "video-model") {
     return {
       schemaVersion: 1,
@@ -1364,6 +1433,108 @@ var CommunitySource = class extends BundledSource {
   }
 };
 
+// src/installed-ai-apps-source.ts
+import { readFile as readFile2 } from "fs/promises";
+import { GezappRegistrySchema } from "@bendyline/gezel";
+import { aiAppItemsDir, aiAppsRegistryFile } from "@bendyline/gezel/paths";
+var AI_APP_KINDS = /* @__PURE__ */ new Set([
+  "project-type",
+  "gezel-template",
+  "craftbook-template"
+]);
+var InstalledAiAppsSource = class {
+  constructor(home, gezelVersion) {
+    this.home = home;
+    this.gezelVersion = gezelVersion;
+  }
+  home;
+  gezelVersion;
+  id = "installed-ai-apps";
+  label = "AI Apps";
+  async listKinds() {
+    return [...AI_APP_KINDS];
+  }
+  async list(kind) {
+    if (!AI_APP_KINDS.has(kind)) return [];
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const source of await this.sources()) {
+      for (const item of await source.list(kind)) {
+        if (seen.has(item.manifest.id)) continue;
+        seen.add(item.manifest.id);
+        out.push(this.rescope(item));
+      }
+    }
+    out.sort((a, b) => a.manifest.name.localeCompare(b.manifest.name));
+    return out;
+  }
+  async get(kind, id, version) {
+    if (!AI_APP_KINDS.has(kind)) return null;
+    for (const source of await this.sources()) {
+      const item = await source.get(kind, id, version);
+      if (item) return this.rescope(item);
+    }
+    return null;
+  }
+  async listVersions(kind, id) {
+    if (!AI_APP_KINDS.has(kind)) return [];
+    const byVersion = /* @__PURE__ */ new Map();
+    for (const source of await this.sources()) {
+      for (const version of await source.listVersions(kind, id)) {
+        if (!byVersion.has(version.version)) byVersion.set(version.version, version);
+      }
+    }
+    return [...byVersion.values()];
+  }
+  async readItemFile(kind, id, relPath, version) {
+    if (!AI_APP_KINDS.has(kind)) return null;
+    for (const source of await this.sources()) {
+      const content = await source.readItemFile(kind, id, relPath, version);
+      if (content) return content;
+    }
+    return null;
+  }
+  async listItemFiles(kind, id) {
+    if (!AI_APP_KINDS.has(kind)) return [];
+    for (const source of await this.sources()) {
+      const files = await source.listItemFiles(kind, id);
+      if (files.length > 0) return files;
+    }
+    return [];
+  }
+  async registry() {
+    try {
+      return GezappRegistrySchema.parse(
+        JSON.parse(await readFile2(aiAppsRegistryFile(this.home), "utf8"))
+      );
+    } catch {
+      return { schemaVersion: 1, apps: [] };
+    }
+  }
+  async sources() {
+    const registry = await this.registry();
+    return registry.apps.filter((entry) => entry.enabled).map(
+      (entry) => new BundledSource({
+        dataDir: aiAppItemsDir(this.home, entry.appId, entry.version),
+        id: `gezapp:${entry.appId}@${entry.version}`,
+        label: this.label,
+        noIndex: true,
+        ...this.gezelVersion !== void 0 ? { gezelVersion: this.gezelVersion } : {}
+      })
+    );
+  }
+  rescope(item) {
+    const { logoUrl: _ignored, ...rest } = item;
+    const logo = item.manifest.logo;
+    const logoUrl = logo && /^https?:\/\//.test(logo) ? logo : logo ? `/api/catalog/${item.kind}/${encodeURIComponent(item.manifest.id)}/file/${encodeURIComponent(logo)}?source=${encodeURIComponent(this.id)}` : void 0;
+    return {
+      ...rest,
+      sourceId: this.id,
+      ...logoUrl ? { logoUrl } : {}
+    };
+  }
+};
+
 // src/local-source.ts
 var LOCAL_KINDS = /* @__PURE__ */ new Set([
   "project-type",
@@ -1412,9 +1583,9 @@ var CatalogService = class {
   contentRootProvider;
   /**
    * @param sources explicit source list (replaces the defaults entirely).
-   * @param opts.localRoot a GEZEL_HOME to read user-installed / `.gzl`-imported
-   *   catalog items from (project types + gezel roles). Appended just ahead of
-   *   the bundled tier so a user's imported item shadows a same-id bundled one.
+   * @param opts.localRoot a GEZEL_HOME to read user-installed catalog items and
+   *   mounted `.gezapp` packages from. Both sit ahead of the bundled tier so a
+   *   user's installed item shadows a same-id bundled one.
    * @param opts.contentRoot dynamic gilde content root for the default
    *   bundled + community tiers, re-read on every disk access. The live
    *   gilde update mechanism flips it without reconstructing this service
@@ -1435,8 +1606,10 @@ var CatalogService = class {
     const contentRoot = opts?.contentRoot;
     const gezelVersion = opts?.gezelVersion;
     const local = opts?.localRoot ? [new LocalCatalogSource(opts.localRoot, gezelVersion)] : [];
+    const aiApps = opts?.localRoot ? [new InstalledAiAppsSource(opts.localRoot, gezelVersion)] : [];
     this.sources = [
       new BuiltinToolsetsSource(),
+      ...aiApps,
       ...local,
       new BundledSource({
         ...contentRoot ? { dataDir: contentRoot } : {},
@@ -1462,7 +1635,7 @@ var CatalogService = class {
     return this.sources.map((s) => ({ id: s.id, label: s.label }));
   }
   /**
-   * Merged listing across sources. Items from earlier sources (bundled)
+   * Merged listing across sources. Items from earlier sources
    * shadow later sources (remote) on id collision.
    */
   async list(kind) {
@@ -1833,11 +2006,276 @@ function categorizeToolset(input) {
   return "other";
 }
 
+// src/craftbook-step-policy.ts
+import { deliverableKindForStep, requiredOutputMediaForGate } from "@bendyline/gezel";
+var BUILTIN_BY_ID2 = new Map(BUILTIN_TOOLSETS.map((group) => [group.id, group]));
+var SPECIALIZED_GROUP_SIGNALS = {
+  "security-intel": /\b(?:security|vulnerabilit|threat|attack surface|taint|secret scan)\b/i,
+  "image-intel": /\b(?:image library|photo library|similar images|search_images|describe_folder)\b/i,
+  "entity-intel": /\b(?:find_entity|entity mentions|cross-file entit)\b/i,
+  archives: /\b(?:archive|zip|tar|extract_archive|list_archive)\b/i,
+  "data-tables": /\b(?:sql|query_table|describe_table|list_tables|data table)\b/i,
+  craftbooks: /\b(?:craftbook_(?:read|write|add|remove|reorder|update)|edit (?:the )?craftbook)\b/i,
+  "ai-apps": /\b(?:export_ai_app|import_ai_app|\.gezapp\b|ai app bundle)\b/i,
+  audio: /\b(?:transcribe_audio|synthesize_speech|speech[- ]to[- ]text|text[- ]to[- ]speech)\b/i,
+  videos: /\b(?:generate_video|video generation|generate (?:a )?video)\b/i,
+  images: /\b(?:generate_image|render_image|describe_image|read_image|image generation|generate (?:an? )?image|render (?:a )?(?:chart|diagram))\b/i,
+  "browser-automation": /\b(?:run_playwright_script|playwright|browser automation|headless browser)\b/i,
+  git: /\b(?:run_git|github_|git\b|pull request|\bPR\s*#?\d*)\b/i,
+  web: /\b(?:web_search|wikipedia_|fetch_url|live web|search the web|external source|https?:\/\/)\b/i,
+  "team-management": /\b(?:ensure_gezel|message_gezel|create_gezel|update_gezel|start_project|delegate|hand (?:the )?work)\b/i,
+  "role-delegation": /\b(?:ask_specialist|ask_gezel|delegate_[a-z]|consult_[a-z])\b/i,
+  "role-delegation-escalation": /\b(?:escalat|second opinion|ask_specialist|consult_[a-z])\b/i
+};
+var DECLARED_TOOLSET_SIGNALS = {
+  docblocks: /\b(?:docblocks|list_roots|convert_document|preview_document|save_artifact|document artifact uri)\b/i,
+  github: SPECIALIZED_GROUP_SIGNALS.git,
+  "@playwright/mcp": /\b(?:playwright|browser_|browser automation|headless browser)\b/i,
+  "microsoft-playwright-mcp": /\b(?:playwright|browser_|browser automation|headless browser)\b/i
+};
+var TASK_NOTE_OUTPUT_SIGNAL = /\bwrite_task_note\b|\b(?:write|record|append|summarize)[^.!?\n]{0,100}\b(?:task\s+)?notes?\b|\bwrite\s+PASS\s*\/\s*FAIL\b/i;
+function procedureText(step) {
+  return [step.name, step.description, step.prompt, step.suggestedRole].filter(Boolean).join("\n");
+}
+function gateChecks(step) {
+  const gate = step.gate;
+  return gate && "checks" in gate && Array.isArray(gate.checks) ? gate.checks : [];
+}
+function outputMediumForCraftbookBlueprint(step) {
+  const gateRequiredMedia = [...requiredOutputMediaForGate(step.gate)];
+  if (step.toolPolicy?.outputMedium) {
+    if (step.toolPolicy.outputMedium === "none" && gateRequiredMedia[0]) {
+      return gateRequiredMedia[0];
+    }
+    return step.toolPolicy.outputMedium;
+  }
+  if (step.deliverable?.path) return step.deliverable.artifact ? "artifact" : "workspace";
+  if (step.advanceWhen?.file) return step.advanceWhen.artifact ? "artifact" : "workspace";
+  const fileCheck = gateChecks(step).find(
+    (check) => typeof check.file === "string" && check.file.length > 0
+  );
+  if (fileCheck) return fileCheck.artifact === true ? "artifact" : "workspace";
+  if (gateRequiredMedia[0]) return gateRequiredMedia[0];
+  const text = procedureText(step);
+  if (/\b(?:write_file|append_to_file|replace_in_file|replace_lines|apply_patch|insert_at_marker)\b/i.test(
+    text
+  )) {
+    return "workspace";
+  }
+  if (/\bwrite_artifact\b/i.test(text)) return "artifact";
+  return TASK_NOTE_OUTPUT_SIGNAL.test(text) ? "task-note" : "none";
+}
+function outputMediaForCraftbookBlueprint(step) {
+  const primary = outputMediumForCraftbookBlueprint(step);
+  return /* @__PURE__ */ new Set([
+    ...primary === "none" ? [] : [primary],
+    ...additionalOutputMediaForStep(step, primary)
+  ]);
+}
+function additionalOutputMediaForStep(step, primary) {
+  if (primary === "none") return [];
+  const text = procedureText(step);
+  const out = new Set(step.toolPolicy?.additionalOutputMedia ?? []);
+  for (const medium of requiredOutputMediaForGate(step.gate)) out.add(medium);
+  if (/\b(?:write_file|append_to_file|replace_in_file|replace_lines|apply_patch|insert_at_marker)\b|\b(?:edit|change|patch|fix)\b[^.!?\n]{0,80}\b(?:actual|workspace|source|project)\s+files?\b/i.test(
+    text
+  )) {
+    out.add("workspace");
+  }
+  if (/\bwrite_artifact\b/i.test(text)) out.add("artifact");
+  if (TASK_NOTE_OUTPUT_SIGNAL.test(text)) out.add("task-note");
+  out.delete(primary);
+  return [...out].sort();
+}
+function groupToolMentioned(groupId, text) {
+  const group = BUILTIN_BY_ID2.get(groupId);
+  return group?.tools.some((tool) => new RegExp(`\\b${tool}\\b`, "i").test(text)) ?? false;
+}
+function needsCodeExecution(step, text) {
+  const kind = step.deliverable?.kind ?? deliverableKindForStep(step);
+  if (kind === "code-module" || kind === "code-with-tests" || kind === "data-file" || kind === "json" || kind === "audio-file") {
+    return true;
+  }
+  if (gateChecks(step).some((check) => check.kind === "nodeRuns" || check.kind === "commandEvidence")) {
+    return true;
+  }
+  if (step.onExit !== void 0) return true;
+  if (groupToolMentioned("code-execution", text)) return true;
+  return /\b(?:execute|npm|npx|sandbox|compile|transform)\b|\b(?:re-?run|run)[^.!?\n]{0,50}\b(?:test|script|build|command|suite)\b/i.test(
+    text
+  );
+}
+function builtinDisallows(step, medium, additionalMedia) {
+  const text = procedureText(step);
+  const out = new Set(step.toolPolicy?.disallowBuiltinToolsets ?? []);
+  const media = /* @__PURE__ */ new Set([medium, ...additionalMedia]);
+  if (!media.has("workspace")) out.add("workspace-fs-write");
+  const consumesArtifact = step.consumes?.some((input) => input.artifact) === true;
+  const mentionsArtifact = /\b(?:read_artifact|list_artifacts|grep_artifact|artifacts drawer)\b/i.test(text);
+  if (!media.has("artifact") && !consumesArtifact && !mentionsArtifact) out.add("artifacts");
+  for (const [groupId, signal] of Object.entries(SPECIALIZED_GROUP_SIGNALS)) {
+    if (groupId === "web" && /research/i.test(step.suggestedRole ?? "")) continue;
+    if (!signal.test(text) && !groupToolMentioned(groupId, text)) out.add(groupId);
+  }
+  if (!needsCodeExecution(step, text)) out.add("code-execution");
+  return [...out].sort();
+}
+function explicitlyDeniedExternalToolsets(step, declaredIds) {
+  const text = procedureText(step);
+  const out = new Set(step.toolPolicy?.disallowToolsets ?? []);
+  for (const id of declaredIds) {
+    if (id.startsWith("builtin.")) continue;
+    const escaped = id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const denial = new RegExp(
+      `(?:\\bdo\\s+not\\b|\\bdon't\\b|\\bnever\\b)[^.!?\\n]{0,160}\\b(?:call|use|invoke|run|access|load)\\s+(?:the\\s+)?${escaped}(?=$|[^A-Za-z0-9_-])`,
+      "iu"
+    );
+    const positiveSignal = DECLARED_TOOLSET_SIGNALS[id] ?? new RegExp(escaped, "iu");
+    if (denial.test(text) || !positiveSignal.test(text)) out.add(id);
+  }
+  return [...out].sort();
+}
+function withDefaultPolicy(step, declaredIds) {
+  const outputMedium = outputMediumForCraftbookBlueprint(step);
+  const additionalOutputMedia = additionalOutputMediaForStep(step, outputMedium);
+  const disallowBuiltinToolsets = builtinDisallows(step, outputMedium, additionalOutputMedia);
+  const disallowToolsets = explicitlyDeniedExternalToolsets(step, declaredIds);
+  return {
+    ...step,
+    toolPolicy: {
+      ...disallowToolsets.length > 0 ? { disallowToolsets } : {},
+      ...disallowBuiltinToolsets.length > 0 ? { disallowBuiltinToolsets } : {},
+      outputMedium,
+      ...additionalOutputMedia.length > 0 ? { additionalOutputMedia } : {}
+    }
+  };
+}
+function applyDefaultCraftbookStepPolicies(doc) {
+  const declaredIds = (doc.toolsets ?? []).map((need) => need.toolsetId);
+  return {
+    ...doc,
+    steps: doc.steps.map((step) => withDefaultPolicy(step, declaredIds)),
+    ...doc.spawn ? {
+      spawn: {
+        ...doc.spawn,
+        steps: doc.spawn.steps.map((step) => withDefaultPolicy(step, declaredIds))
+      }
+    } : {}
+  };
+}
+
+// src/gilde-schema-export.ts
+import {
+  ChatModelIdentitySchema,
+  ChatModelVersionManifestSchema as ChatModelVersionManifestSchema2,
+  ConnectorTypeIdentitySchema,
+  ConnectorTypeVersionManifestSchema as ConnectorTypeVersionManifestSchema2,
+  CraftbookDocSchema,
+  CraftbookTemplateIdentitySchema,
+  CraftbookTemplateVersionManifestSchema as CraftbookTemplateVersionManifestSchema2,
+  CraftbookTestSpecSchema,
+  GezelTemplateIdentitySchema,
+  GezelTemplateVersionManifestSchema as GezelTemplateVersionManifestSchema2,
+  ImageModelIdentitySchema,
+  ImageModelVersionManifestSchema as ImageModelVersionManifestSchema2,
+  KnowledgeCatalogIdentitySchema,
+  KnowledgeCatalogVersionManifestSchema as KnowledgeCatalogVersionManifestSchema2,
+  ProjectTypeIdentitySchema,
+  ProjectTypeVersionManifestSchema as ProjectTypeVersionManifestSchema2,
+  ToolsetIdentitySchema,
+  ToolsetVersionManifestSchema as ToolsetVersionManifestSchema2,
+  VideoModelIdentitySchema,
+  VideoModelVersionManifestSchema as VideoModelVersionManifestSchema2
+} from "@bendyline/gezel";
+import { z } from "zod";
+var GILDE_SCHEMA_EXPORTS = [
+  ["toolset-identity.schema.json", ToolsetIdentitySchema],
+  ["toolset-version.schema.json", ToolsetVersionManifestSchema2],
+  ["gezel-template-identity.schema.json", GezelTemplateIdentitySchema],
+  ["gezel-template-version.schema.json", GezelTemplateVersionManifestSchema2],
+  ["craftbook-template-identity.schema.json", CraftbookTemplateIdentitySchema],
+  ["craftbook-template-version.schema.json", CraftbookTemplateVersionManifestSchema2],
+  ["project-type-identity.schema.json", ProjectTypeIdentitySchema],
+  ["project-type-version.schema.json", ProjectTypeVersionManifestSchema2],
+  ["connector-type-identity.schema.json", ConnectorTypeIdentitySchema],
+  ["connector-type-version.schema.json", ConnectorTypeVersionManifestSchema2],
+  ["chat-model-identity.schema.json", ChatModelIdentitySchema],
+  ["chat-model-version.schema.json", ChatModelVersionManifestSchema2],
+  ["image-model-identity.schema.json", ImageModelIdentitySchema],
+  ["image-model-version.schema.json", ImageModelVersionManifestSchema2],
+  ["video-model-identity.schema.json", VideoModelIdentitySchema],
+  ["video-model-version.schema.json", VideoModelVersionManifestSchema2],
+  ["knowledge-catalog-identity.schema.json", KnowledgeCatalogIdentitySchema],
+  ["knowledge-catalog-version.schema.json", KnowledgeCatalogVersionManifestSchema2],
+  ["craftbook-doc.schema.json", CraftbookDocSchema],
+  ["craftbook-test.schema.json", CraftbookTestSpecSchema]
+];
+var CATALOG_INDEX_SCHEMA = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://gezelgilde.com/schemas/catalog-index.schema.json",
+  type: "object",
+  properties: {
+    schemaVersion: { type: "number", const: 1 },
+    kind: { type: "string" },
+    count: { type: "number", minimum: 0 },
+    entries: {
+      type: "array",
+      items: {
+        type: "object",
+        properties: {
+          manifest: { type: "object" },
+          iconSvg: { type: "string" }
+        },
+        required: ["manifest"]
+      }
+    }
+  },
+  required: ["schemaVersion", "kind", "count", "entries"]
+};
+var GILDE_SCHEMAS_README = `# schemas/
+
+JSON Schemas for every content file in \`data/\`, consumed by
+\`tools/validate.mjs\`.
+
+**Generated \u2014 do not edit.** These are exported from the Zod schemas in
+gezel core (\`packages/core/src/schemas/\`), which remain the source of
+truth. Regenerate from a gezel checkout with:
+
+\`\`\`
+pnpm gilde:export-schemas
+\`\`\`
+
+Note: Zod refinements do not survive the export, so validation here is
+slightly looser than gezel's runtime parse. Layout and cross-reference
+rules that matter are re-implemented in \`tools/validate.mjs\`.
+`;
+function renderSchema(filename, schema) {
+  const json = z.toJSONSchema(schema, { target: "draft-2020-12", io: "input" });
+  const withId = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: `https://gezelgilde.com/schemas/${filename}`,
+    ...json
+  };
+  withId.$schema = "https://json-schema.org/draft/2020-12/schema";
+  return `${JSON.stringify(withId, null, 2)}
+`;
+}
+function renderGildeSchemaFiles() {
+  return [
+    ...GILDE_SCHEMA_EXPORTS.map(
+      ([filename, schema]) => [filename, renderSchema(filename, schema)]
+    ),
+    ["catalog-index.schema.json", `${JSON.stringify(CATALOG_INDEX_SCHEMA, null, 2)}
+`],
+    ["README.md", GILDE_SCHEMAS_README]
+  ];
+}
+
 // src/install/npm-package.ts
 import { spawn } from "child_process";
 import { createHash, randomUUID } from "crypto";
 import { createReadStream } from "fs";
-import { mkdir, open, readFile as readFile2, realpath, rename, rm, stat, writeFile } from "fs/promises";
+import { mkdir, open, readFile as readFile3, realpath, rename, rm, stat, writeFile } from "fs/promises";
 import { dirname as dirname2, isAbsolute, join as join5, relative, resolve } from "path";
 import {
   HttpStatusError,
@@ -2046,7 +2484,7 @@ function validateNpmArchiveEntry(path, type) {
   }
 }
 async function validateExtractedPackage(packageDir, expectedName, expectedVersion) {
-  const raw = await readFile2(join5(packageDir, "package.json"), "utf8");
+  const raw = await readFile3(join5(packageDir, "package.json"), "utf8");
   const parsed = JSON.parse(raw);
   if (parsed.name !== expectedName || parsed.version !== expectedVersion) {
     throw new Error("[catalog] extracted package identity does not match the pinned manifest");
@@ -2418,17 +2856,20 @@ async function validateGildeContentUpgrade(opts) {
 
 // src/hf-api.ts
 var HF_HUB_BASE = "https://huggingface.co";
+function apiPrefix(repoType) {
+  return `${HF_HUB_BASE}/api/${repoType === "dataset" ? "datasets" : "models"}`;
+}
 async function fetchHuggingfaceTree(repo, opts = {}) {
   const rev = opts.rev ?? "main";
   const fetchImpl = opts.fetchImpl ?? fetch;
   const out = [];
-  await walk(repo, rev, "", out, fetchImpl);
+  await walk(repo, rev, "", out, fetchImpl, opts.repoType);
   return out;
 }
 async function fetchHuggingfaceCommit(repo, opts = {}) {
   const rev = opts.rev ?? "main";
   const fetchImpl = opts.fetchImpl ?? fetch;
-  const url = `${HF_HUB_BASE}/api/models/${repo}/revision/${encodeURIComponent(rev)}`;
+  const url = `${apiPrefix(opts.repoType)}/${repo}/revision/${encodeURIComponent(rev)}`;
   const res = await fetchImpl(url);
   if (!res.ok) {
     throw new Error(`[hf] commit resolve ${url} failed: ${res.status} ${res.statusText}`);
@@ -2439,8 +2880,8 @@ async function fetchHuggingfaceCommit(repo, opts = {}) {
   }
   return body.sha;
 }
-async function walk(repo, rev, subpath, out, fetchImpl) {
-  const url = `${HF_HUB_BASE}/api/models/${repo}/tree/${rev}${subpath ? `/${subpath}` : ""}`;
+async function walk(repo, rev, subpath, out, fetchImpl, repoType) {
+  const url = `${apiPrefix(repoType)}/${repo}/tree/${rev}${subpath ? `/${subpath}` : ""}`;
   const res = await fetchImpl(url);
   if (!res.ok) {
     throw new Error(`[hf] tree fetch ${url} failed: ${res.status} ${res.statusText}`);
@@ -2448,7 +2889,7 @@ async function walk(repo, rev, subpath, out, fetchImpl) {
   const entries = await res.json();
   for (const e of entries) {
     if (e.type === "directory") {
-      await walk(repo, rev, e.path, out, fetchImpl);
+      await walk(repo, rev, e.path, out, fetchImpl, repoType);
       continue;
     }
     if (e.type !== "file") continue;
@@ -2490,7 +2931,9 @@ export {
   CatalogService,
   CommunitySource,
   GILDE_PACKAGE_NAME,
+  InstalledAiAppsSource,
   LocalCatalogSource,
+  applyDefaultCraftbookStepPolicies,
   builtinCatalogId,
   categorizeToolset,
   compareRelease,
@@ -2503,9 +2946,13 @@ export {
   gildePackageRoot,
   installNpmPackageToolset,
   isGildeReleaseVersion,
+  outputMediaForCraftbookBlueprint,
+  outputMediumForCraftbookBlueprint,
   pickGildePatchUpdate,
   publishStagedNpmInstall,
   recoverInterruptedNpmInstall,
+  renderGildeSchemaFiles,
+  renderSchema,
   selectMlxInstallFiles,
   stageGildeVersion,
   totalSize,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bendyline/gezel-catalog",
-  "version": "1.0.6",
+  "version": "1.1.0",
   "description": "Gezel catalog loader: sources, install pipeline, and authoring scripts over the external @bendyline/gilde content package.",
   "license": "MIT",
   "keywords": [
@@ -47,12 +47,13 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@bendyline/gezel": "1.0.6",
-    "@bendyline/gilde": "0.1.36",
+    "@bendyline/gezel": "1.1.0",
+    "@bendyline/gilde": "0.1.55",
     "tar": "7.5.21",
     "zod": "^4.4.3"
   },
   "devDependencies": {
+    "@bendyline/gezel-knowledge": "1.1.0",
     "esbuild": "^0.28.1",
     "tsup": "^8.5.1",
     "tsx": "^4.23.1",
@@ -69,7 +70,9 @@
     "build-index": "node scripts/run-gilde-build-index.mjs",
     "lint-manifests": "tsx src/chat-model-manifest-lint.ts",
     "generate-craftbooks": "tsx scripts/generate-craftbooks.ts",
+    "migrate-step-policies": "tsx scripts/migrate-craftbook-step-policies.ts",
     "pin-revisions": "tsx scripts/pin-revisions.ts",
-    "export-gilde-schemas": "tsx scripts/export-gilde-schemas.ts"
+    "export-gilde-schemas": "tsx scripts/export-gilde-schemas.ts",
+    "add-knowledge-catalog": "tsx scripts/add-knowledge-catalog.ts"
   }
 }