@fugood/bricks-project 2.25.0-beta.41 → 2.25.0-beta.43

package/compile/config-diff.ts

@@ -0,0 +1,108 @@
+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
+  }
+}
+
+export const summarizeConfigChange = (change: ConfigChange): string => {
+  if (change.status === 'no_baseline') return 'config change: no prior build to compare'
+  if (change.status === 'unavailable') return 'config change: build artifact unavailable'
+  return change.opCount === 0 ? 'config change: none' : `config change: ${change.opCount} op(s)`
+}

package/compile/index.ts

@@ -8,8 +8,10 @@ import type { ExportNamedDeclaration, FunctionDeclaration } from 'acorn'
 import escodegen from 'escodegen'
 import { makeId } from '../utils/id'
 import { generateCalulationMap } from './util'
+import { computeConfigChange, readBuildConfig, summarizeConfigChange } from './config-diff'
 import { templateActionNameMap } from './action-name-map'
 import { templateEventPropsMap } from '../utils/event-props'
+import { sh } from '../tools/_shell'
 import type {
   Application,
   Data,
@@ -700,8 +702,25 @@ const compileAutomation = (automationMap: AutomationMap) =>
     }),
   )
 
+// Print the minimal config delta vs the previous `bun compile` artifact (volatile
+// timestamp fields excluded). Silent when there is no prior build to compare, so
+// direct compile() callers (tests, tooling outside a project) emit nothing.
+const reportConfigChange = (previousConfig: unknown, config: unknown) => {
+  if (previousConfig == null) 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
+  console.log(summarizeConfigChange(change))
+  if (change.opCount > 0) console.log(JSON.stringify(change.ops, null, 2))
+}
+
 export const compile = async (app: Application) => {
   await new Promise((resolve) => setImmediate(resolve, 0))
+  // Snapshot the previous build artifact before the caller's compile.ts overwrites it,
+  // so the config change introduced by this compile can be reported 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))
@@ -1456,12 +1475,15 @@ export const compile = async (app: Application) => {
     automation_map: compiledAutomationMap || app.metadata?.TEMP_automation_map || {},
     update_timestamp: timestamp,
   }
+  reportConfigChange(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/package.json

@@ -1,13 +1,17 @@
 {
   "name": "@fugood/bricks-project",
-  "version": "2.25.0-beta.41",
+  "version": "2.25.0-beta.43",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "build": "bun scripts/build.js"
   },
   "dependencies": {
-    "@fugood/bricks-cli": "^2.25.0-beta.41",
+    "@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.43",
     "@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.41",
+  "version": "2.25.0-beta.43",
   "main": "index.ts",
   "scripts": {
     "typecheck": "tsc --noEmit",
     "build": "bun scripts/build.js"
   },
   "dependencies": {
-    "@fugood/bricks-cli": "^2.25.0-beta.41",
+    "@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.43",
     "@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-design/SKILL.md

@@ -1,30 +1,20 @@
 ---
 name: bricks-design
 description: >-
-  Visual design discipline for Applications and Subspaces — type,
-  palette, asset acquisition, design language, system commitment,
-  visual rhythm, brand. TRIGGER for visual / aesthetic / system /
-  style / brand-asset work even when the user names the surface in
-  product terms — slideshow / pitch deck / introduction / explainer
-  / storyboard; kiosk / signage / menu board / lobby / reception /
-  wayfinding / retail / hospitality / museum / transit; translate /
-  port / rebuild from Figma / HTML / screenshot / website / PDF /
-  brand book; vague creative brief ("design something for the
-  lobby"); branded scene work; iteration on existing Subspace
-  (rework, redesign, audit visual system, tighten the type / palette
-  / motion / rhythm). For end-to-end briefs (kiosk, dashboard,
-  interactive screen) this skill invokes in parallel with bricks-ux,
-  which carries the interaction / flow / usability layer. SKIP for
-  pure usability / flow / journey / affordance / feedback / recovery
-  / accessibility / multilingual audits — those go to bricks-ux. SKIP
-  for single-Brick or Generator template work
-  (create-brick-or-generator), debugging or refactoring with no
-  design intent, or non-display deliverables (CLI, server, tooling).
-  Encodes architecture truths, performance and complexity guardrails,
-  input-translation rules, visual languages library, Direction
-  Advisor for vague briefs, Media Flow protocol for branded work.
-  Verification toolchain (compile, preview tool selection, on-device DevTools,
-  Path 1/2/3) lives in the bricks-ctor skill.
+  Visual design discipline for Applications and Subspaces — type, palette, asset
+  acquisition, design language, system commitment, visual rhythm, brand. TRIGGER
+  for visual / aesthetic / system / style / brand-asset work even when named in
+  product terms — slideshow, pitch deck, explainer, kiosk, signage, menu board,
+  lobby, wayfinding, retail, museum, transit; translate or rebuild from Figma /
+  HTML / screenshot / website / PDF / brand book; vague creative briefs; branded
+  scenes; rework or audit of an existing Subspace's type / palette / motion /
+  rhythm. For end-to-end briefs invoke in parallel with bricks-ux (interaction /
+  flow layer). SKIP for pure usability / flow / accessibility audits (bricks-
+  ux), single-Brick or Generator template work (create-brick-or-generator),
+  debugging without design intent, or non-display deliverables. Encodes
+  architecture truths, performance guardrails, input-translation rules, visual
+  languages, Direction Advisor, Media Flow protocol; verification toolchain
+  lives in bricks-ctor.
 ---
 
 # BRICKS Design

package/skills/bricks-ux/SKILL.md

@@ -1,26 +1,20 @@
 ---
 name: bricks-ux
 description: >-
-  Interaction design and end-user experience for any Application or
-  Subspace built on Canvases, Bricks, Generators, Data, DataCalculation.
-  TRIGGER on usability / flow / interaction / journey / state /
-  affordance / feedback / recovery / accessibility audits and design
-  work — "audit this flow", "improve usability", "design the wait
-  state", "fix the error path", "make the kiosk usable", "what does the
-  user do when X breaks", "design the QR scan UX", "design the payment
-  flow", "design the mic / listening state", "design the monitor's
-  alarm state", "design for multilingual", "design for low vision",
-  "design idle and attractor states". Also triggers in parallel with
-  visual-design work for end-to-end deliverables (kiosk / signage /
-  dashboard / interactive screen / pitch deck) where the interaction
-  shape matters as much as the look. SKIP for purely visual / aesthetic
-  / system / style / brand-asset / typography / palette work — those
-  are visual design, not interaction design. Encodes a universal
-  user-journey spine, interaction archetypes, pressable composition,
-  monitoring-screen discipline, designed flow states, accessibility,
-  and a tiered UX critique. Hardware floors are deployment-relative;
-  web habits (hover affordances, modal-as-default, scroll, page-submit
-  forms) do not transfer.
+  Interaction design and end-user experience for any Application or Subspace
+  built on Canvases, Bricks, Generators, Data, DataCalculation. TRIGGER on
+  usability / flow / interaction / journey / state / affordance / feedback /
+  recovery / accessibility audits and design work — "audit this flow", "improve
+  usability", "design the wait state", "make the kiosk usable", "design the
+  payment flow", "design idle and attractor states", "design for multilingual /
+  low vision". Also triggers in parallel with visual-design work for end-to-end
+  deliverables (kiosk, signage, dashboard, interactive screen, pitch deck) where
+  interaction shape matters as much as look. SKIP for purely visual / aesthetic
+  / style / brand-asset / typography / palette work — that is bricks-design.
+  Encodes a universal user-journey spine, interaction archetypes, pressable
+  composition, monitoring-screen discipline, designed flow states,
+  accessibility, tiered UX critique; hardware floors are deployment-relative and
+  web habits do not transfer.
 ---
 
 # BRICKS UX

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_MCP_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,45 @@
+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 {
+    await sh`bun compile`.cwd(projectDir).env(noColorEnv).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

@@ -11,6 +11,8 @@ export function register(server: McpServer, projectDir: string) {
   const { dirname } = import.meta
 
   server.tool('compile', {}, async () => {
+    // The config-change report is printed by compile() itself (compile/config-diff.ts),
+    // so the spawned `bun compile` output below already carries it.
     let log = 'Type checking & Compiling...\n'
     try {
       log += await sh`bun compile`.cwd(projectDir).env(noColorEnv).text()