@dboio/cli 0.16.2 → 0.19.0

package/src/commands/init.js

@@ -9,7 +9,7 @@ import { log } from '../lib/logger.js';
 import { checkDomainChange, writeAppJsonDomain } from '../lib/domain-guard.js';
 import { performLogin } from './login.js';
 import { runPendingMigrations } from '../lib/migrations.js';
-import { fetchSchema, saveSchema, SCHEMA_FILE } from '../lib/schema.js';
+import { fetchSchema, saveSchema } from '../lib/schema.js';
 import { loadMetadataSchema, saveMetadataSchema, generateMetadataFromSchema } from '../lib/metadata-schema.js';
 import { syncDependencies } from '../lib/dependencies.js';
 import { mergeDependencies } from '../lib/config.js';
@@ -108,7 +108,7 @@ export const initCommand = new Command('init')
       }
 
       // Ensure sensitive files are gitignored
-      await ensureGitignore(['.dbo/credentials.json', '.dbo/cookies.txt', '.dbo/config.local.json', '.dbo/ticketing.local.json', '.dbo/scripts.local.json', '.dbo/errors.log', 'trash/', 'Icon\\r', 'schema.json', '.dbo/dependencies/']);
+      await ensureGitignore(['.app/credentials.json', '.app/cookies.txt', '.app/ticketing.local.json', '.app/scripts.local.json', '.app/errors.log', 'trash/', 'Icon\\r', 'app_dependencies/']);
 
       const createdIgnore = await createDboignore();
       if (createdIgnore) log.dim('  Created .dboignore');
@@ -122,19 +122,19 @@ export const initCommand = new Command('init')
 
       // Create empty scripts.json and scripts.local.json if they don't exist
       const emptyScripts = JSON.stringify({ scripts: {}, targets: {}, entities: {} }, null, 2) + '\n';
-      const dboDir = join(process.cwd(), '.dbo');
-      const scriptsPath = join(dboDir, 'scripts.json');
-      const scriptsLocalPath = join(dboDir, 'scripts.local.json');
+      const appDir = join(process.cwd(), '.app');
+      const scriptsPath = join(appDir, 'scripts.json');
+      const scriptsLocalPath = join(appDir, 'scripts.local.json');
       try { await access(scriptsPath); } catch {
         await writeFile(scriptsPath, emptyScripts);
-        log.dim('  Created .dbo/scripts.json');
+        log.dim('  Created .app/scripts.json');
       }
       try { await access(scriptsLocalPath); } catch {
         await writeFile(scriptsLocalPath, emptyScripts);
-        log.dim('  Created .dbo/scripts.local.json');
+        log.dim('  Created .app/scripts.local.json');
       }
 
