@daeda/mcp-pro 0.1.21 → 0.1.23

package/dist/index.js

@@ -372,6 +372,7 @@ var DATA_ROOT = () => _dataRoot;
 var PORTALS_DIR = () => path2.join(_dataRoot, "portals");
 var portalDir = (portalId) => path2.join(PORTALS_DIR(), String(portalId));
 var dbPath = (portalId) => path2.join(portalDir(portalId), "hubspot.duckdb");
+var replicaDbPath = (portalId) => path2.join(portalDir(portalId), "hubspot.replica.duckdb");
 var stateFilePath = () => path2.join(_dataRoot, "client_state.json");
 var portalStatePath = (portalId) => path2.join(portalDir(portalId), "portal_state.json");
 var errorsDirPath = (portalId) => path2.join(portalDir(portalId), "errors");
@@ -402,7 +403,7 @@ import { Effect as Effect10, pipe as pipe5 } from "effect";
 import fs4 from "fs";
 
 // src/layers/DatabaseLayerLive.ts
-import { Effect as Effect9, Layer, pipe as pipe4 } from "effect";
+import { Effect as Effect9, FiberRef, Layer, pipe as pipe4 } from "effect";
 import { DuckDBInstance as DuckDBInstance2, DuckDBDataChunk, VARCHAR } from "@duckdb/node-api";
 
 // src/services/ConfigService.ts
@@ -461,6 +462,11 @@ var LOCK_ERROR_PATTERNS = [
   "lock on file",
   "already locked"
 ];
+var PORTAL_DB_ALIAS = "portal_db";
+var REPLICA_DB_ALIAS = "portal_replica";
+var writeTransactionRef = FiberRef.unsafeMake(false);
+var DEFAULT_REPLICA_PUBLISH_DEBOUNCE_MS = 5 * 60 * 1e3;
+var replicaPublishDebounceMs = DEFAULT_REPLICA_PUBLISH_DEBOUNCE_MS;
 var isLockedDatabaseError = (e) => {
   const msg = String(e);
   return LOCK_ERROR_PATTERNS.some((p) => msg.includes(p));
@@ -570,10 +576,134 @@ var insertAssociationsViaStaging = (conn, rows) => pipe4(
   )
 );
 var portalDbCache = /* @__PURE__ */ new Map();
