@inneranimalmedia/agentsam-sdk 2.6.5 → 2.6.8

package/src/local/sqlite.js

@@ -90,6 +90,23 @@ export async function createLocalSqliteDatabase(filePath = '.agentsam/data/agent
         },
       };
     },
+    async batch(statements = []) {
+      database.exec('BEGIN IMMEDIATE');
+      try {
+        const results = [];
+        for (const statement of statements) {
+          if (!statement || typeof statement.run !== 'function') {
+            throw new TypeError('Local SQLite batch entries must expose run()');
+          }
+          results.push(await statement.run());
+        }
+        database.exec('COMMIT');
+        return results;
+      } catch (error) {
+        try { database.exec('ROLLBACK'); } catch {}
+        throw error;
+      }
+    },
     exec(sql) {
       database.exec(sql);
     },

package/src/models/discovery.js

@@ -100,15 +100,9 @@ function baseRecord(provider, id, values = {}) {
 
 function openAIModelCapabilities(id) {
   const fallback = fallbackRecord('openai', id);
-  if (fallback?.capabilities) return {};
-  if (/^text-embedding-/i.test(id)) return { agent_runtime: false, embeddings: true };
-  if (/^(?:gpt-image|chatgpt-image|gpt-audio|gpt-realtime|sora|tts|whisper|omni-moderation)/i.test(id)) {
-    return { agent_runtime: false };
-  }
-  if (/^(?:gpt-(?:4o|4\.1|5|6)|o[1-9])/i.test(id)) {
-    return { agent_runtime: true, responses: true };
-  }
-  return { agent_runtime: false };
+  // /v1/models proves credential-scoped availability but does not expose
+  // per-model modality / Responses compatibility. Never guess from names.
+  return fallback?.capabilities ? {} : {};
 }
 
 async function fetchJson(fetchImpl, url, init) {
@@ -157,8 +151,8 @@ export async function discoverAnthropicModels(apiKey, fetchImpl = fetch) {
         return baseRecord('anthropic', id, {
           label: clean(row?.display_name) || id,
           source_url: 'https://api.anthropic.com/v1/models',
-          capabilities: { messages: true, function_calling: true, prompt_caching: true },
-          metadata: { created_at: row?.created_at || null, type: row?.type || null },
+          capabilities: { messages: true },
+          metadata: { created_at: row?.created_at || null, type: row?.type || null, capability_source: 'provider_endpoint_contract' },
         });
       })
       .filter(Boolean);
@@ -179,6 +173,8 @@ export async function discoverGeminiModels(apiKey, fetchImpl = fetch) {
       .map((row) => {
         const id = clean(row?.baseModelId || row?.name).replace(/^models\//, '');
         if (!id) return null;
+        const providerDescription = clean(row?.description);
+        const specializedOutput = /(?:text[- ]to[- ]speech|\btts\b|image generation|generate images?|transcription|transcribe|audio generation)/i.test(providerDescription);
         return baseRecord('gemini', id, {
           label: clean(row?.displayName) || id,
           context_window: positiveInt(row?.inputTokenLimit),
@@ -187,12 +183,15 @@ export async function discoverGeminiModels(apiKey, fetchImpl = fetch) {
           source_url: 'https://generativelanguage.googleapis.com/v1beta/models',
           capabilities: {
             generate_content: true,
-            function_calling: true,
+            text_output: !specializedOutput,
             thinking: row?.thinking === true,
           },
           metadata: {
             version: row?.version || null,
+            description: providerDescription || null,
             supported_generation_methods: row?.supportedGenerationMethods || [],
+            capability_source: 'provider_api',
+            specialized_output: specializedOutput,
           },
         });
       })
@@ -238,22 +237,39 @@ function xaiPricing(row) {
 export async function discoverXaiModels(apiKey, fetchImpl = fetch) {
   if (!clean(apiKey)) return failure('credential unavailable', false);
   try {
-    const body = await fetchJson(fetchImpl, 'https://api.x.ai/v1/models', {
-      headers: { authorization: `Bearer ${clean(apiKey)}` },
-    });
+    const auth = { authorization: 'Bearer ' + clean(apiKey) };
+    const body = await fetchJson(fetchImpl, 'https://api.x.ai/v1/models', { headers: auth });
+    let languageRows = [];
+    try {
+      const languageBody = await fetchJson(fetchImpl, 'https://api.x.ai/v1/language-models', { headers: auth });
+      languageRows = Array.isArray(languageBody?.models) ? languageBody.models : [];
+    } catch {
+      // Keep full availability even if capability discovery is temporarily unavailable.
+    }
+    const languageById = new Map(languageRows.map((row) => [clean(row?.id), row]).filter(([id]) => id));
     const models = (Array.isArray(body?.data) ? body.data : [])
       .map((row) => {
         const id = clean(row?.id);
-        if (!id || /image|video|voice|embedding/i.test(id)) return null;
-        return baseRecord('grok', id, {
-          context_window: positiveInt(row?.context_length),
+        if (!id) return null;
+        const language = languageById.get(id) || null;
+        const outputModalities = Array.isArray(language?.output_modalities)
+          ? language.output_modalities.map(clean).filter(Boolean)
+          : [];
+        return baseRecord('xai', id, {
+          context_window: positiveInt(language?.context_length ?? row?.context_length),
           pricing: xaiPricing(row),
           source_url: 'https://api.x.ai/v1/models',
-          capabilities: { responses: true, function_calling: true, prompt_caching: true },
+          capabilities: {
+            responses: Boolean(language),
+            text_output: Boolean(language) && outputModalities.includes('text'),
+          },
           metadata: {
-            aliases: row?.aliases || [],
-            created: row?.created || null,
-            owned_by: row?.owned_by || null,
+            aliases: row?.aliases || language?.aliases || [],
+            created: row?.created || language?.created || null,
+            owned_by: row?.owned_by || language?.owned_by || null,
+            input_modalities: Array.isArray(language?.input_modalities) ? language.input_modalities : [],
+            output_modalities: outputModalities,
+            capability_source: language ? 'provider_api_language_models' : 'provider_api_models_only',
           },
         });
       })
@@ -288,6 +304,7 @@ export async function discoverCursorModels(apiKey, fetchImpl = fetch) {
             aliases: Array.isArray(row?.aliases) ? row.aliases : [],
             parameters: params,
             variants: Array.isArray(row?.variants) ? row.variants : [],
+            capability_source: 'provider_api',
           },
         });
       })
@@ -332,6 +349,7 @@ export async function discoverCloudflareModels(apiToken, accountId, fetchImpl =
             task,
             author: clean(row?.author) || null,
             description: clean(row?.description) || null,
+            capability_source: 'provider_api_task',
           },
         });
       })

package/src/models/inventory-core.d.ts

@@ -0,0 +1,105 @@
+export type CredentialPlane = "machine" | "studio_vault" | "mixed" | "platform" | string;
+
+export interface ProviderCredentialResolution {
+  configured: boolean;
+  value?: string;
+  source?: string | null;
+  error?: string | null;
+  account_id?: string | null;
+}
+
+export interface DiscoveredModelRecord {
+  provider: string;
+  provider_model_id: string;
+  model_id?: string;
+  model_key: string;
+  label: string;
+  availability: string;
+  availability_source?: string | null;
+  context_window?: number | null;
+  max_output_tokens?: number | null;
+  reasoning_efforts?: string[];
+  service_tiers?: string[];
+  capabilities?: Record<string, unknown>;
+  metadata?: Record<string, unknown>;
+  source?: Record<string, unknown>;
+}
+
+export interface CredentialScopedInventory {
+  schemaVersion: string;
+  generatedAt: string;
+  authority: string;
+  credential_plane: CredentialPlane;
+  providers: Array<{
+    id: string;
+    label: string;
+    configured: boolean;
+    source: string | null;
+    credentialError: string | null;
+  }>;
+  discovery: Record<string, {
+    attempted: boolean;
+    ok: boolean;
+    error: string | null;
+    returnedModelCount: number;
+    curation?: string;
+  }>;
+  providerModels: Record<string, DiscoveredModelRecord[]>;
+  availableModels: DiscoveredModelRecord[];
+}
+
+export const INVENTORY_API_PROVIDERS: readonly Readonly<{
+  id: string;
+  label: string;
+  service: string;
+  env: string;
+  aliases?: readonly string[];
+}>[];
+
+export const WORKERS_AI_CURATED_MODEL_IDS: readonly string[];
+
+export function providerIdForService(serviceName: unknown): string | null;
+export function filterWorkersAiCurated(models?: DiscoveredModelRecord[], options?: { curated?: boolean }): DiscoveredModelRecord[];
+export function makeMapCredentialResolver(
+  credentialByProvider: Map<string, { value: string; source?: string; account_id?: string }>,
+): (providerId: string) => Promise<ProviderCredentialResolution>;
+export function collectCredentialScopedInventory(options: {
+  fetchImpl?: typeof fetch;
+  credentialPlane?: CredentialPlane;
+  curateWorkersAi?: boolean;
+  discoverRemote?: boolean;
+  resolveCredential: (providerId: string) => ProviderCredentialResolution | Promise<ProviderCredentialResolution>;
+}): Promise<CredentialScopedInventory>;
+export function sanitizeInventoryForClient(status?: Partial<CredentialScopedInventory>): {
+  schemaVersion?: string;
+  generatedAt?: string;
+  authority?: string;
+  credential_plane?: CredentialPlane;
+  providers: CredentialScopedInventory["providers"];
+  discovery: CredentialScopedInventory["discovery"];
+  availableModels: Array<{
+    provider: string;
+    model_id: string;
+    model_key: string | null;
+    label: string;
+    availability: string;
+    availability_source: string | null;
+    context_window: number | null;
+    reasoning_efforts: string[];
+    service_tiers: string[];
+    capabilities: Record<string, unknown>;
+    chat_eligible: boolean;
+    eligibility_reason: string | null;
+    eligibility_source: string;
+  }>;
+};
+export function modelChatEligibility(row?: DiscoveredModelRecord): {
+  chat_eligible: boolean;
+  eligibility_reason: string | null;
+  eligibility_source: string;
+};
+export function assertModelAvailableForProvider(
+  inventory: { availableModels?: Array<Record<string, unknown>> },
+  provider: string,
+  modelId: string,
+): Record<string, unknown>;

package/src/models/inventory-core.js

@@ -7,7 +7,7 @@ export const INVENTORY_API_PROVIDERS = Object.freeze([
   { id: 'openai', label: 'OpenAI', service: 'openai', env: 'OPENAI_API_KEY' },
   { id: 'anthropic', label: 'Anthropic', service: 'anthropic', env: 'ANTHROPIC_API_KEY' },
   { id: 'gemini', label: 'Gemini', service: 'gemini', env: 'GEMINI_API_KEY' },
-  { id: 'grok', label: 'Grok / xAI', service: 'xai', env: 'XAI_API_KEY', aliases: ['xai', 'grok'] },
+  { id: 'xai', label: 'Grok / xAI', service: 'xai', env: 'XAI_API_KEY', aliases: ['grok'] },
   { id: 'cursor', label: 'Cursor', service: 'cursor', env: 'CURSOR_API_KEY' },
   { id: 'cloudflare', label: 'Cloudflare', service: 'cloudflare', env: 'CLOUDFLARE_API_TOKEN' },
 ]);
@@ -29,8 +29,8 @@ const SERVICE_TO_PROVIDER = Object.freeze({
   openai: 'openai',
   anthropic: 'anthropic',
   gemini: 'gemini',
-  xai: 'grok',
-  grok: 'grok',
+  xai: 'xai',
+  grok: 'xai',
   cursor: 'cursor',
   cloudflare: 'cloudflare',
 });
@@ -70,6 +70,41 @@ export function makeMapCredentialResolver(credentialByProvider) {
   };
 }
 
