@fugood/bricks-project 2.25.0-beta.42 → 2.25.0-beta.45

package/compile/config-diff.ts

@@ -0,0 +1,102 @@
+import { readFile } from 'node:fs/promises'
+import path from 'node:path'
+
+// The compiled config artifact written by `bun compile` (see the generated
+// project's `compile.ts`; bricks-project-generator/index.js:762).
+export const BUILD_CONFIG_RELATIVE = '.bricks/build/application-config.json'
+
+// `compile()` derives these top-level fields from `Date.now()`
+// (compile/index.ts `title: \`${app.name}(${timestamp})\`` and `update_timestamp`),
+// so they differ on every run regardless of source. Excluded from the comparison —
+// only the *top-level* keys are dropped, so nested subspace/brick `title`s still diff.
+const VOLATILE_TOP_LEVEL_FIELDS = ['title', 'update_timestamp']
+
+// A minimal, path-keyed config change (Option A): a generic patch, not coupled to
+// bricks-config-editor's action vocabulary. `path` is an array of object keys /
+// array indices, ready for the editor's `setYValueAtPath` (or a delete) so applying
+// the patch is a single Yjs `'local'` transaction == one undo/redo entry.
+export type ConfigPatchOp =
+  | { op: 'set'; path: Array<string | number>; value: unknown }
+  | { op: 'unset'; path: Array<string | number> }
+
+export type ConfigChange =
+  | { status: 'ok'; ops: ConfigPatchOp[]; opCount: number }
+  | { status: 'no_baseline' }
+  | { status: 'unavailable' }
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null && !Array.isArray(value)
+
+const deepEqual = (a: unknown, b: unknown): boolean => {
+  if (a === b) return true
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((item, index) => deepEqual(item, b[index]))
+  }
+  if (isRecord(a) && isRecord(b)) {
+    const aKeys = Object.keys(a)
+    return (
+      aKeys.length === Object.keys(b).length &&
+      aKeys.every((key) => key in b && deepEqual(a[key], b[key]))
+    )
+  }
+  return false
+}
+
+const normalizeConfig = (config: unknown) => {
+  if (!isRecord(config)) return config
+  const normalized = { ...config }
+  for (const field of VOLATILE_TOP_LEVEL_FIELDS) delete normalized[field]
+  return normalized
+}
+
+// Objects recurse key-wise; equal-length arrays recurse element-wise; everything else
+// (scalars, type changes, length-changed arrays) emits one whole-value `set` at that
+// path. The editor's `applyJsonDiffToYType` minimizes the actual Yjs ops downstream,
+// so a whole-array `set` on insert/remove still yields a minimal CRDT mutation.
+const diffInto = (
+  before: unknown,
+  after: unknown,
+  currentPath: Array<string | number>,
+  ops: ConfigPatchOp[],
+) => {
+  if (deepEqual(before, after)) return
+
+  if (isRecord(before) && isRecord(after)) {
+    const keys = new Set([...Object.keys(before), ...Object.keys(after)])
+    for (const key of keys) {
+      const nextPath = [...currentPath, key]
+      if (!(key in after)) ops.push({ op: 'unset', path: nextPath })
+      else if (!(key in before)) ops.push({ op: 'set', path: nextPath, value: after[key] })
+      else diffInto(before[key], after[key], nextPath, ops)
+    }
+    return
+  }
+
+  if (Array.isArray(before) && Array.isArray(after) && before.length === after.length) {
+    for (let index = 0; index < after.length; index += 1) {
+      diffInto(before[index], after[index], [...currentPath, index], ops)
+    }
+    return
+  }
+
+  ops.push({ op: 'set', path: currentPath, value: after })
+}
+
+// Diff two compiled configs. `before == null` means there was no prior build to compare
+// (first compile); `after == null` means the fresh artifact could not be read.
+export const computeConfigChange = (before: unknown, after: unknown): ConfigChange => {
+  if (before == null) return { status: 'no_baseline' }
+  if (after == null) return { status: 'unavailable' }
+  const ops: ConfigPatchOp[] = []
+  diffInto(normalizeConfig(before), normalizeConfig(after), [], ops)
+  return { status: 'ok', ops, opCount: ops.length }
+}
+
+// Read the last-compiled config artifact. Returns null when it is absent or unreadable.
+export const readBuildConfig = async (projectDir: string): Promise<unknown> => {
+  try {
+    return JSON.parse(await readFile(path.join(projectDir, BUILD_CONFIG_RELATIVE), 'utf8'))
+  } catch {
+    return null
+  }
+}

