@fugood/bricks-ctor 2.25.0-beta.6 → 2.25.0-beta.60

package/tools/mcp-tools/huggingface.ts

@@ -269,6 +269,28 @@ const fetchHFModelDetails = async (modelId: string): Promise<HFModel> => {
 // Example: Mixtral-8x22B-v0.1.IQ3_XS-00001-of-00005.gguf
 const ggufSplitPattern = /-(\d{5})-of-(\d{5})\.gguf$/
 
+export const buildGGUFSplitFiles = (
+  filename: string,
+  splitTotal: string,
+  siblings: HFSibling[],
+): HFSibling[] => {
+  const siblingByFilename = new Map<string, HFSibling>()
+  for (const sibling of siblings) {
+    if (!siblingByFilename.has(sibling.rfilename)) siblingByFilename.set(sibling.rfilename, sibling)
+  }
+
+  return Array.from({ length: Number(splitTotal) }, (_, i) => {
+    const split = String(i + 1).padStart(5, '0')
+    const splitRFilename = filename.replace(ggufSplitPattern, `-${split}-of-${splitTotal}.gguf`)
+    const sibling = siblingByFilename.get(splitRFilename)
+    return {
+      rfilename: splitRFilename,
+      size: sibling?.size,
+      lfs: sibling?.lfs,
+    }
+  })
+}
+
 export function register(server: McpServer) {
   server.tool(
     'huggingface_search',
@@ -657,19 +679,7 @@ export function register(server: McpServer) {
 
         if (isSplit) {
           const [, , splitTotal] = matched!
-          const splitFiles = Array.from({ length: Number(splitTotal) }, (_, i) => {
-            const split = String(i + 1).padStart(5, '0')
-            const splitRFilename = filename.replace(
-              ggufSplitPattern,
-              `-${split}-of-${splitTotal}.gguf`,
-            )
-            const sibling = siblings.find((sb) => sb.rfilename === splitRFilename)
-            return {
-              rfilename: splitRFilename,
-              size: sibling?.size,
-              lfs: sibling?.lfs,
-            }
-          })
+          const splitFiles = buildGGUFSplitFiles(filename, splitTotal, siblings)
 
           const first = splitFiles[0]
           const rest = splitFiles.slice(1)

package/tools/mcp-tools/icons.ts

@@ -36,11 +36,31 @@ const iconList = Object.entries(glyphmap as Record<string, number>).map(([name,
   return { name, code, styles }
 })
 
-const iconFuse = new Fuse(iconList, {
+const fuseOptions = {
   keys: ['name'],
   threshold: 0.3,
   includeScore: true,
-})
+}
+
+const iconFuse = new Fuse(iconList, fuseOptions)
+const iconFuseByStyle = new Map<IconStyle, Fuse<(typeof iconList)[number]>>()
+
+function getStyleFuse(style: IconStyle) {
+  let fuse = iconFuseByStyle.get(style)
+  if (!fuse) {
+    fuse = new Fuse(
+      iconList.filter((icon) => icon.styles.includes(style)),
+      fuseOptions,
+    )
+    iconFuseByStyle.set(style, fuse)
+  }
+  return fuse
+}
+
+export function searchIcons(query: string, limit: number, style?: IconStyle) {
+  if (style) return getStyleFuse(style).search(query, { limit })
+  return iconFuse.search(query, { limit })
+}
 
 export function register(server: McpServer) {
   server.tool(
@@ -54,11 +74,7 @@ export function register(server: McpServer) {
         .describe('Filter by icon style'),
     },
     async ({ query, limit, style }) => {
-      let results = iconFuse.search(query, { limit: style ? limit * 3 : limit })
-
-      if (style) {
-        results = results.filter((r) => r.item.styles.includes(style)).slice(0, limit)
-      }
+      const results = searchIcons(query, limit, style)
 
       const icons = results.map((r) => ({
         name: r.item.name,

package/tools/mcp-tools/media.ts

@@ -2,9 +2,12 @@ import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import { z } from 'zod'
 import { sh } from '../_shell'
 
+// MCP results are rendered as raw text — disable ANSI colors from the child.
+const noColorEnv = { FORCE_COLOR: '0', NO_COLOR: '1' }
+
 const runBricks = async (projectDir: string, ...args: string[]) => {
   try {
-    return await sh`bunx bricks ${args}`.cwd(projectDir).text()
+    return await sh`bunx bricks ${args}`.cwd(projectDir).env(noColorEnv).text()
   } catch (err: any) {
     throw new Error(err.stderr?.toString() || err.message)
   }

package/tools/postinstall.ts

@@ -12,6 +12,7 @@ import {
 } from 'fs/promises'
 import * as path from 'path'
 import TOML from '@iarna/toml'
+import { handleMcpConfigOverride } from './_mcp-config'
 
 const cwd = process.cwd()
 const projectSkillsDir = path.join(cwd, '.bricks', 'skills')
@@ -69,36 +70,15 @@ const projectMcpServer = {
   args: [`${cwd}/node_modules/@fugood/bricks-ctor/tools/mcp-server.ts`],
 }
 
-type CodexMcpConfig = {
-  mcp_servers: Record<string, typeof projectMcpServer>
-}
-
-// Claude Code and AGENTS.md projects both use the shared project .mcp.json file.
-const defaultMcpConfig = {
-  mcpServers: {
-    'bricks-ctor': projectMcpServer,
-  },
+// Codex cancels MCP tool calls it cannot prompt approval for (e.g. `codex exec`),
+// so the project-local server's tools must be pre-approved in its config entry.
+const codexProjectMcpServer = {
+  ...projectMcpServer,
+  default_tools_approval_mode: 'approve',
 }
 
-const handleMcpConfigOverride = async (mcpConfigPath: string) => {
-  let mcpConfig: { mcpServers: Record<string, typeof projectMcpServer> } | null = null
-  if (await exists(mcpConfigPath)) {
-    const configStr = await readFile(mcpConfigPath, 'utf-8')
-    try {
-      mcpConfig = JSON.parse(configStr)
-      if (!mcpConfig?.mcpServers) throw new Error('mcpServers is not defined')
-      mcpConfig.mcpServers['bricks-ctor'] = projectMcpServer
-      delete mcpConfig.mcpServers['bricks-project']
-    } catch {
-      mcpConfig = defaultMcpConfig
-    }
-  } else {
-    mcpConfig = defaultMcpConfig
-  }
-
-  await writeFile(mcpConfigPath, `${JSON.stringify(mcpConfig, null, 2)}\n`)
-
-  console.log(`Updated ${mcpConfigPath}`)
+type CodexMcpConfig = {
+  mcp_servers: Record<string, typeof codexProjectMcpServer | typeof projectMcpServer>
 }
 
 const hasClaudeCode = await exists(`${cwd}/CLAUDE.md`)
@@ -107,7 +87,7 @@ const hasAgentsMd = await exists(`${cwd}/AGENTS.md`)
 if (hasClaudeCode || hasAgentsMd) {
   // Keep the workspace-level JSON MCP config aligned for tools that read .mcp.json.
   const mcpConfigPath = `${cwd}/.mcp.json`
-  await handleMcpConfigOverride(mcpConfigPath)
+  await handleMcpConfigOverride(mcpConfigPath, projectMcpServer)
 }
 
 const copyMissingSkills = async (sourceDir: string, targetDir: string) => {
@@ -196,27 +176,104 @@ if (hasClaudeCode || hasAgentsMd) {
   await setupSkills()
 }
 
+type ClaudeSettings = {
+  autoMode?: {
+    environment?: string[]
+    allow?: string[]
+    soft_deny?: string[]
+    hard_deny?: string[]
+  }
+  [key: string]: unknown
+}
+
+// Trusted infrastructure for auto mode's classifier. `$defaults` keeps the
+// built-in environment (the working repo and its git remotes); the extra
+// entries stop routine syncs to the BRICKS backend from being treated as
+// external exfiltration. See https://code.claude.com/docs/en/auto-mode-config
+const autoModeEnvironment = [
+  '$defaults',
+  'Organization: BRICKS (bricks.tools). Primary use: building BRICKS apps/modules with the bricks CLI and the local bricks-ctor MCP server.',
+  'Trusted internal domains: all *.bricks.tools services — api.bricks.tools (project GraphQL API), bank.bricks.tools (config & asset Bank API), cdn.bricks.tools (asset CDN), plus the control/display/activity services. This project syncs its config and assets to these endpoints.',
+]
+
+// `.claude/settings.local.json` is per-developer local config; keep it untracked.
+const ensureSettingsLocalGitignored = async () => {
+  const gitignorePath = path.join(cwd, '.gitignore')
+  const entry = '.claude/settings.local.json'
+  const coveredBy = new Set([entry, '.claude', '.claude/', '.claude/*', '*.local.json'])
+
+  let content = ''
+  if (await exists(gitignorePath)) {
+    content = await readFile(gitignorePath, 'utf-8')
+    if (content.split('\n').some((line) => coveredBy.has(line.trim()))) return
+  }
+
+  const separator = content.length === 0 ? '' : content.endsWith('\n') ? '\n' : '\n\n'
+  await writeFile(gitignorePath, `${content}${separator}# Claude Code local settings\n${entry}\n`)
+  console.log(`Added ${entry} to .gitignore`)
+}
+
+// Pre-configure auto mode once, on initial setup. We only seed the classifier's
+// trusted infrastructure — not `permissions.defaultMode: 'auto'`, which Claude
+// Code ignores from project/local settings (a repo can't grant itself auto mode;
+// it only takes effect from ~/.claude/settings.json). An existing autoMode block
+// is left untouched so reinstalls never clobber a developer's customizations.
+const setupClaudeAutoMode = async () => {
+  const settingsPath = path.join(cwd, '.claude', 'settings.local.json')
+
+  let settings: ClaudeSettings = {}
+  if (await exists(settingsPath)) {
+    try {
+      settings = JSON.parse(await readFile(settingsPath, 'utf-8'))
+    } catch {
+      console.warn(`Skipping auto mode setup; ${settingsPath} is not valid JSON`)
+      return
+    }
+    if (settings.autoMode) return
+  }
+
+  settings.autoMode = { environment: autoModeEnvironment }
+
+  await mkdir(path.dirname(settingsPath), { recursive: true })
+  await writeFile(settingsPath, `${JSON.stringify(settings, null, 2)}\n`)
+  console.log(`Set up auto mode in ${settingsPath}`)
+
+  await ensureSettingsLocalGitignored()
+}
+
+if (hasClaudeCode) {
+  // Pre-configure auto mode's trusted infrastructure for Claude Code projects.
+  await setupClaudeAutoMode()
+}
+
 if (hasAgentsMd) {
   // Codex stores its project-local MCP config in .codex/config.toml.
   const defaultCodexMcpConfig = {
     mcp_servers: {
-      'bricks-ctor': projectMcpServer,
+      'bricks-ctor': codexProjectMcpServer,
     },
   }
 
   const handleCodexMcpConfigOverride = async (mcpConfigPath: string) => {
-    let mcpConfig: CodexMcpConfig | null = null
+    let mcpConfig: CodexMcpConfig
     if (await exists(mcpConfigPath)) {
-      const configStr = await readFile(mcpConfigPath, 'utf-8')
+      let parsed: unknown
       try {
-        const parsed = TOML.parse(configStr) as Partial<CodexMcpConfig>
-        if (!parsed?.mcp_servers) throw new Error('mcp_servers is not defined')
-        mcpConfig = { mcp_servers: parsed.mcp_servers }
-        mcpConfig.mcp_servers['bricks-ctor'] = projectMcpServer
-        delete mcpConfig.mcp_servers['bricks-project']
+        parsed = TOML.parse(await readFile(mcpConfigPath, 'utf-8'))
       } catch {
-        mcpConfig = defaultCodexMcpConfig
+        // A malformed config is left untouched (with a warning) rather than overwritten with
+        // the default — clobbering it would silently delete the user's other server entries.
+        // Mirrors handleMcpConfigOverride's handling of a malformed .mcp.json.
+        console.warn(`Skipping .codex/config.toml update; ${mcpConfigPath} is not valid TOML`)
+        return
+      }
+      mcpConfig =
+        parsed && typeof parsed === 'object' ? (parsed as CodexMcpConfig) : { mcp_servers: {} }
+      if (!mcpConfig.mcp_servers || typeof mcpConfig.mcp_servers !== 'object') {
+        mcpConfig.mcp_servers = {}
       }
+      mcpConfig.mcp_servers['bricks-ctor'] = codexProjectMcpServer
+      delete mcpConfig.mcp_servers['bricks-project']
     } else {
       mcpConfig = defaultCodexMcpConfig
     }

package/tools/pull.ts

@@ -1,7 +1,32 @@
-import { readFile, writeFile } from 'node:fs/promises'
+import { mkdir, readdir, readFile, unlink, writeFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { dirname, join, relative } from 'node:path'
 import { format } from 'oxfmt'
 import { sh } from './_shell'
+import { extractCliErrorMessage } from './_cli-error'
 import { buildCommitArgs } from './_git-author'
+import { readLastPushedCommit, writeLastPushedCommit } from './_last-pushed-commit'
+
+// Directories whose .ts contents are entirely owned by the generator.
+// Anything under these dirs not present in the freshly pulled file list is an orphan.
+const ownedTsDirs = ['subspaces', 'automation-tests']
+
+async function walkTsFiles(dir: string, baseDir: string): Promise<string[]> {
+  if (!existsSync(dir)) return []
+  const result: string[] = []
+  const entries = await readdir(dir, { withFileTypes: true })
+  await Promise.all(
+    entries.map(async (entry) => {
+      const full = join(dir, entry.name)
+      if (entry.isDirectory()) {
+        result.push(...(await walkTsFiles(full, baseDir)))
+      } else if (entry.isFile() && entry.name.endsWith('.ts')) {
+        result.push(relative(baseDir, full))
+      }
+    }),
+  )
+  return result
+}
 
 const cwd = process.cwd()
 const args = process.argv.slice(2)
@@ -44,38 +69,47 @@ const result = await sh`bricks ${command} project-pull ${app.id} --json`.quiet()
 
 if (result.exitCode !== 0) {
   const output = result.stderr.toString() || result.stdout.toString()
-  try {
-    const json = JSON.parse(output)
-    throw new Error(json.error || 'Pull failed')
-  } catch {
-    throw new Error(output || 'Pull failed')
-  }
+  throw new Error(extractCliErrorMessage(output, 'Pull failed'))
 }
 
-const { files, lastCommitId } = JSON.parse(result.stdout.toString())
+const { files, lastCommitId: serverLastCommitId } = JSON.parse(result.stdout.toString())
+
+// The locally-saved commit (recorded by deploy/push-config) is the
+// authoritative merge base for THIS clone — the server's value can be an
+// opaque nanoid (config-only updates) or point to a commit other clients
+// produced. Fall back to the server's value only if we have no local
+// record yet.
+const savedLocalCommitId = await readLastPushedCommit(cwd)
+const baseCommitId = savedLocalCommitId || serverLastCommitId
 
-let useMain = false
+const branchName = isModule
+  ? 'BRICKS_PROJECT_try-pull-module'
+  : 'BRICKS_PROJECT_try-pull-application'
+
+let landingBranch = ''
 if (isGitRepo && !force) {
-  console.log(`Checking commit ${lastCommitId}...`)
-  const found = (await sh`cd ${cwd} && git rev-list -1 ${lastCommitId}`.nothrow().text())
+  landingBranch = (await sh`cd ${cwd} && git branch --show-current`.text()).trim()
+  if (!landingBranch) throw new Error('Cannot pull from a detached HEAD')
+
+  console.log(`Checking commit ${baseCommitId}...`)
+  const found = (await sh`cd ${cwd} && git rev-list -1 ${baseCommitId}`.nothrow().text())
     .trim()
     .match(/^[\da-f]{40}$/)
 
-  const commitId = (await sh`cd ${cwd} && git rev-parse HEAD`.text()).trim()
+  const headCommitId = (await sh`cd ${cwd} && git rev-parse HEAD`.text()).trim()
 
-  if (commitId === lastCommitId) throw new Error('Commit not changed')
-
-  const branchName = isModule
-    ? 'BRICKS_PROJECT_try-pull-module'
-    : 'BRICKS_PROJECT_try-pull-application'
+  if (headCommitId === serverLastCommitId) throw new Error('Commit not changed')
 
   await sh`cd ${cwd} && git branch -D ${branchName}`.nothrow()
 
+  // When the base commit isn't reachable in this clone (server stored a
+  // nanoid, or the commit was pruned), fall back to forking from current
+  // HEAD. The downstream merge into the starting branch collapses both paths
+  // into the same result, just with different merge bases.
   if (found) {
-    await sh`cd ${cwd} && git checkout -b ${branchName} ${lastCommitId}`.nothrow()
+    await sh`cd ${cwd} && git checkout -b ${branchName} ${baseCommitId}`.nothrow()
   } else {
     await sh`cd ${cwd} && git checkout -b ${branchName}`
-    useMain = true
   }
 }
 
@@ -89,6 +123,23 @@ const oxfmtConfig = await readFile(`${cwd}/.oxfmtrc.json`, 'utf8')
     printWidth: 100,
   }))
 
+const expectedFiles = new Set(files.map((file: { name: string }) => file.name))
+
+// Remove orphan .ts files under generator-owned directories before writing.
+// File paths are produced by buildApplicationFiles and use forward slashes,
+// so normalise the walked paths the same way for comparison.
+const orphans: string[] = []
+await Promise.all(
+  ownedTsDirs.map(async (dir) => {
+    const existing = await walkTsFiles(join(cwd, dir), cwd)
+    for (const file of existing) {
+      const normalized = file.split(/[\\/]/).join('/')
+      if (!expectedFiles.has(normalized)) orphans.push(normalized)
+    }
+  }),
+)
+await Promise.all(orphans.map((name) => unlink(`${cwd}/${name}`)))
+
 await Promise.all(
   files.map(async (file: { name: string; input: string; formatable?: boolean }) => {
     let content = file.input
@@ -96,7 +147,9 @@ await Promise.all(
       const result = await format(file.name, file.input, oxfmtConfig)
       content = result.code
     }
-    return writeFile(`${cwd}/${file.name}`, content)
+    const target = join(cwd, file.name)
+    await mkdir(dirname(target), { recursive: true })
+    return writeFile(target, content)
   }),
 )
 
@@ -112,11 +165,35 @@ if (isGitRepo) {
     const commitArgs = await buildCommitArgs(cwd, [commitMsg])
     await sh`cd ${cwd} && git ${commitArgs}`
   }
-  if (!force && !useMain) {
-    await sh`cd ${cwd} && git merge main`
+  if (!force) {
+    // Land the pulled commits on the starting branch with a single 3-way merge using
+    // baseCommit as the merge base. The user doesn't have to manage a side
+    // branch, and conflicts (if any) land in the working tree on the starting branch where
+    // auto-compile surfaces them as typecheck errors to resolve in-place.
+    await sh`cd ${cwd} && git checkout ${landingBranch}`
+    const mergeResult = await sh`cd ${cwd} && git merge ${branchName} --no-edit`.nothrow()
+    if (mergeResult.exitCode !== 0) {
+      // Conflict markers are in the working tree — commit them so the tree
+      // is clean for auto-compile to detect, leaving the resolution to the
+      // user. Pre-commit hooks would reject markers (lint/format fail on
+      // invalid syntax), so bypass them for this controlled case.
+      await sh`cd ${cwd} && git add .`
+      const conflictArgs = await buildCommitArgs(
+        cwd,
+        [`chore(project): merge with conflicts (resolve in ${landingBranch})`],
+        ['--no-verify'],
+      )
+      await sh`cd ${cwd} && git ${conflictArgs}`
+    }
+    // The try-pull branch served its purpose; delete it so `git branch`
+    // stays tidy. The next pull recreates it anyway (line 103).
+    await sh`cd ${cwd} && git branch -D ${branchName}`.nothrow()
   }
+  // Record the new sync point so a follow-up pull starts from the right base.
+  const newHead = (await sh`cd ${cwd} && git rev-parse HEAD`.nothrow().text()).trim()
+  if (newHead) await writeLastPushedCommit(cwd, newHead)
 }
 
 console.log(
-  `${isModule ? 'Module' : 'App'} project pulled: ${files.length} files${force ? ' (force)' : ''}`,
+  `${isModule ? 'Module' : 'App'} project pulled: ${files.length} files${orphans.length ? `, removed ${orphans.length} orphan .ts file${orphans.length === 1 ? '' : 's'}` : ''}${force ? ' (force)' : ''}`,
 )

package/tools/push-config.ts

@@ -0,0 +1,114 @@
+import { readFile, writeFile } from 'node:fs/promises'
+import { parseArgs } from 'util'
+import { sh } from './_shell'
+import { extractCliErrorMessage } from './_cli-error'
+import { buildCommitArgs } from './_git-author'
+import { writeLastPushedCommit } from './_last-pushed-commit'
+
+const cwd = process.cwd()
+
+const readJson = async (p: string) => JSON.parse(await readFile(p, 'utf8'))
+
+const {
+  values: { 'auto-commit': autoCommit, 'no-check': noCheck, 'no-validate': noValidate, yes, help },
+} = parseArgs({
+  args: process.argv.slice(2),
+  options: {
+    'auto-commit': { type: 'boolean' },
+    'no-check': { type: 'boolean' },
+    'no-validate': { type: 'boolean' },
+    yes: { type: 'boolean', short: 'y' },
+    help: { type: 'boolean', short: 'h' },
+  },
+  allowPositionals: true,
+})
+
+if (help) {
+  console.log(`Push compiled config to BRICKS without creating a release.
+
+Options:
+  --auto-commit              Auto-commit unstaged changes before pushing
+  --no-check                 Skip the conflict guard (don't pass --last-commit-id)
+  --no-validate              Skip server-side config schema validation
+  -y, --yes                  Skip all prompts
+  -h, --help                 Show this help message`)
+  process.exit(0)
+}
+
+// Detect git repo (mirrors deploy.ts)
+const { exitCode } = await sh`cd ${cwd} && git status`.quiet().nothrow()
+const isGitRepo = exitCode === 0
+
+if (!isGitRepo && !yes) {
+  const confirmContinue = prompt('No git repository found, continue? (y/n)')
+  if (confirmContinue !== 'y') throw new Error('Update cancelled')
+}
+
+// Read application.json + compiled config
+const app = await readJson(`${cwd}/application.json`)
+const config = await readJson(`${cwd}/.bricks/build/application-config.json`)
+
+// Handle unstaged changes the same way deploy.ts does.
+let commitId = ''
+let parentCommitId = ''
+if (isGitRepo) {
+  const unstagedChanges = await sh`cd ${cwd} && git diff --name-only --diff-filter=ACMR`.text()
+  if (unstagedChanges) {
+    if (autoCommit) {
+      // Capture the pre-commit HEAD so we can use it as the conflict-check
+      // baseline (the server should still hold it from the prior deploy).
+      parentCommitId = (await sh`cd ${cwd} && git rev-parse HEAD`.nothrow().text()).trim()
+      await sh`cd ${cwd} && git add -A`
+      const commitArgs = await buildCommitArgs(cwd, ['chore: update bricks config'])
+      await sh`cd ${cwd} && git ${commitArgs}`
+    } else {
+      throw new Error('Unstaged changes found, please commit or stash your changes before updating')
+    }
+  }
+  commitId = (await sh`cd ${cwd} && git rev-parse HEAD`.text()).trim()
+}
+
+// Auto-derive --last-commit-id for the server-side conflict guard.
+//   - parent of the auto-commit (server still holds it from the prior deploy)
+//   - current HEAD (clean tree — server should be at the same commit too)
+let lastCommitId: string | undefined
+if (!noCheck) {
+  if (parentCommitId) lastCommitId = parentCommitId
+  else if (commitId) lastCommitId = commitId
+}
+
+if (!yes) {
+  const confirm = prompt('Are you sure you want to push the new config? (y/n)')
+  if (confirm !== 'y') throw new Error('Update cancelled')
+}
+
+const isModule = app.type === 'module'
+const command = isModule ? 'module' : 'app'
+
+const updateConfig = {
+  ...config,
+  bricks_project_last_commit_id: commitId || undefined,
+}
+const configPath = `${cwd}/.bricks/build/push-config.json`
+await writeFile(configPath, JSON.stringify(updateConfig))
+
+const args = ['bricks', command, 'update', app.id, '-f', configPath, '--json']
+if (noValidate) args.push('--no-validate')
+if (lastCommitId) args.push('--last-commit-id', lastCommitId)
+
+const result = await sh`${args}`.quiet().nothrow()
+
+if (result.exitCode !== 0) {
+  const output = result.stderr.toString() || result.stdout.toString()
+  throw new Error(extractCliErrorMessage(output, 'Update failed'))
+}
+
+const output = JSON.parse(result.stdout.toString())
+
+// Record the commit we just pushed from so a later pull can use it as the
+// merge base regardless of what the server stores in
+// bricks_project_last_commit_id (which may be an opaque nanoid for
+// content-only edits).
+if (commitId) await writeLastPushedCommit(cwd, commitId)
+
+console.log(`${isModule ? 'Module' : 'App'} config updated: ${output.target?.name || app.name}`)