@knowsuchagency/fulcrum 2.8.2 → 2.9.0

package/server/index.js

@@ -2344,9 +2344,6 @@ params: ${params}`);
 });
 
 // node_modules/drizzle-orm/sql/functions/aggregate.js
-function count(expression) {
-  return sql`count(${expression || sql.raw("*")})`.mapWith(Number);
-}
 function max(expression) {
   return sql`max(${expression})`.mapWith(is(expression, Column) ? expression : String);
 }
@@ -4378,10 +4375,9 @@ __export(exports_schema, {
   caldavCalendars: () => caldavCalendars,
   artifacts: () => artifacts,
   apps: () => apps,
-  appServices: () => appServices,
-  actionableEvents: () => actionableEvents
+  appServices: () => appServices
 });
-var tasks, taskRelationships, taskDependencies, taskLinks, taskAttachments, projectLinks, projectAttachments, terminalTabs, terminals, terminalViewState, repositories, apps, appServices, deployments, tunnels, projects, projectRepositories, tags, taskTags, projectTags, chatSessions, chatMessages, artifacts, systemMetrics, messagingConnections, messagingSessionMappings, emailAuthorizedThreads, channelMessages, actionableEvents, sweepRuns, caldavCalendars, caldavEvents, memories;
+var tasks, taskRelationships, taskDependencies, taskLinks, taskAttachments, projectLinks, projectAttachments, terminalTabs, terminals, terminalViewState, repositories, apps, appServices, deployments, tunnels, projects, projectRepositories, tags, taskTags, projectTags, chatSessions, chatMessages, artifacts, systemMetrics, messagingConnections, messagingSessionMappings, emailAuthorizedThreads, channelMessages, sweepRuns, caldavCalendars, caldavEvents, memories;
 var init_schema = __esm(() => {
   init_sqlite_core();
   tasks = sqliteTable("tasks", {
@@ -4690,19 +4686,6 @@ var init_schema = __esm(() => {
     messageTimestamp: text("message_timestamp").notNull(),
     createdAt: text("created_at").notNull()
   });
-  actionableEvents = sqliteTable("actionable_events", {
-    id: text("id").primaryKey(),
-    sourceChannel: text("source_channel").notNull(),
-    sourceId: text("source_id").notNull(),
-    sourceMetadata: text("source_metadata", { mode: "json" }).$type(),
-    status: text("status").notNull().default("pending"),
-    linkedTaskId: text("linked_task_id"),
-    summary: text("summary"),
-    actionLog: text("action_log", { mode: "json" }).$type(),
-    createdAt: text("created_at").notNull(),
-    updatedAt: text("updated_at").notNull(),
-    lastEvaluatedAt: text("last_evaluated_at")
-  });
   sweepRuns = sqliteTable("sweep_runs", {
     id: text("id").primaryKey(),
     type: text("type").notNull(),
@@ -8336,15 +8319,15 @@ function destroyTerminalAndBroadcast(terminalId) {
 function killClaudeInTerminalsForWorktree(worktreePath) {
   const manager = getPTYManager();
   const terminals2 = manager.listTerminals();
-  let count2 = 0;
+  let count = 0;
   for (const terminal of terminals2) {
     if (terminal.cwd === worktreePath) {
       if (manager.killClaudeInTerminal(terminal.id)) {
-        count2++;
+        count++;
       }
     }
   }
-  return count2;
+  return count;
 }
 var ptyManager = null, broadcastFn = null;
 var init_pty_instance = __esm(() => {
@@ -9641,8 +9624,8 @@ var require_Node = __commonJS((exports) => {
       };
       const res = toJS.toJS(this, "", ctx);
       if (typeof onAnchor === "function")
-        for (const { count: count2, res: res2 } of ctx.anchors.values())
-          onAnchor(res2, count2);
+        for (const { count, res: res2 } of ctx.anchors.values())
+          onAnchor(res2, count);
       return typeof reviver === "function" ? applyReviver.applyReviver(reviver, { "": res }, "", res) : res;
     }
   }
@@ -9740,13 +9723,13 @@ var require_Alias = __commonJS((exports) => {
       const anchor = anchors2 && source && anchors2.get(source);
       return anchor ? anchor.count * anchor.aliasCount : 0;
     } else if (identity.isCollection(node)) {
-      let count2 = 0;
+      let count = 0;
       for (const item of node.items) {
         const c = getAliasCount(doc, item, anchors2);
-        if (c > count2)
-          count2 = c;
+        if (c > count)
+          count = c;
       }
-      return count2;
+      return count;
     } else if (identity.isPair(node)) {
       const kc = getAliasCount(doc, node.key, anchors2);
       const vc = getAliasCount(doc, node.value, anchors2);
@@ -12475,8 +12458,8 @@ var require_Document = __commonJS((exports) => {
       };
       const res = toJS.toJS(this.contents, jsonArg ?? "", ctx);
       if (typeof onAnchor === "function")
-        for (const { count: count2, res: res2 } of ctx.anchors.values())
-          onAnchor(res2, count2);
+        for (const { count, res: res2 } of ctx.anchors.values())
+          onAnchor(res2, count);
       return typeof reviver === "function" ? applyReviver.applyReviver(reviver, { "": res }, "", res) : res;
     }
     toJSON(jsonArg, onAnchor) {
@@ -12546,12 +12529,12 @@ var require_errors = __commonJS((exports) => {
       lineStr = prev + lineStr;
     }
     if (/[^ ]/.test(lineStr)) {
-      let count2 = 1;
+      let count = 1;
       const end = error.linePos[1];
       if (end?.line === line && end.col > col) {
-        count2 = Math.max(1, Math.min(end.col - col, 80 - ci));
+        count = Math.max(1, Math.min(end.col - col, 80 - ci));
       }
-      const pointer = " ".repeat(ci) + "^".repeat(count2);
+      const pointer = " ".repeat(ci) + "^".repeat(count);
       error.message += `:
 
 ${lineStr}
@@ -44590,20 +44573,20 @@ var require_resolve = __commonJS((exports) => {
     return false;
   }
   function countKeys(schema2) {
-    let count2 = 0;
+    let count = 0;
     for (const key in schema2) {
       if (key === "$ref")
         return Infinity;
-      count2++;
+      count++;
       if (SIMPLE_INLINED.has(key))
         continue;
       if (typeof schema2[key] == "object") {
-        (0, util_1.eachItem)(schema2[key], (sch) => count2 += countKeys(sch));
+        (0, util_1.eachItem)(schema2[key], (sch) => count += countKeys(sch));
       }
-      if (count2 === Infinity)
+      if (count === Infinity)
         return Infinity;
     }
-    return count2;
+    return count;
   }
   function getFullPath(resolver, id = "", normalize3) {
     if (normalize3 !== false)
@@ -47536,8 +47519,8 @@ var require_contains = __commonJS((exports) => {
       cxt.result(valid, () => cxt.reset());
       function validateItemsWithCount() {
         const schValid = gen.name("_valid");
-        const count2 = gen.let("count", 0);
-        validateItems(schValid, () => gen.if(schValid, () => checkLimits(count2)));
+        const count = gen.let("count", 0);
+        validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)));
       }
       function validateItems(_valid, block) {
         gen.forRange("i", 0, len, (i) => {
@@ -47550,16 +47533,16 @@ var require_contains = __commonJS((exports) => {
           block();
         });
       }
-      function checkLimits(count2) {
-        gen.code((0, codegen_1._)`${count2}++`);
+      function checkLimits(count) {
+        gen.code((0, codegen_1._)`${count}++`);
         if (max2 === undefined) {
-          gen.if((0, codegen_1._)`${count2} >= ${min}`, () => gen.assign(valid, true).break());
+          gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true).break());
         } else {
-          gen.if((0, codegen_1._)`${count2} > ${max2}`, () => gen.assign(valid, false).break());
+          gen.if((0, codegen_1._)`${count} > ${max2}`, () => gen.assign(valid, false).break());
           if (min === 1)
             gen.assign(valid, true);
           else
-            gen.if((0, codegen_1._)`${count2} >= ${min}`, () => gen.assign(valid, true));
+            gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true));
         }
       }
     }
