diff --git a/.github/workflows/ci-lint.yaml b/.github/workflows/ci-lint.yaml
new file mode 100644
index 0000000..354ce73
--- /dev/null
+++ b/.github/workflows/ci-lint.yaml
@@ -0,0 +1,66 @@
+name: CI Lint
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  checks: write
+  contents: read
+  id-token: write
+  pull-requests: write
+
+jobs:
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    concurrency:
+      group: lint-${{ github.head_ref || github.run_id }}
+      cancel-in-progress: true
+    steps:
+      # Checkout the boxel monorepo at root to get tooling and init action
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # 4.2.2
+        with:
+          repository: cardstack/boxel
+
+      # Checkout this catalog repo into a temp location
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # 4.2.2
+        with:
+          path: boxel-catalog-src
+
+      # Copy catalog files into the monorepo's catalog-realm location
+      - name: Copy catalog files into monorepo
+        run: |
+          # TODO: Simplify this step once catalog-realm content is fully migrated out of the monorepo
+          # Remove all files except config files we want to keep
+          cd packages/catalog-realm
+          find . -mindepth 1 \
+            ! -name '.gitignore' \
+            ! -name 'tsconfig.json' \
+            ! -name 'package.json' \
+            ! -name '.realm.json' \
+            ! -name '.' \
+            -exec rm -rf {} + 2>/dev/null || true
+          cd ../..
+          
+          # Copy catalog files
+          cp -r boxel-catalog-src/* packages/catalog-realm/
+
+      - uses: ./.github/actions/init
+
+      # Boxel UI and Boxel Icons need to be built first so that their
+      # linting outputs types are available for projects that depend on them
+      - name: Build common dependencies
+        if: always()
+        run: pnpm run build-common-deps
+
+      - name: Lint Catalog
+        if: always()
+        run: pnpm run lint
+        working-directory: packages/catalog-realm
+
+      - name: Lint Host
+        if: always()
+        run: pnpm run lint
+        working-directory: packages/host
diff --git a/catalog-app/listing/listing.gts b/catalog-app/listing/listing.gts
index 9dc2dd9..2bca284 100644
--- a/catalog-app/listing/listing.gts
+++ b/catalog-app/listing/listing.gts
@@ -9,7 +9,7 @@ import {
   Component,
   instanceOf,
   realmURL,
-  type GetCardMenuItemParams,
+  type GetMenuItemParams,
 } from 'https://cardstack.com/base/card-api';
 import { commandData } from 'https://cardstack.com/base/resources/command-data';
 import MarkdownField from 'https://cardstack.com/base/markdown';
@@ -34,6 +34,7 @@ import {
 import { eq, type MenuItemOptions } from '@cardstack/boxel-ui/helpers';
 import Refresh from '@cardstack/boxel-icons/refresh';
 import Wand from '@cardstack/boxel-icons/wand';
+import Package from '@cardstack/boxel-icons/package';
 
 import AppListingHeader from '../components/app-listing-header';
 import ChooseRealmAction from '../components/choose-realm-action';
@@ -44,8 +45,9 @@ import { listingActions, isReady } from '../resources/listing-actions';
 import GetAllRealmMetasCommand from '@cardstack/boxel-host/commands/get-all-realm-metas';
 import ListingGenerateExampleCommand from '@cardstack/boxel-host/commands/listing-generate-example';
 import ListingUpdateSpecsCommand from '@cardstack/boxel-host/commands/listing-update-specs';
+import CreateListingPRCommand from '@cardstack/boxel-host/commands/create-listing-pr';
 
-import { getCardMenuItems } from '@cardstack/runtime-common';
+import { getMenuItems } from '@cardstack/runtime-common';
 
 import { Publisher } from './publisher';
 import { Category } from './category';
@@ -180,9 +182,9 @@ class EmbeddedTemplate extends Component<typeof Listing> {
   <template>
     <div class='app-listing-embedded'>
       <AppListingHeader
-        @thumbnailUrl={{@model.thumbnailURL}}
+        @thumbnailUrl={{@model.cardThumbnailURL}}
         @name={{this.appName}}
-        @description={{@model.description}}
+        @description={{@model.cardDescription}}
         @publisher={{this.publisherName}}
       >
         <:action>
@@ -562,6 +564,7 @@ class EmbeddedTemplate extends Component<typeof Listing> {
 export class Listing extends CardDef {
   static displayName = 'Listing';
   static headerColor = '#6638ff';
+
   @field name = contains(StringField);
   @field summary = contains(MarkdownField);
   @field specs = linksToMany(() => Spec);
@@ -573,14 +576,14 @@ export class Listing extends CardDef {
   @field examples = linksToMany(() => CardDef);
   @field skills = linksToMany(() => Skill);
 
-  @field title = contains(StringField, {
+  @field cardTitle = contains(StringField, {
     computeVia(this: Listing) {
       return this.name;
     },
   });
 
   protected getGenerateExampleMenuItem(
-    params: GetCardMenuItemParams,
+    params: GetMenuItemParams,
   ): MenuItemOptions | undefined {
     if (!params.commandContext) {
       return undefined;
@@ -613,7 +616,7 @@ export class Listing extends CardDef {
   }
 
   private getUpdateSpecsMenuItem(
-    params: GetCardMenuItemParams,
+    params: GetMenuItemParams,
   ): MenuItemOptions | undefined {
     if (params.menuContext !== 'interact') {
       return;
@@ -635,9 +638,9 @@ export class Listing extends CardDef {
     };
   }
 
-  [getCardMenuItems](params: GetCardMenuItemParams): MenuItemOptions[] {
+  [getMenuItems](params: GetMenuItemParams): MenuItemOptions[] {
     let menuItems = super
-      [getCardMenuItems](params)
+      [getMenuItems](params)
       .filter((item) => item.label?.toLowerCase() !== 'create listing with ai');
     if (params.menuContext === 'interact') {
       const extra = this.getGenerateExampleMenuItem(params);
@@ -648,10 +651,40 @@ export class Listing extends CardDef {
       if (updateSpecs) {
         menuItems = [...menuItems, updateSpecs];
       }
+      const createPRMenuItem = this.getCreatePRMenuItem(params);
+      if (createPRMenuItem) {
+        menuItems = [...menuItems, createPRMenuItem];
+      }
     }
     return menuItems;
   }
 
+  private getCreatePRMenuItem(
+    params: GetMenuItemParams,
+  ): MenuItemOptions | undefined {
+    if (params.menuContext !== 'interact') {
+      return;
+    }
+    if (!this[realmURL]?.href) {
+      return;
+    }
+    const commandContext = params.commandContext;
+    if (!commandContext) {
+      return;
+    }
+
+    return {
+      label: 'Make a PR',
+      action: async () => {
+        await new CreateListingPRCommand(commandContext).execute({
+          listing: this,
+          realm: this[realmURL]!.href,
+        });
+      },
+      icon: Package,
+    };
+  }
+
   static isolated = EmbeddedTemplate;
   static embedded = EmbeddedTemplate;
   static fitted = ListingFittedTemplate;
diff --git a/cloudflare-image.gts b/cloudflare-image.gts
new file mode 100644
index 0000000..e7c0575
--- /dev/null
+++ b/cloudflare-image.gts
@@ -0,0 +1,22 @@
+import ImageCard from 'https://cardstack.com/base/image';
+import { contains, field } from 'https://cardstack.com/base/card-api';
+import StringField from 'https://cardstack.com/base/string';
+import UrlField from 'https://cardstack.com/base/url';
+
+export const CLOUDFLARE_ACCOUNT_ID = '4a94a1eb2d21bbbe160234438a49f687';
+
+const CLOUDFLARE_VARIANT = 'public';
+
+export class CloudflareImage extends ImageCard {
+  static displayName = 'Cloudflare Image';
+
+  @field cloudflareId = contains(StringField);
+  @field url = contains(UrlField, {
+    computeVia(this: CloudflareImage) {
+      if (!this.cloudflareId) {
+        return undefined;
+      }
+      return `https://i.boxel.site/${this.cloudflareId}/${CLOUDFLARE_VARIANT}`;
+    },
+  });
+}
diff --git a/commands/upload-image.ts b/commands/upload-image.ts
new file mode 100644
index 0000000..0799fba
--- /dev/null
+++ b/commands/upload-image.ts
@@ -0,0 +1,449 @@
+import { tracked } from '@glimmer/tracking';
+
+import { isCardInstance, Command } from '@cardstack/runtime-common';
+
+import { CardDef, field, contains } from 'https://cardstack.com/base/card-api';
+import UrlField from 'https://cardstack.com/base/url';
+import StringField from 'https://cardstack.com/base/string';
+
+import SaveCardCommand from '@cardstack/boxel-host/commands/save-card';
+import SendRequestViaProxyCommand from '@cardstack/boxel-host/commands/send-request-via-proxy';
+import { CloudflareImage, CLOUDFLARE_ACCOUNT_ID } from '../cloudflare-image';
+
+const CLOUDFLARE_IMAGE_INGEST_URL = `https://api.cloudflare.com/client/v4/accounts/${CLOUDFLARE_ACCOUNT_ID}/images/v1`;
+const CLOUDFLARE_DIRECT_UPLOAD_URL = `https://api.cloudflare.com/client/v4/accounts/${CLOUDFLARE_ACCOUNT_ID}/images/v2/direct_upload`;
+
+type UploadProgressStep =
+  | 'idle'
+  | 'requesting-direct-upload-url'
+  | 'parsing-data-uri'
+  | 'fetching-local-file'
+  | 'uploading-local-file'
+  | 'uploading-remote-url'
+  | 'saving-card'
+  | 'completed'
+  | 'error';
+
+interface CloudflareUploadResponse {
+  success: boolean;
+  errors: unknown[];
+  result?: {
+    id?: string;
+    uploadURL?: string;
+    [key: string]: unknown;
+  };
+}
+
+interface DirectUploadDetails {
+  uploadURL: string;
+  id: string;
+}
+
+export class UploadImageInput extends CardDef {
+  @field sourceImageUrl = contains(UrlField);
+  @field targetRealmUrl = contains(StringField);
+}
+
+export class CardIdCard extends CardDef {
+  @field cardId = contains(StringField);
+}
+
+export default class UploadImageCommand extends Command<
+  typeof UploadImageInput,
+  typeof CardIdCard
+> {
+  static actionVerb = 'Upload';
+  description =
+    'Uploads an image to Cloudflare Images and saves a CloudflareImage card in the specified realm';
+
+  @tracked progressStep: UploadProgressStep = 'idle';
+
+  async getInputType() {
+    return UploadImageInput;
+  }
+
+  protected async run(input: UploadImageInput): Promise<CardIdCard> {
+    if (!input.sourceImageUrl) {
+      throw new Error('sourceImageUrl is required');
+    }
+    if (!input.targetRealmUrl) {
+      throw new Error('targetRealm is required');
+    }
+
+    const sourceImageUrl = input.sourceImageUrl.trim();
+
+    let isBlobUrl = sourceImageUrl.startsWith('blob:');
+    let isDataUri = sourceImageUrl.startsWith('data:');
+    if (!isBlobUrl && !isDataUri && !sourceImageUrl.startsWith('http')) {
+      throw new Error('sourceImageUrl must be a valid URL');
+    }
+
+    const sendRequestCommand = new SendRequestViaProxyCommand(
+      this.commandContext,
+    );
+    let cloudflareId: string;
+
+    try {
+      if (isBlobUrl || isDataUri) {
+        this.progressStep = 'requesting-direct-upload-url';
+        let { uploadURL, id } = await this.requestDirectUploadUrl(
+          sendRequestCommand,
+        );
+
+        let blobDetails;
+        if (isDataUri) {
+          this.progressStep = 'parsing-data-uri';
+          blobDetails = this.parseDataUri(sourceImageUrl);
+        } else {
+          this.progressStep = 'fetching-local-file';
+          blobDetails = await this.fetchBlobFromObjectUrl(sourceImageUrl);
+        }
+        let { blob, fileName, contentType } = blobDetails;
+
+        this.progressStep = 'uploading-local-file';
+        let uploadPayload = await this.uploadBlobToCloudflare(
+          uploadURL,
+          blob,
+          fileName,
+          contentType,
+        );
+
+        cloudflareId = uploadPayload.result?.id ?? id;
+        if (!cloudflareId) {
+          throw new Error(
+            'Cloudflare upload succeeded but no image id was returned',
+          );
+        }
+      } else {
+        this.progressStep = 'uploading-remote-url';
+        let payload = await this.forwardRemoteUrl(
+          sendRequestCommand,
+          sourceImageUrl,
+        );
+
+        const remoteUploadId = payload.result?.id;
+        if (!remoteUploadId) {
+          throw new Error(
+            'Cloudflare upload succeeded but no image id was returned',
+          );
+        }
+        cloudflareId = remoteUploadId;
+      }
+
+      this.progressStep = 'saving-card';
+
+      let saveCardCommand = new SaveCardCommand(this.commandContext);
+      let cloudflareImageCard: CloudflareImage = new CloudflareImage({
+        cloudflareId,
+      });
+      await saveCardCommand.execute({
+        card: cloudflareImageCard,
+        realm: input.targetRealmUrl,
+      });
+      if (!isCardInstance(cloudflareImageCard)) {
+        throw new Error(
+          `Failed to save CloudflareImage card: ${JSON.stringify(cloudflareImageCard, null, 2)}`,
+        );
+      }
+
+      if (!cloudflareImageCard.id) {
+        throw new Error('Saved CloudflareImage card does not have an id');
+      }
+
+      this.progressStep = 'completed';
+
+      return new CardIdCard({
+        cardId: cloudflareImageCard.id,
+      });
+    } catch (error) {
+      this.progressStep = 'error';
+      throw error;
+    }
+  }
+
+  private async requestDirectUploadUrl(
+    sendRequestCommand: SendRequestViaProxyCommand,
+  ): Promise<DirectUploadDetails> {
+    const directUploadResult = await sendRequestCommand.execute({
+      url: CLOUDFLARE_DIRECT_UPLOAD_URL,
+      method: 'POST',
+      requestBody: JSON.stringify({
+        requireSignedURLs: false,
+      }),
+      multipart: true,
+    });
+
+    const responseText = await directUploadResult.response.text();
+    if (!directUploadResult.response.ok) {
+      throw new Error(
+        `Cloudflare direct upload URL request failed: ${directUploadResult.response.status} - ${responseText}`,
+      );
+    }
+
+    let payload: CloudflareUploadResponse;
+    try {
+      payload = JSON.parse(responseText) as CloudflareUploadResponse;
+    } catch (parseError) {
+      throw new Error(
+        `Unable to parse Cloudflare direct upload response: ${String(parseError)}`,
+      );
+    }
+
+    if (!payload.success) {
+      throw new Error(
+        `Cloudflare direct upload request failed: ${JSON.stringify(payload, null, 2)}`,
+      );
+    }
+    let uploadURL = payload.result?.uploadURL;
+    let id = payload.result?.id;
+    if (!uploadURL || !id) {
+      throw new Error(
+        'Cloudflare direct upload response did not include required fields',
+      );
+    }
+
+    return { uploadURL, id };
+  }
+
+  private parseDataUri(dataUri: string) {
+    const trimmed = dataUri.trim();
+    if (!trimmed.startsWith('data:')) {
+      throw new Error('Invalid data URI: missing data: prefix');
+    }
+
+    const commaIndex = trimmed.indexOf(',');
+    if (commaIndex === -1) {
+      throw new Error('Invalid data URI: missing data payload');
+    }
+
+    const metadataSection = trimmed.substring(5, commaIndex); // remove "data:"
+    const payloadSection = trimmed.substring(commaIndex + 1);
+
+    if (!payloadSection) {
+      throw new Error('Invalid data URI: empty data payload');
+    }
+
+    const metadataParts = metadataSection.split(';').filter(Boolean);
+
+    let mimeType = 'text/plain;charset=US-ASCII';
+    let isBase64 = false;
+    let providedFileName: string | undefined;
+
+    for (let part of metadataParts) {
+      if (part === 'base64') {
+        isBase64 = true;
+        continue;
+      }
+      if (part.startsWith('name=')) {
+        providedFileName = part.slice('name='.length);
+        continue;
+      }
+      if (part.includes('/')) {
+        mimeType = part;
+      } else if (part.startsWith('charset=')) {
+        // Preserve charset parameter when no explicit mime type provided
+        if (!mimeType.includes('/')) {
+          mimeType = `text/plain;${part}`;
+        }
+      }
+    }
+
+    if (!mimeType.includes('/')) {
+      mimeType = 'application/octet-stream';
+    }
+
+    const cleanedPayload = payloadSection.replace(/\s+/g, '');
+    if (!cleanedPayload) {
+      throw new Error('Invalid data URI: payload contains no data');
+    }
+
+    let byteArray: Uint8Array;
+    const nodeBuffer = (globalThis as any).Buffer as
+      | { from(input: string, encoding: string): Uint8Array }
+      | undefined;
+    if (isBase64) {
+      try {
+        if (nodeBuffer) {
+          byteArray = new Uint8Array(
+            nodeBuffer.from(cleanedPayload, 'base64'),
+          );
+        } else if (typeof atob === 'function') {
+          const binaryString = atob(cleanedPayload);
+          byteArray = new Uint8Array(binaryString.length);
+          for (let i = 0; i < binaryString.length; i++) {
+            byteArray[i] = binaryString.charCodeAt(i);
+          }
+        } else {
+          throw new Error('No base64 decoder available in this environment');
+        }
+      } catch (error) {
+        throw new Error(`Failed to decode base64 data URI payload: ${String(error)}`);
+      }
+    } else {
+      try {
+        const decoded = decodeURIComponent(cleanedPayload);
+        const TextEncoderCtor = (globalThis as any).TextEncoder as
+          | { new (): { encode(input: string): Uint8Array } }
+          | undefined;
+        if (TextEncoderCtor) {
+          byteArray = new TextEncoderCtor().encode(decoded);
+        } else {
+          byteArray = new Uint8Array(decoded.length);
+          for (let i = 0; i < decoded.length; i++) {
+            byteArray[i] = decoded.charCodeAt(i);
+          }
+        }
+      } catch (error) {
+        throw new Error(`Failed to decode data URI payload: ${String(error)}`);
+      }
+    }
+
+    const blob = new Blob([byteArray], { type: mimeType });
+    if (providedFileName) {
+      providedFileName = providedFileName.replace(/^"(.*)"$/, '$1');
+      try {
+        providedFileName = decodeURIComponent(providedFileName);
+      } catch {
+        // ignore decoding errors and keep original value
+      }
+    }
+    const fileName =
+      providedFileName ?? this.deriveFileNameFromMimeType(mimeType);
+    const contentType = mimeType || 'application/octet-stream';
+
+    return { blob, fileName, contentType };
+  }
+
+  private deriveFileNameFromMimeType(mimeType: string) {
+    const extensionMap: Record<string, string> = {
+      'image/png': 'png',
+      'image/jpeg': 'jpg',
+      'image/gif': 'gif',
+      'image/webp': 'webp',
+      'image/svg+xml': 'svg',
+      'image/avif': 'avif',
+    };
+
+    const extension = extensionMap[mimeType] ?? 'bin';
+    return `upload.${extension}`;
+  }
+
+  private async fetchBlobFromObjectUrl(objectUrl: string) {
+    let response: Response;
+    try {
+      response = await fetch(objectUrl);
+    } finally {
+      if (typeof URL.revokeObjectURL === 'function') {
+        try {
+          URL.revokeObjectURL(objectUrl);
+        } catch {
+          // Ignore - the browser may already have released the URL.
+        }
+      }
+    }
+
+    if (!response.ok) {
+      throw new Error(
+        `Failed to read local file from object URL: ${response.status} ${response.statusText}`,
+      );
+    }
+    const blob = await response.blob();
+
+    const maybeFile = blob as Blob & { name?: string };
+    const fileName =
+      typeof maybeFile.name === 'string' && maybeFile.name
+        ? maybeFile.name
+        : 'upload';
+    const contentType = blob.type || 'application/octet-stream';
+
+    return { blob, fileName, contentType };
+  }
+
+  private async uploadBlobToCloudflare(
+    uploadURL: string,
+    blob: Blob,
+    fileName: string,
+    contentType: string,
+  ) {
+    let fileForUpload: Blob;
+    if (typeof File === 'function') {
+      if (blob instanceof File) {
+        fileForUpload = blob;
+      } else {
+        fileForUpload = new File([blob], fileName, { type: contentType });
+      }
+    } else {
+      fileForUpload = blob;
+    }
+
+    const formData = new FormData();
+    formData.append('file', fileForUpload, fileName);
+
+    const response = await fetch(uploadURL, {
+      method: 'POST',
+      body: formData,
+    });
+
+    const responseText = await response.text();
+    if (!response.ok) {
+      throw new Error(
+        `Cloudflare direct upload failed: ${response.status} - ${responseText}`,
+      );
+    }
+
+    let payload: CloudflareUploadResponse;
+    try {
+      payload = JSON.parse(responseText) as CloudflareUploadResponse;
+    } catch (parseError) {
+      throw new Error(
+        `Unable to parse Cloudflare direct upload result: ${String(parseError)}`,
+      );
+    }
+
+    if (!payload.success) {
+      throw new Error(
+        `Cloudflare direct upload failed: ${JSON.stringify(payload, null, 2)}`,
+      );
+    }
+
+    return payload;
+  }
+
+  private async forwardRemoteUrl(
+    sendRequestCommand: SendRequestViaProxyCommand,
+    sourceImageUrl: string,
+  ) {
+    const proxyResult = await sendRequestCommand.execute({
+      url: CLOUDFLARE_IMAGE_INGEST_URL,
+      method: 'POST',
+      requestBody: JSON.stringify({
+        url: sourceImageUrl,
+      }),
+      multipart: true,
+    });
+
+    const responseText = await proxyResult.response.text();
+    if (!proxyResult.response.ok) {
+      throw new Error(
+        `Cloudflare upload failed: ${proxyResult.response.status} - ${responseText}`,
+      );
+    }
+
+    let payload: CloudflareUploadResponse;
+    try {
+      payload = JSON.parse(responseText) as CloudflareUploadResponse;
+    } catch (parseError) {
+      throw new Error(
+        `Unable to parse Cloudflare upload response: ${String(parseError)}`,
+      );
+    }
+    if (!payload.success) {
+      throw new Error(
+        `Cloudflare upload failed: ${JSON.stringify(payload, null, 2)}`,
+      );
+    }
+
+    return payload;
+  }
+
+}
diff --git a/system-card/model-configuration.gts b/system-card/model-configuration.gts
index 6302929..9d9df47 100644
--- a/system-card/model-configuration.gts
+++ b/system-card/model-configuration.gts
@@ -47,11 +47,11 @@ export class ModelConfiguration extends BaseModelConfiguration {
     },
   });
 
-  // Override inherited title to respect cardInfo.title
-  @field title = contains(StringField, {
+  // Override inherited title to respect cardInfo.name
+  @field cardTitle = contains(StringField, {
     computeVia: function (this: ModelConfiguration) {
       return (
-        this.cardInfo?.title ||
+        this.cardInfo?.name ||
         this.name ||
         this.modelId ||
         'Model Configuration'
@@ -114,7 +114,7 @@ export class ModelConfiguration extends BaseModelConfiguration {
                 <div class='strip-title'>{{if
                     @model.name
                     @model.name
-                    (if @model.title @model.title 'Model')
+                    (if @model.cardTitle @model.cardTitle 'Model')
                   }}</div>
               </div>
               <div class='strip-spacer'></div>
@@ -204,7 +204,7 @@ export class ModelConfiguration extends BaseModelConfiguration {
           <h4 class='tile-title'>{{if
               @model.name
               @model.name
-              (if @model.title @model.title 'Model')
+              (if @model.cardTitle @model.cardTitle 'Model')
             }}</h4>
           {{#if @model.modelId}}
             <div class='tile-id'>{{@model.modelId}}</div>
@@ -301,7 +301,7 @@ export class ModelConfiguration extends BaseModelConfiguration {
             <h4 class='card-title'>{{if
                 @model.name
                 @model.name
-                (if @model.title @model.title 'Model')
+                (if @model.cardTitle @model.cardTitle 'Model')
               }}</h4>
             {{#if @model.modelId}}
               <div class='card-id'>{{@model.modelId}}</div>
diff --git a/system-card/model-updater.gts b/system-card/model-updater.gts
index 16c6767..a5a17c7 100644
--- a/system-card/model-updater.gts
+++ b/system-card/model-updater.gts
@@ -274,7 +274,7 @@ class Isolated extends Component<typeof ModelUpdater> {
           workingModelCard.canonicalSlug = apiModel.canonical_slug;
           workingModelCard.name = apiModel.name;
           workingModelCard.created = apiModel.created;
-          workingModelCard.description = apiModel.description || '';
+          workingModelCard.cardDescription = apiModel.description || '';
           workingModelCard.contextLength = apiModel.context_length;
 
           if (apiModel.pricing) {
@@ -346,7 +346,7 @@ class Isolated extends Component<typeof ModelUpdater> {
                 canonicalSlug: workingModelCard.canonicalSlug,
                 name: workingModelCard.name,
                 created: workingModelCard.created,
-                description: workingModelCard.description,
+                description: workingModelCard.cardDescription,
                 pricing: workingModelCard.pricing
                   ? {
                       prompt: workingModelCard.pricing.prompt,
@@ -477,7 +477,7 @@ class Isolated extends Component<typeof ModelUpdater> {
   <template>
     <article class='model-updater'>
       <header class='header'>
-        <h1>{{if @model.title @model.title 'OpenRouter Model Updater'}}</h1>
+        <h1>{{if @model.cardTitle @model.cardTitle 'OpenRouter Model Updater'}}</h1>
         <p class='subtitle'>Fetch and update OpenRouter model data</p>
       </header>
 
@@ -879,9 +879,9 @@ export class ModelUpdater extends CardDef {
     description: 'Status of the last update operation',
   });
 
-  @field title = contains(StringField, {
+  @field cardTitle = contains(StringField, {
     computeVia: function (this: ModelUpdater) {
-      return this.cardInfo?.title || 'OpenRouter Model Updater';
+      return this.cardInfo?.name || 'OpenRouter Model Updater';
     },
   });
   static isolated = Isolated;
diff --git a/system-card/openrouter-model.gts b/system-card/openrouter-model.gts
index 0e50807..c23213e 100644
--- a/system-card/openrouter-model.gts
+++ b/system-card/openrouter-model.gts
@@ -97,11 +97,11 @@ class Isolated extends Component<typeof OpenRouterModel> {
   }
 
   get truncatedDescription(): string {
-    if (!this.args.model.description) return '';
+    if (!this.args.model.cardDescription) return '';
     const maxLength = 200;
-    if (this.args.model.description.length <= maxLength)
-      return this.args.model.description;
-    return this.args.model.description.substring(0, maxLength) + '...';
+    if (this.args.model.cardDescription.length <= maxLength)
+      return this.args.model.cardDescription;
+    return this.args.model.cardDescription.substring(0, maxLength) + '...';
   }
 
   <template>
@@ -203,16 +203,16 @@ class Isolated extends Component<typeof OpenRouterModel> {
           {{/if}}
         </div>
 
-        {{#if @model.description}}
+        {{#if @model.cardDescription}}
           <div class='description-block'>
             <p class='description-text'>
               {{#if this.showFullDescription}}
-                {{@model.description}}
+                {{@model.cardDescription}}
               {{else}}
                 {{this.truncatedDescription}}
               {{/if}}
             </p>
-            {{#if (gt @model.description.length 200)}}
+            {{#if (gt @model.cardDescription.length 200)}}
               <button
                 class='show-more-btn'
                 {{on 'click' this.toggleDescription}}
@@ -776,7 +776,7 @@ export class OpenRouterModel extends ModelConfiguration {
   // Identification (modelId and canonicalSlug inherited from parent)
   @field name = contains(StringField); // e.g., "GPT-4"
   @field created = contains(NumberField); // epoch seconds
-  @field description = contains(StringField);
+  @field cardDescription = contains(StringField);
 
   // Pricing
   @field pricing = contains(OpenRouterPricing);
@@ -800,10 +800,10 @@ export class OpenRouterModel extends ModelConfiguration {
   @field defaultParameters = contains(OpenRouterDefaultParameters);
 
   // Override inherited title to use name or modelId
-  @field title = contains(StringField, {
+  @field cardTitle = contains(StringField, {
     computeVia: function (this: OpenRouterModel) {
       return (
-        this.cardInfo?.title || this.name || this.modelId || 'OpenRouter Model'
+        this.cardInfo?.name || this.name || this.modelId || 'OpenRouter Model'
       );
     },
   });
@@ -887,8 +887,8 @@ export class OpenRouterModel extends ModelConfiguration {
           {{/if}}
         </div>
 
-        {{#if @model.description}}
-          <p class='embedded-description'>{{@model.description}}</p>
+        {{#if @model.cardDescription}}
+          <p class='embedded-description'>{{@model.cardDescription}}</p>
         {{/if}}
 
         <div class='model-stats'>
diff --git a/system-card/recommended-model.gts b/system-card/recommended-model.gts
index a8eb2b4..835298f 100644
--- a/system-card/recommended-model.gts
+++ b/system-card/recommended-model.gts
@@ -74,7 +74,7 @@ export class RecommendedModel extends ModelConfiguration {
     },
   });
 
-  @field title = contains(StringField, {
+  @field cardTitle = contains(StringField, {
     computeVia: function (this: RecommendedModel) {
       // Get the full model name (e.g., "OpenAI: GPT-5.1 Chat" or "Google: Gemini 2.5 Flash")
       let fullModelName = '';
@@ -132,8 +132,8 @@ export class RecommendedModel extends ModelConfiguration {
       // Non-role-specific: ✓ OpenAI: GPT-5.1 Chat
       const autoTitle = `${purposeSegment}${modelSegment}${thinkingSuffix}`;
 
-      // Allow manual override via cardInfo.title
-      return this.cardInfo?.title || autoTitle;
+      // Allow manual override via cardInfo.name
+      return this.cardInfo?.name || autoTitle;
     },
   });
 
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 0000000..f521f14
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,41 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "allowJs": true,
+    "module": "es2022",
+    "moduleResolution": "nodenext",
+    "allowSyntheticDefaultImports": true,
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "strictNullChecks": true,
+    "strictPropertyInitialization": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noEmitOnError": false,
+    "noEmit": true,
+    "inlineSourceMap": true,
+    "inlineSources": true,
+    "baseUrl": ".",
+    "strict": true,
+    "experimentalDecorators": true,
+    "skipLibCheck": true,
+    "paths": {
+      "https://cardstack.com/base/*": ["../base/*"],
+      "@cardstack/catalog/commands/*": ["../catalog-realm/commands/*"],
+      "@cardstack/catalog/*": ["../catalog-realm/catalog-app/*"],
+      "*": ["types/*"]
+    },
+    "types": ["@cardstack/local-types"]
+  },
+  "glint": {
+    "environment": ["ember-loose", "ember-template-imports"]
+  },
+  "include": [
+    "../base/**/*",
+    "../catalog-realm/**/*"
+  ],
+  "exclude": ["../base/**/__boxel/**"]
+}