@matatbread/matbot-triggers 0.3.2 → 0.3.4

package/package.json

@@ -4,7 +4,7 @@
     "node",
     "browser"
   ],
-  "version": "0.3.2",
+  "version": "0.3.4",
   "engines": {
     "node": ">=24.0.0"
   },
@@ -33,11 +33,11 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@matatbread/matbot-plugin-api": "^0.3.2"
+    "@matatbread/matbot-plugin-api": "^0.3.4"
   },
   "devDependencies": {
     "typescript": "^6.0.3",
-    "@matatbread/matbot-plugin-api": "^0.3.2"
+    "@matatbread/matbot-plugin-api": "^0.3.4"
   },
   "scripts": {
     "typecheck": "tsc --noEmit"

package/src/manager.ts

@@ -27,7 +27,6 @@ function invokeKey(t: { invoke: Trigger['invoke'] }): string {
  * Constructed only with web-platform primitives, so it runs in the browser too.
  */
 export class TriggerManager implements Triggers {
-  private readonly triggers = new Map<string, Trigger>();
   private readonly store:    Store<Trigger>;
   private readonly services: MatbotMachine;
   // Aborts on teardown (clear()), ending the mounted-swap subscription set up in setupTriggers.
@@ -38,8 +37,7 @@ export class TriggerManager implements Triggers {
     this.services = services;
   }
 
-  /** Ends with the manager (teardown). Hand to `services.mounted.consume` so a StorageBackend swap
-   *  re-reads the new backend's triggers, and the loop stops when the plugin unloads. */
+  /** Aborts on teardown (clear()) — ends any in-flight classifier call the manager owns. */
   get signal(): AbortSignal { return this.lifecycle.signal; }
 
   // The classifier provider, resolved live per evaluation (so a triggers_config change takes effect on
@@ -53,26 +51,25 @@ export class TriggerManager implements Triggers {
     return turnProvider;
   }
 
-  /** (Re)load persisted triggers into memory. Re-runnable: the initial boot load and every later
-   *  StorageBackend swap funnel through here. Reading `this.store` (a swap-following proxy) always hits
-   *  the live backend, so a swap re-reads the new backend's triggers. Clears first — the old in-memory
-   *  set belongs to the displaced backend. */
-  async load(): Promise<void> {
-    this.triggers.clear();
+  /** Read straight through the backing store on every call — no in-memory snapshot. The store is a
+   *  swap-following proxy, so this always reflects the live backend AND the current principal's
+   *  partition, and a shared backend's out-of-band writes are seen too. A snapshot here would be
+   *  principal-blind and go stale under any second writer; caching, if a slow backend needs it,
+   *  belongs in the StorageBackend, not in this consumer. */
+  async all(): Promise<Trigger[]> {
     const { items } = await this.store.query({});
-    for (const t of items) {
-      this.triggers.set(t.id, t);
-    }
+    return items;
   }
 
-  all(): Trigger[] { return [...this.triggers.values()]; }
-  get(id: string): Trigger | undefined { return this.triggers.get(id); }
+  async get(id: string): Promise<Trigger | undefined> {
+    return (await this.store.get(id)) ?? undefined;
+  }
 
   /** Triggers whose invocation matches the filter: `tool` (if given) must equal `invoke.tool`, and
    *  `params` (if given) must deep-equal `invoke.params`. The natural "which trigger(s) fire tool X
    *  (with these args)" lookup — e.g. the one that loads a given skill. */
-  query(filter: { tool?: string; params?: unknown }): Trigger[] {
-    return this.all().filter(t => {
+  async query(filter: { tool?: string; params?: unknown }): Promise<Trigger[]> {
+    return (await this.all()).filter(t => {
       if (filter.tool !== undefined && t.invoke.tool !== filter.tool) return false;
       if (filter.params !== undefined &&
           JSON.stringify(t.invoke.params ?? null) !== JSON.stringify(filter.params)) return false;
@@ -92,13 +89,12 @@ export class TriggerManager implements Triggers {
       updatedAt:  now,
     };
     await this.store.set(doc.id, doc);
-    this.triggers.set(doc.id, doc);
     return doc;
   }
 
   async update(id: string, patch: Partial<TriggerSpec>): Promise<Trigger | undefined> {
-    const cur = this.triggers.get(id);
-    if (cur === undefined) return undefined;
+    const cur = await this.store.get(id);
+    if (cur === null) return undefined;
     return this.casMutate(cur, prev => ({
       ...prev,
       ...(patch.conditions !== undefined ? { conditions: patch.conditions } : {}),
@@ -110,21 +106,20 @@ export class TriggerManager implements Triggers {
   }
 
   async remove(id: string): Promise<boolean> {
-    const cur = this.triggers.get(id);
-    if (cur === undefined) return false;
+    const cur = await this.store.get(id);
+    if (cur === null) return false;
     await this.store.delete(id, cur.version);
-    this.triggers.delete(id);
     return true;
   }
 
   async importIfAbsent(spec: TriggerSpec): Promise<Trigger> {
     const key      = invokeKey(spec);
-    const existing = this.all().find(t => invokeKey(t) === key);
+    const existing = (await this.all()).find(t => invokeKey(t) === key);
     if (existing !== undefined) return existing;
     return this.add(spec);
   }
 
-  clear(): void { this.lifecycle.abort(); this.triggers.clear(); }
+  clear(): void { this.lifecycle.abort(); }
 
   /**
    * LLM-judge every enabled condition on `surface` against the current turn and return the distinct
@@ -148,7 +143,8 @@ export class TriggerManager implements Triggers {
     // Candidate key is `${triggerId}#${conditionIndex}` — addressing conditions by index is fine
     // because evaluation is per-turn and the trigger set is stable for its duration. The surface a
     // condition belongs to is derived from its `kind` (ephemeral/contextual→user, retract/followup→agent).
-    const candidates = this.all()
+    const triggers   = await this.all();
+    const candidates = triggers
       .filter(t => t.enabled !== false)
       .flatMap(t => t.conditions
         .map((c, i) => ({ triggerId: t.id, key: `${t.id}#${i}`, index: i, kind: c.kind, rule: c.rule }))
@@ -195,8 +191,9 @@ export class TriggerManager implements Triggers {
       list.push({ index: c.index, kind: c.kind, rule: c.rule, ...(why !== undefined ? { why } : {}) });
       firedByTrigger.set(c.triggerId, list);
     }
+    const byId = new Map(triggers.map(t => [t.id, t]));
     return [...firedByTrigger].flatMap(([id, matched]) => {
-      const trigger = this.triggers.get(id);
+      const trigger = byId.get(id);
       return trigger ? [{ trigger, kinds: [...new Set(matched.map(m => m.kind))], matched }] : [];
     });
   }
@@ -206,11 +203,10 @@ export class TriggerManager implements Triggers {
     for (;;) {
       const next = mutate(cur);
       const r = await this.store.cas(cur.id, cur.version, next);
-      if (r.ok) { this.triggers.set(next.id, next); return next; }
+      if (r.ok) return next;
       const fresh = await this.store.get(cur.id);
       if (fresh === null) {
         await this.store.set(next.id, next);
-        this.triggers.set(next.id, next);
         return next;
       }
       cur = fresh;

package/src/plugin.ts

@@ -148,11 +148,8 @@ export async function setupTriggers(services: MatbotMachine): Promise<TriggerMan
 
   const store   = services.createStore<Trigger>('triggers') as Store<Trigger>;
   const manager = new TriggerManager(store, services);
-  await manager.load();
-  // Re-read after a deferred StorageBackend swap lands: the new backend's `triggers` namespace replaces
-  // the old in-memory set. No `replay` — the initial load is the boot load above; this reacts only to
-  // future swaps. Ends with the manager (teardown aborts manager.signal).
-  services.mounted.consume({ key: 'StorageBackend', signal: manager.signal }, () => void manager.load());
+  // No boot load and no StorageBackend-swap re-read: the manager reads straight through `store` (a
+  // swap-following proxy) on every call, so it always reflects the live backend and current partition.
   await services.register('Triggers', manager);
 
   services.tools.register(createTriggerActionTool(manager));

package/src/tools.ts

@@ -90,20 +90,20 @@ export function createTriggerActionTool(manager: TriggerManager): Tool<ToolResul
 
       switch (args.action) {
         case 'list': {
-          yield { type: 'result', value: { triggers: manager.all() } };
+          yield { type: 'result', value: { triggers: await manager.all() } };
           return;
         }
 
         case 'query': {
           const a = args as Extract<TriggerActionInput, { action: 'query' }>;
-          yield { type: 'result', value: { triggers: manager.query(queryFilter(a)) } };
+          yield { type: 'result', value: { triggers: await manager.query(queryFilter(a)) } };
           return;
         }
 
         case 'get': {
           const { id } = args as Extract<TriggerActionInput, { action: 'get' }>;
           if (!id) { yield { type: 'error', message: 'action "get" requires "id".' }; return; }
-          const t = manager.get(id);
+          const t = await manager.get(id);
           if (!t) { yield { type: 'error', message: `Trigger not found: "${id}"` }; return; }
           yield { type: 'result', value: t };
           return;
@@ -128,10 +128,13 @@ export function createTriggerActionTool(manager: TriggerManager): Tool<ToolResul
           if (!a.id) { yield { type: 'error', message: 'action "update" requires "id".' }; return; }
           if (a.conditions !== undefined && !validConditions(a.conditions)) { yield { type: 'error', message: '"conditions" must be [{ kind, rule }].' }; return; }
           if (a.tool !== undefined && typeof a.tool !== 'string')           { yield { type: 'error', message: '"tool" must be a string.' }; return; }
+          const priorTool = (a.tool !== undefined || a.params !== undefined)
+            ? (await manager.get(a.id))?.invoke.tool ?? ''
+            : '';
           const t = await manager.update(a.id, {
             ...(a.conditions !== undefined ? { conditions: a.conditions } : {}),
             ...(a.tool !== undefined || a.params !== undefined
-              ? { invoke: { tool: a.tool ?? manager.get(a.id)?.invoke.tool ?? '', ...(a.params !== undefined ? { params: a.params } : {}) } }
+              ? { invoke: { tool: a.tool ?? priorTool, ...(a.params !== undefined ? { params: a.params } : {}) } }
               : {}),
             ...(a.enabled !== undefined ? { enabled: a.enabled } : {}),
           });
@@ -168,7 +171,7 @@ export function createTriggerActionTool(manager: TriggerManager): Tool<ToolResul
           if (a.tool === undefined && a.params === undefined) { yield { type: 'error', message: 'action "move" requires a filter ("tool" and/or "params") selecting which triggers to re-target — refusing to move every trigger.' }; return; }
           const invoke = { tool: a.toTool, ...(a.toParams !== undefined ? { params: a.toParams } : {}) };
           const triggers: Trigger[] = [];
-          for (const t of manager.query(queryFilter(a))) {
+          for (const t of await manager.query(queryFilter(a))) {
             const updated = await manager.update(t.id, { invoke });
             if (updated !== undefined) triggers.push(updated);
           }
@@ -182,7 +185,7 @@ export function createTriggerActionTool(manager: TriggerManager): Tool<ToolResul
           if (a.tool === undefined && a.params === undefined) { yield { type: 'error', message: 'action "copy" requires a filter ("tool" and/or "params") selecting which triggers to duplicate — refusing to duplicate every trigger.' }; return; }
           const invoke = { tool: a.toTool, ...(a.toParams !== undefined ? { params: a.toParams } : {}) };
           const triggers: Trigger[] = [];
-          for (const t of manager.query(queryFilter(a))) {
+          for (const t of await manager.query(queryFilter(a))) {
             triggers.push(await manager.add({
               conditions: t.conditions,
               invoke,

package/src/types.ts

@@ -92,11 +92,11 @@ export interface TriggerSpec {
  * triggers plugin, which owns the hooks that drive them.
  */
 export interface Triggers {
-  all(): Trigger[];
-  get(id: string): Trigger | undefined;
+  all(): Promise<Trigger[]>;
+  get(id: string): Promise<Trigger | undefined>;
   /** Triggers whose invocation matches the filter — `tool` (if given) equals `invoke.tool`, `params`
    *  (if given) deep-equals `invoke.params`. The "which trigger(s) fire tool X" lookup. */
-  query(filter: { tool?: string; params?: unknown }): Trigger[];
+  query(filter: { tool?: string; params?: unknown }): Promise<Trigger[]>;
   add(spec: TriggerSpec): Promise<Trigger>;
   update(id: string, patch: Partial<TriggerSpec>): Promise<Trigger | undefined>;
   remove(id: string): Promise<boolean>;