@@ -50903,20 +50886,20 @@ var require_resolve2 = __commonJS((exports) => {
     return false;
   }
   function countKeys(schema2) {
-    let count2 = 0;
+    let count = 0;
     for (const key in schema2) {
       if (key === "$ref")
         return Infinity;
-      count2++;
+      count++;
       if (SIMPLE_INLINED.has(key))
         continue;
       if (typeof schema2[key] == "object") {
-        (0, util_1.eachItem)(schema2[key], (sch) => count2 += countKeys(sch));
+        (0, util_1.eachItem)(schema2[key], (sch) => count += countKeys(sch));
       }
-      if (count2 === Infinity)
+      if (count === Infinity)
         return Infinity;
     }
-    return count2;
+    return count;
   }
   function getFullPath(resolver, id = "", normalize3) {
     if (normalize3 !== false)
@@ -53169,8 +53152,8 @@ var require_contains2 = __commonJS((exports) => {
       cxt.result(valid, () => cxt.reset());
       function validateItemsWithCount() {
         const schValid = gen.name("_valid");
-        const count2 = gen.let("count", 0);
-        validateItems(schValid, () => gen.if(schValid, () => checkLimits(count2)));
+        const count = gen.let("count", 0);
+        validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)));
       }
       function validateItems(_valid, block) {
         gen.forRange("i", 0, len, (i) => {
@@ -53183,16 +53166,16 @@ var require_contains2 = __commonJS((exports) => {
           block();
         });
       }
-      function checkLimits(count2) {
-        gen.code((0, codegen_1._)`${count2}++`);
+      function checkLimits(count) {
+        gen.code((0, codegen_1._)`${count}++`);
         if (max2 === undefined) {
-          gen.if((0, codegen_1._)`${count2} >= ${min}`, () => gen.assign(valid, true).break());
+          gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true).break());
         } else {
-          gen.if((0, codegen_1._)`${count2} > ${max2}`, () => gen.assign(valid, false).break());
+          gen.if((0, codegen_1._)`${count} > ${max2}`, () => gen.assign(valid, false).break());
           if (min === 1)
             gen.assign(valid, true);
           else
-            gen.if((0, codegen_1._)`${count2} >= ${min}`, () => gen.assign(valid, true));
+            gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true));
         }
       }
     }