-      log.success(`Initialized .dbo/ for ${domain}`);
+      log.success(`Initialized .app/ for ${domain}`);
 
       // Authenticate early so the session is ready for subsequent operations
       if (!options.nonInteractive && username) {
@@ -145,12 +145,12 @@ export const initCommand = new Command('init')
       try {
         const schemaData = await fetchSchema({ domain, verbose: options.verbose });
         await saveSchema(schemaData);
-        log.dim(`  Saved ${SCHEMA_FILE}`);
+        log.dim(`  Refreshed _system dependency baseline`);
 
         const existing = await loadMetadataSchema();
         const updated = generateMetadataFromSchema(schemaData, existing ?? {});
         await saveMetadataSchema(updated);
-        log.dim(`  Updated .dbo/metadata_schema.json`);
+        log.dim(`  Updated metadata schema`);
       } catch (err) {
         log.warn(`  Could not fetch schema (${err.message}) — run 'dbo clone --schema' after login.`);
       }
@@ -168,7 +168,7 @@ export const initCommand = new Command('init')
             domain,
             force: explicitDeps ? true : undefined,
             verbose: options.verbose,
-            systemSchemaPath: join(process.cwd(), SCHEMA_FILE),
+            systemSchemaPath: join(process.cwd(), 'app_dependencies', '_system', '.app', '_system.json'),
             only: explicitDeps || undefined,
           });
         } catch (err) {

package/src/commands/install.js

@@ -248,7 +248,7 @@ async function resolvePluginScope(pluginName, options) {
   if (storedScope) return storedScope;
 
   // Infer from existing installation — avoids re-prompting on re-installs
-  // (e.g. postinstall after npm install when .dbo/ isn't in cwd)
+  // (e.g. postinstall after npm install when .app/ isn't in cwd)
   const registry = await readPluginRegistry();
   const key = `${pluginName}@${PLUGIN_MARKETPLACE}`;
   if (registry.plugins[key]) return 'global';
@@ -735,7 +735,7 @@ export async function installOrUpdateClaudeCommands(options = {}) {
           version: pluginVersion,
         });
       } else if (targetScope === 'global' && !hasProject) {
-        log.warn(`Cannot persist scope preference (no .dbo/ directory). Run "dbo init" first.`);
+        log.warn(`Cannot persist scope preference (no .app/ directory). Run "dbo init" first.`);
       }
 
       // Clean up legacy command files (but not ones we just extracted from commands/)
@@ -933,7 +933,7 @@ async function installOrUpdateSpecificCommand(name, options = {}) {
         version: pluginVersion,
       });
     } else if (targetScope === 'global' && !hasProject) {
-      log.warn(`Cannot persist scope preference (no .dbo/ directory). Run "dbo init" first.`);
+      log.warn(`Cannot persist scope preference (no .app/ directory). Run "dbo init" first.`);
     }
 
     // Clean up legacy command files (but not ones we just extracted from commands/)

package/src/commands/login.js

@@ -49,7 +49,7 @@ export async function performLogin(domain, knownUsername) {
   }
 
   log.success(`Authenticated as ${username} on ${await client.getDomain()}`);
