@hotmeshio/hotmesh 0.5.7 → 0.5.8

package/README.md

@@ -1,289 +1,189 @@
 # HotMesh
 
-**Durable Memory + Coordinated Execution**
+**Integrate AI automation into your current stack — without breaking it**
 
 ![beta release](https://img.shields.io/badge/release-beta-blue.svg)
 
-HotMesh removes the repetitive glue of building durable agents, pipelines, and long‑running workflows. You focus on *what* to change; HotMesh handles *how*, safely and durably.
+HotMesh modernizes existing business systems by introducing a durable workflow layer that connects AI, automation, and human-in-the-loop steps — **without replacing your current stack**.
+Each process runs with persistent memory in Postgres, surviving retries, crashes, and human delays.
 
----
-
-## Why Choose HotMesh
-
-- **Zero Boilerplate** - Transactional Postgres without the setup hassle
-- **Built-in Durability** - Automatic crash recovery and replay protection
-- **Parallel by Default** - Run hooks concurrently without coordination
-- **SQL-First** - Query pipeline status and agent memory directly
+```bash
+npm install @hotmeshio/hotmesh
+```
 
 ---
 
-## Core Abstractions
-
-### 1. Entities
-
-Durable JSONB documents representing *process memory*. Each entity:
-
-* Has a stable identity (`workflowId` / logical key).
-* Evolves via atomic commands.
-* Is versioned implicitly by transactional history.
-* Can be partially indexed for targeted query performance.
-
-> **Design Note:** Treat entity shape as *contractual surface* + *freeform interior*. Index only the minimal surface required for lookups or dashboards.
-
-### 2. Hooks
-
-Re‑entrant, idempotent, interruptible units of work that *maintain* an entity. Hooks can:
-
-* Start, stop, or be re‑invoked without corrupting state.
-* Run concurrently (Postgres ensures isolation on write).
-* Emit signals to let coordinators or sibling hooks know a perspective / phase completed.
-
-### 3. Workflow Coordinators
+## What It Solves
 
-Thin entrypoints that:
+Modernization often stalls where systems meet people and AI.
+HotMesh builds a **durable execution bridge** across those seams — linking your database, APIs, RPA, and AI agents into one recoverable process.
 
-* Seed initial entity state.
-* Fan out perspective / phase hooks.
-* Optionally synthesize or finalize.
-* Return a snapshot (often the final entity state) — *the workflow result is just memory*.
-
-### 4. Commands (Entity Mutation Primitives)
-
-| Command     | Purpose                                   | Example                                          |
-| ----------- | ----------------------------------------- | ------------------------------------------------ |
-| `set`       | Replace full value (first write or reset) | `await e.set({ user: { id: 123, name: "John" } })` |
-| `merge`     | Deep JSON merge                           | `await e.merge({ user: { email: "john@example.com" } })` |
-| `append`    | Append to an array field                  | `await e.append('items', { id: 1, name: "New Item" })` |
-| `prepend`   | Add to start of array field              | `await e.prepend('items', { id: 0, name: "First Item" })` |
-| `remove`    | Remove item from array by index          | `await e.remove('items', 0)` |
-| `increment` | Numeric counters / progress               | `await e.increment('counter', 5)` |
-| `toggle`    | Toggle boolean value                      | `await e.toggle('settings.enabled')` |
-| `setIfNotExists` | Set value only if path doesn't exist | `await e.setIfNotExists('user.id', 123)` |
-| `delete`    | Remove field at specified path           | `await e.delete('user.email')` |
-| `get`       | Read value at path (or full entity)      | `await e.get('user.email')` |
-| `signal`    | Mark hook milestone / unlock waiters      | `await MemFlow.workflow.signal('phase-x', data)` |
+* **AI that can fail safely** — retries, resumable state, and confidence tracking
+* **Human steps that don’t block** — pause for days, resume instantly
+* **Legacy systems that stay connected** — SQL and RPA coexist seamlessly
+* **Full visibility** — query workflows and outcomes directly in SQL
 
 ---
 
-## Table of Contents
+## Core Model
 
-1. [Quick Start](#quick-start)
-2. [Memory Architecture](#memory-architecture)
-3. [Durable AI Agents](#durable-ai-agents)
-4. [Stateful Pipelines](#stateful-pipelines)
-5. [Indexing Strategy](#indexing-strategy)
-6. [Operational Notes](#operational-notes)
-7. [Documentation & Links](#documentation--links)
-
----
+### Entity — the Business Process Record
 
-## Quick Start
+Every workflow writes to a durable JSON document in Postgres called an **Entity**.
+It becomes the shared memory between APIs, RPA jobs, LLM agents, and human operators.
 
-### Install
-
-```bash
-npm install @hotmeshio/hotmesh
-```
-
-### Minimal Setup
 ```ts
-import { MemFlow } from '@hotmeshio/hotmesh';
-import { Client as Postgres } from 'pg';
-
-async function main() {
-  // Auto-provisions required tables/index scaffolding on first run
-  const mf = await MemFlow.init({
-    appId: 'my-app',
-    engine: {
-      connection: {
-        class: Postgres,
-        options: { connectionString: process.env.DATABASE_URL }
-      }
-    }
-  });
-
-  // Start a durable research agent (entity-backed workflow)
-  const handle = await mf.workflow.start({
-    entity: 'research-agent',
-    workflowName: 'researchAgent',
-    workflowId: 'agent-session-jane-001',
-    args: ['Long-term impacts of renewable energy subsidies'],
-    taskQueue: 'agents'
-  });
-
-  console.log('Final Memory Snapshot:', await handle.result());
-}
-
-main().catch(console.error);
+const e = await MemFlow.workflow.entity();
+
+// initialize from a source event
+await e.set({
+  caseId: "A42",
+  stage: "verification",
+  retries: 0,
+  notes: []
+});
+
+// AI step adds structured output
+await e.merge({
+  aiSummary: { result: "Verified coverage", confidence: 0.93 },
+  stage: "approval",
+});
+
+// human operator review
+await e.append("notes", { reviewer: "ops1", comment: "ok to proceed" });
+
+// maintain counters
+await e.increment("retries", 1);
+
+// retrieve current process state
+const data = await e.get();
 ```
 
-### Value Checklist (What You Did *Not* Have To Do)
-- Create tables / migrations
-- Define per-agent caches
-- Implement optimistic locking
-- Build a queue fan‑out mechanism
-- Hand-roll replay protection
+**Minimal surface contract**
 
----
-
-## Memory Architecture
-Each workflow = **1 durable entity**. Hooks are stateless functions *shaped by* that entity's evolving JSON. You can inspect or modify it at any time using ordinary SQL or the provided API.
+| Command       | Purpose                            |
+| ------------- | ---------------------------------- |
+| `set()`       | Initialize workflow state          |
+| `merge()`     | Update any JSON path               |
+| `append()`    | Add entries to lists (logs, notes) |
+| `increment()` | Maintain counters or metrics       |
+| `get()`       | Retrieve current state             |
 
-### Programmatic Indexing
-```ts
-// Create index for premium research agents
-await MemFlow.Entity.createIndex('research-agent', 'isPremium', hotMeshClient);
-
-// Find premium agents needing verification
-const agents = await MemFlow.Entity.find('research-agent', {
-  isPremium: true,
-  needsVerification: true
-}, hotMeshClient);
-```
+Entities are stored in plain SQL tables, directly queryable:
 
-### Direct SQL Access
 ```sql
--- Same index via SQL (more control over index type/conditions)
-CREATE INDEX idx_research_agents_premium ON my_app.jobs (id)
-WHERE entity = 'research-agent' AND (context->>'isPremium')::boolean = true;
-
--- Ad hoc query example
-SELECT id, context->>'status' as status, context->>'confidence' as confidence
+SELECT id, context->>'stage', context->'aiSummary'->>'result'
 FROM my_app.jobs
-WHERE entity = 'research-agent'
-  AND (context->>'isPremium')::boolean = true
-  AND (context->>'confidence')::numeric > 0.8;
+WHERE entity = 'claims-review'
+  AND context->>'stage' != 'complete';
 ```
 
-**Guidelines:**
-1. *Model intent, not mechanics.* Keep ephemeral calculation artifacts minimal; store derived values only if reused.
-2. *Index sparingly.* Each index is a write amplification cost. Start with 1–2 selective partial indexes.
-3. *Keep arrays append‑only where possible.* Supports audit and replay semantics cheaply.
-4. *Choose your tool:* Use Entity methods for standard queries, raw SQL for complex analytics or custom indexes.
-
 ---
 
-## Durable AI Agents
-Agents become simpler: the *agent* is the memory record; hooks supply perspectives, verification, enrichment, or lifecycle progression.
+### Hook — Parallel Work Units
+
+Hooks are stateless functions that operate on the shared Entity.
+Each hook executes independently (API, RPA, or AI), retrying automatically until success.
 
-### Coordinator (Research Agent)
 ```ts
-export async function researchAgent(query: string) {
-  const entity = await MemFlow.workflow.entity();
-
-  const initial = {
-    query,
-    findings: [],
-    perspectives: {},
-    confidence: 0,
-    verification: {},
-    status: 'researching',
-    startTime: new Date().toISOString()
-  };
-  await entity.set<typeof initial>(initial);
-
-  // Fan-out perspectives
-  await MemFlow.workflow.execHook({ taskQueue: 'agents', workflowName: 'optimisticPerspective', args: [query], signalId: 'optimistic-complete' });
-  await MemFlow.workflow.execHook({ taskQueue: 'agents', workflowName: 'skepticalPerspective', args: [query], signalId: 'skeptical-complete' });
-  await MemFlow.workflow.execHook({ taskQueue: 'agents', workflowName: 'verificationHook', args: [query], signalId: 'verification-complete' });
-  await MemFlow.workflow.execHook({ taskQueue: 'agents', workflowName: 'synthesizePerspectives', args: [], signalId: 'synthesis-complete' });
-
-  return await entity.get();
-}
+await MemFlow.workflow.execHook({
+  workflowName: "verifyCoverage",
+  args: ["A42"]
+});
 ```
 
-### Synthesis Hook
+To run independent work in parallel, use a **batch execution** pattern:
+
 ```ts
-export async function synthesizePerspectives({ signal }: { signal: string }) {
-  const e = await MemFlow.workflow.entity();
-  const ctx = await e.get();
-
-  const synthesized = await analyzePerspectives(ctx.perspectives);
-  await e.merge({
-    perspectives: {
-      synthesis: {
-        finalAssessment: synthesized,
-        confidence: calculateConfidence(ctx.perspectives)
-      }
-    },
-    status: 'completed'
-  });
-  await MemFlow.workflow.signal(signal, {});
-}
+// Run independent research perspectives in parallel using batch execution
+await MemFlow.workflow.execHookBatch([
+  {
+    key: 'optimistic',
+    options: {
+      taskQueue: 'agents',
+      workflowName: 'optimisticPerspective',
+      args: [query],
+      signalId: 'optimistic-complete'
+    }
+  },
+  {
+    key: 'skeptical',
+    options: {
+      taskQueue: 'agents',
+      workflowName: 'skepticalPerspective',
+      args: [query],
+      signalId: 'skeptical-complete'
+    }
+  }
+]);
 ```
 
-> **Pattern:** Fan-out hooks that write *adjacent* subtrees (e.g., `perspectives.optimistic`, `perspectives.skeptical`). A final hook merges a compact synthesis object. Avoid cross-hook mutation of the same nested branch.
+Each hook runs in its own recoverable context, allowing AI, API, and RPA agents to operate independently while writing to the same durable Entity.
 
 ---
 
-## Stateful Pipelines
-Pipelines are identical in structure to agents: a coordinator seeds memory; phase hooks advance state; the entity is the audit trail.
+## Example — AI-Assisted Claims Review
 
-### Document Processing Pipeline (Coordinator)
 ```ts
-export async function documentProcessingPipeline() {
-  const pipeline = await MemFlow.workflow.entity();
-
-  const initial = {
-    documentId: `doc-${Date.now()}`,
-    status: 'started',
-    startTime: new Date().toISOString(),
-    imageRefs: [],
-    extractedInfo: [],
-    validationResults: [],
-    finalResult: null,
-    processingSteps: [],
-    errors: [],
-    pageSignals: {}
-  };
-  await pipeline.set<typeof initial>(initial);
-
-  await pipeline.merge({ status: 'loading-images' });
-  await pipeline.append('processingSteps', 'image-load-started');
-  const imageRefs = await activities.loadImagePages();
-  if (!imageRefs?.length) throw new Error('No image references found');
-  await pipeline.merge({ imageRefs });
-  await pipeline.append('processingSteps', 'image-load-completed');
-
-  // Page hooks
-  for (const [i, ref] of imageRefs.entries()) {
-    const page = i + 1;
-    await MemFlow.workflow.execHook({
-      taskQueue: 'pipeline',
-      workflowName: 'pageProcessingHook',
-      args: [ref, page, initial.documentId],
-      signalId: `page-${page}-complete`
-    });
-  }
+export async function claimsWorkflow(caseId: string) {
+  const e = await MemFlow.workflow.entity();
+  await e.set({ caseId, stage: "intake", approved: false });
+
+  // Run verification and summarization in parallel
+  await MemFlow.workflow.execHookBatch([
+    {
+      key: 'verifyCoverage',
+      options: {
+        taskQueue: 'agents',
+        workflowName: 'verifyCoverage',
+        args: [caseId],
+        signalId: 'verify-complete'
+      }
+    },
+    {
+      key: 'generateSummary',
+      options: {
+        taskQueue: 'agents',
+        workflowName: 'generateSummary',
+        args: [caseId],
+        signalId: 'summary-complete'
+      }
+    }
+  ]);
 
-  // Validation
-  await MemFlow.workflow.execHook({ taskQueue: 'pipeline', workflowName: 'validationHook', args: [initial.documentId], signalId: 'validation-complete' });
-  // Approval
-  await MemFlow.workflow.execHook({ taskQueue: 'pipeline', workflowName: 'approvalHook', args: [initial.documentId], signalId: 'approval-complete' });
-  // Notification
-  await MemFlow.workflow.execHook({ taskQueue: 'pipeline', workflowName: 'notificationHook', args: [initial.documentId], signalId: 'processing-complete' });
+  // Wait for human sign-off
+  const approval = await MemFlow.workflow.waitFor("human-approval");
+  await e.merge({ approved: approval === true, stage: "complete" });
 
-  await pipeline.merge({ status: 'completed', completedAt: new Date().toISOString() });
-  await pipeline.append('processingSteps', 'pipeline-completed');
-  return await pipeline.get();
+  return await e.get();
 }
 ```
 
-**Operational Characteristics:**
-- *Replay Friendly*: Each hook can be retried; pipeline memory records invariant progress markers (`processingSteps`).
-- *Parallelizable*: Pages fan out naturally without manual queue wiring.
-- *Auditable*: Entire lifecycle captured in a single evolving JSON record.
+This bridges:
+
+* an existing insurance or EHR system (status + audit trail)
+* LLM agents for data validation and summarization
+* a human reviewer for final sign-off
+
+—all within one recoverable workflow record.
 
 ---
 
-## Documentation & Links
-* **SDK Reference** – https://hotmeshio.github.io/sdk-typescript
-* **Agent Example Tests** – https://github.com/hotmeshio/sdk-typescript/tree/main/tests/memflow/agent
-* **Pipeline Example Tests** – https://github.com/hotmeshio/sdk-typescript/tree/main/tests/memflow/pipeline
-* **Sample Projects** – https://github.com/hotmeshio/samples-typescript
+## Why It Fits Integration Work
+
+HotMesh is purpose-built for **incremental modernization**.
+
+| Need                          | What HotMesh Provides                    |
+| ----------------------------- | ---------------------------------------- |
+| Tie AI into legacy apps       | Durable SQL bridge with full visibility  |
+| Keep human review steps       | Wait-for-signal workflows                |
+| Handle unstable APIs          | Built-in retries and exponential backoff |
+| Trace process across systems  | Unified JSON entity per workflow         |
+| Store long-running AI results | Durable state for agents and automations |
 
 ---
 
 ## License
-Apache 2.0 with commercial restrictions* – see `LICENSE`.
->*NOTE: It's open source with one commercial exception: Build, sell, and share solutions made with HotMesh. But don't white-label the orchestration core and repackage it as your own workflow-as-a-service.
+
+Apache 2.0 — free to build, integrate, and deploy.
+Do not resell the core engine as a hosted service.

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.5.7",
+    "version": "0.5.8",
     "description": "Permanent-Memory Workflows & AI Agents",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",
@@ -106,7 +106,7 @@
         "eslint-config-prettier": "^9.1.0",
         "eslint-plugin-import": "^2.29.1",
         "eslint-plugin-prettier": "^5.1.3",
-        "javascript-obfuscator": "^4.1.1",
+        "javascript-obfuscator": "^0.6.2",
         "jest": "^29.5.0",
         "nats": "^2.28.0",
         "openai": "^5.9.0",

package/build/services/memflow/workflow/execHookBatch.d.ts

@@ -0,0 +1,54 @@
+import { ExecHookOptions } from './execHook';
+/**
+ * Configuration for a single hook in a batch execution
+ */
+export interface BatchHookConfig<T = any> {
+    /** Unique key to identify this hook's result in the returned object */
+    key: string;
+    /** Hook execution options */
+    options: ExecHookOptions;
+}
+/**
+ * Executes multiple hooks in parallel and awaits all their signal responses.
+ * This solves the race condition where Promise.all() with execHook() would prevent
+ * all waitFor() registrations from completing.
+ *
+ * The method ensures all waitFor() registrations happen before any hooks execute,
+ * preventing signals from being sent before the framework is ready to receive them.
+ *
+ * @template T - Object type with keys matching the batch hook keys and values as expected response types
+ * @param {BatchHookConfig[]} hookConfigs - Array of hook configurations with unique keys
+ * @returns {Promise<T>} Object with keys from hookConfigs and values as the signal responses
+ *
+ * @example
+ * ```typescript
+ * // Execute multiple research perspectives in parallel
+ * const results = await MemFlow.workflow.execHookBatch<{
+ *   optimistic: OptimisticResult;
+ *   skeptical: SkepticalResult;
+ * }>([
+ *   {
+ *     key: 'optimistic',
+ *     options: {
+ *       taskQueue: 'agents',
+ *       workflowName: 'optimisticPerspective',
+ *       args: [query],
+ *       signalId: 'optimistic-complete'
+ *     }
+ *   },
+ *   {
+ *     key: 'skeptical',
+ *     options: {
+ *       taskQueue: 'agents',
+ *       workflowName: 'skepticalPerspective',
+ *       args: [query],
+ *       signalId: 'skeptical-complete'
+ *     }
+ *   }
+ * ]);
+ *
+ * // results.optimistic contains the OptimisticResult
+ * // results.skeptical contains the SkepticalResult
+ * ```
+ */
+export declare function execHookBatch<T extends Record<string, any>>(hookConfigs: BatchHookConfig[]): Promise<T>;

package/build/services/memflow/workflow/execHookBatch.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execHookBatch = void 0;
+const hook_1 = require("./hook");
+const waitFor_1 = require("./waitFor");
+/**
+ * Executes multiple hooks in parallel and awaits all their signal responses.
+ * This solves the race condition where Promise.all() with execHook() would prevent
+ * all waitFor() registrations from completing.
+ *
+ * The method ensures all waitFor() registrations happen before any hooks execute,
+ * preventing signals from being sent before the framework is ready to receive them.
+ *
+ * @template T - Object type with keys matching the batch hook keys and values as expected response types
+ * @param {BatchHookConfig[]} hookConfigs - Array of hook configurations with unique keys
+ * @returns {Promise<T>} Object with keys from hookConfigs and values as the signal responses
+ *
+ * @example
+ * ```typescript
+ * // Execute multiple research perspectives in parallel
+ * const results = await MemFlow.workflow.execHookBatch<{
+ *   optimistic: OptimisticResult;
+ *   skeptical: SkepticalResult;
+ * }>([
+ *   {
+ *     key: 'optimistic',
+ *     options: {
+ *       taskQueue: 'agents',
+ *       workflowName: 'optimisticPerspective',
+ *       args: [query],
+ *       signalId: 'optimistic-complete'
+ *     }
+ *   },
+ *   {
+ *     key: 'skeptical',
+ *     options: {
+ *       taskQueue: 'agents',
+ *       workflowName: 'skepticalPerspective',
+ *       args: [query],
+ *       signalId: 'skeptical-complete'
+ *     }
+ *   }
+ * ]);
+ *
+ * // results.optimistic contains the OptimisticResult
+ * // results.skeptical contains the SkepticalResult
+ * ```
+ */
+async function execHookBatch(hookConfigs) {
+    // Generate signal IDs for hooks that don't have them
+    const processedConfigs = hookConfigs.map(config => ({
+        ...config,
+        options: {
+            ...config.options,
+            signalId: config.options.signalId || `memflow-hook-${crypto.randomUUID()}`
+        }
+    }));
+    // STEP 1: Fire off all hooks (but don't await them)
+    // This registers the hooks/streams with the system immediately
+    await Promise.all(processedConfigs.map(config => {
+        const hookOptions = {
+            ...config.options,
+            args: [...config.options.args, {
+                    signal: config.options.signalId,
+                    $memflow: true
+                }]
+        };
+        return (0, hook_1.hook)(hookOptions);
+    }));
+    // STEP 2: Await all waitFor operations 
+    // This ensures all waitFor registrations happen in the same call stack
+    // before any MemFlowWaitForError is thrown (via setImmediate mechanism)
+    const results = await Promise.all(processedConfigs.map(config => (0, waitFor_1.waitFor)(config.options.signalId)));
+    // STEP 3: Return results as a keyed object
+    return Object.fromEntries(processedConfigs.map((config, i) => [config.key, results[i]]));
+}
+exports.execHookBatch = execHookBatch;

package/build/services/memflow/workflow/index.d.ts

@@ -6,6 +6,7 @@ import { enrich } from './enrich';
 import { emit } from './emit';
 import { execChild, startChild } from './execChild';
 import { execHook } from './execHook';
+import { execHookBatch } from './execHookBatch';
 import { proxyActivities } from './proxyActivities';
 import { search } from './searchMethods';
 import { random } from './random';
@@ -53,6 +54,7 @@ export declare class WorkflowService {
     static executeChild: typeof execChild;
     static startChild: typeof startChild;
     static execHook: typeof execHook;
+    static execHookBatch: typeof execHookBatch;
     static proxyActivities: typeof proxyActivities;
     static search: typeof search;
     static entity: typeof entity;

package/build/services/memflow/workflow/index.js

@@ -9,6 +9,7 @@ const enrich_1 = require("./enrich");
 const emit_1 = require("./emit");
 const execChild_1 = require("./execChild");
 const execHook_1 = require("./execHook");
+const execHookBatch_1 = require("./execHookBatch");
 const proxyActivities_1 = require("./proxyActivities");
 const searchMethods_1 = require("./searchMethods");
 const random_1 = require("./random");
@@ -71,6 +72,7 @@ WorkflowService.execChild = execChild_1.execChild;
 WorkflowService.executeChild = execChild_1.executeChild;
 WorkflowService.startChild = execChild_1.startChild;
 WorkflowService.execHook = execHook_1.execHook;
+WorkflowService.execHookBatch = execHookBatch_1.execHookBatch;
 WorkflowService.proxyActivities = proxyActivities_1.proxyActivities;
 WorkflowService.search = searchMethods_1.search;
 WorkflowService.entity = entityMethods_1.entity;

package/build/services/store/providers/postgres/kvtables.js

@@ -267,9 +267,32 @@ const KVTables = (context) => ({
                 field TEXT NOT NULL,
                 value TEXT,
                 type ${schemaName}.type_enum NOT NULL,
+                created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+                updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
                 PRIMARY KEY (job_id, field),
                 FOREIGN KEY (job_id) REFERENCES ${fullTableName} (id) ON DELETE CASCADE
               ) PARTITION BY HASH (job_id);
+            `);
+                        // Create trigger function for updating updated_at only for mutable types
+                        await client.query(`
+              CREATE OR REPLACE FUNCTION ${schemaName}.update_attributes_updated_at()
+              RETURNS TRIGGER AS $$
+              BEGIN
+                  IF NEW.type IN ('udata', 'jdata', 'hmark', 'jmark') AND 
+                     (OLD.value IS NULL OR NEW.value <> OLD.value) THEN
+                      NEW.updated_at = NOW();
+                  END IF;
+                  RETURN NEW;
+              END;
+              $$ LANGUAGE plpgsql;
+            `);
+                        // Create trigger for updated_at updates
+                        await client.query(`
+              DROP TRIGGER IF EXISTS trg_update_attributes_updated_at ON ${attributesTableName};
+              CREATE TRIGGER trg_update_attributes_updated_at
+                  BEFORE UPDATE ON ${attributesTableName}
+                  FOR EACH ROW
+                  EXECUTE FUNCTION ${schemaName}.update_attributes_updated_at();
             `);
                         // Create partitions for attributes table
                         await client.query(`

package/build/services/sub/providers/postgres/postgres.d.ts

@@ -8,6 +8,7 @@ declare class PostgresSubService extends SubService<PostgresClientType & Provide
     private static clientSubscriptions;
     private static clientHandlers;
     private instanceSubscriptions;
+    private instanceId;
     constructor(eventClient: PostgresClientType & ProviderClient, storeClient?: PostgresClientType & ProviderClient);
     init(namespace: string, appId: string, engineId: string, logger: ILogger): Promise<void>;
     private setupNotificationHandler;

package/build/services/sub/providers/postgres/postgres.js

@@ -11,7 +11,8 @@ class PostgresSubService extends index_1.SubService {
     constructor(eventClient, storeClient) {
         super(eventClient, storeClient);
         // Instance-level subscriptions for cleanup
-        this.instanceSubscriptions = new Set();
+        this.instanceSubscriptions = new Map(); // topic -> callbackKey mapping
+        this.instanceId = crypto_1.default.randomUUID();
     }
     async init(namespace = key_1.HMNS, appId, engineId, logger) {
         this.namespace = namespace;
@@ -36,8 +37,10 @@ class PostgresSubService extends index_1.SubService {
             if (callbacks && callbacks.size > 0) {
                 try {
                     const payload = JSON.parse(msg.payload || '{}');
-                    // Call all callbacks registered for this channel across all SubService instances
-                    callbacks.forEach((callback) => {
+                    // Collect callbacks first to avoid modification during iteration
+                    const callbackArray = Array.from(callbacks.entries());
+                    // Call all callbacks
+                    callbackArray.forEach(([callbackKey, callback], index) => {
                         try {
                             callback(msg.channel, payload);
                         }
@@ -97,13 +100,16 @@ class PostgresSubService extends index_1.SubService {
             // Start listening to the safe topic (only once per channel across all instances)
             await this.eventClient.query(`LISTEN "${safeKey}"`);
         }
-        // Add this callback to the list
-        callbacks.set(this, callback);
+        // Generate unique callback key to avoid overwrites
+        const callbackKey = `${this.instanceId}-${Date.now()}-${Math.random()}`;
+        // Add this callback to the list with unique key
+        callbacks.set(callbackKey, callback);
         // Track this subscription for cleanup
-        this.instanceSubscriptions.add(safeKey);
+        this.instanceSubscriptions.set(safeKey, callbackKey);
         this.logger.debug(`postgres-subscribe`, {
             originalKey,
             safeKey,
+            callbackKey,
             totalCallbacks: callbacks.size,
         });
     }
@@ -117,11 +123,12 @@ class PostgresSubService extends index_1.SubService {
             return;
         }
         const callbacks = clientSubscriptions.get(safeKey);
-        if (!callbacks || callbacks.size === 0) {
+        const callbackKey = this.instanceSubscriptions.get(safeKey);
+        if (!callbacks || callbacks.size === 0 || !callbackKey) {
             return;
         }
-        // Remove callback from this specific instance
-        callbacks.delete(this);
+        // Remove callback using the tracked unique key
+        callbacks.delete(callbackKey);
         // Remove from instance tracking
         this.instanceSubscriptions.delete(safeKey);
         // Stop listening to the safe topic if no more callbacks exist
@@ -132,6 +139,7 @@ class PostgresSubService extends index_1.SubService {
         this.logger.debug(`postgres-unsubscribe`, {
             originalKey,
             safeKey,
+            callbackKey,
             remainingCallbacks: callbacks.size,
         });
     }
@@ -144,10 +152,10 @@ class PostgresSubService extends index_1.SubService {
         if (!clientSubscriptions) {
             return;
         }
-        for (const safeKey of this.instanceSubscriptions) {
+        for (const [safeKey, callbackKey] of this.instanceSubscriptions) {
             const callbacks = clientSubscriptions.get(safeKey);
             if (callbacks) {
-                callbacks.delete(this);
+                callbacks.delete(callbackKey);
                 // If no more callbacks exist for this channel, stop listening
                 if (callbacks.size === 0) {
                     clientSubscriptions.delete(safeKey);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/hotmesh",
-  "version": "0.5.7",
+  "version": "0.5.8",
   "description": "Permanent-Memory Workflows & AI Agents",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -106,7 +106,7 @@
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-prettier": "^5.1.3",
-    "javascript-obfuscator": "^4.1.1",
+    "javascript-obfuscator": "^0.6.2",
     "jest": "^29.5.0",
     "nats": "^2.28.0",
     "openai": "^5.9.0",