@dypai-ai/mcp 1.6.15 → 1.6.17

package/src/tools/project-deploy-production.js

@@ -0,0 +1,210 @@
+import { existsSync, readFileSync } from "fs"
+import { basename, dirname, join, resolve as resolvePath } from "path"
+import YAML from "yaml"
+import { deployFromSource } from "./deploy.js"
+import { proxyToolCall } from "./proxy.js"
+import { resolveOutDir } from "./sync/path-resolver.js"
+
+function resolveWorkspace({ workspace_root, sourceDirectory, root_dir } = {}) {
+  if (workspace_root) {
+    const workspaceRoot = resolvePath(workspace_root)
+    return { workspaceRoot, rootDir: resolvePath(workspaceRoot, "dypai"), source: "workspace_root" }
+  }
+  if (sourceDirectory) {
+    const workspaceRoot = resolvePath(sourceDirectory)
+    return { workspaceRoot, rootDir: resolvePath(workspaceRoot, "dypai"), source: "sourceDirectory" }
+  }
+  const resolved = resolveOutDir(root_dir || "./dypai")
+  const rootDir = resolved.path
+  const workspaceRoot = basename(rootDir) === "dypai" ? dirname(rootDir) : rootDir
+  return { workspaceRoot, rootDir, source: `root_dir:${resolved.source}` }
+}
+
+function readProjectIdFromConfig(rootDir) {
+  const configPath = join(rootDir, "dypai.config.yaml")
+  if (!existsSync(configPath)) return null
+  try {
+    const doc = YAML.parse(readFileSync(configPath, "utf8"))
+    return typeof doc?.project_id === "string" && doc.project_id.trim()
+      ? doc.project_id.trim()
+      : null
+  } catch {
+    return null
+  }
+}
+
+function draftCount(result) {
+  if (!result || result.error) return null
+  if (Number.isFinite(result.total)) return result.total
+  if (Array.isArray(result.drafts)) return result.drafts.length
+  if (Array.isArray(result.items)) return result.items.length
+  if (Array.isArray(result.resources)) return result.resources.length
+  return 0
+}
+
+function isSuccessful(result) {
+  return result && result.success !== false && !result.error
+}
+
+export const dypaiDeployProductionTool = {
+  name: "dypai_deploy_production",
+  description:
+    "PUBLISH PRODUCTION — make the saved DYPAI project live. Requires confirm:true. " +
+    "By default publishes/merges pending backend drafts first, then deploys the frontend to production. " +
+    "Use target:'backend' for backend-only Flow/Automation releases; use target:'frontend' only when backend drafts must stay pending. " +
+    "Use only after the user explicitly approves going live. For saving work without production, use dypai_push.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      project_id: {
+        type: "string",
+        description: "Project UUID. Auto-injected from dypai.config.yaml when omitted.",
+      },
+      workspace_root: {
+        type: "string",
+        description: "Absolute project root containing package.json and dypai/. Optional when cwd/env can resolve it.",
+      },
+      sourceDirectory: {
+        type: "string",
+        description: "Alias for workspace_root. Temporary: production frontend deploy still uses local source until the API supports deploying directly from Studio HEAD.",
+      },
+      root_dir: {
+        type: "string",
+        description: "Backend dypai/ folder used to infer workspace/project. Default ./dypai.",
+        default: "./dypai",
+      },
+      force: {
+        type: "boolean",
+        description: "Frontend only. Re-send all files even if the local manifest says nothing changed.",
+        default: false,
+      },
+      target: {
+        type: "string",
+        enum: ["all", "backend", "frontend"],
+        description: "What to publish. all = backend drafts + frontend production. backend = publish only pending backend drafts. frontend = deploy only frontend source.",
+        default: "all",
+      },
+      confirm: {
+        type: "boolean",
+        description: "Required true. This publishes production/live.",
+        default: false,
+      },
+    },
+    required: ["confirm"],
+  },
+
+  async execute({ project_id, workspace_root, sourceDirectory, root_dir = "./dypai", force = false, target = "all", confirm = false } = {}) {
+    const { workspaceRoot, rootDir, source } = resolveWorkspace({ workspace_root, sourceDirectory, root_dir })
+    const targetProjectId = project_id || readProjectIdFromConfig(rootDir)
+    const publishTarget = ["all", "backend", "frontend"].includes(target) ? target : "all"
+    const publishBackend = publishTarget === "all" || publishTarget === "backend"
+    const deployFrontend = publishTarget === "all" || publishTarget === "frontend"
+
+    if (confirm !== true) {
+      return {
+        confirmation_required: true,
+        live_changed: false,
+        summary:
+          publishTarget === "backend"
+            ? "This will publish pending backend drafts to PRODUCTION without deploying frontend. Get explicit user approval, then call again with confirm:true."
+            : publishTarget === "frontend"
+              ? "This will deploy the frontend to PRODUCTION without publishing pending backend drafts. Get explicit user approval, then call again with confirm:true."
+              : "This will publish pending backend drafts and deploy the frontend to PRODUCTION. Get explicit user approval, then call again with confirm:true.",
+        next_call: {
+          tool: "dypai_deploy_production",
+          ...(targetProjectId ? { project_id: targetProjectId } : {}),
+          workspace_root: workspaceRoot,
+          ...(force ? { force: true } : {}),
+          ...(publishTarget !== "all" ? { target: publishTarget } : {}),
+          confirm: true,
+        },
+      }
+    }
+
+    if (!targetProjectId) {
+      return {
+        success: false,
+        error: "project_id is required. Pass project_id or run from a workspace containing dypai/dypai.config.yaml.",
+        workspace_root: workspaceRoot,
+        root_dir: rootDir,
+        resolved_via: source,
+        live_changed: false,
+      }
+    }
+
+    let pendingDrafts = 0
+    let backend = {
+      skipped: true,
+      reason: publishBackend ? "no_pending_drafts" : "target_frontend",
+      pending_drafts: 0,
+    }
+
+    if (publishBackend) {
+      const draftsList = await proxyToolCall("manage_drafts", {
+        project_id: targetProjectId,
+        operation: "list",
+      })
+      pendingDrafts = draftCount(draftsList)
+      if (pendingDrafts == null) {
+        return {
+          success: false,
+          phase: "list_backend_drafts",
+          target: publishTarget,
+          backend: draftsList,
+          frontend: { skipped: true, reason: "could_not_list_backend_drafts" },
+          live_changed: false,
+        }
+      }
+
+      if (pendingDrafts > 0) {
+        backend = await proxyToolCall("manage_drafts", {
+          project_id: targetProjectId,
+          operation: "publish",
+          confirm: true,
+        })
+        if (!isSuccessful(backend)) {
+          return {
+            success: false,
+            phase: "publish_backend_drafts",
+            target: publishTarget,
+            backend,
+            frontend: { skipped: true, reason: "backend_publish_failed" },
+            live_changed: false,
+          }
+        }
+      }
+    }
+
+    let frontend = {
+      skipped: true,
+      reason: deployFrontend ? "no_local_package_json" : "target_backend",
+      note: deployFrontend
+        ? "Temporary limitation: frontend production deploy currently needs local sourceDirectory/workspace_root. API deploy-from-Studio-HEAD is the next backend change."
+        : undefined,
+    }
+    if (deployFrontend && existsSync(join(workspaceRoot, "package.json"))) {
+      frontend = await deployFromSource({
+        sourceDirectory: workspaceRoot,
+        project_id: targetProjectId,
+        force: !!force,
+        target: "both",
+      })
+    }
+
+    const frontendOk = frontend.skipped === true || isSuccessful(frontend)
+    return {
+      success: frontendOk,
+      project_id: targetProjectId,
+      workspace_root: workspaceRoot,
+      target: publishTarget,
+      backend,
+      frontend,
+      backend_published: pendingDrafts > 0 && isSuccessful(backend),
+      frontend_deploy_queued: frontendOk && frontend.skipped !== true,
+      live_changed: frontendOk && (pendingDrafts > 0 || frontend.skipped !== true),
+      next_step: frontendOk && frontend.skipped !== true
+        ? "Production deploy was queued. Check the production URL/build status until the build reaches success or failure."
+        : undefined,
+    }
+  },
+}