@@ -60092,20 +60075,20 @@ var init_sdk = __esm(() => {
       return false;
     }
     function countKeys(schema2) {
-      let count2 = 0;
+      let count = 0;
       for (const key in schema2) {
         if (key === "$ref")
           return Infinity;
-        count2++;
+        count++;
         if (SIMPLE_INLINED.has(key))
           continue;
         if (typeof schema2[key] == "object") {
-          (0, util_1.eachItem)(schema2[key], (sch) => count2 += countKeys(sch));
+          (0, util_1.eachItem)(schema2[key], (sch) => count += countKeys(sch));
         }
-        if (count2 === Infinity)
+        if (count === Infinity)
           return Infinity;
       }
-      return count2;
+      return count;
     }
     function getFullPath(resolver, id = "", normalize3) {
       if (normalize3 !== false)
@@ -62957,8 +62940,8 @@ var init_sdk = __esm(() => {
         cxt.result(valid, () => cxt.reset());
         function validateItemsWithCount() {
           const schValid = gen.name("_valid");
-          const count2 = gen.let("count", 0);
-          validateItems(schValid, () => gen.if(schValid, () => checkLimits(count2)));
+          const count = gen.let("count", 0);
+          validateItems(schValid, () => gen.if(schValid, () => checkLimits(count)));
         }
         function validateItems(_valid, block) {
           gen.forRange("i", 0, len, (i) => {
@@ -62971,16 +62954,16 @@ var init_sdk = __esm(() => {
             block();
           });
         }
-        function checkLimits(count2) {
-          gen.code((0, codegen_1._)`${count2}++`);
+        function checkLimits(count) {
+          gen.code((0, codegen_1._)`${count}++`);
           if (max2 === undefined) {
-            gen.if((0, codegen_1._)`${count2} >= ${min}`, () => gen.assign(valid, true).break());
+            gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true).break());
           } else {
-            gen.if((0, codegen_1._)`${count2} > ${max2}`, () => gen.assign(valid, false).break());
+            gen.if((0, codegen_1._)`${count} > ${max2}`, () => gen.assign(valid, false).break());
             if (min === 1)
               gen.assign(valid, true);
             else
-              gen.if((0, codegen_1._)`${count2} >= ${min}`, () => gen.assign(valid, true));
+              gen.if((0, codegen_1._)`${count} >= ${min}`, () => gen.assign(valid, true));
           }
         }
       }
@@ -71029,12 +71012,9 @@ You have access to Fulcrum's MCP tools. Use them proactively to help users.
 
 **Assistant Tools (Proactive Agent):**
 - \`message\` - Send a message to a channel (email, whatsapp)
-- \`create_actionable_event\` - Track something noticed (message, request)
-- \`list_actionable_events\` - Review your event memory
-- \`get_actionable_event\` - Get event details
-- \`update_actionable_event\` - Update event status, link to task
-- \`get_assistant_stats\` - Get event counts and last sweep times
 - \`get_last_sweep\` - Check when last sweep ran
+- Use \`memory_store\` with tag \`actionable\` to track things that need attention
+- Use \`memory_search\` to review tracked items (search for tags \`actionable\` or \`monitoring\`)
 
 **Memory Tools:**
 - \`memory_store\` - Store a piece of knowledge in persistent memory with optional tags
@@ -71351,7 +71331,7 @@ Fulcrum is your digital concierge - a personal command center where you track ev
 - send_notification
 - memory_store, memory_search (persistent knowledge across sessions)
 - message (send to email/WhatsApp - concierge mode)
-- create_actionable_event, list_actionable_events (track decisions - concierge mode)
+- memory_store with tag \`actionable\` (track things needing attention - concierge mode)
 
 **Remember:** When users need external services (email, cloud, APIs), guide them on what credentials to provide - don't say "Fulcrum can't do that."`;
 }
@@ -81505,14 +81485,14 @@ var require_Messages = __commonJS((exports, module) => {
     [DjsErrorCodes.ShardingInProcess]: "Shards are still being spawned.",
     [DjsErrorCodes.ShardingInvalidEvalBroadcast]: "Script to evaluate must be a function",
     [DjsErrorCodes.ShardingShardNotFound]: (id) => `Shard ${id} could not be found.`,
-    [DjsErrorCodes.ShardingAlreadySpawned]: (count2) => `Already spawned ${count2} shards.`,
+    [DjsErrorCodes.ShardingAlreadySpawned]: (count) => `Already spawned ${count} shards.`,
     [DjsErrorCodes.ShardingProcessExists]: (id) => `Shard ${id} already has an active process.`,
     [DjsErrorCodes.ShardingWorkerExists]: (id) => `Shard ${id} already has an active worker.`,
     [DjsErrorCodes.ShardingReadyTimeout]: (id) => `Shard ${id}'s Client took too long to become ready.`,
     [DjsErrorCodes.ShardingReadyDisconnected]: (id) => `Shard ${id}'s Client disconnected before becoming ready.`,
     [DjsErrorCodes.ShardingReadyDied]: (id) => `Shard ${id}'s process exited before its Client became ready.`,
     [DjsErrorCodes.ShardingNoChildExists]: (id) => `Shard ${id} has no active process or worker.`,
-    [DjsErrorCodes.ShardingShardMiscalculation]: (shard, guild, count2) => `Calculated invalid shard ${shard} for guild ${guild} with ${count2} shards.`,
+    [DjsErrorCodes.ShardingShardMiscalculation]: (shard, guild, count) => `Calculated invalid shard ${shard} for guild ${guild} with ${count} shards.`,
     [DjsErrorCodes.ColorRange]: "Color must be within the range 0 - 16777215 (0xFFFFFF).",
     [DjsErrorCodes.ColorConvert]: (color) => `Unable to convert "${color}" to a number.`,
     [DjsErrorCodes.InviteOptionsMissingChannel]: "A valid guild channel must be provided when GuildScheduledEvent is EXTERNAL.",
@@ -83682,7 +83662,7 @@ var require_GuildChannel = __commonJS((exports, module) => {
     get position() {
       const selfIsCategory = this.type === ChannelType.GuildCategory;
       const types4 = getSortableGroupTypes(this.type);
-      let count2 = 0;
+      let count = 0;
       for (const channel of this.guild.channels.cache.values()) {
         if (!types4.includes(channel.type))
           continue;
@@ -83690,12 +83670,12 @@ var require_GuildChannel = __commonJS((exports, module) => {
           continue;
         if (this.rawPosition === channel.rawPosition) {
           if (Snowflake.compare(channel.id, this.id) === -1)
-            count2++;
+            count++;
         } else if (this.rawPosition > channel.rawPosition) {
-          count2++;
+          count++;
         }
       }
-      return count2;
+      return count;
     }
     permissionsFor(memberOrRole, checkAdmin = true) {
       const member = this.guild.members.resolve(memberOrRole);
@@ -113554,14 +113534,14 @@ var require__stream_writable = __commonJS((exports, module) => {
       var buffer = new Array(l);
       var holder = state.corkedRequestsFree;
       holder.entry = entry;
-      var count2 = 0;
+      var count = 0;
       var allBuffers = true;
       while (entry) {
-        buffer[count2] = entry;
+        buffer[count] = entry;
         if (!entry.isBuf)
           allBuffers = false;
         entry = entry.next;
-        count2 += 1;
+        count += 1;
       }
       buffer.allBuffers = allBuffers;
       doWrite(stream3, state, true, state.length, buffer, "", holder.finish);
@@ -116395,9 +116375,9 @@ var require_util6 = __commonJS((exports, module) => {
   function isIdentifier(str) {
     return rident.test(str);
   }
-  function filledRange(count2, prefix, suffix) {
-    var ret2 = new Array(count2);
-    for (var i = 0;i < count2; ++i) {
+  function filledRange(count, prefix, suffix) {
+    var ret2 = new Array(count);
+    for (var i = 0;i < count; ++i) {
       ret2[i] = prefix + i + suffix;
     }
     return ret2;
@@ -119530,9 +119510,9 @@ var require_promisify = __commonJS((exports, module) => {
         var newParameterCount = Math.max(0, parameterCount(fn) - 1);
         var argumentOrder = switchCaseArgumentOrder(newParameterCount);
         var shouldProxyThis = typeof callback === "string" || receiver2 === THIS;
-        function generateCallForArgumentCount(count2) {
-          var args = argumentSequence(count2).join(", ");
-          var comma = count2 > 0 ? ", " : "";
+        function generateCallForArgumentCount(count) {
+          var args = argumentSequence(count).join(", ");
+          var comma = count > 0 ? ", " : "";
           var ret;
           if (shouldProxyThis) {
             ret = `ret = callback.call(this, {{args}}, nodeback); break;
@@ -120078,8 +120058,8 @@ var require_some = __commonJS((exports, module) => {
     SomePromiseArray.prototype.howMany = function() {
       return this._howMany;
     };
-    SomePromiseArray.prototype.setHowMany = function(count2) {
-      this._howMany = count2;
+    SomePromiseArray.prototype.setHowMany = function(count) {
+      this._howMany = count;
     };
     SomePromiseArray.prototype._promiseFulfilled = function(value) {
       this._addFulfilled(value);
@@ -120137,8 +120117,8 @@ var require_some = __commonJS((exports, module) => {
     SomePromiseArray.prototype._canPossiblyFulfill = function() {
       return this.length() - this._rejected();
     };
-    SomePromiseArray.prototype._getRangeError = function(count2) {
-      var message = "Input array must contain at least " + this._howMany + " items but contains only " + count2 + " items";
+    SomePromiseArray.prototype._getRangeError = function(count) {
+      var message = "Input array must contain at least " + this._howMany + " items but contains only " + count + " items";
       return new RangeError2(message);
     };
     SomePromiseArray.prototype._resolveEmptyArray = function() {
@@ -122494,21 +122474,21 @@ var require_parseDate = __commonJS((exports) => {
     dec: 11
   };
   function parseDigits(token, minDigits, maxDigits, trailingOK) {
-    let count2 = 0;
-    while (count2 < token.length) {
-      const c = token.charCodeAt(count2);
+    let count = 0;
+    while (count < token.length) {
+      const c = token.charCodeAt(count);
       if (c <= 47 || c >= 58) {
         break;
       }
-      count2++;
+      count++;
     }
-    if (count2 < minDigits || count2 > maxDigits) {
+    if (count < minDigits || count > maxDigits) {
       return;
     }
-    if (!trailingOK && count2 != token.length) {
+    if (!trailingOK && count != token.length) {
       return;
     }
-    return parseInt(token.slice(0, count2), 10);
+    return parseInt(token.slice(0, count), 10);
   }
   function parseTime(token) {
     const parts = token.split(":");
@@ -129745,10 +129725,10 @@ var require_utils6 = __commonJS((exports, module) => {
     "aes-256-cbc": { key: 32, iv: 16 }
   };
   var PKCS5_SALT_LEN = 8;
-  function opensslKeyDeriv(cipher, salt, passphrase, count2) {
+  function opensslKeyDeriv(cipher, salt, passphrase, count) {
     assert4.buffer(salt, "salt");
     assert4.buffer(passphrase, "passphrase");
-    assert4.number(count2, "iteration count");
+    assert4.number(count, "iteration count");
     var clen = CIPHER_LEN[cipher];
     assert4.object(clen, "supported cipher");
     salt = salt.slice(0, PKCS5_SALT_LEN);
@@ -129761,7 +129741,7 @@ var require_utils6 = __commonJS((exports, module) => {
       bufs.push(passphrase);
       bufs.push(salt);
       D = Buffer3.concat(bufs);
-      for (var j = 0;j < count2; ++j)
+      for (var j = 0;j < count; ++j)
         D = crypto5.createHash("md5").update(D).digest();
       material = Buffer3.concat([material, D]);
       D_prev = D;
@@ -133098,7 +133078,7 @@ var require_bcrypt_pbkdf = __commonJS((exports, module) => {
     }
   }
   function bcrypt_pbkdf(pass, passlen, salt, saltlen, key, keylen, rounds) {
-    var sha2pass = new Uint8Array(64), sha2salt = new Uint8Array(64), out = new Uint8Array(BCRYPT_HASHSIZE), tmpout = new Uint8Array(BCRYPT_HASHSIZE), countsalt = new Uint8Array(saltlen + 4), i, j, amt, stride, dest, count2, origkeylen = keylen;
+    var sha2pass = new Uint8Array(64), sha2salt = new Uint8Array(64), out = new Uint8Array(BCRYPT_HASHSIZE), tmpout = new Uint8Array(BCRYPT_HASHSIZE), countsalt = new Uint8Array(saltlen + 4), i, j, amt, stride, dest, count, origkeylen = keylen;
     if (rounds < 1)
       return -1;
     if (passlen === 0 || saltlen === 0 || keylen === 0 || keylen > out.byteLength * out.byteLength || saltlen > 1 << 20)
@@ -133108,11 +133088,11 @@ var require_bcrypt_pbkdf = __commonJS((exports, module) => {
     for (i = 0;i < saltlen; i++)
       countsalt[i] = salt[i];
     crypto_hash_sha512(sha2pass, pass, passlen);
-    for (count2 = 1;keylen > 0; count2++) {
-      countsalt[saltlen + 0] = count2 >>> 24;
-      countsalt[saltlen + 1] = count2 >>> 16;
-      countsalt[saltlen + 2] = count2 >>> 8;
-      countsalt[saltlen + 3] = count2;
+    for (count = 1;keylen > 0; count++) {
+      countsalt[saltlen + 0] = count >>> 24;
+      countsalt[saltlen + 1] = count >>> 16;
+      countsalt[saltlen + 2] = count >>> 8;
+      countsalt[saltlen + 3] = count;
       crypto_hash_sha512(sha2salt, countsalt, saltlen + 4);
       bcrypt_hash(sha2pass, sha2salt, tmpout);
       for (i = out.byteLength;i--; )
@@ -133125,7 +133105,7 @@ var require_bcrypt_pbkdf = __commonJS((exports, module) => {
       }
       amt = Math.min(amt, keylen);
       for (i = 0;i < amt; i++) {
-        dest = i * stride + (count2 - 1);
+        dest = i * stride + (count - 1);
         if (dest >= origkeylen)
           break;
         key[dest] = out[i];
@@ -153238,21 +153218,21 @@ var require_cookie3 = __commonJS((exports) => {
 `.replace(/\s*\/\/.*$/gm, "").replace(/\n/g, "").trim();
   var IP_V6_REGEX_OBJECT = new RegExp(`^${IP_V6_REGEX}$`);
   function parseDigits(token, minDigits, maxDigits, trailingOK) {
-    let count2 = 0;
-    while (count2 < token.length) {
-      const c = token.charCodeAt(count2);
+    let count = 0;
+    while (count < token.length) {
+      const c = token.charCodeAt(count);
       if (c <= 47 || c >= 58) {
         break;
       }
-      count2++;
+      count++;
     }
-    if (count2 < minDigits || count2 > maxDigits) {
+    if (count < minDigits || count > maxDigits) {
       return null;
     }
-    if (!trailingOK && count2 != token.length) {
+    if (!trailingOK && count != token.length) {
       return null;
     }
-    return parseInt(token.substr(0, count2), 10);
+    return parseInt(token.substr(0, count), 10);
   }
   function parseTime(token) {
     const parts = token.split(":");
@@ -181704,15 +181684,15 @@ var require_lower_bound = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   function lowerBound(array5, value, comparator) {
     let first = 0;
-    let count2 = array5.length;
-    while (count2 > 0) {
-      const step = count2 / 2 | 0;
+    let count = array5.length;
+    while (count > 0) {
+      const step = count / 2 | 0;
       let it = first + step;
       if (comparator(array5[it], value) <= 0) {
         first = ++it;
-        count2 -= step + 1;
+        count -= step + 1;
       } else {
-        count2 = step;
+        count = step;
       }
     }
     return first;
@@ -182098,11 +182078,11 @@ var require_retry_operation = __commonJS((exports, module) => {
     for (var i = 0;i < this._errors.length; i++) {
       var error47 = this._errors[i];
       var message = error47.message;
-      var count2 = (counts[message] || 0) + 1;
-      counts[message] = count2;
-      if (count2 >= mainErrorCount) {
+      var count = (counts[message] || 0) + 1;
+      counts[message] = count;
+      if (count >= mainErrorCount) {
         mainError = error47;
-        mainErrorCount = count2;
+        mainErrorCount = count;
       }
     }
     return mainError;
@@ -281356,8 +281336,8 @@ var require_elf = __commonJS((exports, module) => {
     }
     const offset = elf.readUInt32LE(32);
     const size = elf.readUInt16LE(54);
-    const count2 = elf.readUInt16LE(56);
-    for (let i = 0;i < count2; i++) {
+    const count = elf.readUInt16LE(56);
+    for (let i = 0;i < count; i++) {
       const headerOffset = offset + i * size;
       const type = elf.readUInt32LE(headerOffset);
       if (type === 3) {
@@ -295593,8 +295573,8 @@ var init_DsdiffParser = __esm(() => {
           }
           case "CMPR": {
             const compressionIdCode = (await this.tokenizer.readToken(FourCcToken)).trim();
-            const count2 = await this.tokenizer.readToken(UINT8);
-            const compressionName = await this.tokenizer.readToken(new StringType(count2, "ascii"));
+            const count = await this.tokenizer.readToken(UINT8);
+            const compressionName = await this.tokenizer.readToken(new StringType(count, "ascii"));
             if (compressionIdCode === "DSD") {
               this.metadata.setFormat("lossless", true);
               this.metadata.setFormat("bitsPerSample", 1);
@@ -300865,8 +300845,8 @@ var createSignalIdentity = (wid, accountSignatureKey) => {
     }
   }
   return extracted;
-}, getNextPreKeys = async ({ creds, keys }, count2) => {
-  const { newPreKeys, lastPreKeyId, preKeysRange } = generateOrGetPreKeys(creds, count2);
+}, getNextPreKeys = async ({ creds, keys }, count) => {
+  const { newPreKeys, lastPreKeyId, preKeysRange } = generateOrGetPreKeys(creds, count);
   const update2 = {
     nextPreKeyId: Math.max(lastPreKeyId + 1, creds.nextPreKeyId),
     firstUnuploadedPreKeyId: Math.max(creds.firstUnuploadedPreKeyId, lastPreKeyId + 1)
@@ -300874,9 +300854,9 @@ var createSignalIdentity = (wid, accountSignatureKey) => {
   await keys.set({ "pre-key": newPreKeys });
   const preKeys = await getPreKeys(keys, preKeysRange[0], preKeysRange[0] + preKeysRange[1]);
   return { update: update2, preKeys };
-}, getNextPreKeysNode = async (state, count2) => {
+}, getNextPreKeysNode = async (state, count) => {
   const { creds } = state;
-  const { update: update2, preKeys } = await getNextPreKeys(state, count2);
+  const { update: update2, preKeys } = await getNextPreKeys(state, count);
   const node = {
     tag: "iq",
     attrs: {
@@ -304166,11 +304146,11 @@ var shorthandToMilliseconds = (shorthand) => {
     }
     this._count--;
   }
-  setCount(count2) {
+  setCount(count) {
     if (!this._enabled) {
       return;
     }
-    this._count = count2;
+    this._count = count;
   }
   roughSizeOfString(value) {
     return value.length * 2;
@@ -306386,15 +306366,15 @@ var init_p_timeout = __esm(() => {
 // node_modules/p-queue/dist/lower-bound.js
 function lowerBound(array5, value, comparator) {
   let first = 0;
-  let count2 = array5.length;
-  while (count2 > 0) {
-    const step = Math.trunc(count2 / 2);
+  let count = array5.length;
+  while (count > 0) {
+    const step = Math.trunc(count / 2);
     let it = first + step;
     if (comparator(array5[it], value) <= 0) {
       first = ++it;
-      count2 -= step + 1;
+      count -= step + 1;
     } else {
-      count2 = step;
+      count = step;
     }
   }
   return first;
@@ -306885,15 +306865,15 @@ var init_dist10 = __esm(() => {
         }
         return;
       }
-      let count2;
+      let count;
       if (this.#strict) {
         const now = Date.now();
         this.#cleanupStrictTicks(now);
-        count2 = this.#getActiveTicksCount();
+        count = this.#getActiveTicksCount();
       } else {
-        count2 = this.#intervalCount;
+        count = this.#intervalCount;
       }
-      const shouldBeRateLimited = count2 >= this.#intervalCap;
+      const shouldBeRateLimited = count >= this.#intervalCap;
       if (shouldBeRateLimited !== previous) {
         this.#rateLimitedInInterval = shouldBeRateLimited;
         this.emit(shouldBeRateLimited ? "rateLimit" : "rateLimitCleared");
@@ -315548,7 +315528,7 @@ var import_boom11, makeSocket = (config4) => {
   };
   let uploadPreKeysPromise = null;
   let lastUploadTime = 0;
-  const uploadPreKeys = async (count2 = MIN_PREKEY_COUNT, retryCount = 0) => {
+  const uploadPreKeys = async (count = MIN_PREKEY_COUNT, retryCount = 0) => {
     if (retryCount === 0) {
       const timeSinceLastUpload = Date.now() - lastUploadTime;
       if (timeSinceLastUpload < MIN_UPLOAD_INTERVAL) {
@@ -315561,24 +315541,24 @@ var import_boom11, makeSocket = (config4) => {
       await uploadPreKeysPromise;
     }
     const uploadLogic = async () => {
-      logger3.info({ count: count2, retryCount }, "uploading pre-keys");
+      logger3.info({ count, retryCount }, "uploading pre-keys");
       const node = await keys.transaction(async () => {
-        logger3.debug({ requestedCount: count2 }, "generating pre-keys with requested count");
-        const { update: update2, node: node2 } = await getNextPreKeysNode({ creds, keys }, count2);
+        logger3.debug({ requestedCount: count }, "generating pre-keys with requested count");
+        const { update: update2, node: node2 } = await getNextPreKeysNode({ creds, keys }, count);
         ev.emit("creds.update", update2);
         return node2;
       }, creds?.me?.id || "upload-pre-keys");
       try {
         await query2(node);
-        logger3.info({ count: count2 }, "uploaded pre-keys successfully");
+        logger3.info({ count }, "uploaded pre-keys successfully");
         lastUploadTime = Date.now();
       } catch (uploadError) {
-        logger3.error({ uploadError: uploadError.toString(), count: count2 }, "Failed to upload pre-keys to server");
+        logger3.error({ uploadError: uploadError.toString(), count }, "Failed to upload pre-keys to server");
         if (retryCount < 3) {
           const backoffDelay = Math.min(1000 * Math.pow(2, retryCount), 1e4);
           logger3.info(`Retrying pre-key upload in ${backoffDelay}ms`);
           await new Promise((resolve6) => setTimeout(resolve6, backoffDelay));
-          return uploadPreKeys(count2, retryCount + 1);
+          return uploadPreKeys(count, retryCount + 1);
         }
         throw uploadError;
       }
@@ -315604,16 +315584,16 @@ var import_boom11, makeSocket = (config4) => {
   };
   const uploadPreKeysToServerIfRequired = async () => {
     try {
-      let count2 = 0;
+      let count = 0;
       const preKeyCount = await getAvailablePreKeysOnServer();
       if (preKeyCount === 0)
-        count2 = INITIAL_PREKEY_COUNT;
+        count = INITIAL_PREKEY_COUNT;
       else
-        count2 = MIN_PREKEY_COUNT;
+        count = MIN_PREKEY_COUNT;
       const { exists: currentPreKeyExists, currentPreKeyId } = await verifyCurrentPreKeyExists();
       logger3.info(`${preKeyCount} pre-keys found on server`);
       logger3.info(`Current prekey ID: ${currentPreKeyId}, exists in storage: ${currentPreKeyExists}`);
-      const lowServerCount = preKeyCount <= count2;
+      const lowServerCount = preKeyCount <= count;
       const missingCurrentPreKey = !currentPreKeyExists && currentPreKeyId > 0;
       const shouldUpload = lowServerCount || missingCurrentPreKey;
       if (shouldUpload) {
@@ -315623,7 +315603,7 @@ var import_boom11, makeSocket = (config4) => {
         if (missingCurrentPreKey)
           reasons.push(`current prekey ${currentPreKeyId} missing from storage`);
         logger3.info(`Uploading PreKeys due to: ${reasons.join(", ")}`);
-        await uploadPreKeys(count2);
+        await uploadPreKeys(count);
       } else {
         logger3.info(`PreKey validation passed - Server: ${preKeyCount}, Current prekey ${currentPreKeyId} exists`);
       }
@@ -317373,9 +317353,9 @@ var parseNewsletterCreateResponse = (response) => {
         ]
       });
     },
-    newsletterFetchMessages: async (jid, count2, since, after) => {
+    newsletterFetchMessages: async (jid, count, since, after) => {
       const messageUpdateAttrs = {
-        count: count2.toString()
+        count: count.toString()
       };
       if (typeof since === "number") {
         messageUpdateAttrs.since = since.toString();
@@ -318335,7 +318315,7 @@ var import_boom15, makeMessagesRecvSocket = (config4) => {
   });
   const identityAssertDebounce = new index_default({ stdTTL: 5, useClones: false });
   let sendActiveReceipts = false;
-  const fetchMessageHistory = async (count2, oldestMsgKey, oldestMsgTimestamp) => {
+  const fetchMessageHistory = async (count, oldestMsgKey, oldestMsgTimestamp) => {
     if (!authState.creds.me?.id) {
       throw new import_boom15.Boom("Not authenticated");
     }
@@ -318345,7 +318325,7 @@ var import_boom15, makeMessagesRecvSocket = (config4) => {
         oldestMsgFromMe: oldestMsgKey.fromMe,
         oldestMsgId: oldestMsgKey.id,
         oldestMsgTimestampMs: oldestMsgTimestamp,
-        onDemandMsgCount: count2
+        onDemandMsgCount: count
       },
       peerDataOperationRequestType: proto.Message.PeerDataOperationRequestType.HISTORY_SYNC_ON_DEMAND
     };
@@ -318677,9 +318657,9 @@ var import_boom15, makeMessagesRecvSocket = (config4) => {
     const from = node.attrs.from;
     if (from === S_WHATSAPP_NET) {
       const countChild = getBinaryNodeChild(node, "count");
-      const count2 = +countChild.attrs.value;
-      const shouldUploadMorePreKeys = count2 < MIN_PREKEY_COUNT;
-      logger3.debug({ count: count2, shouldUploadMorePreKeys }, "recv pre-key count");
+      const count = +countChild.attrs.value;
+      const shouldUploadMorePreKeys = count < MIN_PREKEY_COUNT;
+      logger3.debug({ count, shouldUploadMorePreKeys }, "recv pre-key count");
       if (shouldUploadMorePreKeys) {
         await uploadPreKeys();
       }
@@ -322161,19 +322141,19 @@ var require_chunkstream = __commonJS((exports, module) => {
   ChunkStream.prototype._processRead = function(read) {
     this._reads.shift();
     let pos = 0;
-    let count2 = 0;
+    let count = 0;
     let data = Buffer.alloc(read.length);
     while (pos < read.length) {
-      let buf = this._buffers[count2++];
+      let buf = this._buffers[count++];
       let len = Math.min(buf.length, read.length - pos);
       buf.copy(data, pos, 0, len);
       pos += len;
       if (len !== buf.length) {
-        this._buffers[--count2] = buf.slice(len);
+        this._buffers[--count] = buf.slice(len);
       }
     }
-    if (count2 > 0) {
-      this._buffers.splice(0, count2);
+    if (count > 0) {
+      this._buffers.splice(0, count);
     }
     this._buffered -= read.length;
     read.func.call(this, data);
@@ -322845,12 +322825,12 @@ var require_bitmapper = __commonJS((exports) => {
       }
     }
     return {
-      get: function(count2) {
-        while (leftOver.length < count2) {
+      get: function(count) {
+        while (leftOver.length < count) {
           split();
         }
-        let returner = leftOver.slice(0, count2);
-        leftOver = leftOver.slice(count2);
+        let returner = leftOver.slice(0, count);
+        leftOver = leftOver.slice(count);
         return returner;
       },
       resetAfterLine: function() {
@@ -331964,8 +331944,8 @@ var require_depd = __commonJS((exports, module) => {
     return deprecate;
   }
   function eehaslisteners(emitter, type) {
-    var count2 = typeof emitter.listenerCount !== "function" ? emitter.listeners(type).length : emitter.listenerCount(type);
-    return count2 > 0;
+    var count = typeof emitter.listenerCount !== "function" ? emitter.listeners(type).length : emitter.listenerCount(type);
+    return count > 0;
   }
   function isignored(namespace) {
     if (process.noDeprecation) {
@@ -353762,15 +353742,15 @@ var require_urlencoded = __commonJS((exports, module) => {
     };
   }
   function parameterCount(body, limit2) {
-    let count2 = 0;
+    let count = 0;
     let index = -1;
     do {
-      count2++;
-      if (count2 > limit2)
+      count++;
+      if (count > limit2)
         return;
       index = body.indexOf("&", index + 1);
     } while (index !== -1);
-    return count2;
+    return count;
   }
 });
 
@@ -356578,13 +356558,13 @@ var require_mediaType = __commonJS((exports, module) => {
     return spec.q > 0;
   }
   function quoteCount(string8) {
-    var count2 = 0;
+    var count = 0;
     var index = 0;
     while ((index = string8.indexOf('"', index)) !== -1) {
-      count2++;
+      count++;
       index++;
     }
-    return count2;
+    return count;
   }
   function splitKeyValuePair(str) {
     var index = str.indexOf("=");
@@ -357899,8 +357879,8 @@ var require_send = __commonJS((exports, module) => {
     }
   }
   function hasListeners(emitter, type) {
-    var count2 = typeof emitter.listenerCount !== "function" ? emitter.listeners(type).length : emitter.listenerCount(type);
-    return count2 > 0;
+    var count = typeof emitter.listenerCount !== "function" ? emitter.listeners(type).length : emitter.listenerCount(type);
+    return count > 0;
   }
   function normalizeList(val, name) {
     var list = [].concat(val || []);
@@ -408269,15 +408249,15 @@ var init_imap_flow = __esm(() => {
       if (!untagged || !untagged.command || isNaN(untagged.command)) {
         return;
       }
-      let count2 = Number(untagged.command);
-      if (count2 === this.mailbox.exists) {
+      let count = Number(untagged.command);
+      if (count === this.mailbox.exists) {
         return;
       }
       let prevCount = this.mailbox.exists;
-      this.mailbox.exists = count2;
+      this.mailbox.exists = count;
       this.emit("exists", {
         path: this.mailbox.path,
-        count: count2,
+        count,
         prevCount
       });
     }
@@ -411430,15 +411410,15 @@ ${context.metadata?.threadId ? `**Thread ID**: ${context.metadata.threadId}` : "
 
 2. **Take appropriate action(s)**:
    - **Simple conversations**: Just use \`message\` to reply - no tracking needed for "hi", "thanks", general questions
-   - **Actionable requests**: Create an actionable_event to track it, optionally create a Fulcrum task
-   - **Spam/newsletters**: Silently ignore (no response, optionally log as dismissed)
+   - **Actionable requests**: Store a memory (via \`memory_store\`) with tag \`actionable\`, optionally create a Fulcrum task
+   - **Spam/newsletters**: Silently ignore (no response)
 
 ## Important
 
-- **You don't need to create actionable_events for every message** - only for things that need tracking/follow-up
-- Simple greetings, questions, and conversations can be answered directly without any event tracking
+- **You don't need to store a memory for every message** - only for things that need tracking/follow-up
+- Simple greetings, questions, and conversations can be answered directly without any memory tracking
 - For replies, use the \`message\` tool with: channel="${context.channel}", to="${context.sender}"${context.metadata?.messageId ? `, replyToMessageId="${context.metadata.messageId}"` : ""}
-- Only create actionable_events for requests, reminders, or things you need to remember
+- Only store memories with tag \`actionable\` for requests, reminders, or things you need to remember
 - Spam, newsletters, and automated notifications should be ignored (no response)
 
 ${formattingGuide}`;
@@ -411462,13 +411442,11 @@ ${context.metadata?.isGroup ? `**Group Chat**: yes` : ""}
 
 Silently analyze this message and decide if it needs to be tracked:
 
-1. **Actionable requests directed at the user** (deadlines, meetings, tasks) \u2192 Create an actionable_event
-2. **Important information** (confirmations, updates about ongoing matters) \u2192 Create an actionable_event
+1. **Actionable requests directed at the user** (deadlines, meetings, tasks) \u2192 Store a memory with tag \`actionable\`
+2. **Important information** (confirmations, updates about ongoing matters) \u2192 Store a memory with tag \`monitoring\`
 3. **Casual messages, spam, or irrelevant content** \u2192 Do nothing
 
-If you create an actionable_event, set an appropriate status:
-- \`pending\` - Needs attention/action
-- \`monitoring\` - Worth tracking but no immediate action needed
+Use \`memory_store\` to persist important observations. Include the source channel as the \`source\` field (e.g., "channel:${context.channel}").
 
 **Remember: NO responses. Observe only.**`;
 }
@@ -411481,32 +411459,31 @@ You are performing your hourly sweep.
 
 **Context:**
 - Last sweep completed: ${context.lastSweepTime ?? "never"}
-- Pending actionable events: ${context.pendingCount}
+- Memories tagged 'actionable': ${context.actionableMemoryCount}
 - Open Fulcrum tasks (TO_DO + IN_PROGRESS + IN_REVIEW): ${context.openTaskCount}
 
 ## Your Task
 
-1. **Review actionable events** - use \`list_actionable_events\` to list recent events (limit 50) and check for:
-   - Events that should be updated (e.g., acted upon externally)
-   - Events that can be dismissed (no longer relevant)
-   - Patterns or connections between events
-   - Events that should be linked to tasks
+1. **Review actionable memories** - use \`memory_search\` to find memories tagged \`actionable\` or \`monitoring\` and check for:
+   - Items that have been resolved (delete the memory or remove the tag)
+   - Patterns or connections between tracked items
+   - Items that should be linked to tasks
 
 2. **Review Fulcrum tasks** - use \`list_tasks\` to get tasks that are TO_DO, IN_PROGRESS, or IN_REVIEW:
    - Any that need attention or follow-up?
-   - Any related to recent events?
+   - Any related to tracked memories?
    - Any blocked or overdue?
 
 3. **Catch up** - if you find messages that weren't properly handled:
-   - Create actionable events for missed items
+   - Store memories with tag \`actionable\` for missed items
    - Take action if still relevant
 
-4. **Update your records** - use \`update_actionable_event\` to log what you've done
+4. **Update your records** - delete resolved memories or update their tags
 
 ## Output
 
 After completing your sweep, provide a brief summary of:
-- Events reviewed and actions taken
+- Memories reviewed and actions taken
 - Tasks updated or created
 - Any patterns noticed
 - Items requiring user attention`;
@@ -411631,7 +411608,7 @@ async function handleIncomingMessage(msg) {
       channelType: msg.channelType,
       senderId: msg.senderId
     });
-    await processForActionableEvents(msg);
+    await processObserveOnlyMessage(msg);
     return;
   }
   if (COMMANDS.RESET.some((cmd) => content.toLowerCase() === cmd)) {
@@ -411848,7 +411825,7 @@ function splitMessage(content, maxLength) {
   }
   return parts;
 }
-async function processForActionableEvents(msg) {
+async function processObserveOnlyMessage(msg) {
   const observeSessionKey = `observe-${msg.connectionId}`;
   const { session: session3 } = getOrCreateSession(msg.connectionId, observeSessionKey, "Observer");
   const context = {
@@ -411872,7 +411849,7 @@ async function processForActionableEvents(msg) {
     for await (const event of stream3) {
       if (event.type === "error") {
         const errorMsg = event.data.message;
-        log2.messaging.error("Assistant error processing observe-only message", { error: errorMsg });
+        log2.messaging.error("Error in observe-only message processing", { error: errorMsg });
       }
     }
   } catch (err) {
@@ -421843,8 +421820,8 @@ app2.post("/:id/kill-claude", (c) => {
     return c.json({ success: true, terminalsAffected: 0 });
   }
   try {
-    const count2 = killClaudeInTerminalsForWorktree(task.worktreePath);
-    return c.json({ success: true, terminalsAffected: count2 });
+    const count = killClaudeInTerminalsForWorktree(task.worktreePath);
+    return c.json({ success: true, terminalsAffected: count });
   } catch {
     return c.json({ success: true, terminalsAffected: 0 });
   }
@@ -423350,17 +423327,17 @@ app4.post("/edit", async (c) => {
       return c.json({ error: "Path is not a file" }, 400);
     }
     const content = fs10.readFileSync(resolvedPath, "utf-8");
-    let count2 = 0;
+    let count = 0;
     let index = 0;
     while ((index = content.indexOf(old_string, index)) !== -1) {
-      count2++;
+      count++;
       index += old_string.length;
     }
-    if (count2 === 0) {
+    if (count === 0) {
       return c.json({ error: "String not found in file" }, 400);
     }
-    if (count2 > 1) {
-      return c.json({ error: `String found ${count2} times, provide more context to make it unique` }, 400);
+    if (count > 1) {
+      return c.json({ error: `String found ${count} times, provide more context to make it unique` }, 400);
     }
     const newContent = content.replace(old_string, new_string);
     fs10.writeFileSync(resolvedPath, newContent, "utf-8");
@@ -455723,8 +455700,8 @@ function az_default() {
   };
 }
 // node_modules/zod/v4/locales/be.js
-function getBelarusianPlural(count2, one, few, many) {
-  const absCount = Math.abs(count2);
+function getBelarusianPlural(count, one, few, many) {
+  const absCount = Math.abs(count);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -459474,8 +459451,8 @@ function pt_default() {
   };
 }
 // node_modules/zod/v4/locales/ru.js
-function getRussianPlural(count2, one, few, many) {
-  const absCount = Math.abs(count2);
+function getRussianPlural(count, one, few, many) {
+  const absCount = Math.abs(count);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -464310,6 +464287,13 @@ var toolRegistry = [
     keywords: ["tags", "categories", "filter", "search", "discover"],
     defer_loading: false
   },
+  {
+    name: "delete_tag",
+    description: "Delete a tag from the database and all its associations",
+    category: "tasks",
+    keywords: ["tag", "delete", "remove", "cleanup"],
+    defer_loading: false
+  },
   {
     name: "list_task_attachments",
     description: "List all file attachments for a task",
@@ -464471,41 +464455,6 @@ var toolRegistry = [
     keywords: ["message", "send", "reply", "email", "whatsapp", "communicate", "respond"],
     defer_loading: false
   },
-  {
-    name: "create_actionable_event",
-    description: "Create an actionable event to track something noticed",
-    category: "assistant",
-    keywords: ["event", "actionable", "track", "remember", "log", "decision", "memory"],
-    defer_loading: false
-  },
-  {
-    name: "list_actionable_events",
-    description: "List actionable events by status or channel",
-    category: "assistant",
-    keywords: ["event", "actionable", "list", "pending", "review", "memory"],
-    defer_loading: false
-  },
-  {
-    name: "get_actionable_event",
-    description: "Get details of a specific actionable event",
-    category: "assistant",
-    keywords: ["event", "actionable", "get", "details", "history"],
-    defer_loading: false
-  },
-  {
-    name: "update_actionable_event",
-    description: "Update an actionable event status or link to a task",
-    category: "assistant",
-    keywords: ["event", "actionable", "update", "status", "link", "task", "log"],
-    defer_loading: false
-  },
-  {
-    name: "get_assistant_stats",
-    description: "Get assistant statistics: event counts by status and last sweep times",
-    category: "assistant",
-    keywords: ["assistant", "stats", "statistics", "events", "sweep", "summary"],
-    defer_loading: false
-  },
   {
     name: "get_last_sweep",
     description: "Get information about the last sweep run of a type",
@@ -465036,9 +464985,9 @@ var registerTaskTools = (server, client) => {
           }
         }
       }
-      let tags2 = Array.from(tagCounts.entries()).map(([name, count2]) => ({
+      let tags2 = Array.from(tagCounts.entries()).map(([name, count]) => ({
         name,
-        count: count2
+        count
       }));
       if (search) {
         const searchLower = search.toLowerCase();
@@ -465050,6 +464999,16 @@ var registerTaskTools = (server, client) => {
       return handleToolError(err);
     }
   });
+  server.tool("delete_tag", "Delete a tag from the database. This removes the tag and all its associations with tasks and projects.", {
+    tag: exports_external.string().describe("The exact name of the tag to delete")
+  }, async ({ tag }) => {
+    try {
+      await client.deleteTag(tag);
+      return formatSuccess({ deleted: tag });
+    } catch (err) {
+      return handleToolError(err);
+    }
+  });
   server.tool("list_tasks_by_due_date", "List tasks within a date range based on due date", {
     startDate: exports_external.optional(exports_external.string()).describe("Start date (YYYY-MM-DD), inclusive"),
     endDate: exports_external.optional(exports_external.string()).describe("End date (YYYY-MM-DD), inclusive"),
@@ -465938,10 +465897,9 @@ var registerEmailTools = (server, client) => {
   });
 };
 
-// cli/src/mcp/tools/assistant-events.ts
-var ActionableEventStatusSchema = exports_external.enum(["pending", "acted_upon", "dismissed", "monitoring"]);
+// cli/src/mcp/tools/assistant.ts
 var ChannelSchema = exports_external.enum(["email", "whatsapp", "discord", "telegram", "slack", "all"]);
-var registerAssistantEventTools = (server, client) => {
+var registerAssistantTools = (server, client) => {
   server.tool("message", "Send a message to a messaging channel (email, WhatsApp, etc.). Use this to reply to messages or send proactive communications.", {
     channel: ChannelSchema.describe("Target channel: email, whatsapp, discord, telegram, slack, or all"),
     to: exports_external.string().describe("Recipient (email address, phone number, or channel ID)"),
@@ -465964,79 +465922,6 @@ var registerAssistantEventTools = (server, client) => {
       return handleToolError(err);
     }
   });
-  server.tool("create_actionable_event", "Create an actionable event to track something noticed (message, request, etc.). Use this to log decisions and maintain memory of things that need attention.", {
-    source_channel: ChannelSchema.exclude(["all"]).describe("Channel where the event originated"),
-    source_id: exports_external.string().describe("ID of the source message/email"),
-    source_metadata: exports_external.optional(exports_external.record(exports_external.string(), exports_external.any())).describe("Additional context (sender, subject, etc.)"),
-    summary: exports_external.optional(exports_external.string()).describe("AI-generated description of what this event is about"),
-    status: exports_external.optional(ActionableEventStatusSchema).describe("Event status (default: pending)"),
-    linked_task_id: exports_external.optional(exports_external.string()).describe("Fulcrum task ID if this event relates to a task")
-  }, async ({ source_channel, source_id, source_metadata, summary, status, linked_task_id }) => {
-    try {
-      const result = await client.createActionableEvent({
-        sourceChannel: source_channel,
-        sourceId: source_id,
-        sourceMetadata: source_metadata,
-        summary,
-        status,
-        linkedTaskId: linked_task_id
-      });
-      return formatSuccess(result);
-    } catch (err) {
-      return handleToolError(err);
-    }
-  });
-  server.tool("list_actionable_events", "List actionable events. Use this to review what needs attention, check for patterns, or avoid creating duplicates.", {
-    status: exports_external.optional(ActionableEventStatusSchema).describe("Filter by status"),
-    source_channel: exports_external.optional(exports_external.string()).describe("Filter by source channel"),
-    limit: exports_external.optional(exports_external.number()).describe("Maximum events to return (default: 50)")
-  }, async ({ status, source_channel, limit: limit2 }) => {
-    try {
-      const result = await client.listActionableEvents({
-        status,
-        channel: source_channel,
-        limit: limit2 ?? 50
-      });
-      return formatSuccess(result);
-    } catch (err) {
-      return handleToolError(err);
-    }
-  });
-  server.tool("get_actionable_event", "Get details of a specific actionable event including its action log and linked task.", {
-    id: exports_external.string().describe("Event ID")
-  }, async ({ id }) => {
-    try {
-      const result = await client.getActionableEvent(id);
-      return formatSuccess(result);
-    } catch (err) {
-      return handleToolError(err);
-    }
-  });
-  server.tool("update_actionable_event", "Update an actionable event status, link it to a task, or add to its action log. Use action_log_entry to record decisions/actions taken.", {
-    id: exports_external.string().describe("Event ID"),
-    status: exports_external.optional(ActionableEventStatusSchema).describe("New status"),
-    linked_task_id: exports_external.optional(exports_external.string()).describe("Link to a Fulcrum task (use empty string to unlink)"),
-    action_log_entry: exports_external.optional(exports_external.string()).describe('Action to log (e.g., "Replied with project update")')
-  }, async ({ id, status, linked_task_id, action_log_entry }) => {
-    try {
-      const result = await client.updateActionableEvent(id, {
-        status,
-        linkedTaskId: linked_task_id === "" ? null : linked_task_id,
-        actionLogEntry: action_log_entry
-      });
-      return formatSuccess(result);
-    } catch (err) {
-      return handleToolError(err);
-    }
-  });
-  server.tool("get_assistant_stats", "Get assistant statistics: event counts by status and last sweep times. Useful for understanding workload and activity.", {}, async () => {
-    try {
-      const result = await client.getAssistantStats();
-      return formatSuccess(result);
-    } catch (err) {
-      return handleToolError(err);
-    }
-  });
   server.tool("get_last_sweep", "Get information about the last sweep run of a specific type. Useful for context about what was last reviewed.", {
     type: exports_external.enum(["hourly", "morning_ritual", "evening_ritual"]).describe("Type of sweep")
   }, async ({ type }) => {
@@ -466191,7 +466076,7 @@ function registerTools(server, client) {
   registerSettingsTools(server, client);
   registerBackupTools(server, client);
   registerEmailTools(server, client);
-  registerAssistantEventTools(server, client);
+  registerAssistantTools(server, client);
   registerCaldavTools(server, client);
   registerMemoryTools(server, client);
 }
@@ -466492,6 +466377,13 @@ class FulcrumClient {
       method: "DELETE"
     });
   }
+  async deleteTag(tagName) {
+    const allTags = await this.fetch("/api/tags");
+    const tag = allTags.find((t) => t.name === tagName);
+    if (!tag)
+      throw new ApiError(404, "Tag not found");
+    return this.fetch(`/api/tags/${tag.id}`, { method: "DELETE" });
+  }
   async setTaskDueDate(taskId, dueDate) {
     return this.fetch(`/api/tasks/${taskId}/due-date`, {
       method: "PATCH",
@@ -466782,39 +466674,6 @@ class FulcrumClient {
       body: JSON.stringify({ uids, limit: limit2 })
     });
   }
-  async listActionableEvents(options) {
-    const params = new URLSearchParams;
-    if (options?.status)
-      params.set("status", options.status);
-    if (options?.channel)
-      params.set("channel", options.channel);
-    if (options?.limit)
-      params.set("limit", String(options.limit));
-    if (options?.offset)
-      params.set("offset", String(options.offset));
-    const query = params.toString();
-    return this.fetch(`/api/assistant/events${query ? `?${query}` : ""}`);
-  }
-  async getActionableEvent(id) {
-    return this.fetch(`/api/assistant/events/${id}`);
-  }
-  async createActionableEvent(data) {
-    return this.fetch("/api/assistant/events", {
-      method: "POST",
-      body: JSON.stringify(data)
-    });
-  }
-  async updateActionableEvent(id, updates) {
-    return this.fetch(`/api/assistant/events/${id}`, {
-      method: "PATCH",
-      body: JSON.stringify(updates)
-    });
-  }
-  async deleteActionableEvent(id) {
-    return this.fetch(`/api/assistant/events/${id}`, {
-      method: "DELETE"
-    });
-  }
   async listSweepRuns(options) {
     const params = new URLSearchParams;
     if (options?.type)
@@ -466906,9 +466765,6 @@ class FulcrumClient {
   async deleteMemory(id) {
     return this.fetch(`/api/memory/${id}`, { method: "DELETE" });
   }
-  async getAssistantStats() {
-    return this.fetch("/api/assistant/stats");
-  }
 }
 
 // server/routes/mcp.ts
@@ -466922,7 +466778,7 @@ mcpRoutes.all("/", async (c) => {
   });
   const server = new McpServer({
     name: "fulcrum",
-    version: "2.8.2"
+    version: "2.9.0"
   });
   const client = new FulcrumClient(`http://localhost:${port}`);
   registerTools(server, client);
@@ -469038,7 +468894,6 @@ chatRoutes.delete("/:sessionId", async (c) => {
 var chat_default = chatRoutes;
 
 // server/routes/assistant.ts
-init_nanoid();
 init_db2();
 init_schema();
 init_drizzle_orm();
@@ -469246,113 +469101,6 @@ assistantRoutes.delete("/documents/:sessionId", async (c) => {
     return c.json({ error: message }, 500);
   }
 });
-assistantRoutes.get("/events", async (c) => {
-  const status = c.req.query("status");
-  const channel = c.req.query("channel");
-  const limit2 = parseInt(c.req.query("limit") || "50");
-  const offset = parseInt(c.req.query("offset") || "0");
-  try {
-    const conditions2 = [];
-    if (status) {
-      conditions2.push(eq(actionableEvents.status, status));
-    }
-    if (channel) {
-      conditions2.push(eq(actionableEvents.sourceChannel, channel));
-    }
-    const whereClause = conditions2.length > 0 ? and(...conditions2) : undefined;
-    const events = db2.select().from(actionableEvents).where(whereClause).orderBy(desc(actionableEvents.createdAt)).limit(limit2).offset(offset).all();
-    const [{ total }] = db2.select({ total: count() }).from(actionableEvents).where(whereClause).all();
-    return c.json({ events, total });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return c.json({ error: message }, 500);
-  }
-});
-assistantRoutes.get("/events/:id", async (c) => {
-  const id = c.req.param("id");
-  try {
-    const event = db2.select().from(actionableEvents).where(eq(actionableEvents.id, id)).get();
-    if (!event) {
-      return c.json({ error: "Event not found" }, 404);
-    }
-    let linkedTask = null;
-    if (event.linkedTaskId) {
-      linkedTask = db2.select().from(tasks).where(eq(tasks.id, event.linkedTaskId)).get();
-    }
-    return c.json({ ...event, linkedTask });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return c.json({ error: message }, 500);
-  }
-});
-assistantRoutes.post("/events", async (c) => {
-  const body = await c.req.json();
-  if (!body.sourceChannel || !body.sourceId) {
-    return c.json({ error: "sourceChannel and sourceId are required" }, 400);
-  }
-  try {
-    const now = new Date().toISOString();
-    const event = {
-      id: nanoid(),
-      sourceChannel: body.sourceChannel,
-      sourceId: body.sourceId,
-      sourceMetadata: body.sourceMetadata,
-      summary: body.summary,
-      status: body.status || "pending",
-      linkedTaskId: body.linkedTaskId,
-      actionLog: [],
-      createdAt: now,
-      updatedAt: now
-    };
-    db2.insert(actionableEvents).values(event).run();
-    return c.json(event, 201);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return c.json({ error: message }, 500);
-  }
-});
-assistantRoutes.patch("/events/:id", async (c) => {
-  const id = c.req.param("id");
-  const body = await c.req.json();
-  try {
-    const existing = db2.select().from(actionableEvents).where(eq(actionableEvents.id, id)).get();
-    if (!existing) {
-      return c.json({ error: "Event not found" }, 404);
-    }
-    const now = new Date().toISOString();
-    const updates = { updatedAt: now };
-    if (body.status !== undefined) {
-      updates.status = body.status;
-    }
-    if (body.linkedTaskId !== undefined) {
-      updates.linkedTaskId = body.linkedTaskId;
-    }
-    if (body.actionLogEntry) {
-      const existingLog = existing.actionLog || [];
-      updates.actionLog = [...existingLog, { timestamp: now, action: body.actionLogEntry }];
-    }
-    db2.update(actionableEvents).set(updates).where(eq(actionableEvents.id, id)).run();
-    const updated = db2.select().from(actionableEvents).where(eq(actionableEvents.id, id)).get();
-    return c.json(updated);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return c.json({ error: message }, 500);
-  }
-});
-assistantRoutes.delete("/events/:id", async (c) => {
-  const id = c.req.param("id");
-  try {
-    const existing = db2.select().from(actionableEvents).where(eq(actionableEvents.id, id)).get();
-    if (!existing) {
-      return c.json({ error: "Event not found" }, 404);
-    }
-    db2.delete(actionableEvents).where(eq(actionableEvents.id, id)).run();
-    return c.json({ success: true });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return c.json({ error: message }, 500);
-  }
-});
 assistantRoutes.get("/sweeps", async (c) => {
   const type = c.req.query("type");
   const limit2 = parseInt(c.req.query("limit") || "20");
@@ -469388,57 +469136,6 @@ assistantRoutes.get("/sweeps/:id", async (c) => {
     return c.json({ error: message }, 500);
   }
 });
-assistantRoutes.get("/stats", async (c) => {
-  try {
-    const eventCounts = db2.select({
-      status: actionableEvents.status,
-      count: count()
-    }).from(actionableEvents).groupBy(actionableEvents.status).all();
-    const eventStats = {
-      pending: 0,
-      actedUpon: 0,
-      dismissed: 0,
-      monitoring: 0,
-      total: 0
-    };
-    for (const row of eventCounts) {
-      const cnt = Number(row.count);
-      eventStats.total += cnt;
-      if (row.status === "pending")
-        eventStats.pending = cnt;
-      else if (row.status === "acted_upon")
-        eventStats.actedUpon = cnt;
-      else if (row.status === "dismissed")
-        eventStats.dismissed = cnt;
-      else if (row.status === "monitoring")
-        eventStats.monitoring = cnt;
-    }
-    const lastSweeps = {
-      hourly: null,
-      morningRitual: null,
-      eveningRitual: null
-    };
-    const latestSweeps = db2.select({
-      type: sweepRuns.type,
-      completedAt: sql`MAX(${sweepRuns.completedAt})`.as("completedAt")
-    }).from(sweepRuns).where(eq(sweepRuns.status, "completed")).groupBy(sweepRuns.type).all();
-    for (const sweep of latestSweeps) {
-      if (sweep.type === "hourly")
-        lastSweeps.hourly = sweep.completedAt;
-      else if (sweep.type === "morning_ritual")
-        lastSweeps.morningRitual = sweep.completedAt;
-      else if (sweep.type === "evening_ritual")
-        lastSweeps.eveningRitual = sweep.completedAt;
-    }
-    return c.json({
-      events: eventStats,
-      lastSweeps
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return c.json({ error: message }, 500);
-  }
-});
 var assistant_default = assistantRoutes;
 
 // server/routes/messaging.ts
@@ -472778,7 +472475,7 @@ async function searchMemories(input) {
               SELECT 1 FROM json_each(m.tags) je
               WHERE je.value IN ${input.tags}
             )
-          ORDER BY bm25(memories_fts)
+          ORDER BY bm25(memories_fts) * (1.0 / (1.0 + (julianday('now') - julianday(m.created_at))))
           LIMIT ${limit2}`);
     return results2.map((r) => ({
       ...r,
@@ -472789,7 +472486,7 @@ async function searchMemories(input) {
         FROM memories_fts fts
         JOIN memories m ON m.rowid = fts.rowid
         WHERE memories_fts MATCH ${ftsQuery}
-        ORDER BY bm25(memories_fts)
+        ORDER BY bm25(memories_fts) * (1.0 / (1.0 + (julianday('now') - julianday(m.created_at))))
         LIMIT ${limit2}`);
   return results.map((r) => ({
     ...r,
@@ -473166,18 +472863,18 @@ async function runHourlySweep() {
   const run2 = createSweepRun("hourly");
   try {
     const lastSweep = getLastSweepRun("hourly");
-    const pendingCount = countEventsByStatus("pending");
+    const actionableMemoryCount = countActionableMemories();
     const openTaskCount = countOpenTasks();
     log2.assistant.info("Running hourly sweep", {
       runId: run2.id,
-      pendingEvents: pendingCount,
+      actionableMemories: actionableMemoryCount,
       openTasks: openTaskCount
     });
     const { session: session3 } = getOrCreateSession(SWEEP_SESSION_PREFIX, "sweep-agent", "Assistant Sweep");
     const prompt = `Perform your hourly sweep. Last sweep: ${lastSweep?.completedAt ?? "never"}`;
     const systemPrompt = getSweepSystemPrompt({
       lastSweepTime: lastSweep?.completedAt ?? null,
-      pendingCount,
+      actionableMemoryCount,
       openTaskCount
     });
     let eventsProcessed = 0;
@@ -473191,7 +472888,7 @@ async function runHourlySweep() {
       if (event.type === "message:complete") {
         const content = event.data.content;
         summary = content;
-        const processedMatch = content.match(/(\d+)\s*events?\s*(reviewed|processed)/i);
+        const processedMatch = content.match(/(\d+)\s*memories?\s*(reviewed|processed)/i);
         if (processedMatch)
           eventsProcessed = parseInt(processedMatch[1]);
         const tasksMatch = content.match(/(\d+)\s*tasks?\s*(updated|created)/i);
@@ -473319,8 +473016,12 @@ function failSweepRun(id, error47) {
 function getLastSweepRun(type) {
   return db2.select().from(sweepRuns).where(eq(sweepRuns.type, type)).orderBy(desc(sweepRuns.startedAt)).limit(1).get() ?? null;
 }
-function countEventsByStatus(status) {
-  const result = db2.select({ count: sql`count(*)` }).from(actionableEvents).where(eq(actionableEvents.status, status)).get();
+function countActionableMemories() {
+  const [result] = db2.all(sql`SELECT COUNT(*) as count FROM memories m
+        WHERE EXISTS (
+          SELECT 1 FROM json_each(m.tags) je
+          WHERE je.value = 'actionable'
+        )`);
   return result?.count ?? 0;
 }
 function countOpenTasks() {