@daeda/mcp-pro 0.1.29 → 0.1.31

package/dist/index.js

@@ -1549,6 +1549,7 @@ var assertWritable = (masterLock) => {
   }
 };
 var escapeSqlString = (value) => value.replace(/'/g, "''");
+var escapeSqlIdentifier = (value) => `"${value.replace(/"/g, '""')}"`;
 var buildSqlPlaceholders = (count, startAt = 1) => Array.from({ length: count }, (_, index) => `$${index + startAt}`).join(",");
 var buildDatabaseCacheKey = (portalId, mode, encryptionKey) => `${portalId}:${mode}:${encryptionKey ?? ""}`;
 var makeAssociationStagingTableName = (seed = Date.now()) => `_staging_assoc_sync_${seed}`;
@@ -1712,6 +1713,20 @@ async function openDatabaseConnection(portalId, _encryptionKey, options2) {
   if (mode === "read_only" && !fs3.existsSync(sourcePath)) {
     throw new Error(`Replica database not found for portal ${portalId}: ${sourcePath}`);
   }
+  if (mode === "read_only") {
+    const instance2 = await DuckDBInstance.create(":memory:");
+    const connection2 = await instance2.connect();
+    const escapedPath = escapeSqlString(sourcePath);
+    await connection2.run(`ATTACH '${escapedPath}' AS portal_replica (READ_ONLY)`);
+    await connection2.run("USE portal_replica");
+    return {
+      instance: instance2,
+      connection: connection2,
+      mode,
+      sourcePath,
+      replicaFingerprint: getReplicaFingerprint(portalId)
+    };
+  }
   const instance = await DuckDBInstance.create(sourcePath);
   const connection = await instance.connect();
   return {
@@ -1719,7 +1734,7 @@ async function openDatabaseConnection(portalId, _encryptionKey, options2) {
     connection,
     mode,
     sourcePath,
-    replicaFingerprint: mode === "read_only" ? getReplicaFingerprint(portalId) : null
+    replicaFingerprint: null
   };
 }
 var OBJECT_CSV_COLUMNS = ["id", "properties", "last_synced"];
@@ -1784,13 +1799,24 @@ async function bulkAppend(connection, tableName, columns) {
 function cleanupDbArtifacts(filePath) {
   try {
     fs3.unlinkSync(filePath);
-  } catch {
+  } catch (error) {
+    logFsCleanupError("remove file", filePath, error);
   }
   try {
     fs3.unlinkSync(`${filePath}.wal`);
-  } catch {
+  } catch (error) {
+    logFsCleanupError("remove wal", `${filePath}.wal`, error);
   }
 }
+function logFsCleanupError(action, filePath, error) {
+  const code = error?.code;
+  if (code === "ENOENT") return;
+  console.error("[replica] Cleanup step failed", {
+    action,
+    filePath,
+    error: describeError(error)
+  });
+}
 function nextReplicaFileName(seed = Date.now()) {
   return `${REPLICA_VERSION_PREFIX2}${seed}-${process.pid}-${Math.random().toString(36).slice(2, 8)}${REPLICA_VERSION_SUFFIX2}`;
 }
@@ -1802,7 +1828,8 @@ function writeReplicaPointer(portalId, fileName) {
 `, "utf-8");
   try {
     fs3.unlinkSync(pointerPath);
-  } catch {
+  } catch (error) {
+    logFsCleanupError("remove pointer", pointerPath, error);
   }
   fs3.renameSync(nextPointerPath, pointerPath);
 }
@@ -1818,8 +1845,51 @@ function cleanupStaleReplicaFiles(portalId, currentReplicaPath) {
       }
       cleanupDbArtifacts(path2.join(portalDir(portalId), entry));
     }
+  } catch (error) {
+    console.error("[replica] Failed stale replica cleanup", {
+      portalId,
+      currentReplicaPath,
+      error: describeError(error)
+    });
+  }
+}
+function getSourceDatabaseName(filePath) {
+  return path2.parse(filePath).name;
+}
+function getFileSnapshot(filePath) {
+  try {
+    const stats = fs3.statSync(filePath);
+    return {
+      exists: true,
+      sizeBytes: stats.size,
+      mtimeMs: stats.mtimeMs
+    };
   } catch {
+    return {
+      exists: false,
+      sizeBytes: null,
+      mtimeMs: null
+    };
+  }
+}
+function describeError(error) {
+  if (error instanceof Error) {
+    const errnoError = error;
+    return {
+      name: error.name,
+      message: error.message,
+      stack: error.stack,
+      code: errnoError.code,
+      errno: errnoError.errno,
+      syscall: errnoError.syscall,
+      path: errnoError.path,
+      dest: errnoError.dest,
+      cause: errnoError.cause ? describeError(errnoError.cause) : void 0
+    };
   }
+  return {
+    value: String(error)
+  };
 }
 async function publishReplica({
   masterLock,
@@ -1830,11 +1900,87 @@ async function publishReplica({
   const liveDbPath = dbPath(portalId);
   const nextReplicaName = nextReplicaFileName();
   const nextReplicaPath = replicaVersionDbPath(portalId, nextReplicaName);
+  const nextReplicaTempPath = `${nextReplicaPath}.next`;
+  const sourceDatabaseName = getSourceDatabaseName(liveDbPath);
+  const targetDatabaseName = "portal_replica_next";
+  console.error("[replica] Publish starting", {
+    portalId,
+    liveDbPath,
+    nextReplicaPath,
+    nextReplicaTempPath,
+    liveDb: getFileSnapshot(liveDbPath)
+  });
   cleanupDbArtifacts(nextReplicaPath);
-  await handle.connection.run("CHECKPOINT");
-  fs3.copyFileSync(liveDbPath, nextReplicaPath);
-  writeReplicaPointer(portalId, nextReplicaName);
-  cleanupStaleReplicaFiles(portalId, nextReplicaPath);
+  cleanupDbArtifacts(nextReplicaTempPath);
+  try {
+    console.error("[replica] Checkpointing live database", {
+      portalId,
+      liveDbPath
+    });
+    await handle.connection.run("CHECKPOINT");
+    console.error("[replica] Building replica snapshot via DuckDB", {
+      portalId,
+      sourceDatabaseName,
+      targetDatabaseName,
+      nextReplicaTempPath
+    });
+    await handle.connection.run(
+      `ATTACH '${escapeSqlString(nextReplicaTempPath)}' AS ${escapeSqlIdentifier(targetDatabaseName)}`
+    );
+    try {
+      await handle.connection.run(
+        `COPY FROM DATABASE ${escapeSqlIdentifier(sourceDatabaseName)} TO ${escapeSqlIdentifier(targetDatabaseName)}`
+      );
+      await handle.connection.run(`CHECKPOINT ${escapeSqlIdentifier(targetDatabaseName)}`);
+    } finally {
+      await handle.connection.run(`DETACH ${escapeSqlIdentifier(targetDatabaseName)}`);
+    }
+    console.error("[replica] Verifying replica snapshot", {
+      portalId,
+      nextReplicaTempPath,
+      snapshot: getFileSnapshot(nextReplicaTempPath)
+    });
+    const verifyInstance = await DuckDBInstance.create(":memory:");
+    const verifyConnection = await verifyInstance.connect();
+    try {
+      await verifyConnection.run(
+        `ATTACH '${escapeSqlString(nextReplicaTempPath)}' AS portal_replica_verify (READ_ONLY)`
+      );
+      await verifyConnection.run("DETACH portal_replica_verify");
+    } finally {
+      try {
+        verifyConnection.closeSync();
+      } catch {
+      }
+      try {
+        verifyInstance.closeSync();
+      } catch {
+      }
+    }
+    fs3.renameSync(nextReplicaTempPath, nextReplicaPath);
+    console.error("[replica] Writing replica pointer", {
+      portalId,
+      nextReplicaName,
+      nextReplicaPath
+    });
+    writeReplicaPointer(portalId, nextReplicaName);
+    cleanupStaleReplicaFiles(portalId, nextReplicaPath);
+    console.error("[replica] Publish complete", {
+      portalId,
+      nextReplicaPath,
+      replica: getFileSnapshot(nextReplicaPath)
+    });
+  } catch (error) {
+    console.error("[replica] Publish failed", {
+      portalId,
+      liveDbPath,
+      nextReplicaPath,
+      nextReplicaTempPath,
+      error: describeError(error)
+    });
+    cleanupDbArtifacts(nextReplicaTempPath);
+    throw error;
+  }
 }
 async function ensureTable(connection, ddlStatements) {
   for (const statement of ddlStatements) {
@@ -2846,8 +2992,11 @@ var makeReplicaLive = (config = {}) => {
                       dirty: true
                     })),
                     Effect25.flatMap(
-                      () => logStderr3(
-                        `[replica] Failed to publish replica for portal ${portalId}: ${error.message}`
+                      () => Effect25.sync(
+                        () => console.error("[replica] Failed to publish replica", {
+                          portalId,
+                          error
+                        })
                       )
                     ),
                     Effect25.flatMap(() => Effect25.fail(error))
@@ -3919,26 +4068,64 @@ var setSelectedPortal = (portalId) => {
 // src/effects/read-connection.ts
 import { Effect as Effect31, pipe as pipe19 } from "effect";
 import fs6 from "fs";
-var getReadConnection = (portalId) => pipe19(
+var openLiveConnection = (portalId, cause) => Effect31.tryPromise({
+  try: async () => {
+    const handle = await getDatabaseConnection(portalId, null);
+    return handle.connection;
+  },
+  catch: (error) => new DatabaseError({
+    message: `Failed to open live fallback connection for portal ${portalId}`,
+    cause: { replicaError: cause, fallbackError: error }
+  })
+});
+var getReadConnection = (portalId, options2) => pipe19(
   Effect31.sync(() => replicaDbPath(portalId)),
-  Effect31.filterOrFail(
-    (dbFile) => fs6.existsSync(dbFile),
-    () => new DatabaseError({
-      message: `Read replica not found for portal ${portalId}. Has it been synced?`
-    })
-  ),
-  Effect31.flatMap(
-    () => Effect31.tryPromise({
+  Effect31.flatMap((dbFile) => {
+    if (!fs6.existsSync(dbFile)) {
+      if (options2?.allowLiveFallback === true && fs6.existsSync(dbPath(portalId))) {
+        console.error("[read-connection] Replica missing, falling back to live database", {
+          portalId,
+          replicaPath: dbFile,
+          livePath: dbPath(portalId)
+        });
+        return openLiveConnection(
+          portalId,
+          new DatabaseError({
+            message: `Read replica not found for portal ${portalId}. Has it been synced?`
+          })
+        );
+      }
+      return Effect31.fail(
+        new DatabaseError({
+          message: `Read replica not found for portal ${portalId}. Has it been synced?`
+        })
+      );
+    }
+    return Effect31.tryPromise({
       try: async () => {
         const handle = await getDatabaseConnection(portalId, null, { readOnly: true });
         return handle.connection;
       },
-      catch: (e) => new DatabaseError({
-        message: `Failed to open read connection for portal ${portalId}`,
-        cause: e
-      })
-    })
-  )
+      catch: (error) => error
+    });
+  }),
+  Effect31.catchAll((error) => {
+    if (!(options2?.allowLiveFallback === true) || !fs6.existsSync(dbPath(portalId))) {
+      return Effect31.fail(
+        error instanceof DatabaseError ? error : new DatabaseError({
+          message: `Failed to open read connection for portal ${portalId}`,
+          cause: error
+        })
+      );
+    }
+    console.error("[read-connection] Read-only replica open failed, falling back to live database", {
+      portalId,
+      replicaPath: replicaDbPath(portalId),
+      livePath: dbPath(portalId),
+      error
+    });
+    return openLiveConnection(portalId, error);
+  })
 );
 var closeReadConnection = (portalId) => Effect31.promise(() => evictDatabaseConnections(portalId));
 
@@ -5620,8 +5807,10 @@ var resolvePortalIds = (explicitPortalIds, selectedPortalId2, portals) => {
 
 // src/tools/query.ts
 var MAX_ROWS = 200;
-var runQueryForPortal = async (portalId, finalSql, autoCapped) => {
-  const conn = await Effect50.runPromise(getReadConnection(portalId));
+var runQueryForPortal = async (portalId, finalSql, autoCapped, allowLiveFallback) => {
+  const conn = await Effect50.runPromise(
+    getReadConnection(portalId, { allowLiveFallback })
+  );
   const start = performance.now();
   const reader = await conn.runAndReadAll(finalSql);
   const rows = reader.getRowObjects();
@@ -5697,7 +5886,8 @@ Example queries:
           const result = await runQueryForPortal(
             portalId,
             finalSql,
-            !hasExplicitLimit
+            !hasExplicitLimit,
+            deps.isMasterClient()
           );
           return {
             content: [{ type: "text", text: stringifyResult(result) }]
@@ -5718,7 +5908,8 @@ Example queries:
           keyedResults[String(portalId)] = await runQueryForPortal(
             portalId,
             finalSql,
-            !hasExplicitLimit
+            !hasExplicitLimit,
+            deps.isMasterClient()
           );
         } catch (e) {
           hadAnyErrors = true;
@@ -5938,8 +6129,10 @@ function openInBrowser(target) {
 
 // src/tools/chart.ts
 var MAX_ROWS2 = 200;
-var runQueryForPortal2 = async (portalId, sql) => {
-  const conn = await Effect51.runPromise(getReadConnection(portalId));
+var runQueryForPortal2 = async (portalId, sql, allowLiveFallback) => {
+  const conn = await Effect51.runPromise(
+    getReadConnection(portalId, { allowLiveFallback })
+  );
   const start = performance.now();
   const reader = await conn.runAndReadAll(sql);
   const rows = reader.getRowObjects();
@@ -6051,7 +6244,11 @@ SELECT json_extract_string(properties, '$.dealstage') as stage, COUNT(*) as coun
         const [portalId] = portalResolution.portalIds;
         try {
           await deps.ensureFresh(portalId);
-          const result = await runQueryForPortal2(portalId, finalSql);
+          const result = await runQueryForPortal2(
+            portalId,
+            finalSql,
+            deps.isMasterClient()
+          );
           if (result.rows.length === 0) {
             return {
               content: [{ type: "text", text: "Query returned no rows - nothing to chart." }],
@@ -6105,7 +6302,11 @@ SELECT json_extract_string(properties, '$.dealstage') as stage, COUNT(*) as coun
       for (const portalId of portalResolution.portalIds) {
         try {
           await deps.ensureFresh(portalId);
-          const result = await runQueryForPortal2(portalId, finalSql);
+          const result = await runQueryForPortal2(
+            portalId,
+            finalSql,
+            deps.isMasterClient()
+          );
           if (result.rows.length === 0) {
             hadErrors = true;
             keyedPortalResults[String(portalId)] = { error: "Query returned no rows - nothing to chart." };
@@ -6204,8 +6405,10 @@ async function buildConnectionSection(deps) {
     totalPortals: portals.length
   };
 }
-async function buildSchemaSection(portalId) {
-  const conn = await Effect52.runPromise(getReadConnection(portalId));
+async function buildSchemaSection(portalId, deps) {
+  const conn = await Effect52.runPromise(
+    getReadConnection(portalId, { allowLiveFallback: deps.isMasterClient() })
+  );
   const allPluginTableNames = new Set(getAllTableNames());
   const sectionResults = await Promise.all(
     getPlugins().map(async (plugin) => {
@@ -6276,7 +6479,7 @@ Use "all" to get everything at once.`,
           for (const portalId of portalResolution.portalIds) {
             try {
               await deps.ensureFresh(portalId);
-              schemaByPortal[String(portalId)] = await buildSchemaSection(portalId);
+              schemaByPortal[String(portalId)] = await buildSchemaSection(portalId, deps);
             } catch (e) {
               explicitSchemaHadErrors = true;
               const message = e instanceof Error ? e.message : String(e);
@@ -6287,7 +6490,7 @@ Use "all" to get everything at once.`,
         } else {
           const [portalId] = portalResolution.portalIds;
           await deps.ensureFresh(portalId);
-          result.schema = await buildSchemaSection(portalId);
+          result.schema = await buildSchemaSection(portalId, deps);
         }
       }
       return {
@@ -9303,7 +9506,7 @@ var BUILT_IN_ACTION_TYPES = {
       { name: "date", type: "object", required: true, description: "Date spec \u2014 MUST include type: { type: 'STATIC_VALUE', staticValue: '<unix ms>' } or { type: 'OBJECT_PROPERTY', propertyName: '<name>' }. Omitting type causes HTTP 500." },
       { name: "delta", type: "string", required: true, description: "Offset from the date (e.g. '0')" },
       { name: "time_unit", type: "string", required: true, description: "Unit for delta: DAYS, HOURS, MINUTES" },
-      { name: "time_of_day", type: "object", required: true, description: "Required time of day: { hour: number, minute: number }. HubSpot UI rejects delay-until-date actions without it." }
+      { name: "time_of_day", type: "object", required: true, description: "Required time of day: { hour: number, minute: number }. HubSpot UI rejects delay-until-date actions without it. If the workflow continues after this delay, the next action should be a STATIC_BRANCH on hs_delay_status rather than a direct business-action connection." }
     ]
   },
   "0-63809083": {
@@ -9623,7 +9826,7 @@ var WORKFLOW_ACTION_CREATE_METADATA_BY_ID = {
   },
   "0-35": {
     resourceRequirements: [],
-    createGuidanceText: "When using STATIC_VALUE dates, send a future Unix-milliseconds timestamp. time_of_day is required for reliable creation."
+    createGuidanceText: "When using STATIC_VALUE dates, send a future Unix-milliseconds timestamp. time_of_day is required for reliable creation. If the delay action continues to another step, route it into a STATIC_BRANCH that reads inputValue { actionId: '<delay_action_id>', dataKey: 'hs_delay_status', type: 'FIELD_DATA' } and continues from the DATE_MET_AS_PLANNED branch instead of connecting directly to the next business action."
   },
   "0-14": {
     resourceRequirements: [],
@@ -11774,12 +11977,12 @@ var PROPERTY_VALUE_CHANGED_PARAMETER_SCHEMA = [
   {
     name: "property_value_operator",
     required: false,
-    description: "Defaults to IS_KNOWN. Supported values: IS_KNOWN, IS_UNKNOWN, IS_EQUAL_TO, IS_NOT_EQUAL_TO."
+    description: "Defaults to IS_KNOWN. Supported values: IS_KNOWN, IS_UNKNOWN, IS_EQUAL_TO, IS_NOT_EQUAL_TO. This only controls the event refinement filter on hs_value inside the 4-655002 property-change event branch."
   },
   {
     name: "property_value",
     required: false,
-    description: "Required when property_value_operator is IS_EQUAL_TO or IS_NOT_EQUAL_TO."
+    description: "Required when property_value_operator is IS_EQUAL_TO or IS_NOT_EQUAL_TO. This does not add generic object-property filters like pipeline or dealstage to the event branch."
   }
 ];
 var WORKFLOW_REFERENCE_PARAMETER_SCHEMA = [
@@ -11797,7 +12000,7 @@ var PARAMETER_SCHEMA_BY_TEMPLATE = {
 var EVENT_TYPE_METADATA_BY_EVENT_TYPE_ID = {
   "4-655002": {
     requiresRefinementFilters: true,
-    refinementNote: "Requires event-specific refinement filters (e.g. hs_property_name, hs_property_value) embedded in the event filter branch to specify which property and value to trigger on. Standard PROPERTY filters are NOT sufficient. Prefer LIST_BASED enrollment with re-enrollment triggers for 'property changed to X' scenarios."
+    refinementNote: "Requires event-specific refinement filters embedded in the event branch. For MCP these are hs_name and hs_value. Standard object-property filters like pipeline, dealstage, amount, or closedate are not valid inside the 4-655002 branch. Prefer LIST_BASED enrollment with re-enrollment triggers for 'property changed to X' scenarios that also need record eligibility filters."
   }
 };
 var normalizedRows = normalized_triggers_default;
@@ -12235,6 +12438,13 @@ var buildEnrollmentCriteriaFromTrigger = (trigger) => {
 };
 
 // ../shared/pure/workflow-operation-schema.ts
+var ENUMERATION_DISALLOWED_OPERATORS = /* @__PURE__ */ new Set([
+  "IS_EQUAL_TO",
+  "IS_NOT_EQUAL_TO"
+]);
+var REFINEMENT_PROPERTIES_BY_EVENT_TYPE_ID = {
+  "4-655002": /* @__PURE__ */ new Set(["hs_name", "hs_value"])
+};
 var WorkflowConnectionSchema2 = z62.object({
   edgeType: z62.string().min(1),
   nextActionId: z62.string().min(1)
@@ -12262,6 +12472,14 @@ var WorkflowFilterSchema = z62.object({
       message: "property filters require operation",
       path: ["operation"]
     });
+    return;
+  }
+  if (value.operation.operationType === "ENUMERATION" && ENUMERATION_DISALLOWED_OPERATORS.has(value.operation.operator)) {
+    ctx.addIssue({
+      code: z62.ZodIssueCode.custom,
+      message: `operator '${value.operation.operator}' is not valid for ENUMERATION workflow filters. Use operators like IS_ANY_OF, IS_NONE_OF, IS_EXACTLY, or IS_NOT_EXACTLY.`,
+      path: ["operation", "operator"]
+    });
   }
 });
 var WorkflowBranchSchema = z62.object({
@@ -12302,6 +12520,19 @@ var WorkflowEnrollmentBranchSchema = z62.object({
       path: ["eventTypeId"]
     });
   }
+  const allowedRefinementProperties = REFINEMENT_PROPERTIES_BY_EVENT_TYPE_ID[value.eventTypeId];
+  if (!allowedRefinementProperties) return;
+  for (const [index, filter] of value.filters.entries()) {
+    if (!filter || typeof filter !== "object") continue;
+    if (filter.filterType !== "PROPERTY") continue;
+    if (typeof filter.property !== "string") continue;
+    if (allowedRefinementProperties.has(filter.property)) continue;
+    ctx.addIssue({
+      code: z62.ZodIssueCode.custom,
+      message: `eventTypeId '${value.eventTypeId}' only supports refinement filters on ${Array.from(allowedRefinementProperties).join(", ")}. Move generic properties like '${filter.property}' into LIST_BASED criteria or use enrollment_trigger.`,
+      path: ["filters", index, "property"]
+    });
+  }
 });
 var EventBasedEnrollmentCriteriaSchema = z62.object({
   type: z62.literal("EVENT_BASED"),
@@ -12432,7 +12663,7 @@ var fields44 = [
     name: "enrollment_criteria",
     type: "object",
     required: false,
-    description: "Enrollment trigger config. Set type to 'EVENT_BASED', 'LIST_BASED', or 'MANUAL'. Prefer enrollment_trigger for supported single-trigger EVENT_BASED shortcuts. For EVENT_BASED, each eventFilterBranch needs a valid eventTypeId from the workflow_enrollment_triggers table (e.g. '4-655002' for property change, '4-1639801' for form submission). Do NOT use object type IDs like '0-3' as eventTypeId \u2014 those are CRM object types, not events. For LIST_BASED and MANUAL, query workflow_enrollment_triggers rows where shortcut_kind = 'CRITERIA_EXAMPLE' and reuse official_criteria_example_json, criteria_shape_json, usage_guidance, preferred_for_json, and avoid_for_json. IMPORTANT: Some event types (notably '4-655002' property value changed) require event-specific refinement filters (e.g. hs_property_name, hs_property_value) embedded in the event filter branch \u2014 standard PROPERTY filters are NOT sufficient. For 'when property X changes to Y' scenarios, prefer LIST_BASED enrollment with re-enrollment triggers on that property instead. PROPERTY filters must include operation.operationType. For enum properties use 'ENUMERATION' not 'MULTISTRING'. Query synced workflows for structural examples.",
+    description: "Enrollment trigger config. Set type to 'EVENT_BASED', 'LIST_BASED', or 'MANUAL'. Prefer enrollment_trigger for supported single-trigger EVENT_BASED shortcuts. For EVENT_BASED, each eventFilterBranch needs a valid eventTypeId from the workflow_enrollment_triggers table (e.g. '4-655002' for property change, '4-1639801' for form submission). Do NOT use object type IDs like '0-3' as eventTypeId \u2014 those are CRM object types, not events. For LIST_BASED and MANUAL, query workflow_enrollment_triggers rows where shortcut_kind = 'CRITERIA_EXAMPLE' and reuse official_criteria_example_json, criteria_shape_json, usage_guidance, preferred_for_json, and avoid_for_json. IMPORTANT: Some event types (notably '4-655002' property value changed) require event-specific refinement filters embedded in the event branch. For '4-655002', only event refinement properties like hs_name and hs_value belong in that branch; generic record properties like pipeline, dealstage, amount, and closedate do NOT belong there. For 'when property X changes to Y' scenarios that also need record eligibility checks, prefer LIST_BASED enrollment with re-enrollment triggers on that property instead. PROPERTY filters must include operation.operationType. For enum properties use 'ENUMERATION' not 'MULTISTRING'. For LIST_BASED property existence filters like IS_KNOWN / IS_UNKNOWN, prefer operationType 'ALL_PROPERTY' instead of 'TIME_POINT', even for date properties. ENUMERATION filters do not support operators like 'IS_EQUAL_TO' or 'IS_NOT_EQUAL_TO'; use enum operators like 'IS_ANY_OF', 'IS_NONE_OF', 'IS_EXACTLY', or 'IS_NOT_EXACTLY'. Query synced workflows for structural examples.",
     shape: "EVENT_BASED: { shouldReEnroll: boolean, eventFilterBranches: [{ filterBranchType: 'UNIFIED_EVENTS', filterBranchOperator?, eventTypeId: string (REQUIRED, from workflow_enrollment_triggers.event_type_id), operator?, filters: [{ filterType: 'PROPERTY', property: string, operation: { operationType: string, operator: string } }], filterBranches: [...] }], listMembershipFilterBranches?: [...] } | LIST_BASED: { shouldReEnroll: boolean, listFilterBranch: { filterBranchType, filters: [...], filterBranches: [...] }, reEnrollmentTriggersFilterBranches?: [...], unEnrollObjectsNotMeetingCriteria?: boolean } | MANUAL: { shouldReEnroll: boolean }"
   },
   { name: "suppression_list_ids", type: "array", required: false, description: "Array of list IDs to suppress from enrollment" },
@@ -12539,7 +12770,7 @@ var fields45 = [
     description: "Replacement single-trigger shortcut. Query workflow_enrollment_triggers first and only use rows where shortcut_kind = 'EVENT_TRIGGER_SHORTCUT'. Then use catalog_id plus parameter_schema_json, official_filter_template, official_filters_example_json, and required_object_type_ids_json.",
     shape: "{ catalog_id: string, should_re_enroll?: boolean, ...template-specific parameters from parameter_schema_json such as property_name/property_value_operator/property_value or target_workflow_id }"
   },
-  { name: "enrollment_criteria", type: "object", required: false, description: "Replacement enrollment criteria (replaces existing). Set type to EVENT_BASED, LIST_BASED, or MANUAL. Prefer enrollment_trigger for supported single-trigger EVENT_BASED shortcuts. For EVENT_BASED, each UNIFIED_EVENTS branch requires a valid eventTypeId from workflow_enrollment_triggers.event_type_id (e.g. '4-655002' for property change). Do NOT use object type IDs like '0-3' as eventTypeId. For LIST_BASED and MANUAL, query workflow_enrollment_triggers rows where shortcut_kind = 'CRITERIA_EXAMPLE' and reuse official_criteria_example_json, criteria_shape_json, and usage_guidance. IMPORTANT: Event types like '4-655002' (property changed) require event-specific refinement filters (e.g. hs_property_name) \u2014 standard PROPERTY filters are NOT sufficient. Prefer LIST_BASED enrollment with re-enrollment triggers for property-change scenarios." },
+  { name: "enrollment_criteria", type: "object", required: false, description: "Replacement enrollment criteria (replaces existing). Set type to EVENT_BASED, LIST_BASED, or MANUAL. Prefer enrollment_trigger for supported single-trigger EVENT_BASED shortcuts. For EVENT_BASED, each UNIFIED_EVENTS branch requires a valid eventTypeId from workflow_enrollment_triggers.event_type_id (e.g. '4-655002' for property change). Do NOT use object type IDs like '0-3' as eventTypeId. For LIST_BASED and MANUAL, query workflow_enrollment_triggers rows where shortcut_kind = 'CRITERIA_EXAMPLE' and reuse official_criteria_example_json, criteria_shape_json, and usage_guidance. IMPORTANT: Event types like '4-655002' require event-specific refinement filters only. In MCP this means hs_name and hs_value inside the event branch; generic properties like pipeline, dealstage, amount, or closedate do not belong there. ENUMERATION filters also do not support operators like IS_EQUAL_TO or IS_NOT_EQUAL_TO; use IS_ANY_OF, IS_NONE_OF, IS_EXACTLY, or IS_NOT_EXACTLY instead. Prefer LIST_BASED enrollment with re-enrollment triggers for property-change scenarios that also need record eligibility filters." },
   { name: "suppression_list_ids", type: "array", required: false, description: "Replacement suppression list IDs" },
   { name: "time_windows", type: "array", required: false, description: "Replacement execution time windows" },
   { name: "blocked_dates", type: "array", required: false, description: "Replacement blocked date ranges" }
@@ -16949,6 +17180,10 @@ var OPERATION_TYPE_FOR_PROPERTY_TYPE2 = {
   date: "TIME_POINT",
   datetime: "TIME_POINT"
 };
+var ENUMERATION_INVALID_OPERATORS = /* @__PURE__ */ new Set([
+  "IS_EQUAL_TO",
+  "IS_NOT_EQUAL_TO"
+]);
 var isCompatibleEnrollmentOperationType = (operationType, expectedOperationType, propertyType) => operationType === expectedOperationType || operationType === "ALL_PROPERTY" || operationType === "TIME_RANGED" && (propertyType === "date" || propertyType === "datetime");
 var collectPropertyFiltersFromBranches = (branches, parentObjectTypeId, parentEventTypeId) => {
   const refs = [];
@@ -16963,6 +17198,7 @@ var collectPropertyFiltersFromBranches = (branches, parentObjectTypeId, parentEv
       refs.push({
         property: filter.property,
         operationType: operation.operationType,
+        operator: typeof operation.operator === "string" ? operation.operator : void 0,
         objectTypeId: contextObjectTypeId,
         eventTypeId: branchEventTypeId
       });
@@ -17029,6 +17265,15 @@ var validateWorkflowEnrollmentMetadata = (params) => {
       });
       continue;
     }
+    if (filterRef.eventTypeId === "4-655002") {
+      add({
+        severity: "error",
+        operation_index: operationIndex,
+        code: "INVALID_ENROLLMENT_REFINEMENT_FILTER",
+        message: `eventTypeId '4-655002' only supports event refinement filters like hs_name and hs_value. Property '${filterRef.property}' should not appear in that event branch; move it into LIST_BASED criteria or use enrollment_trigger.`
+      });
+      continue;
+    }
     if (!enabledObjectTypeIds.has(filterRef.objectTypeId)) continue;
     const propertyDefinitions = propertyDefinitionsByObjectType.get(filterRef.objectTypeId);
     const propertyDefinition = propertyDefinitions?.get(filterRef.property);
@@ -17043,7 +17288,24 @@ var validateWorkflowEnrollmentMetadata = (params) => {
     }
     const expectedOperationType = OPERATION_TYPE_FOR_PROPERTY_TYPE2[propertyDefinition.type];
     if (!expectedOperationType) continue;
+    if (filterRef.eventTypeId === void 0 && (filterRef.operator === "IS_KNOWN" || filterRef.operator === "IS_UNKNOWN") && filterRef.operationType === "TIME_POINT" && (propertyDefinition.type === "date" || propertyDefinition.type === "datetime")) {
+      add({
+        severity: "error",
+        operation_index: operationIndex,
+        code: "INVALID_ENROLLMENT_FILTER_OPERATION_TYPE",
+        message: `Workflow enrollment filter property '${filterRef.property}' uses operator '${filterRef.operator}' with operationType 'TIME_POINT'. For LIST_BASED property existence checks, use operationType 'ALL_PROPERTY' instead.`
+      });
+      continue;
+    }
     if (isCompatibleEnrollmentOperationType(filterRef.operationType, expectedOperationType, propertyDefinition.type)) {
+      if (propertyDefinition.type === "enumeration" && filterRef.operator !== void 0 && ENUMERATION_INVALID_OPERATORS.has(filterRef.operator)) {
+        add({
+          severity: "error",
+          operation_index: operationIndex,
+          code: "INVALID_ENROLLMENT_FILTER_OPERATOR",
+          message: `Workflow enrollment filter property '${filterRef.property}' has type 'enumeration' but uses operator '${filterRef.operator}'. Use enumeration operators like IS_ANY_OF, IS_NONE_OF, IS_EXACTLY, or IS_NOT_EXACTLY.`
+        });
+      }
       continue;
     }
     add({
@@ -17166,6 +17428,42 @@ var validateDelayUntilDateAction = (params) => {
   }
   return issues;
 };
+var validateDelayUntilDateBranching = (params) => {
+  const { actions, operationIndex } = params;
+  const issues = [];
+  const actionsById = new Map(actions.flatMap(
+    (action) => typeof action.actionId === "string" && action.actionId.length > 0 ? [[action.actionId, action]] : []
+  ));
+  for (const action of actions) {
+    if (action.actionTypeId !== "0-35") continue;
+    const delayActionId = action.actionId ?? "<missing>";
+    const branchActionId = action.connection?.nextActionId;
+    if (!branchActionId) continue;
+    const branchAction = actionsById.get(branchActionId);
+    if (!branchAction || branchAction.type !== "STATIC_BRANCH") {
+      issues.push({
+        severity: "error",
+        operation_index: operationIndex,
+        code: "WORKFLOW_DELAY_UNTIL_DATE_BRANCH_REQUIRED",
+        message: `Action '${delayActionId}' (0-35 delay until date) must flow into a STATIC_BRANCH that reads hs_delay_status before continuing. Do not connect the delay action directly to the next business action.`
+      });
+      continue;
+    }
+    const inputValue = branchAction.inputValue;
+    const hasExpectedInputValue = inputValue?.actionId === action.actionId && inputValue?.dataKey === "hs_delay_status" && inputValue?.type === "FIELD_DATA";
+    const hasDateMetAsPlannedBranch = Array.isArray(branchAction.staticBranches) && branchAction.staticBranches.some(
+      (branch) => isRecord(branch) && branch.branchValue === "DATE_MET_AS_PLANNED" && typeof getNestedNextActionId(branch) === "string"
+    );
+    if (hasExpectedInputValue && hasDateMetAsPlannedBranch) continue;
+    issues.push({
+      severity: "error",
+      operation_index: operationIndex,
+      code: "WORKFLOW_DELAY_UNTIL_DATE_BRANCH_REQUIRED",
+      message: `Action '${delayActionId}' (0-35 delay until date) must be followed by a STATIC_BRANCH with inputValue { actionId: '${delayActionId}', dataKey: 'hs_delay_status', type: 'FIELD_DATA' } and a DATE_MET_AS_PLANNED branch connection.`
+    });
+  }
+  return issues;
+};
 var validateRotateToOwnerAction = (params) => {
   const { action, actionId, operationIndex } = params;
   if (action.actionTypeId !== "0-11") return [];
@@ -17312,6 +17610,7 @@ var validateWorkflowActions = (params) => {
     issues.push(...validateRotateToOwnerAction({ action, actionId, operationIndex }));
     issues.push(...validateCreateTaskAssociations({ action, actionId, operationIndex, context }));
   }
+  issues.push(...validateDelayUntilDateBranching({ actions, operationIndex }));
   for (const action of actions) {
     for (const nextActionId of collectActionNextActionIds(action)) {
       if (actionIds.has(nextActionId)) continue;
@@ -19884,17 +20183,20 @@ var mainProgram = Effect108.gen(function* () {
   };
   registerPortalSelection(server, { ws, config, handoffSelectedPortal });
   registerQueryTool(server, {
+    isMasterClient,
     getSelectedPortalId: getPortalId,
     getPortals,
     ensureFresh
   });
   registerChartTool(server, {
+    isMasterClient,
     getSelectedPortalId: getPortalId,
     getPortals,
     ensureFresh
   });
   registerStatusTool(server, {
     getConnectionState: () => Effect108.runSync(ws.getState()),
+    isMasterClient,
     getPortals,
     getSelectedPortalId: getPortalId,
     ensureFresh

package/package.json

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