@dypai-ai/mcp 1.6.16 → 1.6.18

package/src/tools/frontend.js

@@ -14,11 +14,45 @@ import { deployFromSource } from "./deploy.js"
 import { syncFromRemote } from "./sync.js"
 import { proxyToolCall } from "./proxy.js"
 
+function isSuccessful(result) {
+  return result && result.success !== false && !result.error
+}
+
+export async function pullProjectSource({
+  project_id,
+  targetDirectory,
+  overwrite,
+  source_ref,
+} = {}, deps = {}) {
+  const syncSource = deps.syncFromRemote ?? syncFromRemote
+
+  const source = await syncSource({
+    project_id,
+    targetDirectory,
+    overwrite: !!overwrite,
+    source_ref: source_ref || undefined,
+  })
+
+  if (!isSuccessful(source)) {
+    return {
+      ...source,
+      source_sync: "failed",
+    }
+  }
+
+  return {
+    ...source,
+    source_files_written: source.files_written,
+    source_sync: "success",
+  }
+}
+
 export const dypaiPullTool = {
   name: "dypai_pull",
   description:
-    "NORMAL FIRST STEP — pull/sync the editable DYPAI project source from Git/Studio into a local workspace. " +
-    "This downloads the Studio source branch (src/, package.json, public/, and committed dypai/ such as flows/types/lib). " +
+    "NORMAL FIRST STEP — pull/sync the editable DYPAI project source into a local workspace. " +
+    "This downloads the Studio source branch (src/, package.json, public/, committed dypai/ source). " +
+    "It does not recreate endpoints from platform metadata: Git/Studio source is authoritative. " +
     "Use this when starting work on an existing project or after create_project. " +
     "This is a safe local download: it preserves local-only files like .env, node_modules, and .vscode.",
   inputSchema: {
@@ -51,11 +85,11 @@ export const dypaiPullTool = {
     if (!targetDirectory) {
       return { success: false, error: "targetDirectory is required (absolute path where the source will be written)." }
     }
-    return await syncFromRemote({
+    return await pullProjectSource({
       project_id,
       targetDirectory,
-      overwrite: !!overwrite,
-      source_ref: source_ref || undefined,
+      overwrite,
+      source_ref,
     })
   },
 }
@@ -229,11 +263,11 @@ export const manageFrontendTool = {
           if (!targetDirectory) {
             return { success: false, error: "operation 'sync' requires 'targetDirectory' (absolute path where the source will be written)." }
           }
-          return await syncFromRemote({
+          return await pullProjectSource({
             project_id,
             targetDirectory,
-            overwrite: !!overwrite,
-            source_ref: source_ref || undefined,
+            overwrite,
+            source_ref,
           })
 
         case "status":

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

@@ -50,7 +50,8 @@ export const dypaiDeployProductionTool = {
   name: "dypai_deploy_production",
   description:
     "PUBLISH PRODUCTION — make the saved DYPAI project live. Requires confirm:true. " +
-    "Publishes/merges pending backend drafts first, then deploys the frontend to production. " +
+    "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",
@@ -77,6 +78,12 @@ export const dypaiDeployProductionTool = {
         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.",
@@ -86,22 +93,29 @@ export const dypaiDeployProductionTool = {
     required: ["confirm"],
   },
 
-  async execute({ project_id, workspace_root, sourceDirectory, root_dir = "./dypai", force = false, confirm = false } = {}) {
+  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:
-          "This will publish pending backend drafts and deploy the frontend to PRODUCTION. " +
-          "Get explicit user approval, then call again with confirm:true.",
+          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,
         },
       }
@@ -118,49 +132,57 @@ export const dypaiDeployProductionTool = {
       }
     }
 
-    const draftsList = await proxyToolCall("manage_drafts", {
-      project_id: targetProjectId,
-      operation: "list",
-    })
-    const pendingDrafts = draftCount(draftsList)
-    if (pendingDrafts == null) {
-      return {
-        success: false,
-        phase: "list_backend_drafts",
-        backend: draftsList,
-        frontend: { skipped: true, reason: "could_not_list_backend_drafts" },
-        live_changed: false,
-      }
-    }
-
+    let pendingDrafts = 0
     let backend = {
       skipped: true,
-      reason: "no_pending_drafts",
+      reason: publishBackend ? "no_pending_drafts" : "target_frontend",
       pending_drafts: 0,
     }
-    if (pendingDrafts > 0) {
-      backend = await proxyToolCall("manage_drafts", {
+
+    if (publishBackend) {
+      const draftsList = await proxyToolCall("manage_drafts", {
         project_id: targetProjectId,
-        operation: "publish",
-        confirm: true,
+        operation: "list",
       })
-      if (!isSuccessful(backend)) {
+      pendingDrafts = draftCount(draftsList)
+      if (pendingDrafts == null) {
         return {
           success: false,
-          phase: "publish_backend_drafts",
-          backend,
-          frontend: { skipped: true, reason: "backend_publish_failed" },
+          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: "no_local_package_json",
-      note: "Temporary limitation: frontend production deploy currently needs local sourceDirectory/workspace_root. API deploy-from-Studio-HEAD is the next backend change.",
+      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 (existsSync(join(workspaceRoot, "package.json"))) {
+    if (deployFrontend && existsSync(join(workspaceRoot, "package.json"))) {
       frontend = await deployFromSource({
         sourceDirectory: workspaceRoot,
         project_id: targetProjectId,
@@ -174,6 +196,7 @@ export const dypaiDeployProductionTool = {
       success: frontendOk,
       project_id: targetProjectId,
       workspace_root: workspaceRoot,
+      target: publishTarget,
       backend,
       frontend,
       backend_published: pendingDrafts > 0 && isSuccessful(backend),

package/src/tools/project-push.js

@@ -37,11 +37,6 @@ function isSuccessful(result) {
 function sanitizeLegacyShipText(value) {
   if (typeof value === "string") {
     return value
-      .replace(/manage_drafts\(operation:'publish', confirm:true\)/g, "dypai_deploy_production(confirm:true)")
-      .replace(/manage_drafts\(operation:"publish", confirm:true\)/g, "dypai_deploy_production(confirm:true)")
-      .replace(/manage_drafts\(operation:'list'\)/g, "dypai_diff or dypai_test_endpoint(mode:'draft')")
-      .replace(/manage_drafts\(operation:"list"\)/g, "dypai_diff or dypai_test_endpoint(mode:'draft')")
-      .replace(/\bmanage_drafts\b/g, "dypai_deploy_production")
       .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.")
   }

package/src/tools/storage.js

@@ -255,6 +255,8 @@ export async function uploadFile({
     success: true,
     bucket,
     name: verified?.name || filename,
+    storage_path: verified?.name || filename,
+    file_path,
     object_id: verified?.id || null,
     size_bytes: stat.size,
     size_human: formatBytes(stat.size),

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 backend change(s) — local matches what's already saved. Test with dypai_test_endpoint(mode:'draft'), then use dypai_deploy_production(confirm:true) when the user approves going live.`
-          : draftCount > 0 && totalChanges > 0
-            ? `${draftCount} backend change(s) already pending; this diff would save ${totalChanges} more. Keep testing in preview, or use dypai_deploy_production(confirm:true) after explicit approval.`
-            : draftCount > 0
-              ? `${draftCount} pending backend change(s) — no local changes to push. Test with dypai_test_endpoint(mode:'draft'), then use dypai_deploy_production(confirm:true) after explicit approval.`
-              : 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 ──────────────────────────────────────────────────

package/src/tools/sync/pull.js

@@ -84,7 +84,7 @@ function suspiciousPathWarning(resolvedPath, source) {
 
 // Subfolders that are always created so the layout is predictable. An agent
 // never has to check "does this folder exist?" before writing a new SQL/prompt/JS file.
-const CANONICAL_SUBDIRS = ["endpoints", "flows", "sql", "prompts", "code", "migrations"]
+const CANONICAL_SUBDIRS = ["endpoints", "flows", "automations", "sql", "prompts", "code", "migrations"]
 
 const README_CONTENT = `# dypai/
 
@@ -97,6 +97,8 @@ Declarative snapshot of your DYPAI project's backend.
   Subfolders represent endpoint groups, e.g. \`endpoints/Admin/foo.yaml\` → group "Admin".
 - \`flows/\` — TypeScript flow definitions (\`*.flow.ts\`). **Authoritative for new work.**
   When a flow exists for an endpoint name, it wins over legacy YAML at validate/push/test time.
+- \`automations/\` — TypeScript automation definitions (\`*.automation.ts\`) for scheduled/webhook business processes.
+  Automations compile to normal backend workflows, but also declare setup requirements, notifications, and history metadata for the organization Automations page.
 - \`capability-catalog.json\` — grouped capability catalog (synced by \`dypai_pull\`).
 - \`capability-brief.md\` — compact capability index for agents.
 - \`node-catalog.json\` — every node_type with input/output schemas.
@@ -108,7 +110,7 @@ Declarative snapshot of your DYPAI project's backend.
 ## Workflow
 
 1. \`dypai_pull\` to snapshot the remote state into this folder
-2. Edit \`flows/*.flow.ts\` (preferred) or legacy YAML, SQL, prompts, code
+2. Edit \`flows/*.flow.ts\` for callable endpoints, \`automations/*.automation.ts\` for scheduled/webhook processes, or legacy YAML, SQL, prompts, code
 3. \`dypai_validate\` / \`dypai_test_endpoint\` before push
 4. \`dypai_diff\` to preview changes
 5. \`dypai_push\` to apply to the remote
@@ -523,17 +525,36 @@ function isFlowTsSource(workflowSource) {
   return workflowSource?.kind === "flow-ts"
 }
 
+function isAutomationTsSource(workflowSource) {
+  return workflowSource?.kind === "automation-ts"
+}
+
+function isEditableTsSource(workflowSource) {
+  return isFlowTsSource(workflowSource) || isAutomationTsSource(workflowSource)
+}
+
 function isFlowSourcePath(path) {
   return typeof path === "string" && path.startsWith("dypai/flows/") && /\.flow\.ts$/i.test(path)
 }
 
-export function normalizeFlowSourceFile(workflowSource, endpointName) {
+function isAutomationSourcePath(path) {
+  return typeof path === "string" && path.startsWith("dypai/automations/") && /\.automation\.ts$/i.test(path)
+}
+
+export function normalizeEditableSourceFile(workflowSource, endpointName) {
   const raw = typeof workflowSource?.file === "string" ? workflowSource.file.trim().replace(/\\/g, "/") : ""
   if (isFlowSourcePath(raw)) return raw
+  if (isAutomationSourcePath(raw)) return raw
   if (raw.startsWith("flows/") && /\.flow\.ts$/i.test(raw)) return `dypai/${raw}`
+  if (raw.startsWith("automations/") && /\.automation\.ts$/i.test(raw)) return `dypai/${raw}`
+  if (isAutomationTsSource(workflowSource)) return `dypai/automations/${endpointName}.automation.ts`
   return `dypai/flows/${endpointName}.flow.ts`
 }
 
+export function normalizeFlowSourceFile(workflowSource, endpointName) {
+  return normalizeEditableSourceFile(workflowSource, endpointName)
+}
+
 function flowSourceRelPath(sourceFile) {
   return sourceFile.replace(/^dypai\//, "")
 }
@@ -553,7 +574,7 @@ export function buildPersistedFlowSourceMap(sourcePayload) {
   const byPath = new Map()
   for (const entry of files) {
     const path = typeof entry?.path === "string" ? entry.path.trim().replace(/\\/g, "/") : ""
-    if (!isFlowSourcePath(path)) continue
+    if (!isFlowSourcePath(path) && !isAutomationSourcePath(path)) continue
     const decoded = decodeSourceFileContent(entry)
     if (decoded == null) continue
     byPath.set(path, decoded)
@@ -607,13 +628,15 @@ async function removeEndpointYamlFiles(outDir, name, groupName = null) {
 function renderMissingFlowStub(row, sourceFile, sourceFetch) {
   const refLine = sourceFetch?.ref ? `# Checked Git source ref: ${sourceFetch.ref}\n` : ""
   const errorLine = sourceFetch?.error ? `# Source fetch error: ${sourceFetch.error}\n` : ""
+  const sourceKind = sourceFile.endsWith(".automation.ts") ? "AUTOMATION" : "FLOW"
+  const extension = sourceFile.endsWith(".automation.ts") ? ".automation.ts" : ".flow.ts"
   return (
-    `# MISSING AUTHORITATIVE FLOW SOURCE\n` +
-    `# Remote endpoint '${row.name}' is marked as Flow-authored, but dypai_pull could not find:\n` +
+    `# MISSING AUTHORITATIVE ${sourceKind} SOURCE\n` +
+    `# Remote endpoint '${row.name}' is marked as ${sourceKind.toLowerCase()}-authored, but dypai_pull could not find:\n` +
     `#   ${sourceFile}\n` +
     refLine +
     errorLine +
-    `# Do not edit this YAML stub. Restore or sync the .flow.ts source, then rerun dypai_pull.\n\n` +
+    `# Do not edit this YAML stub. Restore or sync the ${extension} source, then rerun dypai_pull.\n\n` +
     `# name: ${row.name}\n` +
     `# method: ${row.method || "POST"}\n`
   )
@@ -901,9 +924,9 @@ export const dypaiPullTool = {
       row.workflow_source = parseMaybeJson(row.workflow_source)
       try {
         const workflowSource = row.workflow_source
-        if (isFlowTsSource(workflowSource)) {
+        if (isEditableTsSource(workflowSource)) {
           const groupName = row.group_id ? (mapsCtx.groupIdToName[row.group_id] || null) : null
-          const sourceFile = normalizeFlowSourceFile(workflowSource, row.name)
+          const sourceFile = normalizeEditableSourceFile(workflowSource, row.name)
           const relFlowPath = flowSourceRelPath(sourceFile)
           const flowContent = persistedFlowSources.byPath.get(sourceFile)
           // Drop stale YAML/stubs from a previous pull. Any YAML next to a real
@@ -945,8 +968,8 @@ export const dypaiPullTool = {
           errors.push({
             endpoint: row.name,
             error:
-              `Endpoint is Flow-authored but ${sourceFile} was not found in persisted project source. ` +
-              `Restore/sync the .flow.ts source, then rerun dypai_pull.`,
+              `Endpoint is source-authored but ${sourceFile} was not found in persisted project source. ` +
+              `Restore/sync the editable TypeScript source, then rerun dypai_pull.`,
           })
           continue
         }
@@ -1129,11 +1152,11 @@ export const dypaiPullTool = {
       next_steps: pendingDrafts
         ? [
             `${draftsTotal} pending draft(s). Review with manage_drafts(operation:'list'), verify with dypai_test_endpoint(mode:'draft'), then publish or discard.`,
-            "After resolving drafts, edit Flow in dypai/flows/ (preferred) or legacy YAML in dypai/endpoints/, then dypai_diff → dypai_push to stage more.",
+            "After resolving drafts, edit Flow in dypai/flows/, Automations in dypai/automations/, or legacy YAML in dypai/endpoints/, then dypai_diff → dypai_push to stage more.",
           ]
         : (endpoints || []).length === 0
-          ? ["Empty project. Create tables via execute_sql, then write dypai/flows/<name>.flow.ts and dypai_push."]
-          : ["Read dypai/schema.sql before writing queries.", "Edit Flow in dypai/flows/ (preferred) or legacy YAML in dypai/endpoints/, then dypai_diff → dypai_push."],
+          ? ["Empty project. Create tables via execute_sql, then write dypai/flows/<name>.flow.ts for callable endpoints or dypai/automations/<name>.automation.ts for scheduled/webhook processes, then dypai_push."]
+          : ["Read dypai/schema.sql before writing queries.", "Edit Flow in dypai/flows/, Automations in dypai/automations/, or legacy YAML in dypai/endpoints/, then dypai_diff → dypai_push."],
     }
 
     return {
@@ -1155,7 +1178,7 @@ export const dypaiPullTool = {
         : draftsTotal > 0
           ? `${draftsTotal} pending draft(s) on this project — see overview.pending_drafts and decide publish vs discard before pushing more.`
         : endpoints.length === 0
-          ? "Empty project. Create tables with execute_sql, then write flows/<name>.flow.ts and dypai_push."
+          ? "Empty project. Create tables with execute_sql, then write flows/<name>.flow.ts or automations/<name>.automation.ts and dypai_push."
           : undefined,
     }
   },