package/compile/index.ts

@@ -10,6 +10,10 @@ import { makeId } from '../utils/id'
 import { generateCalulationMap } from './util'
 import { templateActionNameMap } from './action-name-map'
 import { templateEventPropsMap } from '../utils/event-props'
+import { sh } from '../tools/_shell'
+import { computeConfigChange, readBuildConfig } from './config-diff'
+import { appendEditRecord, editProvenance } from '../tools/_edits-log'
+import { isTruthyEnv } from '../tools/mcp-env'
 import type {
   Application,
   Data,
@@ -700,8 +704,38 @@ const compileAutomation = (automationMap: AutomationMap) =>
     }),
   )
 
+// Record the minimal compiled-config delta this compile produced to the shared audit
+// log (`.bricks/edits.jsonl`), so editing files directly and running `bun compile`
+// leaves the same trail as the MCP source-editing tools. Maintained only in the
+// editing-tools context (`BRICKS_CTOR_ENABLE_EDITING_TOOLS`); the source-editing tools
+// turn it off for their verify compiles (see _verify.ts) so a tool edit records one
+// richer entry instead of an extra generic compile entry. Also silent when there is no
+// prior build to diff against (fresh projects, package tests, tooling outside a project).
+const recordConfigChange = async (previousConfig: unknown, config: unknown) => {
+  if (previousConfig == null) return
+  if (!isTruthyEnv(process.env.BRICKS_CTOR_ENABLE_EDITING_TOOLS)) return
+  // The baseline was parsed from JSON; round-trip the fresh config the same way so keys
+  // holding undefined (dropped by the artifact's JSON.stringify) don't diff as phantom sets.
+  const change = computeConfigChange(previousConfig, JSON.parse(JSON.stringify(config)))
+  if (change.status !== 'ok') return
+  await appendEditRecord(process.cwd(), {
+    ts: new Date().toISOString(),
+    tool: 'compile',
+    provenance: editProvenance(),
+    outcome: 'ok',
+    summary:
+      change.opCount === 0
+        ? 'compile: no config change'
+        : `compile: ${change.opCount} config op(s)`,
+    configChange: change,
+  }).catch(() => undefined)
+}
+
 export const compile = async (app: Application) => {
   await new Promise((resolve) => setImmediate(resolve, 0))
+  // Snapshot the prior build artifact before the caller's compile.ts overwrites it, so
+  // the config change introduced by this compile can be recorded on return.
+  const previousConfig = await readBuildConfig(process.cwd())
   const timestamp = Date.now()
   // Pre-index subspace ids so the canvas-item validation below stays O(1).
   const subspaceIdSet = new Set(app.subspaces.map((s) => s.id))
@@ -1414,12 +1448,7 @@ export const compile = async (app: Application) => {
                 : null,
             }
 
-            Object.assign(
-              calc,
-              generateCalulationMap(calc.script_config, {
-                snapshotMode: process.env.BRICKS_SNAPSHOT_MODE === '1',
-              }),
-            )
+            Object.assign(calc, generateCalulationMap(calc.script_config, dataCalcId))
           }
           map[dataCalcId] = calc
           return map
@@ -1456,12 +1485,15 @@ export const compile = async (app: Application) => {
     automation_map: compiledAutomationMap || app.metadata?.TEMP_automation_map || {},
     update_timestamp: timestamp,
   }
