primitive-admin 1.0.25 → 1.0.26

package/dist/src/commands/sync.js

@@ -1,5 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync, rmdirSync, statSync } from "fs";
 import { join, basename } from "path";
+import { createHash } from "crypto";
 import * as TOML from "@iarna/toml";
 import { lookup as mimeLookup } from "mime-types";
 import { ApiClient, ConflictError } from "../lib/api-client.js";
@@ -27,6 +28,15 @@ function saveSyncState(configDir, state) {
     const syncFile = join(configDir, ".primitive-sync.json");
     writeFileSync(syncFile, JSON.stringify(state, null, 2));
 }
+export function computeFileHash(filePath) {
+    const content = readFileSync(filePath);
+    return createHash("sha256").update(content).digest("hex");
+}
+export function shouldPushFile(filePath, storedHash) {
+    if (!storedHash)
+        return true;
+    return computeFileHash(filePath) !== storedHash;
+}
 // TOML serialization helpers
 function serializeAppSettings(settings) {
     const data = {
@@ -83,7 +93,7 @@ function serializePrompt(prompt) {
             description: config.description,
             provider: config.provider,
             model: config.model,
-            temperature: config.temperature?.toString(),
+            temperature: config.temperature != null ? Number(config.temperature) : undefined,
             maxTokens: config.maxTokens,
             outputFormat: config.outputFormat,
             systemPrompt: config.systemPrompt,
@@ -96,6 +106,7 @@ function serializeWorkflow(workflow, draft, configs) {
     // Find the active config or use the first one
     const activeConfigId = workflow.activeConfigId;
     const activeConfig = configs?.find((c) => c.configId === activeConfigId) || configs?.[0];
+    const activeConfigName = activeConfig?.configName || "";
     // Determine which steps to use (prefer config steps if non-empty, else draft steps)
     const configSteps = activeConfig?.steps;
     const draftSteps = draft?.steps;
@@ -106,7 +117,7 @@ function serializeWorkflow(workflow, draft, configs) {
             name: workflow.name,
             description: workflow.description,
             status: workflow.status,
-            activeConfigId: activeConfigId,
+            activeConfigName: activeConfigName,
             perUserMaxRunning: workflow.perUserMaxRunning,
             perUserMaxQueued: workflow.perUserMaxQueued,
             dequeueOrder: workflow.dequeueOrder,
@@ -118,7 +129,6 @@ function serializeWorkflow(workflow, draft, configs) {
         steps,
         // Include all configurations
         configs: configs?.map((config) => ({
-            id: config.configId,
             name: config.configName,
             description: config.description,
             status: config.status,
@@ -127,6 +137,33 @@ function serializeWorkflow(workflow, draft, configs) {
     };
     return TOML.stringify(data);
 }
+// Database config serialization helpers
+function serializeDatabaseType(typeConfig, operations, ruleSetIdToName) {
+    const ruleSetName = typeConfig.ruleSetId ? (ruleSetIdToName.get(typeConfig.ruleSetId) || "") : "";
+    const data = {
+        type: {
+            databaseType: typeConfig.databaseType,
+            ruleSetName: ruleSetName,
+        },
+    };
+    if (typeConfig.metadataAccess) {
+        data.type.metadataAccess = typeConfig.metadataAccess;
+    }
+    if (typeConfig.triggers) {
+        data.triggers = typeConfig.triggers;
+    }
+    if (operations.length > 0) {
+        data.operations = operations.map((op) => ({
+            name: op.name,
+            type: op.type,
+            modelName: op.modelName,
+            access: op.access,
+            definition: typeof op.definition === "object" ? JSON.stringify(op.definition) : op.definition,
+            ...(op.params ? { params: typeof op.params === "object" ? JSON.stringify(op.params) : op.params } : {}),
+        }));
+    }
+    return TOML.stringify(data);
+}
 function serializeEmailTemplate(template) {
     // The API returns { emailType, hasOverride, override: { subject, htmlBody, textBody }, default: { ... } }
     // We only serialize overrides (custom templates), using the override fields.
@@ -145,11 +182,138 @@ function serializeEmailTemplate(template) {
     }
     return TOML.stringify(data);
 }
+function serializeRuleSet(ruleSet) {
+    const data = {
+        ruleSet: {
+            name: ruleSet.name,
+            resourceType: ruleSet.resourceType,
+        },
+    };
+    if (ruleSet.description) {
+        data.ruleSet.description = ruleSet.description;
+    }
+    // Rules are structured as { category: { operation: "expression" } }
+    const rules = typeof ruleSet.rules === "string" ? JSON.parse(ruleSet.rules) : (ruleSet.rules || {});
+    if (Object.keys(rules).length > 0) {
+        data.rules = rules;
+    }
+    return TOML.stringify(data);
+}
+function serializeGroupTypeConfig(config, ruleSetIdToName) {
+    const ruleSetName = config.ruleSetId ? (ruleSetIdToName.get(config.ruleSetId) || "") : "";
+    const data = {
+        groupTypeConfig: {
+            groupType: config.groupType,
+            ruleSetName: ruleSetName,
+            autoAddCreator: config.autoAddCreator ?? true,
+        },
+    };
+    return TOML.stringify(data);
+}
+export function parseDatabaseTypeToml(tomlData) {
+    const typeSection = tomlData.type || {};
+    const typeConfig = {
+        databaseType: typeSection.databaseType,
+    };
+    // Support both new key-based reference and legacy ID-based reference
+    if (typeSection.ruleSetName && typeSection.ruleSetName !== "") {
+        typeConfig._ruleSetName = typeSection.ruleSetName;
+    }
+    else if (typeSection.ruleSetId && typeSection.ruleSetId !== "") {
+        typeConfig.ruleSetId = typeSection.ruleSetId;
+    }
+    if (typeSection.metadataAccess) {
+        typeConfig.metadataAccess = typeSection.metadataAccess;
+    }
+    if (tomlData.triggers) {
+        typeConfig.triggers = tomlData.triggers;
+    }
+    const operations = (tomlData.operations || []).map((op) => ({
+        name: op.name,
+        type: op.type,
+        modelName: op.modelName,
+        access: op.access,
+        definition: typeof op.definition === "string" ? JSON.parse(op.definition) : op.definition,
+        params: op.params ? (typeof op.params === "string" ? JSON.parse(op.params) : op.params) : null,
+    }));
+    return { typeConfig, operations };
+}
+function parseRuleSetToml(tomlData) {
+    const ruleSetSection = tomlData.ruleSet || {};
+    return {
+        name: ruleSetSection.name,
+        resourceType: ruleSetSection.resourceType,
+        description: ruleSetSection.description || null,
+        rules: tomlData.rules || {},
+    };
+}
+export function parseGroupTypeConfigToml(tomlData) {
+    const section = tomlData.groupTypeConfig || {};
+    const result = {
+        groupType: section.groupType,
+        autoAddCreator: section.autoAddCreator ?? true,
+    };
+    // Support both new key-based reference and legacy ID-based reference
+    if (section.ruleSetName && section.ruleSetName !== "") {
+        result._ruleSetName = section.ruleSetName;
+    }
+    else if (section.ruleSetId && section.ruleSetId !== "") {
+        result.ruleSetId = section.ruleSetId;
+    }
+    return result;
+}
 // Parsing helpers
 function parseTomlFile(filePath) {
     const content = readFileSync(filePath, "utf-8");
     return TOML.parse(content);
 }
+/**
+ * Paginate through a list endpoint, collecting all items.
+ */
+export async function fetchAll(listFn, pageSize = 100, maxPages = 100) {
+    const all = [];
+    let cursor;
+    let page = 0;
+    do {
+        if (++page > maxPages) {
+            throw new Error(`fetchAll: too many pages (>${maxPages}), aborting to prevent infinite loop`);
+        }
+        const result = await listFn({ limit: pageSize, cursor: cursor });
+        all.push(...result.items);
+        cursor = result.nextCursor || undefined;
+    } while (cursor);
+    return all;
+}
+/**
+ * Safely parse a JSON field that may be a string or already an object.
+ * TOML can parse inline tables as objects, so we need to handle both.
+ */
+export function safeJsonParse(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value === "string")
+        return JSON.parse(value);
+    return value; // Already an object (TOML parsed it as a table)
+}
+/**
+ * Resolve a key-based rule set name reference to an ID.
+ * Throws if the name cannot be resolved and throwOnMissing is true.
+ */
+export function resolveRuleSetReference(entityConfig, ruleSetNameToId, entityLabel, options = {}) {
+    if (!entityConfig._ruleSetName)
+        return;
+    const resolvedRuleSetId = ruleSetNameToId.get(entityConfig._ruleSetName);
+    if (resolvedRuleSetId) {
+        entityConfig.ruleSetId = resolvedRuleSetId;
+    }
+    else {
+        const msg = `Rule set "${entityConfig._ruleSetName}" not found for ${entityLabel}. The entity would be created without a rule set.`;
+        if (options.throwOnMissing !== false) {
+            throw new Error(msg);
+        }
+    }
+    delete entityConfig._ruleSetName;
+}
 // Test case helpers (exported for unit testing)
 export function slugifyTestCaseName(name) {
     return name
@@ -175,15 +339,22 @@ function getTestsDir(configDir, blockType, blockKey) {
     const typeDir = blockType === "prompt" ? "prompts" : "workflows";
     return join(configDir, typeDir, `${blockKey}.tests`);
 }
-export function serializeTestCase(testCase) {
+export function serializeTestCase(testCase, lookupMaps) {
+    // Resolve ID references to key-based references
+    const configName = testCase.configId && lookupMaps?.configIdToName
+        ? (lookupMaps.configIdToName.get(testCase.configId) || "") : "";
+    const evaluatorPromptKey = testCase.evaluatorPromptId && lookupMaps?.promptIdToKey
+        ? (lookupMaps.promptIdToKey.get(testCase.evaluatorPromptId) || "") : "";
+    const evaluatorConfigName = testCase.evaluatorConfigId && lookupMaps?.configIdToName
+        ? (lookupMaps.configIdToName.get(testCase.evaluatorConfigId) || "") : "";
     const data = {
         test: {
             name: testCase.name || "",
             description: testCase.description || "",
             inputVariables: testCase.inputVariables || "{}",
-            configId: testCase.configId || "",
-            evaluatorPromptId: testCase.evaluatorPromptId || "",
-            evaluatorConfigId: testCase.evaluatorConfigId || "",
+            configName: configName,
+            evaluatorPromptKey: evaluatorPromptKey,
+            evaluatorConfigName: evaluatorConfigName,
             expectedOutputPattern: testCase.expectedOutputPattern || "",
             expectedOutputContains: testCase.expectedOutputContains || "[]",
             expectedJsonSubset: testCase.expectedJsonSubset || "{}",
@@ -210,6 +381,18 @@ export function parseTestCaseToml(tomlData) {
     if (test.description && test.description !== "") {
         payload.description = test.description;
     }
+    // Support both new key-based references and legacy ID-based references
+    // Key-based references (portable across apps)
+    if (test.configName && test.configName !== "") {
+        payload._configName = test.configName;
+    }
+    if (test.evaluatorPromptKey && test.evaluatorPromptKey !== "") {
+        payload._evaluatorPromptKey = test.evaluatorPromptKey;
+    }
+    if (test.evaluatorConfigName && test.evaluatorConfigName !== "") {
+        payload._evaluatorConfigName = test.evaluatorConfigName;
+    }
+    // Legacy ID-based references (backward compat)
     if (test.configId && test.configId !== "") {
         payload.configId = test.configId;
     }
@@ -240,7 +423,7 @@ export function parseTestCaseToml(tomlData) {
     }
     return payload;
 }
-async function pullTestCasesForBlock(client, appId, blockType, blockId, blockKey, configDir, testCaseEntities) {
+async function pullTestCasesForBlock(client, appId, blockType, blockId, blockKey, configDir, testCaseEntities, lookupMaps) {
     let testCases;
     try {
         const result = await client.listTestCases(appId, blockType, blockId);
@@ -261,7 +444,7 @@ async function pullTestCasesForBlock(client, appId, blockType, blockId, blockKey
         pulledSlugs.add(slug);
         // Write test case TOML
         const tomlPath = join(testsDir, `${slug}.toml`);
-        writeFileSync(tomlPath, serializeTestCase(tc));
+        writeFileSync(tomlPath, serializeTestCase(tc, lookupMaps));
         // Handle attachments
         let attachmentFilenames = [];
         try {
@@ -297,6 +480,7 @@ async function pullTestCasesForBlock(client, appId, blockType, blockId, blockKey
             slug,
             modifiedAt: tc.modifiedAt || tc.createdAt || new Date().toISOString(),
             attachmentFilenames: attachmentFilenames.length > 0 ? attachmentFilenames : undefined,
+            contentHash: computeFileHash(tomlPath),
         };
     }
     // Clean up local files for remotely-deleted test cases
@@ -326,21 +510,75 @@ async function pullTestCasesForBlock(client, appId, blockType, blockId, blockKey
     }
     return testCases.length;
 }
-async function pushTestCasesForBlock(client, appId, blockType, blockId, blockKey, configDir, syncState, dryRun, changes) {
+async function pushTestCasesForBlock(client, appId, blockType, blockId, blockKey, configDir, syncState, dryRun, changes, resolutionMaps, options) {
+    let skipped = 0;
     const testsDir = getTestsDir(configDir, blockType, blockKey);
     if (!existsSync(testsDir))
-        return;
+        return 0;
     const files = readdirSync(testsDir).filter((f) => f.endsWith(".toml"));
     if (files.length === 0)
-        return;
+        return 0;
     const TEN_MB = 10 * 1024 * 1024;
     for (const file of files) {
         const slug = basename(file, ".toml");
         const filePath = join(testsDir, file);
         const tomlData = parseTomlFile(filePath);
         const testPayload = parseTestCaseToml(tomlData);
+        // Resolve key-based references to IDs
+        if (resolutionMaps) {
+            // Resolve configName → configId
+            if (testPayload._configName && !testPayload.configId) {
+                const configMapKey = `${blockKey}#${testPayload._configName}`;
+                const configMap = blockType === "prompt"
+                    ? resolutionMaps.promptConfigNameToId
+                    : resolutionMaps.workflowConfigNameToId;
+                const resolvedId = configMap.get(configMapKey);
+                if (resolvedId) {
+                    testPayload.configId = resolvedId;
+                }
+            }
+            delete testPayload._configName;
+            // Resolve evaluatorPromptKey → evaluatorPromptId
+            if (testPayload._evaluatorPromptKey && !testPayload.evaluatorPromptId) {
+                const resolvedId = resolutionMaps.promptKeyToId.get(testPayload._evaluatorPromptKey);
+                if (resolvedId) {
+                    testPayload.evaluatorPromptId = resolvedId;
+                }
+            }
+            const evaluatorPromptKey = testPayload._evaluatorPromptKey;
+            delete testPayload._evaluatorPromptKey;
+            // Resolve evaluatorConfigName → evaluatorConfigId
+            if (testPayload._evaluatorConfigName && !testPayload.evaluatorConfigId && evaluatorPromptKey) {
+                const configMapKey = `${evaluatorPromptKey}#${testPayload._evaluatorConfigName}`;
+                const resolvedId = resolutionMaps.promptConfigNameToId.get(configMapKey);
+                if (resolvedId) {
+                    testPayload.evaluatorConfigId = resolvedId;
+                }
+            }
+            delete testPayload._evaluatorConfigName;
+        }
         const stateKey = `${blockType}/${blockKey}/${slug}`;
         const existingEntry = syncState?.entities?.testCases?.[stateKey];
+        // Skip if file hasn't changed since last sync (also check for attachment changes)
+        if (!options?.force && existingEntry?.id && !shouldPushFile(filePath, existingEntry.contentHash)) {
+            const attachDir = join(testsDir, slug);
+            const localAttachFiles = existsSync(attachDir)
+                ? readdirSync(attachDir).filter((f) => { try {
+                    return statSync(join(attachDir, f)).isFile();
+                }
+                catch {
+                    return false;
+                } })
+                : [];
+            const prevAttachFiles = existingEntry.attachmentFilenames || [];
+            const attachmentsChanged = localAttachFiles.length !== prevAttachFiles.length ||
+                localAttachFiles.some((f) => !prevAttachFiles.includes(f)) ||
+                prevAttachFiles.some((f) => !localAttachFiles.includes(f));
+            if (!attachmentsChanged) {
+                skipped++;
+                continue;
+            }
+        }
         if (existingEntry?.id) {
             // Update existing test case
             changes.push({ type: "test-case", action: "update", key: `${blockKey}/${slug}` });
@@ -348,6 +586,9 @@ async function pushTestCasesForBlock(client, appId, blockType, blockId, blockKey
                 try {
                     await client.updateTestCase(appId, blockType, blockId, existingEntry.id, testPayload);
                     info(`  Updated test case: ${blockKey}/${slug}`);
+                    if (syncState?.entities?.testCases?.[stateKey]) {
+                        syncState.entities.testCases[stateKey].contentHash = computeFileHash(filePath);
+                    }
                 }
                 catch (err) {
                     warn(`  Failed to update test case ${blockKey}/${slug}: ${err.message}`);
@@ -378,6 +619,7 @@ async function pushTestCasesForBlock(client, appId, blockType, blockId, blockKey
                             blockKey,
                             slug,
                             modifiedAt: created.modifiedAt || created.createdAt || new Date().toISOString(),
+                            contentHash: computeFileHash(filePath),
                         };
                     }
                 }
@@ -456,6 +698,7 @@ async function pushTestCasesForBlock(client, appId, blockType, blockId, blockKey
             }
         }
     }
+    return skipped;
 }
 function formatFileSize(bytes) {
     if (bytes < 1024)
@@ -477,14 +720,17 @@ Examples:
 
 Directory Structure:
   config/
-    .primitive-sync.json        # Sync state (auto-managed)
-    app.toml                    # App settings
-    integrations/*.toml         # Integration configs
-    prompts/*.toml              # Prompt configs
-    prompts/{key}.tests/*.toml  # Prompt test cases
-    workflows/*.toml            # Workflow definitions
-    workflows/{key}.tests/*.toml # Workflow test cases
-    email-templates/*.toml      # Email template overrides
+    .primitive-sync.json            # Sync state (auto-managed)
+    app.toml                        # App settings
+    integrations/*.toml             # Integration configs
+    prompts/*.toml                  # Prompt configs
+    prompts/{key}.tests/*.toml      # Prompt test cases
+    workflows/*.toml                # Workflow definitions
+    workflows/{key}.tests/*.toml    # Workflow test cases
+    database-types/*.toml           # Database type configs + operations
+    rule-sets/*.toml                # Access rule sets
+    group-type-configs/*.toml       # Group type configs
+    email-templates/*.toml          # Email template overrides
 `);
     // Init
     sync
@@ -500,6 +746,9 @@ Directory Structure:
         ensureDir(join(configDir, "integrations"));
         ensureDir(join(configDir, "prompts"));
         ensureDir(join(configDir, "workflows"));
+        ensureDir(join(configDir, "database-types"));
+        ensureDir(join(configDir, "rule-sets"));
+        ensureDir(join(configDir, "group-type-configs"));
         ensureDir(join(configDir, "email-templates"));
         const state = {
             appId: resolvedAppId,
@@ -526,17 +775,17 @@ Directory Structure:
         info(`Pulling configuration for app ${resolvedAppId}...`);
         try {
             // Fetch all data
-            const [settings, integrationsResult, promptsResult, workflowsResult, emailTemplatesResult] = await Promise.all([
+            const [settings, integrationItems, promptItems, workflowItems, emailTemplatesResult] = await Promise.all([
                 client.getAppSettings(resolvedAppId).catch(() => null),
-                client.listIntegrations(resolvedAppId, { limit: 100 }),
-                client.listPrompts(resolvedAppId, { limit: 100 }),
-                client.listWorkflows(resolvedAppId, { limit: 100 }),
+                fetchAll((p) => client.listIntegrations(resolvedAppId, p)),
+                fetchAll((p) => client.listPrompts(resolvedAppId, p)),
+                fetchAll((p) => client.listWorkflows(resolvedAppId, p)),
                 client.listEmailTemplates(resolvedAppId).catch(() => ({ templates: [] })),
             ]);
             // Fetch details for each entity
-            const integrations = await Promise.all(integrationsResult.items.map((i) => client.getIntegration(resolvedAppId, i.integrationId)));
-            const prompts = await Promise.all(promptsResult.items.map((p) => client.getPrompt(resolvedAppId, p.promptId)));
-            const workflows = await Promise.all(workflowsResult.items.map(async (w) => {
+            const integrations = await Promise.all(integrationItems.map((i) => client.getIntegration(resolvedAppId, i.integrationId)));
+            const prompts = await Promise.all(promptItems.map((p) => client.getPrompt(resolvedAppId, p.promptId)));
+            const workflows = await Promise.all(workflowItems.map(async (w) => {
                 const workflowData = await client.getWorkflow(resolvedAppId, w.workflowId);
                 // Fetch active config with steps if available
                 const activeConfigId = workflowData.workflow?.activeConfigId;
@@ -564,25 +813,42 @@ Directory Structure:
                 json({ settings, integrations, prompts, workflows, emailTemplates });
                 return;
             }
+            // Fetch database config resources
+            const [databaseTypeConfigsResult, ruleSetsResult, groupTypeConfigsResult] = await Promise.all([
+                client.listDatabaseTypeConfigs(resolvedAppId).catch(() => []),
+                client.listRuleSets(resolvedAppId).catch(() => []),
+                client.listGroupTypeConfigs(resolvedAppId).catch(() => []),
+            ]);
+            // Fetch operations for each database type
+            const databaseTypesWithOps = await Promise.all((Array.isArray(databaseTypeConfigsResult) ? databaseTypeConfigsResult : []).map(async (typeConfig) => {
+                const ops = await client.listDatabaseTypeOperations(resolvedAppId, typeConfig.databaseType).catch(() => []);
+                return { typeConfig, operations: Array.isArray(ops) ? ops : [] };
+            }));
             // Ensure directories exist
             ensureDir(configDir);
             ensureDir(join(configDir, "integrations"));
             ensureDir(join(configDir, "prompts"));
             ensureDir(join(configDir, "workflows"));
+            ensureDir(join(configDir, "database-types"));
+            ensureDir(join(configDir, "rule-sets"));
+            ensureDir(join(configDir, "group-type-configs"));
             ensureDir(join(configDir, "email-templates"));
             // Write app settings
             if (settings) {
-                writeFileSync(join(configDir, "app.toml"), serializeAppSettings(settings));
+                const appTomlPath = join(configDir, "app.toml");
+                writeFileSync(appTomlPath, serializeAppSettings(settings));
                 info("  Wrote app.toml");
             }
             // Write integrations
             const integrationEntities = {};
             for (const integration of integrations) {
                 const filename = `${integration.integrationKey}.toml`;
-                writeFileSync(join(configDir, "integrations", filename), serializeIntegration(integration));
+                const filePath = join(configDir, "integrations", filename);
+                writeFileSync(filePath, serializeIntegration(integration));
                 integrationEntities[integration.integrationKey] = {
                     id: integration.integrationId,
                     modifiedAt: integration.modifiedAt || new Date().toISOString(),
+                    contentHash: computeFileHash(filePath),
                 };
                 info(`  Wrote integrations/${filename}`);
             }
@@ -590,10 +856,12 @@ Directory Structure:
             const promptEntities = {};
             for (const prompt of prompts) {
                 const filename = `${prompt.promptKey}.toml`;
-                writeFileSync(join(configDir, "prompts", filename), serializePrompt(prompt));
+                const filePath = join(configDir, "prompts", filename);
+                writeFileSync(filePath, serializePrompt(prompt));
                 promptEntities[prompt.promptKey] = {
                     id: prompt.promptId,
                     modifiedAt: prompt.modifiedAt || new Date().toISOString(),
+                    contentHash: computeFileHash(filePath),
                 };
                 info(`  Wrote prompts/${filename}`);
             }
@@ -601,15 +869,37 @@ Directory Structure:
             const workflowEntities = {};
             for (const { workflow, draft, configs } of workflows) {
                 const filename = `${workflow.workflowKey}.toml`;
-                writeFileSync(join(configDir, "workflows", filename), serializeWorkflow(workflow, draft, configs || []));
+                const filePath = join(configDir, "workflows", filename);
+                writeFileSync(filePath, serializeWorkflow(workflow, draft, configs || []));
                 workflowEntities[workflow.workflowKey] = {
                     id: workflow.workflowId,
                     modifiedAt: workflow.modifiedAt || new Date().toISOString(),
                     activeConfigId: workflow.activeConfigId,
+                    contentHash: computeFileHash(filePath),
                 };
                 info(`  Wrote workflows/${filename}`);
             }
-            // Write email templates
+            // Build lookup maps for test case serialization
+            const configIdToName = new Map();
+            const promptIdToKey = new Map();
+            for (const prompt of prompts) {
+                promptIdToKey.set(prompt.promptId, prompt.promptKey);
+                if (prompt.configs) {
+                    for (const config of prompt.configs) {
+                        configIdToName.set(config.configId, config.configName);
+                    }
+                }
+            }
+            // Also include workflow config names
+            for (const { configs } of workflows) {
+                if (configs) {
+                    for (const config of configs) {
+                        configIdToName.set(config.configId, config.configName);
+                    }
+                }
+            }
+            const testCaseLookupMaps = { configIdToName, promptIdToKey };
+            // Write email templates (use detailed emailTemplates, not summaries)
             const emailTemplateEntities = {};
             for (const template of emailTemplates) {
                 const filename = `${template.emailType}.toml`;
@@ -637,31 +927,87 @@ Directory Structure:
             const testCaseEntities = {};
             let totalTestCases = 0;
             for (const prompt of prompts) {
-                const count = await pullTestCasesForBlock(client, resolvedAppId, "prompt", prompt.promptId, prompt.promptKey, configDir, testCaseEntities);
+                const count = await pullTestCasesForBlock(client, resolvedAppId, "prompt", prompt.promptId, prompt.promptKey, configDir, testCaseEntities, testCaseLookupMaps);
                 if (count > 0) {
                     info(`  Wrote ${count} test case(s) for prompt: ${prompt.promptKey}`);
                 }
                 totalTestCases += count;
             }
             for (const { workflow } of workflows) {
-                const count = await pullTestCasesForBlock(client, resolvedAppId, "workflow", workflow.workflowId, workflow.workflowKey, configDir, testCaseEntities);
+                const count = await pullTestCasesForBlock(client, resolvedAppId, "workflow", workflow.workflowId, workflow.workflowKey, configDir, testCaseEntities, testCaseLookupMaps);
                 if (count > 0) {
                     info(`  Wrote ${count} test case(s) for workflow: ${workflow.workflowKey}`);
                 }
                 totalTestCases += count;
             }
+            // Build ruleSetId → name map for database types and group type configs
+            const ruleSets = Array.isArray(ruleSetsResult) ? ruleSetsResult : [];
+            const ruleSetIdToName = new Map();
+            for (const ruleSet of ruleSets) {
+                ruleSetIdToName.set(ruleSet.ruleSetId, ruleSet.name);
+            }
+            // Write database types
+            const databaseTypeEntities = {};
+            for (const { typeConfig, operations } of databaseTypesWithOps) {
+                const filename = `${typeConfig.databaseType}.toml`;
+                const filePath = join(configDir, "database-types", filename);
+                writeFileSync(filePath, serializeDatabaseType(typeConfig, operations, ruleSetIdToName));
+                const opsEntities = {};
+                for (const op of operations) {
+                    opsEntities[op.name] = {
+                        modifiedAt: op.modifiedAt || new Date().toISOString(),
+                    };
+                }
+                databaseTypeEntities[typeConfig.databaseType] = {
+                    databaseType: typeConfig.databaseType,
+                    modifiedAt: typeConfig.modifiedAt || new Date().toISOString(),
+                    operations: Object.keys(opsEntities).length > 0 ? opsEntities : undefined,
+                    contentHash: computeFileHash(filePath),
+                };
+                info(`  Wrote database-types/${filename}`);
+            }
+            // Write rule sets
+            const ruleSetEntities = {};
+            for (const ruleSet of ruleSets) {
+                const fileKey = (ruleSet.name || ruleSet.ruleSetId).replace(/[/\\:*?"<>|]/g, "_");
+                const filename = `${fileKey}.toml`;
+                const filePath = join(configDir, "rule-sets", filename);
+                writeFileSync(filePath, serializeRuleSet(ruleSet));
+                ruleSetEntities[fileKey] = {
+                    id: ruleSet.ruleSetId,
+                    modifiedAt: ruleSet.modifiedAt || new Date().toISOString(),
+                    contentHash: computeFileHash(filePath),
+                };
+                info(`  Wrote rule-sets/${filename}`);
+            }
+            // Write group type configs
+            const groupTypeConfigEntities = {};
+            const groupTypeConfigs = Array.isArray(groupTypeConfigsResult) ? groupTypeConfigsResult : [];
+            for (const config of groupTypeConfigs) {
+                const filename = `${config.groupType}.toml`;
+                const filePath = join(configDir, "group-type-configs", filename);
+                writeFileSync(filePath, serializeGroupTypeConfig(config, ruleSetIdToName));
+                groupTypeConfigEntities[config.groupType] = {
+                    modifiedAt: config.modifiedAt || new Date().toISOString(),
+                    contentHash: computeFileHash(filePath),
+                };
+                info(`  Wrote group-type-configs/${filename}`);
+            }
             // Save sync state
             const state = {
                 appId: resolvedAppId,
                 serverUrl: getServerUrl(),
                 lastSyncedAt: new Date().toISOString(),
                 entities: {
-                    app: settings ? { modifiedAt: new Date().toISOString() } : undefined,
+                    app: settings ? { modifiedAt: new Date().toISOString(), contentHash: computeFileHash(join(configDir, "app.toml")) } : undefined,
                     integrations: integrationEntities,
                     prompts: promptEntities,
                     workflows: workflowEntities,
                     emailTemplates: Object.keys(emailTemplateEntities).length > 0 ? emailTemplateEntities : undefined,
                     testCases: Object.keys(testCaseEntities).length > 0 ? testCaseEntities : undefined,
+                    databaseTypes: Object.keys(databaseTypeEntities).length > 0 ? databaseTypeEntities : undefined,
+                    ruleSets: Object.keys(ruleSetEntities).length > 0 ? ruleSetEntities : undefined,
+                    groupTypeConfigs: Object.keys(groupTypeConfigEntities).length > 0 ? groupTypeConfigEntities : undefined,
                 },
             };
             saveSyncState(configDir, state);
@@ -672,6 +1018,9 @@ Directory Structure:
             keyValue("Workflows", workflows.length);
             keyValue("Email Templates", emailTemplates.length);
             keyValue("Test Cases", totalTestCases);
+            keyValue("Database Types", databaseTypesWithOps.length);
+            keyValue("Rule Sets", ruleSets.length);
+            keyValue("Group Type Configs", groupTypeConfigs.length);
         }
         catch (err) {
             error(err.message);
@@ -695,38 +1044,159 @@ Directory Structure:
             error(`Config directory not found: ${configDir}`);
             process.exit(1);
         }
-        const syncState = loadSyncState(configDir);
+        let syncState = loadSyncState(configDir);
+        // Detect cross-app push: if pushing to a different app, clear entity IDs
+        // so everything goes through the create path
+        const isCrossAppPush = syncState && syncState.appId !== resolvedAppId;
+        if (isCrossAppPush) {
+            info(`Cross-app push detected: ${syncState.appId} → ${resolvedAppId}`);
+            info("All entities will be created fresh in the target app.");
+            syncState = {
+                appId: resolvedAppId,
+                serverUrl: syncState.serverUrl,
+                lastSyncedAt: new Date().toISOString(),
+                entities: {},
+            };
+        }
         info(`Pushing configuration for app ${resolvedAppId}...`);
         try {
             const changes = [];
+            let skippedCount = 0;
             const conflicts = [];
+            // Track name→ID mappings for resolving cross-references during push
+            const ruleSetNameToId = new Map();
+            const promptKeyToId = new Map();
+            const promptConfigNameToId = new Map(); // key: "promptKey#configName"
+            const workflowConfigNameToId = new Map(); // key: "workflowKey#configName"
             // Process app settings
             const appTomlPath = join(configDir, "app.toml");
             if (existsSync(appTomlPath)) {
-                const tomlData = parseTomlFile(appTomlPath);
-                const settings = {};
-                if (tomlData.app) {
-                    Object.assign(settings, tomlData.app);
-                }
-                if (tomlData.auth) {
-                    settings.googleOAuthEnabled = tomlData.auth.googleOAuthEnabled;
-                    settings.passkeyEnabled = tomlData.auth.passkeyEnabled;
-                    settings.magicLinkEnabled = tomlData.auth.magicLinkEnabled;
-                    if (tomlData.auth.passkeys) {
-                        settings.passkeyRpConfig = tomlData.auth.passkeys;
-                    }
+                const appChanged = options.force || !syncState?.entities?.app?.contentHash ||
+                    shouldPushFile(appTomlPath, syncState.entities.app.contentHash);
+                if (!appChanged) {
+                    skippedCount++;
+                    info("  Skipped app settings (unchanged)");
                 }
-                if (tomlData.cors) {
-                    settings.corsMode = tomlData.cors.mode;
-                    settings.corsAllowedOrigins = tomlData.cors.allowedOrigins;
-                    settings.corsAllowCredentials = tomlData.cors.allowCredentials;
-                    settings.corsAllowedMethods = tomlData.cors.allowedMethods;
-                    settings.corsMaxAge = tomlData.cors.maxAge;
+                else {
+                    const tomlData = parseTomlFile(appTomlPath);
+                    const settings = {};
+                    if (tomlData.app) {
+                        Object.assign(settings, tomlData.app);
+                        // Don't overwrite the target app's name during cross-app push
+                        if (isCrossAppPush) {
+                            delete settings.name;
+                        }
+                    }
+                    if (tomlData.auth) {
+                        settings.googleOAuthEnabled = tomlData.auth.googleOAuthEnabled;
+                        settings.passkeyEnabled = tomlData.auth.passkeyEnabled;
+                        settings.magicLinkEnabled = tomlData.auth.magicLinkEnabled;
+                        if (tomlData.auth.passkeys) {
+                            settings.passkeyRpConfig = tomlData.auth.passkeys;
+                        }
+                    }
+                    if (tomlData.cors) {
+                        settings.corsMode = tomlData.cors.mode;
+                        settings.corsAllowedOrigins = tomlData.cors.allowedOrigins;
+                        settings.corsAllowCredentials = tomlData.cors.allowCredentials;
+                        settings.corsAllowedMethods = tomlData.cors.allowedMethods;
+                        settings.corsMaxAge = tomlData.cors.maxAge;
+                    }
+                    changes.push({ type: "app", action: "update", key: "settings" });
+                    if (!options.dryRun) {
+                        await client.updateAppSettings(resolvedAppId, settings);
+                        info("  Updated app settings");
+                        // Store content hash after successful push
+                        if (syncState) {
+                            if (!syncState.entities.app) {
+                                syncState.entities.app = { modifiedAt: new Date().toISOString() };
+                            }
+                            syncState.entities.app.contentHash = computeFileHash(appTomlPath);
+                        }
+                    }
                 }
-                changes.push({ type: "app", action: "update", key: "settings" });
-                if (!options.dryRun) {
-                    await client.updateAppSettings(resolvedAppId, settings);
-                    info("  Updated app settings");
+            }
+            // Process rule sets first (other entities may reference them by name)
+            const ruleSetsDir = join(configDir, "rule-sets");
+            if (existsSync(ruleSetsDir)) {
+                const files = readdirSync(ruleSetsDir).filter((f) => f.endsWith(".toml"));
+                for (const file of files) {
+                    const filePath = join(ruleSetsDir, file);
+                    const tomlData = parseTomlFile(filePath);
+                    const ruleSetData = parseRuleSetToml(tomlData);
+                    const fileKey = basename(file, ".toml");
+                    const existingId = syncState?.entities?.ruleSets?.[fileKey]?.id;
+                    // Skip if file hasn't changed since last sync
+                    if (!options.force && existingId && !shouldPushFile(filePath, syncState?.entities?.ruleSets?.[fileKey]?.contentHash)) {
+                        skippedCount++;
+                        ruleSetNameToId.set(ruleSetData.name, existingId);
+                        continue;
+                    }
+                    if (existingId) {
+                        // Update existing rule set
+                        changes.push({ type: "rule-set", action: "update", key: fileKey });
+                        if (!options.dryRun) {
+                            const expectedModifiedAt = options.force
+                                ? undefined
+                                : syncState?.entities?.ruleSets?.[fileKey]?.modifiedAt;
+                            try {
+                                const updated = await client.updateRuleSet(resolvedAppId, existingId, {
+                                    name: ruleSetData.name,
+                                    description: ruleSetData.description,
+                                    rules: ruleSetData.rules,
+                                }, expectedModifiedAt);
+                                info(`  Updated rule set: ${fileKey}`);
+                                if (syncState?.entities?.ruleSets?.[fileKey] && updated?.modifiedAt) {
+                                    syncState.entities.ruleSets[fileKey].modifiedAt = updated.modifiedAt;
+                                    syncState.entities.ruleSets[fileKey].contentHash = computeFileHash(filePath);
+                                }
+                            }
+                            catch (err) {
+                                if (err instanceof ConflictError) {
+                                    conflicts.push({
+                                        type: "rule-set",
+                                        key: fileKey,
+                                        serverModifiedAt: err.serverModifiedAt,
+                                        localModifiedAt: expectedModifiedAt || "unknown",
+                                    });
+                                }
+                                else {
+                                    throw err;
+                                }
+                            }
+                        }
+                        // Track name→ID for cross-reference resolution
+                        ruleSetNameToId.set(ruleSetData.name, existingId);
+                    }
+                    else {
+                        // Create new rule set
+                        changes.push({ type: "rule-set", action: "create", key: fileKey });
+                        if (!options.dryRun) {
+                            const created = await client.createRuleSet(resolvedAppId, {
+                                name: ruleSetData.name,
+                                resourceType: ruleSetData.resourceType,
+                                rules: ruleSetData.rules,
+                                description: ruleSetData.description,
+                            });
+                            info(`  Created rule set: ${fileKey}`);
+                            if (syncState && created?.ruleSetId) {
+                                if (!syncState.entities.ruleSets) {
+                                    syncState.entities.ruleSets = {};
+                                }
+                                syncState.entities.ruleSets[fileKey] = {
+                                    id: created.ruleSetId,
+                                    modifiedAt: created.modifiedAt || new Date().toISOString(),
+                                    contentHash: computeFileHash(filePath),
+                                };
+                            }
+                            // Track name→ID for cross-reference resolution
+                            ruleSetNameToId.set(ruleSetData.name, created.ruleSetId);
+                        }
+                        else {
+                            // In dry-run mode, use a placeholder so dependent entities can resolve
+                            ruleSetNameToId.set(ruleSetData.name, `dry-run-${ruleSetData.name}`);
+                        }
+                    }
                 }
             }
             // Process integrations
@@ -739,6 +1209,11 @@ Directory Structure:
                     const integration = tomlData.integration || {};
                     const key = integration.key || basename(file, ".toml");
                     const existingId = syncState?.entities?.integrations?.[key]?.id;
+                    // Skip if file hasn't changed since last sync
+                    if (!options.force && existingId && !shouldPushFile(filePath, syncState?.entities?.integrations?.[key]?.contentHash)) {
+                        skippedCount++;
+                        continue;
+                    }
                     const payload = {
                         integrationKey: key,
                         displayName: integration.displayName || key,
@@ -759,6 +1234,7 @@ Directory Structure:
                                 // Update sync state with new modifiedAt
                                 if (syncState?.entities?.integrations?.[key] && updated?.modifiedAt) {
                                     syncState.entities.integrations[key].modifiedAt = updated.modifiedAt;
+                                    syncState.entities.integrations[key].contentHash = computeFileHash(filePath);
                                 }
                             }
                             catch (err) {
@@ -789,6 +1265,7 @@ Directory Structure:
                                 syncState.entities.integrations[key] = {
                                     id: created.integrationId,
                                     modifiedAt: created.modifiedAt,
+                                    contentHash: computeFileHash(filePath),
                                 };
                             }
                         }
@@ -806,9 +1283,26 @@ Directory Structure:
                     const key = prompt.key || basename(file, ".toml");
                     const configs = tomlData.configs || [];
                     const existingId = syncState?.entities?.prompts?.[key]?.id;
+                    // Skip if file hasn't changed since last sync
+                    if (!options.force && existingId && !shouldPushFile(filePath, syncState?.entities?.prompts?.[key]?.contentHash)) {
+                        skippedCount++;
+                        promptKeyToId.set(key, existingId);
+                        // Only fetch config name→ID mappings if test cases exist for this prompt
+                        const promptTestsDir = getTestsDir(configDir, "prompt", key);
+                        if (!options.dryRun && existsSync(promptTestsDir)) {
+                            const fullPrompt = await client.getPrompt(resolvedAppId, existingId);
+                            if (fullPrompt?.configs) {
+                                for (const config of fullPrompt.configs) {
+                                    promptConfigNameToId.set(`${key}#${config.configName}`, config.configId);
+                                }
+                            }
+                        }
+                        continue;
+                    }
                     if (existingId) {
                         // Update existing prompt
                         changes.push({ type: "prompt", action: "update", key });
+                        promptKeyToId.set(key, existingId);
                         if (!options.dryRun) {
                             const expectedModifiedAt = options.force
                                 ? undefined
@@ -824,6 +1318,55 @@ Directory Structure:
                                 // Update sync state with new modifiedAt
                                 if (syncState?.entities?.prompts?.[key] && updated?.modifiedAt) {
                                     syncState.entities.prompts[key].modifiedAt = updated.modifiedAt;
+                                    syncState.entities.prompts[key].contentHash = computeFileHash(filePath);
+                                }
+                                // Fetch full prompt to get config name→ID mappings
+                                // (updatePrompt response doesn't include configs)
+                                const fullPrompt = await client.getPrompt(resolvedAppId, existingId);
+                                if (fullPrompt?.configs) {
+                                    for (const config of fullPrompt.configs) {
+                                        promptConfigNameToId.set(`${key}#${config.configName}`, config.configId);
+                                    }
+                                }
+                                // Update existing prompt configs with TOML values
+                                if (fullPrompt?.configs && configs.length > 0) {
+                                    for (const tomlConfig of configs) {
+                                        const configName = tomlConfig.name;
+                                        if (!configName)
+                                            continue;
+                                        const serverConfig = fullPrompt.configs.find((c) => c.configName === configName);
+                                        if (serverConfig) {
+                                            // Update existing config
+                                            await client.updatePromptConfig(resolvedAppId, existingId, serverConfig.configId, {
+                                                description: tomlConfig.description,
+                                                provider: tomlConfig.provider,
+                                                model: tomlConfig.model,
+                                                systemPrompt: tomlConfig.systemPrompt,
+                                                userPromptTemplate: tomlConfig.userPromptTemplate,
+                                                temperature: tomlConfig.temperature,
+                                                maxTokens: tomlConfig.maxTokens,
+                                                outputFormat: tomlConfig.outputFormat,
+                                            });
+                                        }
+                                        else {
+                                            // Create new config that doesn't exist on server yet
+                                            const newConfig = await client.createPromptConfig(resolvedAppId, existingId, {
+                                                configName,
+                                                description: tomlConfig.description,
+                                                provider: tomlConfig.provider || "openrouter",
+                                                model: tomlConfig.model || "google/gemini-2.0-flash-001",
+                                                systemPrompt: tomlConfig.systemPrompt,
+                                                userPromptTemplate: tomlConfig.userPromptTemplate,
+                                                temperature: tomlConfig.temperature,
+                                                maxTokens: tomlConfig.maxTokens,
+                                                outputFormat: tomlConfig.outputFormat,
+                                            });
+                                            if (newConfig?.configId) {
+                                                promptConfigNameToId.set(`${key}#${configName}`, newConfig.configId);
+                                            }
+                                        }
+                                    }
+                                    info(`    Synced ${configs.length} config(s) for prompt: ${key}`);
                                 }
                             }
                             catch (err) {
@@ -868,8 +1411,44 @@ Directory Structure:
                                 syncState.entities.prompts[key] = {
                                     id: created.promptId,
                                     modifiedAt: created.modifiedAt,
+                                    contentHash: computeFileHash(filePath),
                                 };
                             }
+                            // Track prompt key→ID and config name→ID
+                            if (created?.promptId) {
+                                promptKeyToId.set(key, created.promptId);
+                            }
+                            if (created?.configs) {
+                                for (const config of created.configs) {
+                                    promptConfigNameToId.set(`${key}#${config.configName}`, config.configId);
+                                }
+                            }
+                            // Create additional configs (configs[1..n]) that weren't included in the initial create
+                            if (created?.promptId && configs.length > 1) {
+                                for (let i = 1; i < configs.length; i++) {
+                                    const extraConfig = configs[i];
+                                    const extraCreated = await client.createPromptConfig(resolvedAppId, created.promptId, {
+                                        configName: extraConfig.name || `config-${i + 1}`,
+                                        description: extraConfig.description,
+                                        provider: extraConfig.provider || firstConfig.provider || "openrouter",
+                                        model: extraConfig.model || firstConfig.model || "google/gemini-2.0-flash-001",
+                                        systemPrompt: extraConfig.systemPrompt,
+                                        userPromptTemplate: extraConfig.userPromptTemplate,
+                                        temperature: extraConfig.temperature,
+                                        maxTokens: extraConfig.maxTokens,
+                                        outputFormat: extraConfig.outputFormat,
+                                    });
+                                    if (extraCreated?.configId) {
+                                        const configName = extraConfig.name || `config-${i + 1}`;
+                                        promptConfigNameToId.set(`${key}#${configName}`, extraCreated.configId);
+                                    }
+                                    // Activate this config if it was the active one
+                                    if (extraConfig.isActive && extraCreated?.configId) {
+                                        await client.activatePromptConfig(resolvedAppId, created.promptId, extraCreated.configId);
+                                    }
+                                }
+                                info(`    Created ${configs.length - 1} additional config(s) for prompt: ${key}`);
+                            }
                         }
                     }
                 }
@@ -886,6 +1465,21 @@ Directory Structure:
                     const steps = tomlData.steps || [];
                     const existingId = syncState?.entities?.workflows?.[key]?.id;
                     const existingActiveConfigId = syncState?.entities?.workflows?.[key]?.activeConfigId;
+                    // Skip if file hasn't changed since last sync
+                    if (!options.force && existingId && !shouldPushFile(filePath, syncState?.entities?.workflows?.[key]?.contentHash)) {
+                        skippedCount++;
+                        // Only fetch config name→ID mappings if test cases exist for this workflow
+                        const workflowTestsDir = getTestsDir(configDir, "workflow", key);
+                        if (!options.dryRun && existsSync(workflowTestsDir)) {
+                            const fullWorkflow = await client.getWorkflow(resolvedAppId, existingId);
+                            if (fullWorkflow?.configs) {
+                                for (const config of fullWorkflow.configs) {
+                                    workflowConfigNameToId.set(`${key}#${config.configName}`, config.configId);
+                                }
+                            }
+                        }
+                        continue;
+                    }
                     if (existingId) {
                         // Update existing workflow
                         changes.push({ type: "workflow", action: "update", key });
@@ -902,8 +1496,8 @@ Directory Structure:
                                     perUserMaxRunning: workflow.perUserMaxRunning,
                                     perUserMaxQueued: workflow.perUserMaxQueued,
                                     dequeueOrder: workflow.dequeueOrder,
-                                    inputSchema: workflow.inputSchema ? JSON.parse(workflow.inputSchema) : null,
-                                    outputSchema: workflow.outputSchema ? JSON.parse(workflow.outputSchema) : null,
+                                    inputSchema: workflow.inputSchema ? safeJsonParse(workflow.inputSchema) : null,
+                                    outputSchema: workflow.outputSchema ? safeJsonParse(workflow.outputSchema) : null,
                                 }, expectedModifiedAt);
                                 // Update active configuration steps (or draft for legacy)
                                 if (existingActiveConfigId) {
@@ -915,13 +1509,22 @@ Directory Structure:
                                     // Fallback to draft update for legacy workflows
                                     await client.updateWorkflowDraft(resolvedAppId, existingId, {
                                         steps,
-                                        inputSchema: workflow.inputSchema ? JSON.parse(workflow.inputSchema) : null,
+                                        inputSchema: workflow.inputSchema ? safeJsonParse(workflow.inputSchema) : null,
                                     });
                                 }
                                 info(`  Updated workflow: ${key}`);
                                 // Update sync state with new modifiedAt
                                 if (syncState?.entities?.workflows?.[key] && updated?.workflow?.modifiedAt) {
                                     syncState.entities.workflows[key].modifiedAt = updated.workflow.modifiedAt;
+                                    syncState.entities.workflows[key].contentHash = computeFileHash(filePath);
+                                }
+                                // Fetch full workflow to get config name→ID mappings
+                                // (updateWorkflow response doesn't include configs)
+                                const fullWorkflow = await client.getWorkflow(resolvedAppId, existingId);
+                                if (fullWorkflow?.configs) {
+                                    for (const config of fullWorkflow.configs) {
+                                        workflowConfigNameToId.set(`${key}#${config.configName}`, config.configId);
+                                    }
                                 }
                             }
                             catch (err) {
@@ -948,8 +1551,8 @@ Directory Structure:
                                 name: workflow.name || key,
                                 description: workflow.description,
                                 steps,
-                                inputSchema: workflow.inputSchema ? JSON.parse(workflow.inputSchema) : undefined,
-                                outputSchema: workflow.outputSchema ? JSON.parse(workflow.outputSchema) : undefined,
+                                inputSchema: workflow.inputSchema ? safeJsonParse(workflow.inputSchema) : undefined,
+                                outputSchema: workflow.outputSchema ? safeJsonParse(workflow.outputSchema) : undefined,
                                 perUserMaxRunning: workflow.perUserMaxRunning,
                                 perUserMaxQueued: workflow.perUserMaxQueued,
                                 dequeueOrder: workflow.dequeueOrder,
@@ -964,6 +1567,271 @@ Directory Structure:
                                     id: created.workflow.workflowId,
                                     modifiedAt: created.workflow.modifiedAt,
                                     activeConfigId: created.workflow.activeConfigId,
+                                    contentHash: computeFileHash(filePath),
+                                };
+                            }
+                            // Track config name→ID mappings
+                            if (created?.configs) {
+                                for (const config of created.configs) {
+                                    workflowConfigNameToId.set(`${key}#${config.configName}`, config.configId);
+                                }
+                            }
+                            const workflowId = created?.workflow?.workflowId;
+                            const tomlConfigs = tomlData.configs || [];
+                            // Create additional workflow configs (configs[1..n]) beyond the default
+                            if (workflowId && tomlConfigs.length > 1) {
+                                for (let i = 1; i < tomlConfigs.length; i++) {
+                                    const extraConfig = tomlConfigs[i];
+                                    const extraCreated = await client.createWorkflowConfig(resolvedAppId, workflowId, {
+                                        configName: extraConfig.name || `config-${i + 1}`,
+                                        description: extraConfig.description,
+                                        steps,
+                                    });
+                                    if (extraCreated?.configId) {
+                                        const configName = extraConfig.name || `config-${i + 1}`;
+                                        workflowConfigNameToId.set(`${key}#${configName}`, extraCreated.configId);
+                                    }
+                                }
+                                info(`    Created ${tomlConfigs.length - 1} additional config(s) for workflow: ${key}`);
+                            }
+                            // Activate the correct config based on activeConfigName from TOML
+                            if (workflowId && workflow.activeConfigName) {
+                                const activeConfigId = workflowConfigNameToId.get(`${key}#${workflow.activeConfigName}`);
+                                if (activeConfigId && activeConfigId !== created?.workflow?.activeConfigId) {
+                                    await client.activateWorkflowConfig(resolvedAppId, workflowId, activeConfigId);
+                                    info(`    Activated config "${workflow.activeConfigName}" for workflow: ${key}`);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            // Process database types
+            const dbTypesDir = join(configDir, "database-types");
+            if (existsSync(dbTypesDir)) {
+                const files = readdirSync(dbTypesDir).filter((f) => f.endsWith(".toml"));
+                for (const file of files) {
+                    const filePath = join(dbTypesDir, file);
+                    const tomlData = parseTomlFile(filePath);
+                    const { typeConfig, operations } = parseDatabaseTypeToml(tomlData);
+                    const dbType = typeConfig.databaseType || basename(file, ".toml");
+                    // Resolve ruleSetName → ruleSetId if using key-based reference
+                    resolveRuleSetReference(typeConfig, ruleSetNameToId, `database type ${dbType}`);
+                    const existingEntry = syncState?.entities?.databaseTypes?.[dbType];
+                    // Skip if file hasn't changed since last sync
+                    if (!options.force && existingEntry && !shouldPushFile(filePath, existingEntry.contentHash)) {
+                        skippedCount++;
+                        continue;
+                    }
+                    if (existingEntry) {
+                        // Update existing type config
+                        changes.push({ type: "database-type", action: "update", key: dbType });
+                        if (!options.dryRun) {
+                            const expectedModifiedAt = options.force
+                                ? undefined
+                                : existingEntry.modifiedAt;
+                            try {
+                                const updateData = {};
+                                if ("ruleSetId" in typeConfig)
+                                    updateData.ruleSetId = typeConfig.ruleSetId || null;
+                                if ("triggers" in typeConfig)
+                                    updateData.triggers = typeConfig.triggers || null;
+                                if ("metadataAccess" in typeConfig)
+                                    updateData.metadataAccess = typeConfig.metadataAccess || null;
+                                const updated = await client.updateDatabaseTypeConfig(resolvedAppId, dbType, updateData, expectedModifiedAt);
+                                info(`  Updated database type: ${dbType}`);
+                                if (syncState?.entities?.databaseTypes?.[dbType] && updated?.modifiedAt) {
+                                    syncState.entities.databaseTypes[dbType].modifiedAt = updated.modifiedAt;
+                                    syncState.entities.databaseTypes[dbType].contentHash = computeFileHash(filePath);
+                                }
+                            }
+                            catch (err) {
+                                if (err instanceof ConflictError) {
+                                    conflicts.push({
+                                        type: "database-type",
+                                        key: dbType,
+                                        serverModifiedAt: err.serverModifiedAt,
+                                        localModifiedAt: expectedModifiedAt || "unknown",
+                                    });
+                                }
+                                else {
+                                    throw err;
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        // Create new type config
+                        changes.push({ type: "database-type", action: "create", key: dbType });
+                        if (!options.dryRun) {
+                            const createData = {
+                                databaseType: dbType,
+                            };
+                            if (typeConfig.ruleSetId)
+                                createData.ruleSetId = typeConfig.ruleSetId;
+                            if (typeConfig.triggers)
+                                createData.triggers = typeConfig.triggers;
+                            if (typeConfig.metadataAccess)
+                                createData.metadataAccess = typeConfig.metadataAccess;
+                            const created = await client.createDatabaseTypeConfig(resolvedAppId, createData);
+                            info(`  Created database type: ${dbType}`);
+                            if (syncState) {
+                                if (!syncState.entities.databaseTypes) {
+                                    syncState.entities.databaseTypes = {};
+                                }
+                                syncState.entities.databaseTypes[dbType] = {
+                                    databaseType: dbType,
+                                    modifiedAt: created?.modifiedAt || new Date().toISOString(),
+                                    contentHash: computeFileHash(filePath),
+                                };
+                            }
+                        }
+                    }
+                    // Process operations for this type
+                    const existingOps = existingEntry?.operations || {};
+                    const tomlOpNames = new Set(operations.map((op) => op.name));
+                    for (const op of operations) {
+                        const existingOp = existingOps[op.name];
+                        if (existingOp) {
+                            // Update existing operation
+                            changes.push({ type: "operation", action: "update", key: `${dbType}/${op.name}` });
+                            if (!options.dryRun) {
+                                const expectedOpModifiedAt = options.force
+                                    ? undefined
+                                    : existingOp.modifiedAt;
+                                try {
+                                    const updated = await client.updateDatabaseTypeOperation(resolvedAppId, dbType, op.name, {
+                                        modelName: op.modelName,
+                                        access: op.access,
+                                        definition: op.definition,
+                                        params: op.params,
+                                    }, expectedOpModifiedAt);
+                                    info(`  Updated operation: ${dbType}/${op.name}`);
+                                    if (syncState?.entities?.databaseTypes?.[dbType]?.operations?.[op.name] && updated?.modifiedAt) {
+                                        syncState.entities.databaseTypes[dbType].operations[op.name].modifiedAt = updated.modifiedAt;
+                                    }
+                                }
+                                catch (err) {
+                                    if (err instanceof ConflictError) {
+                                        conflicts.push({
+                                            type: "operation",
+                                            key: `${dbType}/${op.name}`,
+                                            serverModifiedAt: err.serverModifiedAt,
+                                            localModifiedAt: expectedOpModifiedAt || "unknown",
+                                        });
+                                    }
+                                    else {
+                                        throw err;
+                                    }
+                                }
+                            }
+                        }
+                        else {
+                            // Create new operation
+                            changes.push({ type: "operation", action: "create", key: `${dbType}/${op.name}` });
+                            if (!options.dryRun) {
+                                const created = await client.createDatabaseTypeOperation(resolvedAppId, dbType, {
+                                    name: op.name,
+                                    type: op.type,
+                                    modelName: op.modelName,
+                                    access: op.access,
+                                    definition: op.definition,
+                                    params: op.params,
+                                });
+                                info(`  Created operation: ${dbType}/${op.name}`);
+                                if (syncState?.entities?.databaseTypes?.[dbType]) {
+                                    if (!syncState.entities.databaseTypes[dbType].operations) {
+                                        syncState.entities.databaseTypes[dbType].operations = {};
+                                    }
+                                    syncState.entities.databaseTypes[dbType].operations[op.name] = {
+                                        modifiedAt: created?.modifiedAt || new Date().toISOString(),
+                                    };
+                                }
+                            }
+                        }
+                    }
+                    // Delete operations that were removed from TOML
+                    for (const existingOpName of Object.keys(existingOps)) {
+                        if (!tomlOpNames.has(existingOpName)) {
+                            changes.push({ type: "operation", action: "delete", key: `${dbType}/${existingOpName}` });
+                            if (!options.dryRun) {
+                                await client.deleteDatabaseTypeOperation(resolvedAppId, dbType, existingOpName);
+                                info(`  Deleted operation: ${dbType}/${existingOpName}`);
+                                if (syncState?.entities?.databaseTypes?.[dbType]?.operations) {
+                                    delete syncState.entities.databaseTypes[dbType].operations[existingOpName];
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            // Process group type configs
+            const groupTypeConfigsDir = join(configDir, "group-type-configs");
+            if (existsSync(groupTypeConfigsDir)) {
+                const files = readdirSync(groupTypeConfigsDir).filter((f) => f.endsWith(".toml"));
+                for (const file of files) {
+                    const filePath = join(groupTypeConfigsDir, file);
+                    const tomlData = parseTomlFile(filePath);
+                    const configData = parseGroupTypeConfigToml(tomlData);
+                    const groupType = configData.groupType || basename(file, ".toml");
+                    // Resolve ruleSetName → ruleSetId if using key-based reference
+                    resolveRuleSetReference(configData, ruleSetNameToId, `group type ${groupType}`);
+                    const existingEntry = syncState?.entities?.groupTypeConfigs?.[groupType];
+                    // Skip if file hasn't changed since last sync
+                    if (!options.force && existingEntry && !shouldPushFile(filePath, existingEntry.contentHash)) {
+                        skippedCount++;
+                        continue;
+                    }
+                    if (existingEntry) {
+                        // Update existing group type config
+                        changes.push({ type: "group-type-config", action: "update", key: groupType });
+                        if (!options.dryRun) {
+                            const expectedModifiedAt = options.force
+                                ? undefined
+                                : existingEntry.modifiedAt;
+                            try {
+                                const updated = await client.updateGroupTypeConfig(resolvedAppId, groupType, {
+                                    ruleSetId: configData.ruleSetId,
+                                    autoAddCreator: configData.autoAddCreator,
+                                }, expectedModifiedAt);
+                                info(`  Updated group type config: ${groupType}`);
+                                if (syncState?.entities?.groupTypeConfigs?.[groupType] && updated?.modifiedAt) {
+                                    syncState.entities.groupTypeConfigs[groupType].modifiedAt = updated.modifiedAt;
+                                    syncState.entities.groupTypeConfigs[groupType].contentHash = computeFileHash(filePath);
+                                }
+                            }
+                            catch (err) {
+                                if (err instanceof ConflictError) {
+                                    conflicts.push({
+                                        type: "group-type-config",
+                                        key: groupType,
+                                        serverModifiedAt: err.serverModifiedAt,
+                                        localModifiedAt: expectedModifiedAt || "unknown",
+                                    });
+                                }
+                                else {
+                                    throw err;
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        // Create new group type config
+                        changes.push({ type: "group-type-config", action: "create", key: groupType });
+                        if (!options.dryRun) {
+                            const created = await client.createGroupTypeConfig(resolvedAppId, {
+                                groupType,
+                                ruleSetId: configData.ruleSetId || undefined,
+                                autoAddCreator: configData.autoAddCreator,
+                            });
+                            info(`  Created group type config: ${groupType}`);
+                            if (syncState) {
+                                if (!syncState.entities.groupTypeConfigs) {
+                                    syncState.entities.groupTypeConfigs = {};
+                                }
+                                syncState.entities.groupTypeConfigs[groupType] = {
+                                    modifiedAt: created?.modifiedAt || new Date().toISOString(),
+                                    contentHash: computeFileHash(filePath),
                                 };
                             }
                         }
@@ -1007,6 +1875,11 @@ Directory Structure:
                 }
             }
             // Push test cases for prompts and workflows
+            const pushMaps = {
+                promptKeyToId,
+                promptConfigNameToId,
+                workflowConfigNameToId,
+            };
             const promptsDir2 = join(configDir, "prompts");
             if (existsSync(promptsDir2)) {
                 for (const file of readdirSync(promptsDir2).filter((f) => f.endsWith(".toml"))) {
@@ -1014,7 +1887,7 @@ Directory Structure:
                     const promptKey = tomlData.prompt?.key || basename(file, ".toml");
                     const blockId = syncState?.entities?.prompts?.[promptKey]?.id;
                     if (blockId) {
-                        await pushTestCasesForBlock(client, resolvedAppId, "prompt", blockId, promptKey, configDir, syncState, options.dryRun, changes);
+                        skippedCount += await pushTestCasesForBlock(client, resolvedAppId, "prompt", blockId, promptKey, configDir, syncState, options.dryRun, changes, pushMaps, { force: options.force });
                     }
                 }
             }
@@ -1025,7 +1898,7 @@ Directory Structure:
                     const workflowKey = tomlData.workflow?.key || basename(file, ".toml");
                     const blockId = syncState?.entities?.workflows?.[workflowKey]?.id;
                     if (blockId) {
-                        await pushTestCasesForBlock(client, resolvedAppId, "workflow", blockId, workflowKey, configDir, syncState, options.dryRun, changes);
+                        skippedCount += await pushTestCasesForBlock(client, resolvedAppId, "workflow", blockId, workflowKey, configDir, syncState, options.dryRun, changes, pushMaps, { force: options.force });
                     }
                 }
             }
@@ -1076,10 +1949,23 @@ Directory Structure:
                     syncState.lastSyncedAt = new Date().toISOString();
                     saveSyncState(configDir, syncState);
                 }
-                success(`Pushed ${changes.length} changes.`);
+                const pushMsg = skippedCount > 0
+                    ? `Pushed ${changes.length} change(s), skipped ${skippedCount} unchanged file(s).`
+                    : `Pushed ${changes.length} changes.`;
+                success(pushMsg);
             }
         }
         catch (err) {
+            // Save sync state even on failure so partial progress is preserved
+            if (syncState) {
+                try {
+                    syncState.lastSyncedAt = new Date().toISOString();
+                    saveSyncState(configDir, syncState);
+                }
+                catch {
+                    // Don't mask the original error
+                }
+            }
             error(err.message);
             process.exit(1);
         }
@@ -1103,15 +1989,15 @@ Directory Structure:
         info(`Comparing local configuration with app ${resolvedAppId}...`);
         try {
             // Fetch remote state
-            const [integrationsResult, promptsResult, workflowsResult, emailTemplatesResult] = await Promise.all([
-                client.listIntegrations(resolvedAppId, { limit: 100 }),
-                client.listPrompts(resolvedAppId, { limit: 100 }),
-                client.listWorkflows(resolvedAppId, { limit: 100 }),
+            const [integrationItems, promptItems, workflowItems, emailTemplatesResult] = await Promise.all([
+                fetchAll((p) => client.listIntegrations(resolvedAppId, p)),
+                fetchAll((p) => client.listPrompts(resolvedAppId, p)),
+                fetchAll((p) => client.listWorkflows(resolvedAppId, p)),
                 client.listEmailTemplates(resolvedAppId).catch(() => ({ templates: [] })),
             ]);
-            const remoteIntegrations = new Set(integrationsResult.items.map((i) => i.integrationKey));
-            const remotePrompts = new Set(promptsResult.items.map((p) => p.promptKey));
-            const remoteWorkflows = new Set(workflowsResult.items.map((w) => w.workflowKey));
+            const remoteIntegrations = new Set(integrationItems.map((i) => i.integrationKey));
+            const remotePrompts = new Set(promptItems.map((p) => p.promptKey));
+            const remoteWorkflows = new Set(workflowItems.map((w) => w.workflowKey));
             const remoteEmailTemplates = new Set((emailTemplatesResult.templates || [])
                 .filter((t) => t.hasOverride)
                 .map((t) => t.emailType));
@@ -1247,12 +2133,12 @@ Directory Structure:
                 }
             };
             // Compare test cases for synced blocks
-            for (const p of promptsResult.items) {
+            for (const p of promptItems) {
                 if (localPrompts.has(p.promptKey)) {
                     await compareTestCases("prompt", p.promptId, p.promptKey);
                 }
             }
-            for (const w of workflowsResult.items) {
+            for (const w of workflowItems) {
                 if (localWorkflows.has(w.workflowKey)) {
                     await compareTestCases("workflow", w.workflowId, w.workflowKey);
                 }