+var escapeSqlString = (value) => value.replace(/'/g, "''");
+var buildAttachSql = (filePath, alias, encryptionKey, readOnly) => {
+  const options2 = [];
+  if (encryptionKey) {
+    options2.push(`ENCRYPTION_KEY '${escapeSqlString(encryptionKey)}'`);
+  }
+  if (readOnly) {
+    options2.push("READ_ONLY");
+  }
+  const escapedFile = escapeSqlString(filePath);
+  return options2.length > 0 ? `ATTACH '${escapedFile}' AS ${alias} (${options2.join(", ")})` : `ATTACH '${escapedFile}' AS ${alias}`;
+};
+var getReplicaVersion = (portalId) => {
+  try {
+    return fs3.statSync(replicaDbPath(portalId)).mtimeMs;
+  } catch {
+    return null;
+  }
+};
+var cleanupDbArtifacts = (filePath) => {
+  try {
+    fs3.unlinkSync(filePath);
+  } catch {
+  }
+  try {
+    fs3.unlinkSync(filePath + ".wal");
+  } catch {
+  }
+};
+var createPendingReplicaPublish = () => {
+  let resolve;
+  const promise = new Promise((res) => {
+    resolve = res;
+  });
+  return { promise, resolve };
+};
+var publishReplica = async (conn, portalId, encryptionKey) => {
+  const replicaPath = replicaDbPath(portalId);
+  const nextReplicaPath = `${replicaPath}.next`;
+  cleanupDbArtifacts(nextReplicaPath);
+  await conn.run(`CHECKPOINT ${PORTAL_DB_ALIAS}`);
+  await conn.run(buildAttachSql(nextReplicaPath, REPLICA_DB_ALIAS, encryptionKey, false));
+  try {
+    await conn.run(`COPY FROM DATABASE ${PORTAL_DB_ALIAS} TO ${REPLICA_DB_ALIAS}`);
+    await conn.run(`CHECKPOINT ${REPLICA_DB_ALIAS}`);
+  } finally {
+    try {
+      await conn.run(`DETACH ${REPLICA_DB_ALIAS}`);
+    } catch {
+    }
+  }
+  cleanupDbArtifacts(replicaPath);
+  fs3.renameSync(nextReplicaPath, replicaPath);
+  const version = getReplicaVersion(portalId);
+  if (version === null) {
+    throw new Error(`Replica publish failed for portal ${portalId}`);
+  }
+  return version;
+};
+var closePortalDb = (portalDb) => {
+  clearScheduledReplicaPublish(portalDb);
+  portalDb.pendingReplicaPublish?.resolve();
+  portalDb.pendingReplicaPublish = null;
+  const { conn, instance } = portalDb;
+  try {
+    conn.closeSync();
+  } catch {
+  }
+  try {
+    instance.closeSync();
+  } catch {
+  }
+};
+var clearScheduledReplicaPublish = (portalDb) => {
+  if (portalDb.replicaPublishTimer !== null) {
+    clearTimeout(portalDb.replicaPublishTimer);
+    portalDb.replicaPublishTimer = null;
+  }
+};
+var scheduleReplicaPublish = (portalDb, portalId, encryptionKey) => {
+  if (portalDb.readOnly) return;
+  portalDb.replicaDirty = true;
+  const pending = portalDb.pendingReplicaPublish ?? createPendingReplicaPublish();
+  portalDb.pendingReplicaPublish = pending;
+  clearScheduledReplicaPublish(portalDb);
+  portalDb.replicaPublishTimer = setTimeout(() => {
+    portalDb.replicaPublishTimer = null;
+    void Effect9.runPromise(
+      pipe4(
+        portalDb.txMutex.withPermits(1)(
+          Effect9.tryPromise({
+            try: async () => {
+              try {
+                if (!portalDb.replicaDirty) return;
+                portalDb.replicaVersion = await publishReplica(portalDb.conn, portalId, encryptionKey);
+                portalDb.replicaDirty = false;
+              } finally {
+                if (portalDb.pendingReplicaPublish === pending) {
+                  portalDb.pendingReplicaPublish = null;
+                }
+              }
+            },
+            catch: (e) => new DatabaseError({ message: `Failed to publish replica for portal ${portalId}`, cause: e })
+          })
+        ),
+        Effect9.matchEffect({
+          onFailure: (error) => Effect9.sync(() => {
+            console.error(`[db] Failed to publish replica for portal ${portalId}:`, error);
+            pending.resolve();
+          }),
+          onSuccess: () => Effect9.sync(() => {
+            pending.resolve();
+          })
+        })
+      )
+    );
+  }, replicaPublishDebounceMs);
+};
+var shouldRefreshPortalDb = (portalId, portalDb) => {
+  if (!portalDb.readOnly) return false;
+  return getReplicaVersion(portalId) !== portalDb.replicaVersion;
+};
 var initializePortalDb = async (portalId, encryptionKey) => {
   fs3.mkdirSync(portalDir(portalId), { recursive: true });
+  const liveDbPath = dbPath(portalId);
+  const replicaPath = replicaDbPath(portalId);
   if (encryptionKey) {
-    const existingDb = dbPath(portalId);
+    const existingDb = liveDbPath;
     const walFile = existingDb + ".wal";
     if (fs3.existsSync(existingDb)) {
       const HEADER_SIZE = 24;
@@ -600,46 +730,64 @@ var initializePortalDb = async (portalId, encryptionKey) => {
   }
   const instance = await DuckDBInstance2.create(":memory:");
   const conn = await instance.connect();
-  const dbFile = dbPath(portalId).replace(/'/g, "''");
-  const attachSql = encryptionKey ? `ATTACH '${dbFile}' AS portal_db (ENCRYPTION_KEY '${encryptionKey.replace(/'/g, "''")}')` : `ATTACH '${dbFile}' AS portal_db`;
+  let readOnly = false;
+  let sourcePath = liveDbPath;
+  let replicaVersion = null;
   try {
-    await conn.run(attachSql);
+    await conn.run(buildAttachSql(liveDbPath, PORTAL_DB_ALIAS, encryptionKey, false));
   } catch (e) {
     if (isLockedDatabaseError(e)) {
-      try {
-        conn.closeSync();
-      } catch {
-      }
-      try {
-        instance.closeSync();
-      } catch {
-      }
-      throw new Error(`Database for portal ${portalId} is locked by another client. Only one MCP client can access a portal at a time.`);
-    }
-    if (!isCorruptedDatabaseError(e)) throw e;
-    const file = dbPath(portalId);
-    console.error(`[recovery] Corrupted database detected during ATTACH for portal ${portalId}, deleting and retrying`);
-    try {
-      fs3.unlinkSync(file);
-    } catch {
-    }
-    try {
-      fs3.unlinkSync(file + ".wal");
-    } catch {
+      console.error(`[db] Portal ${portalId} is locked for writes by another process; opening published replica read-only`);
+      replicaVersion = getReplicaVersion(portalId);
+      if (replicaVersion === null) {
+        throw new Error(`No published replica is available for portal ${portalId}`);
+      }
+      await conn.run(buildAttachSql(replicaPath, PORTAL_DB_ALIAS, encryptionKey, true));
+      readOnly = true;
+      sourcePath = replicaPath;
+    } else {
+      if (!isCorruptedDatabaseError(e)) throw e;
+      const file = liveDbPath;
+      console.error(`[recovery] Corrupted database detected during ATTACH for portal ${portalId}, deleting and retrying`);
+      cleanupDbArtifacts(file);
+      await conn.run(buildAttachSql(liveDbPath, PORTAL_DB_ALIAS, encryptionKey, false));
     }
-    await conn.run(attachSql);
   }
-  await conn.run("USE portal_db");
-  return { instance, conn, txMutex: Effect9.unsafeMakeSemaphore(1) };
+  await conn.run(`USE ${PORTAL_DB_ALIAS}`);
+  if (!readOnly) {
+    replicaVersion = await publishReplica(conn, portalId, encryptionKey);
+  }
+  return {
+    instance,
+    conn,
+    txMutex: Effect9.unsafeMakeSemaphore(1),
+    readOnly,
+    sourcePath,
+    replicaVersion,
+    replicaDirty: false,
+    replicaPublishTimer: null,
+    pendingReplicaPublish: null
+  };
 };
-var getOrCreatePortalDb = (portalId, encryptionKey) => {
-  const cached = portalDbCache.get(portalId);
-  if (cached) return cached;
+var createPortalDb = (portalId, encryptionKey) => {
   const creating = initializePortalDb(portalId, encryptionKey);
   portalDbCache.set(portalId, creating);
   creating.catch(() => portalDbCache.delete(portalId));
   return creating;
 };
+var getOrCreatePortalDb = async (portalId, encryptionKey) => {
+  const cached = portalDbCache.get(portalId);
+  if (!cached) {
+    return createPortalDb(portalId, encryptionKey);
+  }
+  const portalDb = await cached;
+  if (!shouldRefreshPortalDb(portalId, portalDb)) {
+    return portalDb;
+  }
+  portalDbCache.delete(portalId);
+  closePortalDb(portalDb);
+  return createPortalDb(portalId, encryptionKey);
+};
 var getPortalInstance = async (portalId, encryptionKey) => {
   const portalDb = await getOrCreatePortalDb(portalId, encryptionKey);
   return portalDb.instance;
@@ -648,16 +796,7 @@ var evictPortalDb = (portalId) => {
   const cached = portalDbCache.get(portalId);
   if (!cached) return;
   portalDbCache.delete(portalId);
-  cached.then(({ conn, instance }) => {
-    try {
-      conn.closeSync();
-    } catch {
-    }
-    try {
-      instance.closeSync();
-    } catch {
-    }
-  }).catch(() => {
+  cached.then(closePortalDb).catch(() => {
   });
 };
 var makeDatabaseLive = (portalId, encryptionKey) => Layer.effect(
@@ -667,10 +806,36 @@ var makeDatabaseLive = (portalId, encryptionKey) => Layer.effect(
       try: () => getOrCreatePortalDb(portalId, encryptionKey),
       catch: (e) => new DatabaseError({ message: "Failed to acquire database connection", cause: e })
     }),
-    Effect9.map(({ conn, txMutex }) => {
+    Effect9.map((portalDb) => {
+      const { conn, txMutex, readOnly } = portalDb;
       const pluginTableNames = new Set(
         getAllTableNames().map((tableName) => sanitizeTableName(tableName))
       );
+      const failReadOnly = () => new DatabaseError({
+        message: `Portal ${portalId} is opened in read-only mode because another MCP process holds the write lock`
+      });
+      const requireWritable = (effect) => readOnly ? Effect9.fail(failReadOnly()) : effect;
+      const scheduleReplicaPublishEffect = () => Effect9.sync(() => {
+        scheduleReplicaPublish(portalDb, portalId, encryptionKey);
+      });
+      const serializeWrite = (effect) => pipe4(
+        FiberRef.get(writeTransactionRef),
+        Effect9.flatMap(
+          (inWriteTransaction) => inWriteTransaction ? requireWritable(effect) : requireWritable(
+            txMutex.withPermits(1)(
+              pipe4(
+                effect,
+                Effect9.flatMap(
+                  (result) => pipe4(
+                    scheduleReplicaPublishEffect(),
+                    Effect9.as(result)
+                  )
+                )
+              )
+            )
+          )
+        )
+      );
       const initializeDb = (_portalId) => Effect9.tryPromise({
         try: async () => {
           await conn.run(SYNC_METADATA_TABLE_STATEMENT);
@@ -762,6 +927,7 @@ var makeDatabaseLive = (portalId, encryptionKey) => Layer.effect(
               catch: (e) => new DatabaseError({ message: "Failed to commit transaction", cause: e })
             })
           ),
+          Effect9.flatMap(() => scheduleReplicaPublishEffect()),
           Effect9.map(() => rows.length),
           Effect9.catchAll(
             (e) => pipe4(
@@ -840,6 +1006,7 @@ var makeDatabaseLive = (portalId, encryptionKey) => Layer.effect(
             catch: (e) => new DatabaseError({ message: "Failed to commit plugin schema migration", cause: e })
           })
         ),
+        Effect9.flatMap(() => scheduleReplicaPublishEffect()),
         Effect9.asVoid,
         Effect9.catchAll(
           (e) => pipe4(
@@ -943,6 +1110,7 @@ var makeDatabaseLive = (portalId, encryptionKey) => Layer.effect(
               await bulkAppend(conn, name, columns);
             }
             await conn.run("COMMIT");
+            scheduleReplicaPublish(portalDb, portalId, encryptionKey);
           } catch (e) {
             try {
               await conn.run("ROLLBACK");
@@ -962,14 +1130,19 @@ var makeDatabaseLive = (portalId, encryptionKey) => Layer.effect(
           try: () => conn.run("BEGIN TRANSACTION"),
           catch: (e) => new DatabaseError({ message: "Failed to begin transaction", cause: e })
         }),
-        Effect9.flatMap(() => effect),
+        Effect9.flatMap(() => pipe4(effect, Effect9.locally(writeTransactionRef, true))),
         Effect9.flatMap(
           (result) => pipe4(
             Effect9.tryPromise({
               try: () => conn.run("COMMIT"),
               catch: (e) => new DatabaseError({ message: "Failed to commit transaction", cause: e })
             }),
-            Effect9.map(() => result)
+            Effect9.flatMap(
+              () => pipe4(
+                scheduleReplicaPublishEffect(),
+                Effect9.as(result)
+              )
+            )
           )
         ),
         Effect9.catchAll(
@@ -1031,6 +1204,7 @@ var makeDatabaseLive = (portalId, encryptionKey) => Layer.effect(
             );
             const countResult = await conn.runAndReadAll(`SELECT COUNT(*) as count FROM "${name}"`);
             await conn.run("COMMIT");
+            scheduleReplicaPublish(portalDb, portalId, encryptionKey);
             const row = countResult.getRowObjects()[0];
             return Number(row.count);
           } catch (e) {
@@ -1073,6 +1247,7 @@ var makeDatabaseLive = (portalId, encryptionKey) => Layer.effect(
             );
             await conn.run(`DROP TABLE IF EXISTS "${staging}"`);
             await conn.run("COMMIT");
+            scheduleReplicaPublish(portalDb, portalId, encryptionKey);
             const row = countResult.getRowObjects()[0];
             return Number(row.count);
           } catch (e) {
@@ -1090,26 +1265,26 @@ var makeDatabaseLive = (portalId, encryptionKey) => Layer.effect(
         catch: (e) => new DatabaseError({ message: `Failed to atomically replace association CSV`, cause: e })
       }));
       return {
-        initializeDb,
-        ensureObjectTable,
-        insertObjects,
-        insertAssociations,
-        upsertObjects,
-        upsertAssociations,
-        importObjectsFromCsv,
-        importAssociationsFromCsv,
-        atomicReplaceObjectsFromCsv,
-        atomicReplaceAssociationsFromCsv,
+        initializeDb: (targetPortalId) => serializeWrite(initializeDb(targetPortalId)),
+        ensureObjectTable: (objectType) => serializeWrite(ensureObjectTable(objectType)),
+        insertObjects: (tableName, rows) => serializeWrite(insertObjects(tableName, rows)),
+        insertAssociations: (rows) => serializeWrite(insertAssociations(rows)),
+        upsertObjects: (tableName, rows) => serializeWrite(upsertObjects(tableName, rows)),
+        upsertAssociations: (changedObjectIds, changedObjectType, rows) => requireWritable(upsertAssociations(changedObjectIds, changedObjectType, rows)),
+        importObjectsFromCsv: (tableName, csvPath) => serializeWrite(importObjectsFromCsv(tableName, csvPath)),
+        importAssociationsFromCsv: (csvPath, fromType, toType) => serializeWrite(importAssociationsFromCsv(csvPath, fromType, toType)),
+        atomicReplaceObjectsFromCsv: (tableName, csvPath) => requireWritable(atomicReplaceObjectsFromCsv(tableName, csvPath)),
+        atomicReplaceAssociationsFromCsv: (csvPath, fromType, toType) => requireWritable(atomicReplaceAssociationsFromCsv(csvPath, fromType, toType)),
         getObjectSyncTimes,
-        clearObjectTable,
-        clearAssociations,
-        rebuildPluginTables,
+        clearObjectTable: (tableName) => serializeWrite(clearObjectTable(tableName)),
+        clearAssociations: (fromType, toType) => serializeWrite(clearAssociations(fromType, toType)),
+        rebuildPluginTables: (tableNames, ddlStatements) => requireWritable(rebuildPluginTables(tableNames, ddlStatements)),
         executeReadQuery,
         getRecordCounts,
         getMetadata,
-        setMetadata,
-        replacePluginTable,
-        withTransaction
+        setMetadata: (key, value) => serializeWrite(setMetadata(key, value)),
+        replacePluginTable: (tableName, columns) => requireWritable(replacePluginTable(tableName, columns)),
+        withTransaction: (effect) => requireWritable(withTransaction(effect))
       };
     })
   )
@@ -1126,12 +1301,11 @@ var closeHandle = (portalId) => {
   }
   handles.delete(portalId);
 };
-var openReadHandle = (portalId, encryptionKey) => Effect10.tryPromise({
+var openReadHandle = (portalId, encryptionKey, instance) => Effect10.tryPromise({
   try: async () => {
-    const instance = await getPortalInstance(portalId, encryptionKey);
     const conn = await instance.connect();
     await conn.run("USE portal_db");
-    handles.set(portalId, { conn });
+    handles.set(portalId, { conn, instance });
     return conn;
   },
   catch: (e) => new DatabaseError({
@@ -1147,9 +1321,21 @@ var getReadConnection = (portalId, encryptionKey) => pipe5(
       message: `Database not found for portal ${portalId}. Has it been synced?`
     })
   ),
-  Effect10.flatMap(() => {
+  Effect10.flatMap(
+    () => Effect10.tryPromise({
+      try: () => getPortalInstance(portalId, encryptionKey),
+      catch: (e) => new DatabaseError({
+        message: `Failed to resolve database instance for portal ${portalId}`,
+        cause: e
+      })
+    })
+  ),
+  Effect10.flatMap((instance) => {
     const existing = handles.get(portalId);
-    return existing ? Effect10.succeed(existing.conn) : openReadHandle(portalId, encryptionKey);
+    if (existing && existing.instance !== instance) {
+      closeHandle(portalId);
+    }
+    return existing && existing.instance === instance ? Effect10.succeed(existing.conn) : openReadHandle(portalId, encryptionKey, instance);
   })
 );
 var closeReadConnection = (portalId) => Effect10.sync(() => {
@@ -4500,7 +4686,7 @@ Use "all" to get everything at once.`,
 }
 
 // src/tools/build_plan.ts
-import { z as z67 } from "zod";
+import { z as z68 } from "zod";
 
 // src/tools/draft_state.ts
 var drafts = /* @__PURE__ */ new Map();
@@ -4539,10 +4725,10 @@ var clearDraft = (portalId) => {
 };
 
 // src/pure/operation-conversion.ts
-import { z as z66 } from "zod";
+import { z as z67 } from "zod";
 
 // ../shared/types/plan.ts
-import { z as z65 } from "zod";
+import { z as z66 } from "zod";
 
 // ../shared/operations/create-property/meta.ts
 import { z as z17 } from "zod";
@@ -7070,65 +7256,298 @@ var deleteSnippetMeta = {
 };
 
 // ../shared/operations/create-workflow/meta.ts
-import { z as z61 } from "zod";
+import { z as z62 } from "zod";
 
 // ../shared/pure/workflow-operation-schema.ts
+import { z as z61 } from "zod";
+
+// ../shared/types/workflow-actions-types/index.ts
 import { z as z60 } from "zod";
+var NonEmptyStringSchema = z60.string().min(1);
 var WorkflowConnectionSchema = z60.object({
-  edgeType: z60.string().min(1),
-  nextActionId: z60.string().min(1)
+  edgeType: NonEmptyStringSchema,
+  nextActionId: NonEmptyStringSchema
+}).passthrough();
+var WorkflowStaticBranchSchema = z60.object({
+  branchValue: NonEmptyStringSchema,
+  connection: WorkflowConnectionSchema.optional()
+}).passthrough();
+var AssociationSpecSchema = z60.object({
+  associationCategory: NonEmptyStringSchema,
+  associationTypeId: z60.number().int()
+}).passthrough();
+var StaticValueSchema = z60.object({
+  type: z60.literal("STATIC_VALUE"),
+  staticValue: z60.string()
+}).passthrough();
+var ObjectPropertyValueSchema = z60.object({
+  type: z60.literal("OBJECT_PROPERTY"),
+  propertyName: NonEmptyStringSchema
+}).passthrough();
+var ActionValueSchema = z60.union([
+  StaticValueSchema,
+  ObjectPropertyValueSchema
+]);
+var AssociationValueSchema = z60.union([
+  z60.object({
+    type: z60.literal("ENROLLED_OBJECT")
+  }).passthrough(),
+  z60.object({
+    type: z60.literal("COPY_ASSOCIATION"),
+    sourceSpec: AssociationSpecSchema
+  }).passthrough()
+]);
+var ActionAssociationSchema = z60.object({
+  target: AssociationSpecSchema,
+  value: AssociationValueSchema
 }).passthrough();
-var WorkflowFilterOperationSchema = z60.object({
-  operationType: z60.string().min(1, "operation.operationType is required for workflow property filters"),
-  operator: z60.string().min(1)
+var TimeOfDaySchema = z60.object({
+  hour: z60.number().int().min(0).max(23),
+  minute: z60.number().int().min(0).max(59)
 }).passthrough();
-var WorkflowFilterSchema = z60.object({
-  filterType: z60.string().min(1),
-  property: z60.string().optional(),
+var RelativeTimeSchema = z60.object({
+  delta: z60.number().int(),
+  timeUnit: NonEmptyStringSchema,
+  timeOfDay: TimeOfDaySchema,
+  daysOfWeek: z60.array(NonEmptyStringSchema)
+}).passthrough();
+var ActionFieldDataInputSchema = z60.object({
+  actionId: NonEmptyStringSchema,
+  dataKey: NonEmptyStringSchema,
+  type: z60.literal("FIELD_DATA")
+}).passthrough();
+var SingleConnectionActionBaseSchema = z60.object({
+  actionId: NonEmptyStringSchema,
+  actionTypeVersion: z60.number().int().optional(),
+  connection: WorkflowConnectionSchema.optional(),
+  type: z60.literal("SINGLE_CONNECTION")
+}).passthrough();
+var buildSingleConnectionActionSchema = (actionTypeId, fields48) => SingleConnectionActionBaseSchema.extend({
+  actionTypeId: z60.literal(actionTypeId),
+  fields: fields48
+});
+var BooleanStringSchema = z60.enum(["true", "false"]);
+var DelayForSetAmountOfTimeActionSchema = buildSingleConnectionActionSchema("0-1", z60.object({
+  delta: NonEmptyStringSchema,
+  time_unit: NonEmptyStringSchema
+}).passthrough());
+var RotateRecordToOwnerActionSchema = buildSingleConnectionActionSchema("0-11", z60.object({
+  user_ids: z60.array(NonEmptyStringSchema).min(1),
+  target_property: NonEmptyStringSchema,
+  overwrite_current_owner: BooleanStringSchema
+}).passthrough());
+var CreateRecordPropertySchema = z60.object({
+  targetProperty: NonEmptyStringSchema,
+  value: ActionValueSchema
+}).passthrough();
+var CreateRecordActionSchema = buildSingleConnectionActionSchema("0-14", z60.object({
+  object_type_id: NonEmptyStringSchema,
+  properties: z60.array(CreateRecordPropertySchema).optional(),
+  associations: z60.array(ActionAssociationSchema).optional(),
+  use_explicit_associations: BooleanStringSchema.optional()
+}).passthrough());
+var GoToWorkflowActionSchema = buildSingleConnectionActionSchema("0-15", z60.object({
+  flow_id: NonEmptyStringSchema
+}).passthrough());
+var CreateNoteActionSchema = buildSingleConnectionActionSchema("0-169425243", z60.object({
+  note_body: z60.string(),
+  pin_note: BooleanStringSchema
+}).passthrough());
+var SummarizeRecordActionSchema = buildSingleConnectionActionSchema("0-195318603", z60.object({}).passthrough());
+var TrackIntentSignalsActionSchema = buildSingleConnectionActionSchema("0-219160146", z60.object({
+  targetCompany: NonEmptyStringSchema
+}).passthrough());
+var StopTrackingIntentSignalsActionSchema = buildSingleConnectionActionSchema("0-219161394", z60.object({
+  targetCompany: NonEmptyStringSchema
+}).passthrough());
+var ValidateAndFormatPhoneNumberActionSchema = buildSingleConnectionActionSchema("0-225935194", z60.object({
+  defaultCountryCodeMode: NonEmptyStringSchema
+}).passthrough());
+var DelayUntilEventOccursActionSchema = buildSingleConnectionActionSchema("0-29", z60.object({
+  expiration_minutes: NonEmptyStringSchema
+}).passthrough());
+var TaskOwnerAssignmentSchema = z60.object({
+  type: NonEmptyStringSchema,
+  value: StaticValueSchema
+}).passthrough();
+var CreateTaskActionSchema = buildSingleConnectionActionSchema("0-3", z60.object({
+  task_type: NonEmptyStringSchema,
+  subject: NonEmptyStringSchema,
+  body: z60.string(),
+  associations: z60.array(ActionAssociationSchema).optional(),
+  use_explicit_associations: BooleanStringSchema.optional(),
+  priority: NonEmptyStringSchema.optional(),
+  due_time: RelativeTimeSchema.optional(),
+  reminder_time: RelativeTimeSchema.optional(),
+  owner_assignment: TaskOwnerAssignmentSchema.optional()
+}).passthrough());
+var SetMarketingContactStatusActionSchema = buildSingleConnectionActionSchema("0-31", z60.object({
+  targetContact: NonEmptyStringSchema,
+  marketableType: NonEmptyStringSchema
+}).passthrough());
+var DelayUntilDateActionSchema = buildSingleConnectionActionSchema("0-35", z60.object({
+  date: ActionValueSchema,
+  delta: NonEmptyStringSchema,
+  time_unit: NonEmptyStringSchema,
+  time_of_day: TimeOfDaySchema
+}).passthrough());
+var EditRecordsSetPropertyActionSchema = buildSingleConnectionActionSchema("0-5", z60.object({
+  property_name: NonEmptyStringSchema,
+  association: AssociationSpecSchema.optional(),
+  value: ActionValueSchema
+}).passthrough());
+var RemoveAssociationLabelsActionSchema = buildSingleConnectionActionSchema("0-61139476", z60.object({
+  fromObjectType: NonEmptyStringSchema,
+  toObjectType: NonEmptyStringSchema,
+  labelToRemove: NonEmptyStringSchema,
+  fullyDissociate: BooleanStringSchema
+}).passthrough());
+var CreateAssociationsActionSchema = buildSingleConnectionActionSchema("0-63189541", z60.object({
+  fromObjectType: NonEmptyStringSchema,
+  toObjectType: NonEmptyStringSchema,
+  createAssociationOnly: BooleanStringSchema,
+  labelToApply: NonEmptyStringSchema,
+  matchBy: NonEmptyStringSchema,
+  enrolledObjectPropertyNameToMatch: NonEmptyStringSchema,
+  associatedObjectPropertyNameToMatch: NonEmptyStringSchema
+}).passthrough());
+var AddToStaticListActionSchema = buildSingleConnectionActionSchema("0-63809083", z60.object({
+  listId: NonEmptyStringSchema
+}).passthrough());
+var RemoveFromStaticListActionSchema = buildSingleConnectionActionSchema("0-63863438", z60.object({
+  listId: NonEmptyStringSchema
+}).passthrough());
+var ApplyAssociationLabelsActionSchema = buildSingleConnectionActionSchema("0-73444249", z60.object({
+  fromObjectType: NonEmptyStringSchema,
+  toObjectType: NonEmptyStringSchema,
+  labelToApply: NonEmptyStringSchema,
+  applyLabelToAllAssociatedObjects: BooleanStringSchema
+}).passthrough());
+var SendInternalEmailNotificationActionSchema = buildSingleConnectionActionSchema("0-8", z60.object({
+  user_ids: z60.array(NonEmptyStringSchema).min(1),
+  subject: NonEmptyStringSchema,
+  body: NonEmptyStringSchema,
+  owner_properties: z60.array(NonEmptyStringSchema).optional()
+}).passthrough());
+var SendInAppNotificationActionSchema = buildSingleConnectionActionSchema("0-9", z60.object({
+  user_ids: z60.array(NonEmptyStringSchema).min(1),
+  delivery_method: z60.enum(["APP", "MOBILE"]),
+  subject: NonEmptyStringSchema,
+  body: NonEmptyStringSchema,
+  owner_properties: z60.array(NonEmptyStringSchema).optional()
+}).passthrough());
+var StaticBranchWorkflowActionSchema = z60.object({
+  actionId: NonEmptyStringSchema,
+  inputValue: ActionFieldDataInputSchema,
+  staticBranches: z60.array(WorkflowStaticBranchSchema).min(1),
+  defaultBranchName: NonEmptyStringSchema,
+  type: z60.literal("STATIC_BRANCH")
+}).passthrough();
+var WorkflowActionSchemasByDefinitionKey = {
+  "0-1": DelayForSetAmountOfTimeActionSchema,
+  "0-11": RotateRecordToOwnerActionSchema,
+  "0-14": CreateRecordActionSchema,
+  "0-15": GoToWorkflowActionSchema,
+  "0-169425243": CreateNoteActionSchema,
+  "0-195318603": SummarizeRecordActionSchema,
+  "0-219160146": TrackIntentSignalsActionSchema,
+  "0-219161394": StopTrackingIntentSignalsActionSchema,
+  "0-225935194": ValidateAndFormatPhoneNumberActionSchema,
+  "0-29": DelayUntilEventOccursActionSchema,
+  "0-3": CreateTaskActionSchema,
+  "0-31": SetMarketingContactStatusActionSchema,
+  "0-35": DelayUntilDateActionSchema,
+  "0-5": EditRecordsSetPropertyActionSchema,
+  "0-61139476": RemoveAssociationLabelsActionSchema,
+  "0-63189541": CreateAssociationsActionSchema,
+  "0-63809083": AddToStaticListActionSchema,
+  "0-63863438": RemoveFromStaticListActionSchema,
+  "0-73444249": ApplyAssociationLabelsActionSchema,
+  "0-8": SendInternalEmailNotificationActionSchema,
+  "0-9": SendInAppNotificationActionSchema,
+  STATIC_BRANCH: StaticBranchWorkflowActionSchema
+};
+var WorkflowDefinitionActionSchema = z60.union([
+  DelayForSetAmountOfTimeActionSchema,
+  RotateRecordToOwnerActionSchema,
+  CreateRecordActionSchema,
+  GoToWorkflowActionSchema,
+  CreateNoteActionSchema,
+  SummarizeRecordActionSchema,
+  TrackIntentSignalsActionSchema,
+  StopTrackingIntentSignalsActionSchema,
+  ValidateAndFormatPhoneNumberActionSchema,
+  DelayUntilEventOccursActionSchema,
+  CreateTaskActionSchema,
+  SetMarketingContactStatusActionSchema,
+  DelayUntilDateActionSchema,
+  EditRecordsSetPropertyActionSchema,
+  RemoveAssociationLabelsActionSchema,
+  CreateAssociationsActionSchema,
+  AddToStaticListActionSchema,
+  RemoveFromStaticListActionSchema,
+  ApplyAssociationLabelsActionSchema,
+  SendInternalEmailNotificationActionSchema,
+  SendInAppNotificationActionSchema,
+  StaticBranchWorkflowActionSchema
+]);
+
+// ../shared/pure/workflow-operation-schema.ts
+var WorkflowConnectionSchema2 = z61.object({
+  edgeType: z61.string().min(1),
+  nextActionId: z61.string().min(1)
+}).passthrough();
+var WorkflowFilterOperationSchema = z61.object({
+  operationType: z61.string().min(1, "operation.operationType is required for workflow property filters"),
+  operator: z61.string().min(1)
+}).passthrough();
+var WorkflowFilterSchema = z61.object({
+  filterType: z61.string().min(1),
+  property: z61.string().optional(),
   operation: WorkflowFilterOperationSchema.optional()
 }).passthrough().superRefine((value, ctx) => {
   if (value.filterType !== "PROPERTY") return;
   if (!value.property || value.property.length === 0) {
     ctx.addIssue({
-      code: z60.ZodIssueCode.custom,
+      code: z61.ZodIssueCode.custom,
       message: "property filters require property",
       path: ["property"]
     });
   }
   if (!value.operation) {
     ctx.addIssue({
-      code: z60.ZodIssueCode.custom,
+      code: z61.ZodIssueCode.custom,
       message: "property filters require operation",
       path: ["operation"]
     });
   }
 });
-var WorkflowBranchSchema = z60.object({
-  connection: WorkflowConnectionSchema.optional(),
-  nextActionId: z60.string().min(1).optional()
+var WorkflowBranchSchema = z61.object({
+  connection: WorkflowConnectionSchema2.optional(),
+  nextActionId: z61.string().min(1).optional()
 }).passthrough().superRefine((value, ctx) => {
   if (value.connection || value.nextActionId) return;
   ctx.addIssue({
-    code: z60.ZodIssueCode.custom,
+    code: z61.ZodIssueCode.custom,
     message: "workflow branches require connection.nextActionId or nextActionId",
     path: ["connection"]
   });
 });
-var WorkflowEnrollmentBranchSchema = z60.object({
-  filterBranchType: z60.string().min(1),
-  filterBranchOperator: z60.string().optional(),
-  filterBranches: z60.array(z60.lazy(() => WorkflowEnrollmentBranchSchema)).default([]),
-  filters: z60.array(WorkflowFilterSchema).default([]),
-  eventTypeId: z60.string().optional(),
-  operator: z60.string().optional(),
-  objectTypeId: z60.string().optional(),
-  associationTypeId: z60.number().optional(),
-  associationCategory: z60.string().optional()
+var WorkflowEnrollmentBranchSchema = z61.object({
+  filterBranchType: z61.string().min(1),
+  filterBranchOperator: z61.string().optional(),
+  filterBranches: z61.array(z61.lazy(() => WorkflowEnrollmentBranchSchema)).default([]),
+  filters: z61.array(WorkflowFilterSchema).default([]),
+  eventTypeId: z61.string().optional(),
+  operator: z61.string().optional(),
+  objectTypeId: z61.string().optional(),
+  associationTypeId: z61.number().optional(),
+  associationCategory: z61.string().optional()
 }).passthrough().superRefine((value, ctx) => {
   if (value.filterBranchType !== "UNIFIED_EVENTS") return;
   if (!value.eventTypeId || value.eventTypeId.length === 0) {
     ctx.addIssue({
-      code: z60.ZodIssueCode.custom,
+      code: z61.ZodIssueCode.custom,
       message: "UNIFIED_EVENTS filter branches require eventTypeId (e.g. '4-655002' for property change). Query workflow_event_types for valid IDs.",
       path: ["eventTypeId"]
     });
@@ -7136,39 +7555,39 @@ var WorkflowEnrollmentBranchSchema = z60.object({
   }
   if (/^0-\d+$/.test(value.eventTypeId)) {
     ctx.addIssue({
-      code: z60.ZodIssueCode.custom,
+      code: z61.ZodIssueCode.custom,
       message: `eventTypeId '${value.eventTypeId}' looks like a CRM object type ID, not an event type ID. Event type IDs use '4-*' or '6-*' prefix (e.g. '4-655002' for property change). Query workflow_event_types for valid IDs.`,
       path: ["eventTypeId"]
     });
   }
 });
-var EventBasedEnrollmentCriteriaSchema = z60.object({
-  type: z60.literal("EVENT_BASED"),
-  shouldReEnroll: z60.boolean(),
-  eventFilterBranches: z60.array(WorkflowEnrollmentBranchSchema).min(1),
-  listMembershipFilterBranches: z60.array(WorkflowEnrollmentBranchSchema).default([])
+var EventBasedEnrollmentCriteriaSchema = z61.object({
+  type: z61.literal("EVENT_BASED"),
+  shouldReEnroll: z61.boolean(),
+  eventFilterBranches: z61.array(WorkflowEnrollmentBranchSchema).min(1),
+  listMembershipFilterBranches: z61.array(WorkflowEnrollmentBranchSchema).default([])
 }).passthrough();
-var ListBasedEnrollmentCriteriaSchema = z60.object({
-  type: z60.literal("LIST_BASED"),
-  shouldReEnroll: z60.boolean(),
+var ListBasedEnrollmentCriteriaSchema = z61.object({
+  type: z61.literal("LIST_BASED"),
+  shouldReEnroll: z61.boolean(),
   listFilterBranch: WorkflowEnrollmentBranchSchema,
-  reEnrollmentTriggersFilterBranches: z60.array(WorkflowEnrollmentBranchSchema).default([])
+  reEnrollmentTriggersFilterBranches: z61.array(WorkflowEnrollmentBranchSchema).default([])
 }).passthrough();
-var WorkflowEnrollmentCriteriaSchema = z60.union([
+var WorkflowEnrollmentCriteriaSchema = z61.union([
   EventBasedEnrollmentCriteriaSchema,
   ListBasedEnrollmentCriteriaSchema
 ]);
-var WorkflowActionSchema = z60.object({
-  actionId: z60.string().min(1),
-  type: z60.string().min(1),
-  actionTypeId: z60.string().optional(),
-  actionTypeVersion: z60.number().int().optional(),
-  connection: WorkflowConnectionSchema.optional(),
-  fields: z60.record(z60.string(), z60.unknown()).optional(),
-  staticBranches: z60.array(WorkflowBranchSchema).optional(),
-  listBranches: z60.array(WorkflowBranchSchema).optional(),
+var BaseWorkflowActionSchema = z61.object({
+  actionId: z61.string().min(1),
+  type: z61.string().min(1),
+  actionTypeId: z61.string().optional(),
+  actionTypeVersion: z61.number().int().optional(),
+  connection: WorkflowConnectionSchema2.optional(),
+  fields: z61.record(z61.string(), z61.unknown()).optional(),
+  staticBranches: z61.array(WorkflowBranchSchema).optional(),
+  listBranches: z61.array(WorkflowBranchSchema).optional(),
   defaultBranch: WorkflowBranchSchema.optional(),
-  defaultBranchName: z60.string().optional()
+  defaultBranchName: z61.string().optional()
 }).passthrough().superRefine((value, ctx) => {
   if (value.type !== "BRANCH") return;
   const hasStaticBranches = (value.staticBranches?.length ?? 0) > 0;
@@ -7176,25 +7595,40 @@ var WorkflowActionSchema = z60.object({
   const hasDefaultBranch = value.defaultBranch != null;
   if (hasStaticBranches || hasListBranches || hasDefaultBranch) return;
   ctx.addIssue({
-    code: z60.ZodIssueCode.custom,
+    code: z61.ZodIssueCode.custom,
     message: "BRANCH actions require at least one branch target",
     path: ["type"]
   });
 });
+var TypedWorkflowActionSchema = BaseWorkflowActionSchema.superRefine((value, ctx) => {
+  const definitionKey = value.actionTypeId ?? value.type;
+  if (definitionKey === "STATIC_BRANCH") return;
+  const typedSchema = WorkflowActionSchemasByDefinitionKey[definitionKey];
+  if (!typedSchema) return;
+  const result = typedSchema.safeParse(value);
+  if (result.success) return;
+  for (const issue of result.error.issues) {
+    ctx.addIssue(issue);
+  }
+});
+var WorkflowActionSchema = z61.union([
+  TypedWorkflowActionSchema,
+  StaticBranchWorkflowActionSchema
+]);
 
 // ../shared/operations/create-workflow/meta.ts
-var CreateWorkflowOperationSchema = z61.object({
-  type: z61.literal("create_workflow"),
-  description: z61.string().min(1),
-  name: z61.string().min(1),
-  workflow_type: z61.enum(["CONTACT_FLOW", "PLATFORM_FLOW"]),
-  object_type_id: z61.string().min(1),
-  is_enabled: z61.boolean().optional().default(false),
-  actions: z61.array(WorkflowActionSchema).min(1),
+var CreateWorkflowOperationSchema = z62.object({
+  type: z62.literal("create_workflow"),
+  description: z62.string().min(1),
+  name: z62.string().min(1),
+  workflow_type: z62.enum(["CONTACT_FLOW", "PLATFORM_FLOW"]),
+  object_type_id: z62.string().min(1),
+  is_enabled: z62.boolean().optional().default(false),
+  actions: z62.array(WorkflowActionSchema).min(1),
   enrollment_criteria: WorkflowEnrollmentCriteriaSchema.optional(),
-  suppression_list_ids: z61.array(z61.number()).optional(),
-  time_windows: z61.array(z61.record(z61.string(), z61.unknown())).optional(),
-  blocked_dates: z61.array(z61.record(z61.string(), z61.unknown())).optional()
+  suppression_list_ids: z62.array(z62.number()).optional(),
+  time_windows: z62.array(z62.record(z62.string(), z62.unknown())).optional(),
+  blocked_dates: z62.array(z62.record(z62.string(), z62.unknown())).optional()
 });
 var fields44 = [
   { name: "name", type: "string", required: true, description: "Workflow name" },
@@ -7312,17 +7746,17 @@ var createWorkflowMeta = {
 };
 
 // ../shared/operations/update-workflow/meta.ts
-import { z as z62 } from "zod";
-var UpdateWorkflowOperationSchema = z62.object({
-  type: z62.literal("update_workflow"),
-  description: z62.string().min(1),
-  workflow_id: z62.string().min(1),
-  name: z62.string().optional(),
-  actions: z62.array(WorkflowActionSchema).optional(),
+import { z as z63 } from "zod";
+var UpdateWorkflowOperationSchema = z63.object({
+  type: z63.literal("update_workflow"),
+  description: z63.string().min(1),
+  workflow_id: z63.string().min(1),
+  name: z63.string().optional(),
+  actions: z63.array(WorkflowActionSchema).optional(),
   enrollment_criteria: WorkflowEnrollmentCriteriaSchema.optional(),
-  suppression_list_ids: z62.array(z62.number()).optional(),
-  time_windows: z62.array(z62.record(z62.string(), z62.unknown())).optional(),
-  blocked_dates: z62.array(z62.record(z62.string(), z62.unknown())).optional()
+  suppression_list_ids: z63.array(z63.number()).optional(),
+  time_windows: z63.array(z63.record(z63.string(), z63.unknown())).optional(),
+  blocked_dates: z63.array(z63.record(z63.string(), z63.unknown())).optional()
 });
 var fields45 = [
   { name: "workflow_id", type: "string", required: true, description: "ID of the workflow to update (query workflows table)" },
@@ -7366,12 +7800,12 @@ var updateWorkflowMeta = {
 };
 
 // ../shared/operations/set-workflow-enabled/meta.ts
-import { z as z63 } from "zod";
-var SetWorkflowEnabledOperationSchema = z63.object({
-  type: z63.literal("set_workflow_enabled"),
-  description: z63.string().min(1),
-  workflow_id: z63.string().min(1),
-  enabled: z63.boolean()
+import { z as z64 } from "zod";
+var SetWorkflowEnabledOperationSchema = z64.object({
+  type: z64.literal("set_workflow_enabled"),
+  description: z64.string().min(1),
+  workflow_id: z64.string().min(1),
+  enabled: z64.boolean()
 });
 var fields46 = [
   { name: "workflow_id", type: "string", required: true, description: "ID of the workflow to enable or disable" },
@@ -7408,11 +7842,11 @@ var setWorkflowEnabledMeta = {
 };
 
 // ../shared/operations/delete-workflow/meta.ts
-import { z as z64 } from "zod";
-var DeleteWorkflowOperationSchema = z64.object({
-  type: z64.literal("delete_workflow"),
-  description: z64.string().min(1),
-  workflow_id: z64.string().min(1)
+import { z as z65 } from "zod";
+var DeleteWorkflowOperationSchema = z65.object({
+  type: z65.literal("delete_workflow"),
+  description: z65.string().min(1),
+  workflow_id: z65.string().min(1)
 });
 var fields47 = [
   { name: "workflow_id", type: "string", required: true, description: "ID of the workflow to delete (irreversible \u2014 cannot be restored via API)" }
@@ -7446,7 +7880,7 @@ var deleteWorkflowMeta = {
 };
 
 // ../shared/types/plan.ts
-var OperationSchema = z65.discriminatedUnion("type", [
+var OperationSchema = z66.discriminatedUnion("type", [
   CreatePropertyOperationSchema,
   CreatePipelineOperationSchema,
   CreateAssociationLabelOperationSchema,
@@ -7495,10 +7929,10 @@ var OperationSchema = z65.discriminatedUnion("type", [
   SetWorkflowEnabledOperationSchema,
   DeleteWorkflowOperationSchema
 ]);
-var WritePlanInputSchema = z65.object({
-  title: z65.string().min(1),
-  description: z65.string().min(1),
-  operations: z65.array(OperationSchema).min(1)
+var WritePlanInputSchema = z66.object({
+  title: z66.string().min(1),
+  description: z66.string().min(1),
+  operations: z66.array(OperationSchema).min(1)
 });
 
 // ../shared/operations/create-property/index.ts
@@ -11878,7 +12312,7 @@ var BUILT_IN_ACTION_TYPES = {
     description: "Set, edit, copy, or clear property values for enrolled or associated records",
     connectionType: "SINGLE_CONNECTION",
     fields: [
-      { name: "property_name", type: "string", required: true, description: "Internal property name to set" },
+      { name: "property", type: "string", required: true, description: "Internal property name to set" },
       { name: "value", type: "object", required: true, description: "MUST include type: 'STATIC_VALUE' when setting a value, e.g. { type: 'STATIC_VALUE', staticValue: 'value' }. Omitting type causes HTTP 500." },
       { name: "association", type: "object", required: false, description: "Association spec if setting on an associated record: { associationCategory: 'HUBSPOT_DEFINED', associationTypeId: <number> }" }
     ]
@@ -12444,7 +12878,7 @@ var collectWorkflowAssociatedPropertyActionRefs = (actions) => actions.flatMap((
   if (actionTypeId !== "0-5") return [];
   const fields48 = isRecord(action.fields) ? action.fields : void 0;
   const association = isRecord(fields48?.association) ? fields48.association : void 0;
-  const propertyName = typeof fields48?.property_name === "string" ? fields48.property_name : void 0;
+  const propertyName = typeof fields48?.property === "string" ? fields48.property : typeof fields48?.property_name === "string" ? fields48.property_name : void 0;
   const associationTypeId = typeof association?.associationTypeId === "number" ? association.associationTypeId : void 0;
   if (!propertyName || associationTypeId === void 0) return [];
   return [{
@@ -12718,10 +13152,9 @@ var normalizeWorkflowActionValues = (actions) => actions.map((action) => {
   if (!fields48) return { ...action };
   const actionTypeId = typeof action.actionTypeId === "string" ? action.actionTypeId : "";
   if (actionTypeId === "0-5") {
-    return {
-      ...action,
-      fields: { ...fields48, value: injectStaticValueType(fields48.value) }
-    };
+    const { property_name, ...restFields } = fields48;
+    const normalizedFields = property_name && !restFields.property ? { ...restFields, property: property_name, value: injectStaticValueType(restFields.value) } : { ...restFields, value: injectStaticValueType(restFields.value) };
+    return { ...action, fields: normalizedFields };
   }
   if (actionTypeId === "0-14" && Array.isArray(fields48.properties)) {
     return {
@@ -12753,7 +13186,7 @@ var collectWorkflowPropertyActionRefs = (actions) => actions.flatMap((action) =>
   const fields48 = typeof action.fields === "object" && action.fields !== null ? action.fields : void 0;
   const association = typeof fields48?.association === "object" && fields48.association !== null ? fields48.association : void 0;
   const value = typeof fields48?.value === "object" && fields48.value !== null ? fields48.value : void 0;
-  const propertyName = typeof fields48?.property_name === "string" ? fields48.property_name : void 0;
+  const propertyName = typeof fields48?.property === "string" ? fields48.property : typeof fields48?.property_name === "string" ? fields48.property_name : void 0;
   if (!propertyName) return [];
   return [{
     actionId: typeof action.actionId === "string" ? action.actionId : "<missing>",
@@ -13661,10 +14094,10 @@ var formatOperationDetail = (def) => {
 };
 
 // src/pure/operation-conversion.ts
-var FlatOperationSchema = z66.object({
-  type: z66.string().describe("Operation type (use describe_operations to see available types)"),
-  description: z66.string().describe("What this operation does"),
-  fields: z66.record(z66.string(), z66.unknown()).describe("Operation-specific fields (use describe_operations to see the required fields for each type)")
+var FlatOperationSchema = z67.object({
+  type: z67.string().describe("Operation type (use describe_operations to see available types)"),
+  description: z67.string().describe("What this operation does"),
+  fields: z67.record(z67.string(), z67.unknown()).describe("Operation-specific fields (use describe_operations to see the required fields for each type)")
 });
 var nestOperation = (flat) => {
   const def = getOperationDef(flat.type);
@@ -13700,9 +14133,9 @@ var convertAndValidateOperations = (operations, startIndex = 1) => {
 
 // src/tools/build_plan.ts
 var OPERATION_TYPE_COUNT = OPERATION_REGISTRY.length;
-var EditSchema = z67.object({
-  action: z67.enum(["replace", "remove"]).describe("'replace' swaps an operation, 'remove' deletes it"),
-  index: z67.number().int().min(1).describe("1-based operation index"),
+var EditSchema = z68.object({
+  action: z68.enum(["replace", "remove"]).describe("'replace' swaps an operation, 'remove' deletes it"),
+  index: z68.number().int().min(1).describe("1-based operation index"),
   operation: FlatOperationSchema.optional().describe("Required for replace, ignored for remove")
 });
 var summariseFields = (op) => {
@@ -13815,12 +14248,12 @@ WORKFLOW:
 4. submit_plan (dry_run: true) - Validate without saving (optional)
 5. submit_plan - Submit after user confirms`,
     inputSchema: {
-      title: z67.string().optional().describe("Short, descriptive title (required when creating a new draft)"),
-      description: z67.string().optional().describe("Detailed explanation of what the plan does and why (required when creating a new draft)"),
-      operations: z67.array(FlatOperationSchema).optional().describe("Operations to add to targeted draft(s)"),
-      edits: z67.array(EditSchema).optional().describe("Edits to apply: replace or remove operations by 1-based index"),
-      force: z67.boolean().optional().describe("If true, discard targeted draft(s) and start fresh"),
-      portalIds: z67.array(z67.number()).optional().describe("Optional explicit portal IDs to target. If provided, responses are keyed by portal ID.")
+      title: z68.string().optional().describe("Short, descriptive title (required when creating a new draft)"),
+      description: z68.string().optional().describe("Detailed explanation of what the plan does and why (required when creating a new draft)"),
+      operations: z68.array(FlatOperationSchema).optional().describe("Operations to add to targeted draft(s)"),
+      edits: z68.array(EditSchema).optional().describe("Edits to apply: replace or remove operations by 1-based index"),
+      force: z68.boolean().optional().describe("If true, discard targeted draft(s) and start fresh"),
+      portalIds: z68.array(z68.number()).optional().describe("Optional explicit portal IDs to target. If provided, responses are keyed by portal ID.")
     }
   }, async ({ title, description, operations, edits, force, portalIds }) => {
     const portalResolution = resolvePortalIds(
@@ -13988,7 +14421,7 @@ Use describe_operations to see the required fields for each operation type.`
 }
 
 // src/tools/describe_operations.ts
-import { z as z68 } from "zod";
+import { z as z69 } from "zod";
 var OPERATION_TYPE_COUNT2 = OPERATION_REGISTRY.length;
 function registerDescribeOperationsTool(server2) {
   server2.registerTool("describe_operations", {
@@ -14001,7 +14434,7 @@ Use cases:
 - Call with no arguments to list all available operation types.
 - Call with specific types to see their full field schemas and examples.`,
     inputSchema: {
-      operation_types: z68.array(z68.string()).optional().describe("Operation types to describe (e.g. ['create_property', 'delete_pipeline']). Omit to list all available types.")
+      operation_types: z69.array(z69.string()).optional().describe("Operation types to describe (e.g. ['create_property', 'delete_pipeline']). Omit to list all available types.")
     }
   }, async ({ operation_types }) => {
     if (!operation_types || operation_types.length === 0) {
@@ -14026,7 +14459,7 @@ Call describe_operations with no arguments to see all available types.`);
 }
 
 // src/tools/submit_plan.ts
-import { z as z69 } from "zod";
+import { z as z70 } from "zod";
 import { Effect as Effect97 } from "effect";
 var formatFixHint = (issue, summary) => {
   const opNum = issue.operation_index + 1;
@@ -14250,8 +14683,8 @@ RECOMMENDED WORKFLOW:
 4. Fix any issues with build_plan(edits: [...])
 5. Call submit_plan() to save after user confirms`,
     inputSchema: {
-      dry_run: z69.boolean().optional().describe("If true, validate only without saving. Defaults to false."),
-      portalIds: z69.array(z69.number()).optional().describe("Optional explicit portal IDs to submit. If provided, results are keyed by portal ID.")
+      dry_run: z70.boolean().optional().describe("If true, validate only without saving. Defaults to false."),
+      portalIds: z70.array(z70.number()).optional().describe("Optional explicit portal IDs to submit. If provided, results are keyed by portal ID.")
     }
   }, async ({ dry_run, portalIds }) => {
     const portalResolution = resolvePortalIds(
@@ -14294,7 +14727,7 @@ RECOMMENDED WORKFLOW:
 }
 
 // src/tools/get_plans.ts
-import { z as z70 } from "zod";
+import { z as z71 } from "zod";
 import { Effect as Effect98 } from "effect";
 var serialiseDraft2 = (portalId) => {
   const draft = getDraft(portalId);
@@ -14323,8 +14756,8 @@ Statuses:
 - FAILED: Execution failed
 - REJECTED: User rejected the plan`,
     inputSchema: {
-      status: z70.enum(["DRAFT", "REJECTED", "EXECUTING", "EXECUTED", "FAILED"]).optional().describe("Filter by plan status. Omit to show all plans."),
-      portalIds: z70.array(z70.number()).optional().describe("Optional explicit portal IDs. If provided, results are keyed by portal ID.")
+      status: z71.enum(["DRAFT", "REJECTED", "EXECUTING", "EXECUTED", "FAILED"]).optional().describe("Filter by plan status. Omit to show all plans."),
+      portalIds: z71.array(z71.number()).optional().describe("Optional explicit portal IDs. If provided, results are keyed by portal ID.")
     }
   }, async ({ status, portalIds }) => {
     const portalResolution = resolvePortalIds(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daeda/mcp-pro",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "description": "MCP server for HubSpot CRM — sync, query, and manage your portal data",
   "type": "module",
   "bin": {