+  await recordConfigChange(previousConfig, config)
   return config
 }
 
 export const checkConfig = async (configPath: string) => {
-  const { sh } = await import('../tools/_shell')
   // --validate-automation surfaces broken automation_map / test_map refs early,
   // which catches agent-authored automations that reference deleted bricks.
   await sh`bricks app check-config --validate-automation ${configPath}`
+  // Doctor adds semantic lint checks after structural validation. Warnings are
+  // surfaced in the compile log, but only errors fail by default.
+  await sh`bricks app doctor --validate-automation ${configPath}`
 }

package/compile/util.ts

@@ -1,4 +1,4 @@
-import { makeId } from '../utils/id'
+import { makeSeededId } from '../utils/id'
 
 type ScriptConfig = {
   title?: string
@@ -33,15 +33,18 @@ const padding = 15
 const layerXInterval = 300
 const layerYInterval = 150
 
-export const generateCalulationMap = (config: ScriptConfig, opts?: { snapshotMode?: boolean }) => {
+// `calcId` (the owning script calc's stable id) seeds every derived command-node id, so an
+// unchanged calc recompiles to identical ids and editing one calc never shifts another's —
+// keeping the compiled config byte-stable for change detection. See makeSeededId in utils/id.
+export const generateCalulationMap = (config: ScriptConfig, calcId: string) => {
   validateConfig(config)
-  const sandboxId = makeId('property_bank_command', opts)
-  const sandboxErrorId = makeId('property_bank_command', opts)
-  const sandboxResultId = makeId('property_bank_command', opts)
+  const sandboxId = makeSeededId('property_bank_command', `${calcId}:sandbox-run`)
+  const sandboxErrorId = makeSeededId('property_bank_command', `${calcId}:sandbox-error`)
+  const sandboxResultId = makeSeededId('property_bank_command', `${calcId}:sandbox-result`)
 
   const inputs = Object.entries(config.inputs).reduce(
     (acc, [key, value], index) => {
-      const commandId = makeId('property_bank_command', opts)
+      const commandId = makeSeededId('property_bank_command', `${calcId}:input:${key}`)
       acc.map[key] = {
         type: 'data-node',
         properties: {},
@@ -123,7 +126,7 @@ export const generateCalulationMap = (config: ScriptConfig, opts?: { snapshotMod
   let y = 0
   const outputs = Object.entries(config.outputs).reduce(
     (acc, [key, pbList], index) => {
-      const commandId = makeId('property_bank_command', opts)
+      const commandId = makeSeededId('property_bank_command', `${calcId}:output:${key}`)
       acc.commandIdList.push(commandId)
       acc.map[commandId] = {
         type: 'command-node-object',

package/package.json

@@ -1,13 +1,17 @@
 {
   "name": "@fugood/bricks-project",
-  "version": "2.25.0-beta.42",
+  "version": "2.25.0-beta.45",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "build": "bun scripts/build.js"
   },
   "dependencies": {
-    "@fugood/bricks-cli": "^2.25.0-beta.42",
+    "@babel/generator": "7.28.5",
+    "@babel/parser": "7.28.5",
+    "@babel/traverse": "7.28.5",
+    "@babel/types": "7.28.5",
+    "@fugood/bricks-cli": "^2.25.0-beta.45",
     "@huggingface/gguf": "^0.3.2",
     "@iarna/toml": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.15.0",

package/package.json.bak

@@ -1,13 +1,17 @@
 {
   "name": "@fugood/bricks-ctor",
-  "version": "2.25.0-beta.42",
+  "version": "2.25.0-beta.45",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "build": "bun scripts/build.js"
   },
   "dependencies": {
-    "@fugood/bricks-cli": "^2.25.0-beta.42",
+    "@babel/generator": "7.28.5",
+    "@babel/parser": "7.28.5",
+    "@babel/traverse": "7.28.5",
+    "@babel/types": "7.28.5",
+    "@fugood/bricks-cli": "^2.25.0-beta.45",
     "@huggingface/gguf": "^0.3.2",
     "@iarna/toml": "^3.0.0",
     "@modelcontextprotocol/sdk": "^1.15.0",

package/skills/bricks-ctor/SKILL.md

@@ -12,6 +12,7 @@ This skill covers advanced BRICKS features not in the main project instructions.
 | Rule | Description |
 |------|-------------|
 | [Architecture Patterns](references/architecture-patterns.md) | **Read first** — decompose flows and select patterns |
+| [Source-Editing Tools](references/source-editing-tools.md) | MCP tools for editing entries and data-calcs by AST (new/edit/remove, value grammar, verify) |
 | [Animation](references/animation.md) | Animation system for brick transforms and opacity |
 | [Standby Transition](references/standby-transition.md) | Canvas enter/exit animations |
 | [Automations](references/automations.md) | E2E testing and scheduled tasks |
@@ -26,6 +27,7 @@ This skill covers advanced BRICKS features not in the main project instructions.
 ## Quick Reference
 
 - **Complex flows**: See [Architecture Patterns](references/architecture-patterns.md) for decomposing multi-step workflows
+- **Editing entries/data-calcs**: See [Source-Editing Tools](references/source-editing-tools.md) — prefer the MCP editing tools over hand-editing `subspaces/**`
 - **Multi-device**: See [Local Sync](references/local-sync.md) for LAN coordination
 - **Cloud data**: See [Remote Data Bank](references/remote-data-bank.md) for sync and API access
 - **Media assets**: See [Media Flow](references/media-flow.md) for centralized asset management

package/skills/bricks-ctor/references/architecture-patterns.md

@@ -32,6 +32,12 @@ Sequential `PROPERTY_BANK` / `PROPERTY_BANK_EXPRESSION` actions in one chain rea
 Built-in commands for direct state and UI changes.
 - **PROPERTY_BANK**: set data value
 - **PROPERTY_BANK_EXPRESSION**: inline JS expression for simple compute
+  - The expression engine folds statements into a single expression: only expression
+    statements, simple `const`/`let` declarations, and a final return/expression are
+    supported — **no `if`/`for`/`while`/`switch`** (use ternaries). The same limit
+    applies inside a zero-arg IIFE body. Unsupported statements fail at runtime with
+    the error visible only in a DevTools session, so prefer ternary chains or move the
+    logic to a DataCalculationScript.
 - **CHANGE_CANVAS**: navigate to another canvas
 - **DYNAMIC_ANIMATION**: trigger animation
 - **ALERT / MESSAGE**: system feedback

package/skills/bricks-ctor/references/source-editing-tools.md

@@ -0,0 +1,81 @@
+# MCP Source-Editing Tools
+
+The project-local `bricks-ctor` MCP server exposes tools that edit `subspaces/**` via
+surgical AST edits, keeping files in the standard generated style. Prefer them over
+hand-editing entry files; they validate references, manage imports, compile-verify, and
+record every operation in `.bricks/edits.jsonl`.
+
+## Entry tools (bricks.ts / generators.ts / canvases.ts / data.ts / animations.ts)
+
+| Tool | Purpose |
+|------|---------|
+| `new_entry` | Create a standard entry skeleton (`file`, `type`, `templateKey`, `alias`, optional initial `set`/`events`) |
+| `edit_entry` | Set/unset dotted paths on an entry: `title`, `property.url`, `outlets.response`, `value`, `switches[0].property.text`, … |
+| `edit_events` | Add/remove/replace/move/clear EventAction items in `events.<eventKey>` |
+| `edit_canvas_items` | Add/replace/remove/move brick items on a Canvas `items` array (frames need numeric x/y/width/height) |
+| `edit_switches` | Add/replace/remove/move switches (id, title, conds, override, disabled, break) |
+| `remove_entry` | Delete an entry; cascades same-subspace references by default, `strict: true` refuses and lists sites |
+
+Addressing: `{ file, entry }` (export const name) is primary; `id` works as a global
+fallback (omit `file`). `edit_entry`/`edit_events` accept a `switch` parameter (switch id
+or index) to edit the facets inside one switch — `edit_switches` owns only the array and
+the conds/override shell.
+
+### Event actions
+
+```jsonc
+{
+  "handler": "system",            // or { "ref": "brickOrGeneratorRef" } or { "subspace": "SUBSPACE_id" }
+  "name": "CHANGE_CANVAS",
+  "params": { "canvasId": { "ref": "mainCanvas" } },   // template params, OR:
+  "dataParams": { "someData": 5 },                      // PROPERTY_BANK-style params
+  "waitAsync": false
+}
+```
+
+System actions derive their `as SystemAction...` cast automatically; entity-action casts
+are added only when passed via `cast`. The compiled source form
+`{ handler, action: { name, params: [...], dataParams: [...] }, waitAsync }` is also
+accepted, and `{ "expr": "<raw EventAction>" }` is the escape hatch for shapes the
+structured form cannot express. Handler refs must resolve to a brick or generator.
+`PROPERTY_BANK_EXPRESSION` expressions are validated against the runtime fold rules at
+edit time: only expression statements, simple `const`/`let` declarations, and a final
+return inside a zero-arg IIFE evaluate — no `if`/`for`/`while` (use ternaries, or a
+DataCalculationScript for branching logic).
+
+## Data-calc tools (DataCalculationScript only)
+
+| Tool | Purpose |
+|------|---------|
+| `new_data_calc` | Create `data-calc/data-calculation-{slug}.ts` + `.sandbox.js`, regenerate `data-calc/index.ts`, wire a minimal subspace root |
+| `edit_data_calc` | Set/unset scalar fields, `output`/`error` refs, replace whole `inputs`/`outputs`, or rewrite the sandbox `code` |
+| `edit_data_calc_io` | Add/remove/replace/clear single `inputs`/`outputs` items (input keys unique; output keys may repeat for fan-out) |
+| `remove_data_calc` | Delete the calc `.ts` + its sandbox file and regenerate the index |
+
+Addressing: `{ file }` or `{ subspace, calc }` where `calc` is alias, id, or filename
+slug (subspace defaults to `subspace-0`). Code is canonicalized to the sandbox file form
+(`export function main() { ... }` — wrapped automatically, `async` added when the body
+uses top-level `await`). `DataCalculationMap` (visual node graph) is out of scope and
+returns `fallback_recommended`.
+
+## Value grammar (everywhere a value appears)
+
+| You pass | Emits |
+|----------|-------|
+| JSON scalar/array/object | literal |
+| `{ "link": "dataRefOrAlias" }` | `linkData(() => data.dX)` (property data-links) |
+| `{ "ref": "idOrAliasOrVarName", "subspace"?: 1 }` | `() => namespace.varName` getter |
+| `{ "expr": "raw TypeScript" }` | spliced verbatim |
+
+References resolve by var name, id, or alias within the target subspace and fail loudly
+when missing or ambiguous — this doubles as reference validation.
+
+## Verification and audit
+
+- Every call compile-verifies by default and returns `verify.configChange` — the minimal
+  compiled-config delta (path-keyed set/unset ops). Skip with per-call `verify: false`
+  or `BRICKS_CTOR_MCP_EDIT_VERIFY=0` when batching, then finish with the `compile` tool.
+- All operations append to `.bricks/edits.jsonl` (gitignored) with inputs, outcomes, and
+  touched sites.
+- Non-standard files or entries (hand-written shapes the AST editor cannot safely
+  rewrite) return `fallback_recommended` — use plain file edits for those cases only.

package/skills/bricks-ctor/references/verification-toolchain.md

@@ -71,6 +71,8 @@ Useful flags:
 
 For ad-hoc CDP inspection against this local preview, connect any CDP client to `localhost:19852` — Chrome DevTools front-end works directly. For an agent-friendly CLI over CDP (screenshot, brick tree/query, input emulation, storage reads, runtime eval, network capture), the `bricks-cli` skill documents the `bricks devtools` command surface — read that skill if it is installed in this workspace. If it is not installed, run `bricks --help` and `bricks devtools --help`; the CLI's own help output is authoritative.
 
+To inspect Data / Property Bank or storage state, prefer the dedicated `bricks devtools storage` subcommands — `storage data-bank get <S_xxxx>` (saved Data values), `storage system persist|memory`, `storage system get <key>` — over hand-written `runtime eval`. Reach for `runtime eval` only for *live* store internals that aren't persisted to a data bank (e.g. a current transient value: `runtime eval "system.data.property('S_xxxx', '<alias>')"`); don't reverse-engineer the `system.*` globals.
+
 ### Project Automations
 
 E2E tests authored in TypeScript inside the project (`AutomationTest` / `TestCase`). Test cases include:

package/tools/_edits-log.ts

@@ -0,0 +1,41 @@
+import { appendFile, mkdir, readFile, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+
+const auditLogIgnoreEntry = '.bricks/edits.jsonl'
+
+// Ensure the project's .gitignore excludes the audit log. No-op when it is already
+// ignored directly or via a broader `.bricks` rule.
+const ensureAuditLogIgnored = async (projectDir: string) => {
+  const gitignorePath = path.join(projectDir, '.gitignore')
+  const content = await readFile(gitignorePath, 'utf8').catch((err: any) => {
+    if (err?.code === 'ENOENT') return ''
+    throw err
+  })
+  const ignored = content
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .some((line) => line === auditLogIgnoreEntry || line === '.bricks/' || line === '.bricks')
+  if (ignored) return
+
+  const prefix = content && !content.endsWith('\n') ? '\n' : ''
+  await writeFile(
+    gitignorePath,
+    `${content}${prefix}\n# MCP entry-editing audit log\n${auditLogIgnoreEntry}\n`,
+  )
+}
+
+// Append one JSON record to `.bricks/edits.jsonl`, creating the directory and the
+// gitignore entry as needed. Shared by the source-editing tools and `compile()` so
+// every project mutation lands in the same audit log.
+export const appendEditRecord = async (projectDir: string, record: Record<string, unknown>) => {
+  const bricksDir = path.join(projectDir, '.bricks')
+  await mkdir(bricksDir, { recursive: true })
+  await ensureAuditLogIgnored(projectDir)
+  await appendFile(path.join(bricksDir, 'edits.jsonl'), `${JSON.stringify(record)}\n`)
+}
+
+// Provenance stamped on every audit record: which agent/session produced the change.
+export const editProvenance = () => ({
+  session: process.env.BRICKS_CTOR_SESSION_ID || process.env.CODEX_SESSION_ID,
+  agent: process.env.BRICKS_CTOR_AGENT_ID || process.env.USER,
+})

package/tools/mcp-env.ts

@@ -0,0 +1,13 @@
+const truthyEnvValues = new Set(['1', 'true', 'yes', 'on'])
+
+export function isTruthyEnv(value: string | undefined) {
+  return truthyEnvValues.has(
+    String(value || '')
+      .trim()
+      .toLowerCase(),
+  )
+}
+
+export function shouldRegisterEditingTools(env: Record<string, string | undefined> = process.env) {
+  return isTruthyEnv(env.BRICKS_CTOR_ENABLE_EDITING_TOOLS)
+}

package/tools/mcp-server.ts

@@ -6,6 +6,9 @@ import { register as registerLottie } from './mcp-tools/lottie'
 import { register as registerIcons } from './mcp-tools/icons'
 import { register as registerHuggingface } from './mcp-tools/huggingface'
 import { register as registerMedia } from './mcp-tools/media'
+import { register as registerEntryEditing } from './mcp-tools/entry-editing'
+import { register as registerDataCalcEditing } from './mcp-tools/data-calc-editing'
+import { shouldRegisterEditingTools } from './mcp-env'
 
 const server = new McpServer({
   name: 'bricks-ctor',
@@ -24,5 +27,10 @@ registerIcons(server)
 registerHuggingface(server)
 registerMedia(server, projectDir)
 
+if (shouldRegisterEditingTools()) {
+  registerEntryEditing(server, projectDir)
+  registerDataCalcEditing(server, projectDir)
+}
+
 const transport = new StdioServerTransport()
 await server.connect(transport)

package/tools/mcp-tools/_verify.ts

@@ -0,0 +1,50 @@
+import { sh } from '../_shell'
+import { computeConfigChange, readBuildConfig, type ConfigChange } from '../../compile/config-diff'
+
+// Result of an editing tool's compile verification, carrying the config delta the
+// compile produced. Shared by entry-editing and data-calc-editing.
+export type VerificationResult = {
+  status: 'skipped' | 'compile:ok' | 'compile:failed'
+  errors: string[]
+  configChange?: ConfigChange
+}
+
+// Strip ANSI colors from the spawned compile so the captured output stays plain text.
+const noColorEnv = { FORCE_COLOR: '0', NO_COLOR: '1' }
+
+// Recompile the project and diff the result against the prior build artifact.
+export const compileAndDiff = async (projectDir: string): Promise<VerificationResult> => {
+  // Snapshot the prior compiled config before recompiling (the new artifact overwrites it).
+  const before = await readBuildConfig(projectDir)
+  try {
+    // Turn off the editing-tools audit for this spawned compile so compile() doesn't write
+    // a duplicate generic entry — the calling editing tool records its own richer entry.
+    await sh`bun compile`
+      .cwd(projectDir)
+      .env({ ...noColorEnv, BRICKS_CTOR_ENABLE_EDITING_TOOLS: '0' })
+      .text()
+  } catch (err: any) {
+    const stdout = err.stdout?.toString() ?? ''
+    const stderr = err.stderr?.toString() ?? ''
+    const output = [stdout, stderr, err.message].filter(Boolean).join('\n').trim()
+    return { status: 'compile:failed', errors: output ? [output] : ['bun compile failed'] }
+  }
+  const after = await readBuildConfig(projectDir)
+  return { status: 'compile:ok', errors: [], configChange: computeConfigChange(before, after) }
+}
+
+const shouldVerify = (inputVerify?: boolean) => {
+  if (inputVerify !== undefined) return inputVerify
+  const value = process.env.BRICKS_CTOR_MCP_EDIT_VERIFY ?? 'true'
+  return !['0', 'false', 'no', 'off'].includes(value.toLowerCase())
+}
+
+// Compile verification shared by the source-editing tools: per-call `verify` wins,
+// then the BRICKS_CTOR_MCP_EDIT_VERIFY env toggle, defaulting to on.
+export const verifyProject = async (
+  projectDir: string,
+  verify?: boolean,
+): Promise<VerificationResult> => {
+  if (!shouldVerify(verify)) return { status: 'skipped', errors: [] }
+  return compileAndDiff(projectDir)
+}

package/tools/mcp-tools/compile.ts

@@ -10,6 +10,8 @@ const noColorEnv = { FORCE_COLOR: '0', NO_COLOR: '1' }
 export function register(server: McpServer, projectDir: string) {
   const { dirname } = import.meta
 
+  // `bun compile` records the resulting config delta to `.bricks/edits.jsonl` itself
+  // (see compile() in compile/index.ts), so the spawned output below already reflects it.
   server.tool('compile', {}, async () => {
     let log = 'Type checking & Compiling...\n'
     try {