package/src/tools/project-push.js

@@ -0,0 +1,221 @@
+import { existsSync, readFileSync } from "fs"
+import { basename, dirname, join, resolve as resolvePath } from "path"
+import YAML from "yaml"
+import { deployFromSource } from "./deploy.js"
+import { dypaiPushTool as backendPushTool } from "./sync/push.js"
+import { resolveOutDir } from "./sync/path-resolver.js"
+
+function resolveWorkspace({ workspace_root, sourceDirectory, root_dir } = {}) {
+  if (workspace_root) {
+    const workspaceRoot = resolvePath(workspace_root)
+    return {
+      workspaceRoot,
+      rootDir: resolvePath(workspaceRoot, "dypai"),
+      source: "workspace_root",
+    }
+  }
+
+  if (sourceDirectory) {
+    const workspaceRoot = resolvePath(sourceDirectory)
+    return {
+      workspaceRoot,
+      rootDir: resolvePath(workspaceRoot, "dypai"),
+      source: "sourceDirectory",
+    }
+  }
+
+  const resolved = resolveOutDir(root_dir || "./dypai")
+  const rootDir = resolved.path
+  const workspaceRoot = basename(rootDir) === "dypai" ? dirname(rootDir) : rootDir
+  return { workspaceRoot, rootDir, source: `root_dir:${resolved.source}` }
+}
+
+function isSuccessful(result) {
+  return result && result.success !== false && !result.error
+}
+
+function sanitizeLegacyShipText(value) {
+  if (typeof value === "string") {
+    return value
+      .replace(/\bmanage_frontend\b/g, "dypai_push")
+      .replace(/Frontend code is not affected[^.]*\./g, "Frontend source is saved by the project-level dypai_push wrapper.")
+  }
+  if (Array.isArray(value)) return value.map(sanitizeLegacyShipText)
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, nested]) => [key, sanitizeLegacyShipText(nested)]),
+    )
+  }
+  return value
+}
+
+function readProjectIdFromConfig(rootDir) {
+  const configPath = join(rootDir, "dypai.config.yaml")
+  if (!existsSync(configPath)) return null
+  try {
+    const doc = YAML.parse(readFileSync(configPath, "utf8"))
+    return typeof doc?.project_id === "string" && doc.project_id.trim()
+      ? doc.project_id.trim()
+      : null
+  } catch {
+    return null
+  }
+}
+
+export const dypaiPushProjectTool = {
+  name: "dypai_push",
+  description:
+    "SAVE CHANGES — push all local DYPAI project changes to Studio/DYPAI without publishing production. " +
+    "Backend files under dypai/ are staged as drafts. Frontend files under src/, public/, package.json, and versionable dypai/ source are saved to the Studio branch. " +
+    "Production is never changed by this tool. Use dypai_deploy_production(confirm:true) after explicit user approval to publish live.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      project_id: {
+        type: "string",
+        description: "Project UUID. Auto-injected from dypai.config.yaml when omitted.",
+      },
+      workspace_root: {
+        type: "string",
+        description: "Absolute project root containing package.json and/or dypai/. Optional; inferred from root_dir/cwd when omitted.",
+      },
+      sourceDirectory: {
+        type: "string",
+        description: "Alias for workspace_root, kept for compatibility with older frontend calls.",
+      },
+      root_dir: {
+        type: "string",
+        description: "Backend dypai/ folder. Default ./dypai. Prefer workspace_root for new calls.",
+        default: "./dypai",
+      },
+      delete_orphans: {
+        type: "boolean",
+        description: "Backend only. If true, endpoints in remote but missing locally get deleted as drafts. Default: false.",
+        default: false,
+      },
+      dry_run: {
+        type: "boolean",
+        description: "If true, computes backend plan and does not write backend or frontend.",
+        default: false,
+      },
+      force: {
+        type: "boolean",
+        description: "Backend conflict override and frontend full save. Use only when needed. Default: false.",
+        default: false,
+      },
+      skip_validation: {
+        type: "boolean",
+        description: "Backend only. Skip dypai_validate pre-flight. Default: false.",
+        default: false,
+      },
+      save_frontend: {
+        type: "boolean",
+        description: "If false, only pushes backend drafts. Default: true.",
+        default: true,
+      },
+    },
+    required: [],
+  },
+
+  async execute({
+    project_id,
+    workspace_root,
+    sourceDirectory,
+    root_dir = "./dypai",
+    delete_orphans = false,
+    dry_run = false,
+    force = false,
+    skip_validation = false,
+    save_frontend = true,
+  } = {}) {
+    const { workspaceRoot, rootDir, source } = resolveWorkspace({ workspace_root, sourceDirectory, root_dir })
+    const targetProjectId = project_id || readProjectIdFromConfig(rootDir)
+    const hasBackend = existsSync(rootDir)
+    const hasFrontend = existsSync(join(workspaceRoot, "package.json"))
+
+    if (!hasBackend && !hasFrontend) {
+      return {
+        success: false,
+        error: "No DYPAI project source found. Expected package.json and/or dypai/.",
+        workspace_root: workspaceRoot,
+        root_dir: rootDir,
+        resolved_via: source,
+      }
+    }
+    if (!targetProjectId) {
+      return {
+        success: false,
+        error: "project_id is required. Pass project_id or run from a workspace containing dypai/dypai.config.yaml.",
+        workspace_root: workspaceRoot,
+        root_dir: rootDir,
+        resolved_via: source,
+      }
+    }
+
+    let backend = {
+      skipped: true,
+      reason: hasBackend ? "dry_run_or_disabled" : "no_dypai_folder",
+    }
+
+    if (hasBackend) {
+      backend = sanitizeLegacyShipText(await backendPushTool.execute({
+        project_id: targetProjectId,
+        root_dir: rootDir,
+        delete_orphans,
+        dry_run,
+        force,
+        skip_validation,
+      }))
+    }
+
+    if (!isSuccessful(backend)) {
+      return {
+        success: false,
+        phase: "backend_push",
+        workspace_root: workspaceRoot,
+        root_dir: rootDir,
+        backend,
+        frontend: {
+          skipped: true,
+          reason: "backend_push_failed",
+        },
+        live_changed: false,
+      }
+    }
+
+    let frontend = {
+      skipped: true,
+      reason: dry_run
+        ? "dry_run"
+        : !save_frontend
+          ? "save_frontend_false"
+          : hasFrontend
+            ? "not_run"
+            : "no_package_json",
+    }
+
+    if (!dry_run && save_frontend && hasFrontend) {
+      frontend = await deployFromSource({
+        sourceDirectory: workspaceRoot,
+        project_id: targetProjectId,
+        force: !!force,
+        target: "studio",
+      })
+    }
+
+    const frontendOk = frontend.skipped === true || isSuccessful(frontend)
+    return {
+      success: frontendOk,
+      workspace_root: workspaceRoot,
+      root_dir: rootDir,
+      backend,
+      frontend,
+      backend_saved: hasBackend && isSuccessful(backend),
+      frontend_saved: hasFrontend && frontendOk && frontend.skipped !== true,
+      live_changed: false,
+      next_step: frontendOk
+        ? "Changes are saved to Studio/DYPAI. Test the preview. To publish live, use dypai_deploy_production(confirm:true) after explicit user approval."
+        : "Frontend save failed. Fix the frontend/source issue and run dypai_push again.",
+    }
+  },
+}