-  await ensureGitignore(['.dbo/credentials.json', '.dbo/cookies.txt', '.dbo/ticketing.local.json']);
+  await ensureGitignore(['.app/credentials.json', '.app/cookies.txt', '.app/ticketing.local.json']);
 
   // Fetch and store user info (non-critical)
   try {
@@ -143,7 +143,7 @@ export const loginCommand = new Command('login')
         log.success(`Authenticated as ${username} on ${await client.getDomain()}`);
 
         // Ensure sensitive files are gitignored
-        await ensureGitignore(['.dbo/credentials.json', '.dbo/cookies.txt', '.dbo/ticketing.local.json']);
+        await ensureGitignore(['.app/credentials.json', '.app/cookies.txt', '.app/ticketing.local.json']);
 
         // Fetch current user info to store ID for future submissions
         try {

package/src/commands/mv.js

@@ -3,7 +3,7 @@ import { readFile, writeFile, stat, rename, mkdir, utimes } from 'fs/promises';
 import { join, dirname, basename, extname, relative, isAbsolute } from 'path';
 import { log } from '../lib/logger.js';
 import { formatError } from '../lib/formatter.js';
-import { loadSynchronize, saveSynchronize } from '../lib/config.js';
+import { loadSynchronize, saveSynchronize, appMetadataPath } from '../lib/config.js';
 import {
   loadStructureFile,
   saveStructureFile,
@@ -65,7 +65,7 @@ export const mvCommand = new Command('mv')
 
       // Validate target exists in structure
       if (!structure[targetBinId]) {
-        log.error(`BinID ${targetBinId} not found in .dbo/structure.json`);
+        log.error(`BinID ${targetBinId} not found in .app/directories.json`);
         log.dim('  Run "dbo clone" to refresh project structure.');
         process.exit(1);
       }
@@ -127,7 +127,7 @@ async function promptForBin(structure) {
     .sort((a, b) => (a.fullPath || '').localeCompare(b.fullPath || ''));
 
   if (entries.length === 0) {
-    log.error('No bins found in .dbo/structure.json');
+    log.error('No bins found in .app/directories.json');
     log.dim('  Run "dbo clone" to refresh project structure.');
     process.exit(1);
   }
@@ -371,23 +371,23 @@ async function stageEdit(entry, options) {
   await saveSynchronize(data);
 }
 
-// ── App.json updates ─────────────────────────────────────────────────────
+// ── Metadata file updates ────────────────────────────────────────────────
 
 /**
- * Update a single @path reference in app.json.
+ * Update a single @path reference in the metadata file.
  */
 async function updateAppJsonPath(oldMetaPath, newMetaPath, options) {
   if (options.dryRun) {
-    log.info(`[DRY RUN] Would update app.json: @${oldMetaPath} → @${newMetaPath}`);
+    log.info(`[DRY RUN] Would update metadata: @${oldMetaPath} → @${newMetaPath}`);
     return;
   }
 
-  const appJsonPath = join(process.cwd(), 'app.json');
+  const appJsonPath = await appMetadataPath();
   let appJson;
   try {
     appJson = JSON.parse(await readFile(appJsonPath, 'utf8'));
   } catch {
-    return; // no app.json
+    return; // no metadata file
   }
 
   if (!appJson.children) return;
@@ -408,20 +408,20 @@ async function updateAppJsonPath(oldMetaPath, newMetaPath, options) {
 
   if (changed) {
     await writeFile(appJsonPath, JSON.stringify(appJson, null, 2) + '\n');
-    if (options.verbose) log.verbose(`app.json: ${oldRef} → ${newRef}`);
+    if (options.verbose) log.verbose(`metadata: ${oldRef} → ${newRef}`);
   }
 }
 
 /**
- * Update all @path references that start with a given directory prefix in app.json.
+ * Update all @path references that start with a given directory prefix in the metadata file.
  */
 async function updateAppJsonForDirectoryMove(oldDirPath, newDirPath, options) {
   if (options.dryRun) {
-    log.info(`[DRY RUN] Would update app.json refs: @${oldDirPath}/... → @${newDirPath}/...`);
+    log.info(`[DRY RUN] Would update metadata refs: @${oldDirPath}/... → @${newDirPath}/...`);
     return;
   }
 
-  const appJsonPath = join(process.cwd(), 'app.json');
+  const appJsonPath = await appMetadataPath();
   let appJson;
   try {
     appJson = JSON.parse(await readFile(appJsonPath, 'utf8'));
@@ -447,7 +447,7 @@ async function updateAppJsonForDirectoryMove(oldDirPath, newDirPath, options) {
 
   if (changed) {
     await writeFile(appJsonPath, JSON.stringify(appJson, null, 2) + '\n');
-    if (options.verbose) log.verbose(`app.json: updated directory refs ${oldDirPath} → ${newDirPath}`);
+    if (options.verbose) log.verbose(`metadata: updated directory refs ${oldDirPath} → ${newDirPath}`);
   }
 }
 
@@ -630,7 +630,7 @@ async function mvFile(sourceFile, targetBinId, structure, options) {
     targetValue: targetBinId,
   }, options);
 
-  // 3. Update app.json reference
+  // 3. Update metadata file reference
   await updateAppJsonPath(metaPath, newMetaPath, options);
 
   // 4. Physically move files
@@ -826,7 +826,7 @@ async function mvBin(sourcePath, targetBinId, structure, options) {
     targetValue: targetBinId,
   }, options);
 
-  // 5. Update app.json for all affected file paths
+  // 5. Update metadata file for all affected file paths
   await updateAppJsonForDirectoryMove(oldDirPath, newDirPath, options);
 
   // 6. Save updated structure.json

package/src/commands/pull.js

@@ -267,7 +267,7 @@ export const pullCommand = new Command('pull')
       const config = await loadConfig();
 
       if (!config.AppShortName) {
-        log.error('No AppShortName found in .dbo/config.json.');
+        log.error('No AppShortName found in .app/config.json.');
         log.dim('  Run "dbo clone" first to set up the project.');
         process.exit(1);
       }

package/src/commands/push.js

@@ -1,26 +1,26 @@
 import { Command } from 'commander';
-import { readFile, stat, writeFile, rename as fsRename, mkdir, access } from 'fs/promises';
+import { readFile, stat, writeFile, rename as fsRename, mkdir, access, utimes } from 'fs/promises';
 import { join, dirname, basename, extname, relative } from 'path';
 import { DboClient } from '../lib/client.js';
 import { buildInputBody, checkSubmitErrors, getSessionUserOverride } from '../lib/input-parser.js';
 import { formatResponse, formatError } from '../lib/formatter.js';
 import { log } from '../lib/logger.js';
 import { shouldSkipColumn } from '../lib/columns.js';
-import { loadConfig, loadAppConfig, loadSynchronize, saveSynchronize, loadAppJsonBaseline, saveAppJsonBaseline, hasBaseline, loadScripts, loadScriptsLocal } from '../lib/config.js';
+import { loadConfig, loadAppConfig, loadSynchronize, saveSynchronize, loadAppJsonBaseline, saveAppJsonBaseline, hasBaseline, loadScripts, loadScriptsLocal, addDeleteEntry } from '../lib/config.js';
 import { mergeScriptsConfig, resolveHooks, buildHookEnv, runBuildLifecycle, runPushLifecycle } from '../lib/scripts.js';
 import { checkStoredTicket, applyStoredTicketToSubmission, clearRecordTicket, clearGlobalTicket } from '../lib/ticketing.js';
 import { checkModifyKey, isModifyKeyError, handleModifyKeyError } from '../lib/modify-key.js';
 import { resolveTransactionKey } from '../lib/transaction-key.js';
-import { setFileTimestamps } from '../lib/timestamps.js';
+import { setFileTimestamps, parseServerDate } from '../lib/timestamps.js';
 import { stripUidFromFilename, renameToUidConvention, hasUidInFilename, isMetadataFile, parseMetaFilename, findMetadataForCompanion } from '../lib/filenames.js';
 import { findMetadataFiles, findFileInProject, findByUID } from '../lib/diff.js';
 import { loadIgnore } from '../lib/ignore.js';
-import { detectChangedColumns, findBaselineEntry, detectOutputChanges, getAllUserColumns, isReference, resolveReferencePath, detectBinChanges, synthesizeBinMetadata } from '../lib/delta.js';
+import { detectChangedColumns, findBaselineEntry, detectOutputChanges, detectEntityChildrenChanges, getAllUserColumns, isReference, resolveReferencePath, detectBinChanges, synthesizeBinMetadata } from '../lib/delta.js';
 import { BINS_DIR, ENTITY_DIR_NAMES, loadStructureFile, findBinByPath } from '../lib/structure.js';
 import { ensureTrashIcon, setFileTag } from '../lib/tagging.js';
 import { checkToeStepping } from '../lib/toe-stepping.js';
 import { runPendingMigrations } from '../lib/migrations.js';
-// AUTO-ADD DISABLED: import { findUnaddedFiles, detectBinFile, submitAdd } from './add.js';
+// AUTO-ADD DISABLED: import { findUnaddedFiles, detectBinFile, submitAdd } from '../lib/insert.js';
 
 /**
  * Resolve an @reference file path to an absolute filesystem path.
@@ -157,7 +157,7 @@ export const pushCommand = new Command('push')
   });
 
 /**
- * Process pending delete entries from .dbo/synchronize.json
+ * Process pending delete entries from .app/synchronize.json
  */
 async function processPendingDeletes(client, options, modifyKey = null, transactionKey = 'RowUID') {
   const sync = await loadSynchronize();
@@ -532,7 +532,7 @@ async function pushDirectory(dirPath, client, options, modifyKey = null, transac
   const baseline = await loadAppJsonBaseline();
 
   if (!baseline) {
-    log.warn('No .app.json baseline found — performing full push (run "dbo clone" to enable delta sync)');
+    log.warn('No baseline found — performing full push (run "dbo clone" to enable delta sync)');
   }
 
   // Load server timezone for delta date comparisons
@@ -626,10 +626,19 @@ async function pushDirectory(dirPath, client, options, modifyKey = null, transac
 
     // Detect changed columns (delta detection) — skip for new records
     let changedColumns = null;
+    let childChanges = null;
     if (!isNewRecord && baseline) {
       try {
         changedColumns = await detectChangedColumns(metaPath, baseline, serverTz);
-        if (changedColumns.length === 0) {
+
+        // Also detect child-level changes for entity dir metadata with embedded children
+        if (meta.children && typeof meta.children === 'object'
+            && !['output', 'output_value', 'output_value_filter', 'output_value_entity_column_rel'].includes(meta._entity)) {
+          childChanges = await detectEntityChildrenChanges(metaPath, baseline);
+        }
+        const hasChildChanges = childChanges && Object.keys(childChanges).length > 0;
+
+        if (changedColumns.length === 0 && !hasChildChanges) {
           log.dim(`  Skipping ${basename(metaPath)} — no changes detected`);
           skipped++;
           continue;
@@ -639,7 +648,7 @@ async function pushDirectory(dirPath, client, options, modifyKey = null, transac
       }
     }
 
-    toPush.push({ meta, metaPath, changedColumns, isNew: isNewRecord });
+    toPush.push({ meta, metaPath, changedColumns, isNew: isNewRecord, childChanges });
   }
 
   // Toe-stepping: check for server-side conflicts before submitting
@@ -797,12 +806,24 @@ async function pushDirectory(dirPath, client, options, modifyKey = null, transac
         }
       }
 
-      const success = await pushFromMetadata(item.meta, item.metaPath, client, options, item.changedColumns, modifyKey, transactionKey);
-      if (success) {
+      // Push entity children first (if any changed/added/removed)
+      if (item.childChanges && Object.keys(item.childChanges).length > 0) {
+        await pushEntityChildren(item.meta, item.metaPath, item.childChanges, client, options, baseline, modifyKey, transactionKey);
+      }
+
+      // Only push parent if parent columns changed (skip for child-only changes)
+      if (item.changedColumns && item.changedColumns.length === 0) {
+        // Child-only change — parent was already handled above
         succeeded++;
         successfulPushes.push(item);
       } else {
-        failed++;
+        const success = await pushFromMetadata(item.meta, item.metaPath, client, options, item.changedColumns, modifyKey, transactionKey);
+        if (success) {
+          succeeded++;
+          successfulPushes.push(item);
+        } else {
+          failed++;
+        }
       }
     } catch (err) {
       if (err.message === 'SKIP_ALL') {
@@ -1525,7 +1546,7 @@ async function checkPathMismatch(meta, metaPath, entity, options) {
 
 // ─── Compound Output Push ───────────────────────────────────────────────────
 
-const _COMPOUND_DOC_KEYS = ['column', 'join', 'filter'];
+const _COMPOUND_CHILD_KEYS = ['output_value', 'output_value_filter', 'output_value_entity_column_rel'];
 
 /**
  * Push a compound output file (root + inline children) to the server.
@@ -1625,7 +1646,7 @@ async function pushOutputCompound(meta, metaPath, client, options, baseline, mod
  * Annotates each child with _depth (1 = direct child of root, 2 = grandchild, etc.)
  */
 function _flattenOutputChildren(childrenObj, result, depth = 1) {
-  for (const docKey of _COMPOUND_DOC_KEYS) {
+  for (const docKey of _COMPOUND_CHILD_KEYS) {
     const entityArray = childrenObj[docKey];
     if (!Array.isArray(entityArray) || entityArray.length === 0) continue;
     for (const child of entityArray) {
@@ -1714,10 +1735,151 @@ async function _submitOutputEntity(entity, physicalEntity, changedColumns, metaD
   return true;
 }
 
+// ─── Entity Children Push ────────────────────────────────────────────────────
+
+/**
+ * Push entity dir child record changes to the server.
+ * Handles edits and removals (staged as deletes). New children are warned and skipped.
+ * After all successful edits, rewrites the metadata file with updated child _LastUpdated
+ * values and restores the parent's mtime.
+ *
+ * @param {Object} meta - Parsed parent metadata JSON
+ * @param {string} metaPath - Absolute path to parent metadata file
+ * @param {Object} childChanges - From detectEntityChildrenChanges(): { uid: { childEntity, changedColumns, isNew, isRemoved } }
+ * @param {DboClient} client - API client
+ * @param {Object} options - Push options
+ * @param {Object} baseline - Loaded baseline
+ * @param {string|null} modifyKey - ModifyKey value
+ * @param {string} transactionKey - 'RowUID' or 'RowID'
+ */
+async function pushEntityChildren(meta, metaPath, childChanges, client, options, baseline, modifyKey = null, transactionKey = 'RowUID') {
+  let pushed = 0;
+
+  for (const [uid, info] of Object.entries(childChanges)) {
+    if (info.isNew) {
+      log.warn(`  Child ${info.childEntity}:${uid} has no baseline entry — new children are not supported in this version. Skipping.`);
+      continue;
+    }
+
+    if (info.isRemoved) {
+      // Stage as delete in synchronize.json
+      await addDeleteEntry({
+        UID: uid,
+        entity: info.childEntity,
+        name: `${info.childEntity}:${uid}`,
+        expression: `RowUID:${uid};entity:${info.childEntity}=true`,
+      });
+      log.dim(`  Staged delete for ${info.childEntity}:${uid}`);
+      continue;
+    }
+
+    // Edit: find the child object in meta.children
+    let childObj = null;
+    for (const childArray of Object.values(meta.children || {})) {
+      if (Array.isArray(childArray)) {
+        childObj = childArray.find(c => c.UID === uid);
+        if (childObj) break;
+      }
+    }
+    if (!childObj) {
+      log.warn(`  Could not find child ${uid} in metadata — skipping`);
+      continue;
+    }
+
+    const success = await _submitEntityChild(childObj, info.childEntity, info.changedColumns,
+                                             client, options, modifyKey, transactionKey);
+    if (success) pushed++;
+  }
+
+  if (pushed > 0) {
+    // Rewrite metadata file with updated child _LastUpdated values, then restore parent mtime
+    const parentLastUpdated = meta._LastUpdated;
+    await writeFile(metaPath, JSON.stringify(meta, null, 2) + '\n');
+    if (parentLastUpdated) {
+      try {
+        const cfg = await loadConfig();
+        const ts = parseServerDate(parentLastUpdated, cfg.ServerTimezone);
+        if (ts) await utimes(metaPath, ts, ts);
+      } catch { /* non-critical */ }
+    }
+    log.dim(`  ${pushed} child record(s) pushed; metadata file updated`);
+  }
+}
+
+/**
+ * Submit a single entity child record edit to the server.
+ * Mutates child._LastUpdated from the server response on success.
+ *
+ * @param {Object} child - Child record object (mutated in place on success)
+ * @param {string} physicalEntity - Server entity name (e.g. 'entity_column')
+ * @param {string[]} changedColumns - Column names to submit
+ * @param {DboClient} client
+ * @param {Object} options
+ * @param {string|null} modifyKey
+ * @param {string} transactionKey
+ * @returns {Promise<boolean>} - True if submitted successfully
+ */
+async function _submitEntityChild(child, physicalEntity, changedColumns, client, options, modifyKey = null, transactionKey = 'RowUID') {
+  const uid = child.UID;
+  if (!uid) {
+    log.warn(`  ${physicalEntity} child has no UID — skipping`);
+    return false;
+  }
+
+  const rowKeyPrefix = transactionKey === 'RowID' && child._id ? 'RowID' : 'RowUID';
+  const rowKeyValue = rowKeyPrefix === 'RowID' ? child._id : uid;
+
+  const dataExprs = [];
+  for (const col of changedColumns) {
+    if (shouldSkipColumn(col) || col === 'UID' || col === 'children') continue;
+    const val = child[col];
+    const strValue = (val === null || val === undefined) ? '' : String(val);
+    dataExprs.push(`${rowKeyPrefix}:${rowKeyValue};column:${physicalEntity}.${col}=${strValue}`);
+  }
+
+  if (dataExprs.length === 0) return false;
+
+  log.info(`  Pushing ${physicalEntity}:${uid} — ${dataExprs.length} field(s)`);
+
+  const storedTicket = await applyStoredTicketToSubmission(dataExprs, physicalEntity, uid, uid, options);
+  const extraParams = { '_confirm': options.confirm || 'true' };
+  if (options.ticket) extraParams['_OverrideTicketID'] = options.ticket;
+  else if (storedTicket) extraParams['_OverrideTicketID'] = storedTicket;
+  if (modifyKey) extraParams['_modify_key'] = modifyKey;
+  const cachedUser = getSessionUserOverride();
+  if (cachedUser) extraParams['_OverrideUserID'] = cachedUser;
+
+  const body = await buildInputBody(dataExprs, extraParams);
+  let result = await client.postUrlEncoded('/api/input/submit', body);
+
+  if (!result.successful && result.messages?.some(m => isModifyKeyError(m))) {
+    const retryMK = await handleModifyKeyError();
+    if (retryMK.cancel) { log.info('Submission cancelled'); return false; }
+    extraParams['_modify_key'] = retryMK.modifyKey;
+    const retryBody = await buildInputBody(dataExprs, extraParams);
+    result = await client.postUrlEncoded('/api/input/submit', retryBody);
+  }
+
+  formatResponse(result, { json: options.json, jq: options.jq, verbose: options.verbose });
+
+  if (!result.successful) return false;
+
+  // Update child _LastUpdated from server response (mutates child in place)
+  try {
+    const editResults = result.payload?.Results?.Edit || result.data?.Payload?.Results?.Edit || [];
+    if (editResults.length > 0) {
+      const updated = editResults[0]._LastUpdated || editResults[0].LastUpdated;
+      if (updated) child._LastUpdated = updated;
+    }
+  } catch { /* non-critical */ }
+
+  return true;
+}
+
 // ─── Baseline Update ────────────────────────────────────────────────────────
 
 /**
- * Update baseline file (.app.json) after successful pushes.
+ * Update baseline after successful pushes.
  * Syncs changed column values and timestamps from metadata to baseline.
  *
  * @param {Object} baseline - The baseline JSON object
@@ -1782,6 +1944,23 @@ async function updateBaselineAfterPush(baseline, successfulPushes) {
         modified = true;
       }
     }
+
+    // Update child _LastUpdated values in baseline (from entity children push)
+    if (meta.children && typeof meta.children === 'object' && baselineEntry.children) {
+      for (const [childEntityName, childArray] of Object.entries(meta.children)) {
+        if (!Array.isArray(childArray)) continue;
+        const baselineChildArray = baselineEntry.children?.[childEntityName];
+        if (!Array.isArray(baselineChildArray)) continue;
+        for (const child of childArray) {
+          if (!child.UID || !child._LastUpdated) continue;
+          const baselineChild = baselineChildArray.find(bc => bc.UID === child.UID);
+          if (baselineChild && baselineChild._LastUpdated !== child._LastUpdated) {
+            baselineChild._LastUpdated = child._LastUpdated;
+            modified = true;
+          }
+        }
+      }
+    }
   }
 
   // Save updated baseline

package/src/commands/rm.js

@@ -66,7 +66,7 @@ function getRowId(meta) {
 }
 
 /**
- * Remove a single file record: stage deletion, remove from app.json, delete local files.
+ * Remove a single file record: stage deletion, remove from metadata, delete local files.
  * Returns true if removed, false if skipped.
  */
 async function rmFileRecord(metaPath, options, { skipPrompt = false } = {}) {
@@ -125,7 +125,7 @@ async function rmFileRecord(metaPath, options, { skipPrompt = false } = {}) {
   await removeDeployEntry(uid);
   log.success(`  Staged: ${displayName} → ${expression}`);
 
-  // Remove from app.json
+  // Remove from metadata
   await removeAppJsonReference(metaPath);
 
   // Handle local files

package/src/commands/run.js

@@ -5,7 +5,7 @@ import { mergeScriptsConfig, buildHookEnv, runHook } from '../lib/scripts.js';
 import { log } from '../lib/logger.js';
 
 export const runCommand = new Command('run')
-  .description('Run a named script from .dbo/scripts.json (like npm run)')
+  .description('Run a named script from .app/scripts.json (like npm run)')
   .argument('[script-name]', 'Name of the script to run (omit to list all scripts)')
   .action(async (scriptName, options) => {
     try {
@@ -13,7 +13,7 @@ export const runCommand = new Command('run')
       const local = await loadScriptsLocal();
 
       if (!base && !local) {
-        log.error('No .dbo/scripts.json found');
+        log.error('No .app/scripts.json found');
         process.exit(1);
       }
 
@@ -24,7 +24,7 @@ export const runCommand = new Command('run')
         // List all script names
         const allNames = Object.keys(scripts);
         if (allNames.length === 0) {
-          log.info('No scripts defined in .dbo/scripts.json');
+          log.info('No scripts defined in .app/scripts.json');
           return;
         }
         log.info('Available scripts:');
@@ -37,7 +37,7 @@ export const runCommand = new Command('run')
       }
 
       if (!(scriptName in scripts)) {
-        log.error(`Script "${scriptName}" not found in .dbo/scripts.json`);
+        log.error(`Script "${scriptName}" not found in .app/scripts.json`);
         process.exit(1);
       }
 

package/src/commands/status.js

@@ -15,7 +15,7 @@ export const statusCommand = new Command('status')
       const initialized = await isInitialized();
       const config = await loadConfig();
 
-      log.label('Initialized', initialized ? 'Yes (.dbo/)' : 'No');
+      log.label('Initialized', initialized ? 'Yes (.app/)' : 'No');
       log.label('Domain', config.domain || '(not set)');
       log.label('Username', config.username || '(not set)');
       const userInfo = await loadUserInfo();

package/src/commands/sync.js

@@ -7,7 +7,7 @@ import { runPendingMigrations } from '../lib/migrations.js';
 
 export const syncCommand = new Command('sync')
   .description('Synchronise local state with the server')
-  .option('--baseline', 'Re-fetch server state and update .dbo/.app_baseline.json (does not modify local files)')
+  .option('--baseline', 'Re-fetch server state and update the baseline (does not modify local files)')
   .option('--no-migrate', 'Skip pending migrations for this invocation')
   .action(async (options) => {
     await runPendingMigrations(options);
@@ -66,6 +66,6 @@ export const syncCommand = new Command('sync')
     decodeBase64Fields(baseline);
 
     await saveAppJsonBaseline(baseline);
-    spinner.succeed('.dbo/.app_baseline.json updated from server');
+    spinner.succeed('Baseline updated from server');
     log.dim('  Run "dbo push" to sync local changes against the new baseline');
   });