+const CHAT_ADAPTER_PROVIDERS = new Set(['openai', 'anthropic', 'gemini', 'xai', 'cloudflare']);
+
+export function modelChatEligibility(row = {}) {
+  const rawProvider = String(row.provider || '').trim().toLowerCase();
+  const provider = rawProvider === 'grok' ? 'xai' : rawProvider;
+  const caps = row.capabilities && typeof row.capabilities === 'object' ? row.capabilities : {};
+  const metadata = row.metadata && typeof row.metadata === 'object' ? row.metadata : {};
+  const source = String(metadata.capability_source || (row.source?.fallback?.url ? 'provider_reference' : 'provider_api'));
+
+  if (!CHAT_ADAPTER_PROVIDERS.has(provider)) {
+    return { chat_eligible: false, eligibility_reason: 'provider_adapter_unavailable', eligibility_source: source };
+  }
+  if (caps.embeddings === true) {
+    return { chat_eligible: false, eligibility_reason: 'embedding_model', eligibility_source: source };
+  }
+  if (caps.agent_runtime === false) {
+    return { chat_eligible: false, eligibility_reason: 'capability_excludes_chat', eligibility_source: source };
+  }
+
+  const positive =
+    (provider === 'openai' && caps.responses === true && caps.agent_runtime === true)
+    || (provider === 'anthropic' && caps.messages === true)
+    || (provider === 'gemini' && caps.generate_content === true && caps.text_output === true)
+    || (provider === 'xai' && caps.responses === true && caps.text_output === true)
+    || (provider === 'cloudflare' && caps.workers_ai === true && caps.agent_runtime === true && caps.embeddings !== true);
+
+  if (positive) {
+    return { chat_eligible: true, eligibility_reason: null, eligibility_source: source };
+  }
+  if (metadata.specialized_output === true || caps.text_output === false) {
+    return { chat_eligible: false, eligibility_reason: 'specialized_output_model', eligibility_source: source };
+  }
+  return { chat_eligible: false, eligibility_reason: 'capability_unknown', eligibility_source: source };
+}
+
 /**
  * Merge vault credentials (preferred) with optional platform env credentials.
  * Never returns secret material in the inventory result.
@@ -131,6 +166,15 @@ export async function collectCredentialScopedInventory(options = {}) {
   };
 }
 
+function sanitizeDiscoveryError(error) {
+  const raw = String(error || '').trim();
+  if (!raw) return null;
+  if (/\b(?:401|403)\b|unauthoriz|forbidden|invalid[_ -]?(?:api[_ -]?)?key|credential.*reject/i.test(raw)) {
+    return 'provider_credential_rejected';
+  }
+  return 'provider_discovery_failed';
+}
+
 export function sanitizeInventoryForClient(status = {}) {
   const out = {
     schemaVersion: status.schemaVersion,
@@ -142,11 +186,14 @@ export function sanitizeInventoryForClient(status = {}) {
       label: row.label,
       configured: row.configured === true,
       source: row.source || null,
-      credentialError: row.credentialError || null,
+      credentialError: sanitizeDiscoveryError(row.credentialError),
     })),
-    discovery: status.discovery || {},
+    discovery: Object.fromEntries(Object.entries(status.discovery || {}).map(([provider, row]) => [provider, {
+      ...row,
+      error: sanitizeDiscoveryError(row?.error),
+    }])) ,
     availableModels: (status.availableModels || []).map((row) => ({
-      provider: row.provider,
+      provider: row.provider === 'grok' ? 'xai' : row.provider,
       model_id: row.provider_model_id || row.model_id,
       model_key: row.model_key || null,
       label: row.label || row.provider_model_id || row.model_id,
@@ -156,6 +203,7 @@ export function sanitizeInventoryForClient(status = {}) {
       reasoning_efforts: row.reasoning_efforts || [],
       service_tiers: row.service_tiers || [],
       capabilities: row.capabilities || {},
+      ...modelChatEligibility(row),
     })),
   };
   if (status.local) {

package/src/sam/operations/package-audit.js

@@ -0,0 +1,41 @@
+import { defineSamOperation } from '../define.js';
+import { auditPackages } from '../../commands/package.js';
+
+export const packageAuditOp = defineSamOperation({
+  id: 'package.audit',
+  version: 1,
+  module: 'package',
+  action: 'audit',
+  summary: 'Audit AgentSam package publication intent, registry state, and structural blockers.',
+  purpose:
+    'Establish deterministic package-distribution authority for @inneranimalmedia packages without publishing anything.',
+  outcome:
+    'Return classified package manifests, public-distribution intent, registry state when allowed, and structural blockers.',
+  description:
+    'Discover scoped package manifests, classify public/private intent, optionally query npm registry state, and return a bounded read-only audit.',
+  skill: { id: 'agentsam-progression-guard', help: true },
+  accepts: ['root', 'publicOnly', 'offline'],
+  phases: ['discover_manifests', 'classify_intent', 'resolve_registry_state', 'emit_audit'],
+  execution: {
+    lanes: ['local', 'remote', 'sandbox'],
+    model: 'never',
+    embedding: 'never',
+    network: 'optional',
+    sideEffects: 'none',
+    provider_spend: 'none',
+  },
+  risk: 'read_only',
+  capabilities: ['package.audit'],
+  artifacts: ['package.audit'],
+  cli: { command: [['package', 'audit']] },
+  docs: { section: 'Packages' },
+  status: 'stable',
+  async handler(input = {}, ctx = {}) {
+    const root = input.root || input.cwd || ctx.cwd || process.cwd();
+    return auditPackages({
+      root,
+      publicOnly: input.publicOnly === true || input.public === true,
+      offline: input.offline === true,
+    });
+  },
+});

package/src/sam/seed.js

@@ -8,6 +8,7 @@ import { codebaseindexIngestOp } from './operations/codebaseindex-ingest.js';
 import { planningAstarOp } from './operations/planning-astar.js';
 import { planningGoapOp } from './operations/planning-goap.js';
 import { decisionEvaluateOp } from './operations/decision-evaluate.js';
+import { packageAuditOp } from './operations/package-audit.js';
 
 export const SEED_OPERATIONS = [
   repositoryInspect,
@@ -19,6 +20,7 @@ export const SEED_OPERATIONS = [
   planningAstarOp,
   planningGoapOp,
   decisionEvaluateOp,
+  packageAuditOp,
 ];
 
 let seeded = false;

package/src/security/logs.js

@@ -17,6 +17,9 @@ export function triageLog(text) {
     else if (/\b([1-9]\d*)\s+(?:(?:low|moderate|high|critical)\s+(?:severity\s+)?)?vulnerabilit/i.test(raw) || /npm audit fix/i.test(raw)) add('audit', line, 'rescan-current-lockfile');
     else if (/ExperimentalWarning/.test(raw)) add('experimental-runtime', line, 'informational', { blocking: false });
     else if (/new (?:release|(?:patch |minor |major )?version).*(?:pip|npm)|(?:pip|npm).*new (?:release|version)/i.test(raw)) add('tool-update', line, 'informational', { blocking: false });
+    // package.json allowScripts is the project authority; a user/global .npmrc allow-scripts clash is expected noise.
+    else if (/npm (?:warn|warning) allow-scripts.*declares its own allowScripts/i.test(raw)) add('configuration', line, 'informational', { blocking: false });
+    else if (/npm (?:warn|warning) allow-scripts/i.test(raw)) add('configuration', line, 'review-package-manager-config');
     else if (/npm (?:warn|warning).*config/i.test(raw)) add('configuration', line, 'review-package-manager-config');
     else if (/\b(?:warning|warn|npm ERR!|npm error)\b/i.test(raw)) add('unclassified-warning', line, 'review-log-at-source');
   }

package/src/ui/cli/help.js

@@ -89,6 +89,42 @@ export function renderHelpOverview(version, options = {}) {
   return lines.join('\n');
 }
 
+export function renderCommandHelp(entryOrId, version = String(pkg.version || 'unknown')) {
+  const entry = typeof entryOrId === 'string' ? getCliCommand(entryOrId) : entryOrId;
+  if (!entry) return renderHelpOverview(version);
+
+  const usage = entry.usage?.length ? entry.usage : [`agentsam ${entry.id}`];
+  const lines = [
+    '',
+    '  ' + pc.bold('Agent Sam') + ' ' + pc.dim('v' + version) + ' ' + pc.dim('·') + ' ' + pc.bold(entry.id),
+    '  ' + pc.dim(entry.summary),
+    '',
+    '  ' + pc.bold('Usage'),
+    ...usage.map((row) => '    ' + pc.cyan(row)),
+  ];
+
+  if (entry.options?.length) {
+    const width = Math.min(32, Math.max(...entry.options.map((row) => row.flag.length), 0));
+    lines.push(
+      '',
+      '  ' + pc.bold('Options'),
+      ...entry.options.map((row) => '    ' + pc.cyan(row.flag.padEnd(width)) + '  ' + pc.dim(row.description)),
+    );
+  }
+
+  if (entry.aliases?.length) {
+    lines.push('', '  ' + pc.bold('Aliases'), '    ' + entry.aliases.map((alias) => pc.cyan(`agentsam ${alias}`)).join(' · '));
+  }
+  if (entry.skill) {
+    lines.push('', '  ' + pc.dim(`Skill: agentsam skills ${entry.skill}`));
+  }
+  if (entry.operation) {
+    lines.push('  ' + pc.dim(`Operation: ${entry.operation}`));
+  }
+  lines.push('');
+  return lines.join('\n');
+}
+
 export function renderHelpTopic(topic, version) {
   if (!topic) return renderHelpOverview(version);
   const skillHint = topic.rows?.[0]?.[1]?.includes('skill')
@@ -153,6 +189,11 @@ export async function runHelp(argv = [], options = {}) {
 
   const topicArg = args.find((arg) => !arg.startsWith('-'));
   if (topicArg) {
+    const command = getCliCommand(topicArg);
+    if (command) {
+      write(renderCommandHelp(command, version));
+      return;
+    }
     const topic = resolveHelpTopic(topicArg);
     if (!topic) {
       write(renderHelpOverview(version));

package/apps/client-cms-editor/backend/src/demo-bootstrap.ts

@@ -1,145 +0,0 @@
-/**
- * Offline first-run CMS site for localhost preview — feeds the real CmsEditor shell.
- * Not a separate “scaffold UI”. Migrations/API stay authoritative in production.
- */
-
-export function buildDemoCmsBootstrap(projectSlug = 'demo') {
-  const pageId = 'page_home';
-  const heroId = 'sec_hero';
-  const gridId = 'sec_products';
-  const footerId = 'sec_footer';
-  const textBlockId = 'blk_join';
-
-  return {
-    tenant: {
-      name: 'Heuristic Theme',
-      domain: 'demo.localhost',
-      primary_color: '#1e6a6f',
-    },
-    public_domain: 'demo.localhost',
-    workspace_label: 'Heuristic Theme',
-    home_page: { id: pageId },
-    protocol_version: 1,
-    active_theme: {
-      css_vars: {
-        '--brand-primary': '#1e6a6f',
-        '--brand-secondary': '#123f42',
-        '--brand-accent': '#cfef5b',
-        '--color-bg': '#f5f2ea',
-        '--color-surface': '#ffffff',
-        '--color-text': '#101014',
-        '--color-text-muted': '#73737f',
-        '--font-heading': 'Inter',
-        '--font-body': 'Inter',
-      },
-    },
-    pages: [
-      {
-        id: pageId,
-        title: 'Home page',
-        slug: '/',
-        route_path: '/',
-        page_type: 'Home',
-        status: 'draft',
-        seo_title: 'Heuristic Theme',
-        meta_description: 'Stock CMS theme preview for AgentSam scaffolding.',
-      },
-    ],
-    sections_by_page: {
-      [pageId]: [
-        {
-          id: heroId,
-          section_name: 'Editorial hero',
-          section_type: 'hero',
-          is_visible: 1,
-          sort_order: 10,
-          section_data: {
-            headline: 'My Store',
-            subline: 'Stock heuristic-theme · first-run CMS surface',
-            cta_text: 'Shop collection',
-            eyebrow: 'Heuristic Theme',
-            bg_color: '#101014',
-          },
-        },
-        {
-          id: gridId,
-          section_name: 'Product grid',
-          section_type: 'product-grid',
-          is_visible: 1,
-          sort_order: 20,
-          section_data: {
-            title: 'Featured',
-            columns: 2,
-          },
-        },
-        {
-          id: footerId,
-          section_name: 'Footer',
-          section_type: 'footer',
-          is_visible: 1,
-          sort_order: 30,
-          section_data: {
-            zone: 'FOOTER',
-            bg_color: '#F3F0E8',
-          },
-        },
-      ],
-    },
-    blocks_by_section: {
-      [heroId]: [],
-      [gridId]: [
-        {
-          id: 'blk_card_1',
-          section_id: gridId,
-          block_type: 'product-card',
-          is_visible: 1,
-          sort_order: 10,
-          block_data: { title: 'Classic tee', price: '$19.99' },
-        },
-        {
-          id: 'blk_card_2',
-          section_id: gridId,
-          block_type: 'product-card',
-          is_visible: 1,
-          sort_order: 20,
-          block_data: { title: 'Soft tee', price: '$19.99' },
-        },
-      ],
-      [footerId]: [
-        {
-          id: textBlockId,
-          section_id: footerId,
-          block_type: 'text',
-          is_visible: 1,
-          sort_order: 10,
-          block_data: {
-            text: 'Join our email list',
-            typography_preset: 'Heading 4',
-            width: 'fit',
-            max_width: 'normal',
-            align: 'left',
-          },
-        },
-      ],
-    },
-    component_templates: [
-      { id: 'tpl_baseline_landing', template_name: 'Landing page', template_type: 'page', category: 'Marketing' },
-      { id: 'tpl_baseline_hero', template_name: 'Editorial hero', template_type: 'section', category: 'Portfolio' },
-      { id: 'tpl_baseline_footer', template_name: 'Utility footer', template_type: 'section', category: 'Agency' },
-    ],
-    schemas: {
-      protocol_version: 1,
-      sections: [
-        { key: 'hero', type: 'hero', version: 1, label: 'Editorial hero' },
-        { key: 'product-grid', type: 'product-grid', version: 1, label: 'Product grid' },
-        { key: 'footer', type: 'footer', version: 1, label: 'Footer' },
-      ],
-      blocks: [
-        { key: 'text', type: 'text', version: 1, label: 'Text' },
-        { key: 'product-card', type: 'product-card', version: 1, label: 'Product card' },
-      ],
-    },
-    _demo: true,
-    _project_slug: projectSlug,
-  };
-}