package/src/tools/sql-guard.js

@@ -129,7 +129,7 @@ export function validateSql(sql, opts = {}) {
               : schema === "storage"
                 ? "To manage files, use manage_storage. Read-only SELECTs against storage.* are allowed."
                 : schema === "system"
-                  ? "To manage endpoints, use dypai_push / manage_drafts / manage_users / manage_roles. Read-only SELECTs against system.* are allowed."
+                  ? "To manage endpoints, use dypai_push / dypai_deploy_production / manage_users / manage_roles. Read-only SELECTs against system.* are allowed."
                   : "Read-only SELECTs against this schema are allowed.",
         }
       }

package/src/tools/sync/diff.js

@@ -1,26 +1,13 @@
-/**
- * dypai_diff — preview what dypai_push would change. Read-only, safe.
- *
- * The picture has THREE layers, not two:
- *   - LOCAL  : what's on disk in dypai/
- *   - DRAFT  : what's already been staged via prior pushes (system.config_drafts)
- *   - LIVE   : what the engine actually serves at <project_id>.dypai.dev
- *
- * The diff body reports LOCAL → EFFECTIVE_REMOTE (live + pending drafts) —
- * what `dypai_push` will actually queue. We additionally surface the DRAFT
- * layer metadata so the agent can spot overlap and publish/discard decisions.
- */
-
 import { resolve as resolvePath } from "path"
-import { fetchRemoteState, readLocalEffectiveState, readLocalStateSnapshot, readLocalConfig, computePlan, buildEffectiveRemoteState } from "./planner.js"
-import { proxyToolCall } from "../proxy.js"
+import { readLocalConfig } from "./planner.js"
+import { diffBackendSource } from "./source-diff.js"
 
 export const dypaiDiffTool = {
   name: "dypai_diff",
   description:
-    "Compare the local ./dypai/ folder against the remote project state without applying anything. " +
-    "Returns a plan: endpoints to create, update (with changed fields), delete, and unchanged. " +
-    "Always call this before dypai_push to preview changes safely.",
+    "Fast source diff for the local ./dypai/ folder. " +
+    "It does not compile, call remote services, or stage changes. " +
+    "Use dypai_push to compile, validate, save backend drafts, and regenerate types.",
   inputSchema: {
     type: "object",
     properties: {
@@ -35,138 +22,49 @@ export const dypaiDiffTool = {
       },
       delete_orphans: {
         type: "boolean",
-        description: "If true, endpoints present in remote but missing locally are queued for deletion. Default: false (safe).",
+        description: "Ignored by dypai_diff. Deletions are only applied by dypai_push when explicitly requested.",
         default: false,
       },
     },
   },
 
-  async execute({ project_id, root_dir = "./dypai", delete_orphans = false } = {}) {
+  async execute({ project_id, root_dir = "./dypai" } = {}) {
     const rootDir = resolvePath(process.cwd(), root_dir)
 
     const config = await readLocalConfig(rootDir)
     const targetProjectId = project_id || config?.project_id || null
+    const diff = await diffBackendSource(rootDir)
 
-    const [local, remote, stateSnapshot, draftsResult] = await Promise.all([
-      readLocalEffectiveState(rootDir, targetProjectId),
-      fetchRemoteState(targetProjectId),
-      readLocalStateSnapshot(rootDir),
-      // Pending drafts. Cheap on dev (always 0); on prod surfaces what's
-      // already staged so the agent can reason about overlap with the local
-      // change set. Old engines without the drafts API silently fall back.
-      proxyToolCall("manage_drafts", targetProjectId
-        ? { project_id: targetProjectId, operation: "list" }
-        : { operation: "list" }
-      ).catch(() => ({ total: 0, drafts: [], _unavailable: true })),
-    ])
-
-    if (local.errors.length) {
-      return {
-        success: false,
-        phase: "read_local",
-        errors: local.errors,
-        hint: "Fix the YAML/file errors before running diff again.",
-      }
-    }
-
-    if (!remote || !remote.mapsCtx) {
+    if (!diff.ok) {
       return {
         success: false,
-        phase: "fetch_remote",
-        error: "Remote state could not be fetched (mapsCtx missing). Check your DYPAI_TOKEN and project_id.",
+        phase: "source_diff",
+        reason: diff.reason,
+        error: diff.error,
+        hint: "Fix the local dypai/.dypai/backend-baseline.json or run dypai_pull/sync again.",
       }
     }
 
-    const effectiveRemote = buildEffectiveRemoteState(remote, draftsResult)
-    const plan = computePlan(local, effectiveRemote, remote.mapsCtx, {
-      deleteOrphans: delete_orphans,
-      stateSnapshot,
-      liveRemote: remote,
-    })
-
-    const groupChanges = (plan.groups?.create?.length || 0) + (plan.groups?.delete?.length || 0)
-    const totalChanges = plan.create.length + plan.update.length + plan.delete.length + groupChanges
-    const hasConflicts = (plan.warnings || []).some(w => w.type === "remote_changed_since_pull")
-
-    // ─── Drafts overlay ───────────────────────────────────────────────────
-    // Build a `pending_drafts` view that tells the agent what's already
-    // staged AND highlights the overlap with this diff's local-change set.
-    // The overlap is the agent-relevant signal: same endpoint touched on
-    // BOTH sides means pushing now will overwrite the existing draft.
-    const draftItems = Array.isArray(draftsResult?.drafts) ? draftsResult.drafts : []
-    const draftCount = draftsResult?.total || 0
-
-    const localChangeNames = new Set([
-      ...plan.create.map(p => p.name),
-      ...plan.update.map(p => p.name),
-      ...plan.delete.map(p => p.name),
-    ])
-
-    const overlap = draftItems
-      .filter(d => d.resource_type === "endpoint" && localChangeNames.has(d.resource_name))
-      .map(d => ({
-        endpoint: d.resource_name,
-        existing_draft_op: d.op,
-        local_change_op: plan.create.find(p => p.name === d.resource_name) ? "create"
-          : plan.update.find(p => p.name === d.resource_name) ? "update"
-          : "delete",
-      }))
-
-    const pendingDrafts = draftCount > 0 ? {
-      total: draftCount,
-      counts_by_type: draftsResult?.counts_by_type || {},
-      items: draftItems
-        .map(d => ({
-          resource_type: d.resource_type,
-          resource_name: d.resource_name,
-          op: d.op,
-        }))
-        .sort((a, b) => (a.resource_name || "").localeCompare(b.resource_name || "")),
-      // Endpoints that are BOTH staged AND modified locally — pushing again
-      // replaces the existing draft. Empty array = no overlap (clean signal).
-      overlap_with_local: overlap,
-    } : null
-
-    // ─── Hint priority ────────────────────────────────────────────────────
-    // 1. Conflicts and missing creds always win (block push).
-    // 2. Overlap is next: explicitly tell the agent that re-push overwrites.
-    // 3. Pending drafts (no overlap): suggest publishing or discarding before
-    //    stacking more on top.
-    const hint = hasConflicts
-      ? "Remote changed since your last pull — dypai_pull first, or dypai_push will be blocked."
-      : (plan.warnings || []).some(w => w.type === "missing_credential")
-        ? "Some YAMLs reference credentials missing remotely. Create them in the dashboard before pushing."
-        : overlap.length > 0
-          ? `${overlap.length} endpoint(s) have BOTH a pending draft AND a local change — dypai_push will REPLACE the existing draft with the new version. Review pending_drafts.overlap_with_local before pushing.`
-        : totalChanges === 0 && draftCount > 0
-          ? `${draftCount} pending draft(s) — local matches what's already staged. Test with dypai_test_endpoint(mode:'draft'), then manage_drafts(operation:'publish', confirm:true) when ready.`
-          : draftCount > 0 && totalChanges > 0
-            ? `${draftCount} draft(s) already pending; this diff would queue ${totalChanges} more. Consider manage_drafts(operation:'publish'|'discard', confirm:true) first to keep the staged set focused.`
-            : draftCount > 0
-              ? `${draftCount} pending draft(s) — no local changes to push. Run manage_drafts(operation:'list') to review, then 'publish' (confirm:true) or 'discard' (confirm:true).`
-              : undefined
+    const totalChanges = diff.summary.create + diff.summary.update + diff.summary.delete
 
     return {
       success: true,
+      mode: "source",
+      project_id: targetProjectId,
+      baseline: diff.baseline,
       summary: {
-        create: plan.create.length,
-        update: plan.update.length,
-        delete: plan.delete.length,
-        unchanged: plan.unchanged.length,
-        orphans_ignored: plan.orphansIgnored?.length || 0,
-        groups_create: plan.groups?.create?.length || 0,
-        groups_delete: plan.groups?.delete?.length || 0,
-        groups_unchanged: plan.groups?.unchanged?.length || 0,
-        warnings: plan.warnings?.length || 0,
-        pending_drafts: draftCount,
-        drafts_overlap_with_local: overlap.length,
+        create: diff.summary.create,
+        update: diff.summary.update,
+        delete: diff.summary.delete,
+        unchanged: diff.summary.unchanged,
       },
-      // Only include plan details when there are actual changes or warnings
-      plan: (totalChanges > 0 || plan.warnings?.length) ? plan : undefined,
-      // Always present so the agent knows the key exists. `null` = nothing
-      // staged (cleaner signal than omitted-or-zero ambiguity).
-      pending_drafts: pendingDrafts,
-      hint,
+      source_changes: totalChanges > 0 ? diff.files : undefined,
+      requires_push: totalChanges > 0,
+      requires_compile: totalChanges > 0,
+      pending_drafts: null,
+      hint: totalChanges > 0
+        ? "Local backend source changed. Run dypai_push to compile, validate, save preview drafts, and regenerate types."
+        : "No local backend source changes. Nothing to push.",
     }
   },
 }

package/src/tools/sync/planner.js

@@ -40,6 +40,15 @@ function parseMaybeJson(v) {
   try { return JSON.parse(v) } catch { return v }
 }
 
+function isBackendSourcePath(path) {
+  if (typeof path !== "string") return false
+  return (
+    (path.startsWith("dypai/flows/") && /\.flow\.ts$/i.test(path)) ||
+    (path.startsWith("dypai/automations/") && /\.automation\.ts$/i.test(path)) ||
+    (path.startsWith("dypai/endpoints/") && /\.(ya?ml)$/i.test(path))
+  )
+}
+
 function hydrateRow(row) {
   return {
     ...row,
@@ -453,6 +462,7 @@ export async function readLocalEffectiveState(rootDir, projectId = null, deps =
 
   const payloads = Array.isArray(bulkResult.data?.payloads) ? bulkResult.data.payloads : []
   const diagnostics = Array.isArray(bulkResult.data?.diagnostics) ? bulkResult.data.diagnostics : []
+  const rejected = Array.isArray(bulkResult.data?.rejected) ? bulkResult.data.rejected : []
   const byName = {}
   const shadowed = []
   const flowNames = new Set()
@@ -484,12 +494,21 @@ export async function readLocalEffectiveState(rootDir, projectId = null, deps =
     })
   }
 
+  for (const item of rejected) {
+    if (!isBackendSourcePath(item?.path)) continue
+    yamlState.errors.push({
+      file: item.path,
+      error: `Backend compiler rejected source file: ${item.reason || "rejected"}`,
+      rule: "backend_compiler_rejected_source",
+    })
+  }
+
   for (const [name, entry] of Object.entries(yamlState.byName)) {
     if (flowNames.has(name)) continue
     byName[name] = { ...entry, source: "legacy-yaml" }
   }
 
-  return { byName, errors: yamlState.errors, shadowed, runnerWarning: null }
+  return { byName, errors: yamlState.errors, shadowed, runnerWarning: null, automations: bulkResult.data?.automations ?? null }
 }
 
 // ─── Normalization + diff ──────────────────────────────────────────────────