@c4t4/heyamigo 0.9.24 → 0.10.0

package/dist/queue/worker.js

@@ -10,6 +10,8 @@ import { extractFlags, filterFlagsByRole } from '../memory/digest-flag.js';
 import { isValidSlug } from '../memory/journals.js';
 import { enqueueAsyncTask, enqueueBrowserTask } from './async-tasks.js';
 import { addCronUsage, enqueueCron } from './crons.js';
+import { compressThread, coolThread, createThread, dropThread, resolveThread, touchThread, updateThread, } from './threads.js';
+import { setCategoryWeight } from './thread-weights.js';
 import { enqueueMemoryWrite } from './memory-writes.js';
 import { enqueueOutbound } from './outbound.js';
 import { formatLocalTime, resolveTimeExpression } from './time-expr.js';
@@ -111,7 +113,7 @@ async function callClaude(job) {
         addCronUsage(job.cronId, turnInput, turnOutput);
     }
     const rawFlags = extractFlags(reply);
-    const { clean, digest, journals, journalCreates, asyncTasks, asyncBrowserTasks, sendTexts, crons, reminds, } = filterFlagsByRole(rawFlags, job.allowedTags);
+    const { clean, digest, journals, journalCreates, asyncTasks, asyncBrowserTasks, sendTexts, crons, reminds, threadNews, threadUpdates, threadTouches, threadCools, threadResolves, threadDrops, threadCompresses, threadWeights, } = filterFlagsByRole(rawFlags, job.allowedTags);
     // Detect any stripped tags so we can log + nudge the role config
     // if a user is repeatedly hitting the gate.
     const stripped = [];
@@ -127,6 +129,18 @@ async function callClaude(job) {
         stripped.push('ASYNC-BROWSER');
     if (rawFlags.sendTexts.length !== sendTexts.length)
         stripped.push('SEND-TEXT');
+    // Lump all THREAD-* into a single 'THREAD' bucket for the stripped
+    // log since they all share the 'THREAD' allowedTag.
+    const rawThreadCount = rawFlags.threadNews.length + rawFlags.threadUpdates.length +
+        rawFlags.threadTouches.length + rawFlags.threadCools.length +
+        rawFlags.threadResolves.length + rawFlags.threadDrops.length +
+        rawFlags.threadCompresses.length + rawFlags.threadWeights.length;
+    const filteredThreadCount = threadNews.length + threadUpdates.length +
+        threadTouches.length + threadCools.length +
+        threadResolves.length + threadDrops.length +
+        threadCompresses.length + threadWeights.length;
+    if (rawThreadCount !== filteredThreadCount)
+        stripped.push('THREAD');
     if (stripped.length > 0) {
         logger.warn({ jid: job.jid, senderNumber: job.senderNumber, stripped }, 'tags stripped by role gate');
     }
@@ -339,6 +353,93 @@ async function callClaude(job) {
             chars: r.body.length,
         }, 'REMIND tag scheduled');
     }
+    // THREAD-* tag side effects. Each shape lands on its matching
+    // CRUD helper in queue/threads.ts. Errors per-tag are logged but
+    // don't abort the rest of the reply pipeline.
+    if (config.threads?.enabled) {
+        for (const t of threadNews) {
+            try {
+                createThread({
+                    targetJid: job.jid,
+                    title: t.title,
+                    summary: t.summary,
+                    hotness: t.hotness,
+                    linkedMemory: t.linkedMemory ?? null,
+                    category: t.category,
+                });
+            }
+            catch (err) {
+                logger.warn({ err, jid: job.jid, title: t.title }, 'THREAD-NEW failed');
+            }
+        }
+        for (const t of threadUpdates) {
+            try {
+                updateThread({
+                    id: t.id,
+                    title: t.title,
+                    summary: t.summary,
+                    hotness: t.hotness,
+                    linkedMemory: t.linkedMemory ?? undefined,
+                });
+            }
+            catch (err) {
+                logger.warn({ err, jid: job.jid, id: t.id }, 'THREAD-UPDATE failed');
+            }
+        }
+        for (const t of threadTouches) {
+            try {
+                touchThread(t.id);
+            }
+            catch (err) {
+                logger.warn({ err, jid: job.jid, id: t.id }, 'THREAD-TOUCH failed');
+            }
+        }
+        for (const t of threadCools) {
+            try {
+                coolThread(t.id, t.deferDays);
+            }
+            catch (err) {
+                logger.warn({ err, jid: job.jid, id: t.id }, 'THREAD-COOL failed');
+            }
+        }
+        for (const t of threadResolves) {
+            try {
+                resolveThread(t.id, t.note);
+            }
+            catch (err) {
+                logger.warn({ err, jid: job.jid, id: t.id }, 'THREAD-RESOLVE failed');
+            }
+        }
+        for (const t of threadDrops) {
+            try {
+                dropThread(t.id, t.note);
+            }
+            catch (err) {
+                logger.warn({ err, jid: job.jid, id: t.id }, 'THREAD-DROP failed');
+            }
+        }
+        for (const t of threadCompresses) {
+            try {
+                compressThread(t.id, t.note);
+            }
+            catch (err) {
+                logger.warn({ err, jid: job.jid, id: t.id }, 'THREAD-COMPRESS failed');
+            }
+        }
+        for (const w of threadWeights) {
+            try {
+                setCategoryWeight(w.category, w.weight);
+            }
+            catch (err) {
+                logger.warn({ err, jid: job.jid, category: w.category }, 'THREAD-WEIGHT failed');
+            }
+        }
+    }
+    else if (threadNews.length + threadUpdates.length + threadTouches.length +
+        threadCools.length + threadResolves.length + threadDrops.length +
+        threadCompresses.length + threadWeights.length > 0) {
+        logger.warn({ jid: job.jid }, 'THREAD-* tags emitted but threads feature disabled — ignored');
+    }
     return {
         reply: clean,
         stats: {
@@ -353,7 +454,17 @@ async function callClaude(job) {
             fresh: wasFresh,
             hasDigest: digest !== null,
             journalSlugs: journals.map((j) => j.slug),
-            asyncCount: asyncTasks.length + asyncBrowserTasks.length,
+            journalCreateCount: journalCreates.length,
+            asyncCount: asyncTasks.length,
+            asyncBrowserCount: asyncBrowserTasks.length,
+            remindCount: reminds.length,
+            cronCount: crons.length,
+            sendTextCount: sendTexts.length,
+            threadNewCount: threadNews.length,
+            threadResolveCount: threadResolves.length,
+            threadDropCount: threadDrops.length,
+            threadCompressCount: threadCompresses.length,
+            threadTouchCount: threadTouches.length,
         },
         jobCards: jobCards.length > 0 ? jobCards : undefined,
     };

package/migrations/0010_create_threads.sql

@@ -0,0 +1,27 @@
+CREATE TABLE `thread_category_weights` (
+	`category` text PRIMARY KEY NOT NULL,
+	`weight` integer DEFAULT 50 NOT NULL,
+	`samples` integer DEFAULT 0 NOT NULL,
+	`updated_at` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE TABLE `threads` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`target_jid` text NOT NULL,
+	`title` text NOT NULL,
+	`summary` text NOT NULL,
+	`hotness` integer DEFAULT 50 NOT NULL,
+	`status` text DEFAULT 'live' NOT NULL,
+	`linked_memory` text,
+	`opened_at` integer NOT NULL,
+	`last_touched_at` integer NOT NULL,
+	`next_review_at` integer NOT NULL,
+	`resolution_note` text,
+	`total_input_tokens` integer DEFAULT 0 NOT NULL,
+	`total_output_tokens` integer DEFAULT 0 NOT NULL,
+	`enabled` integer DEFAULT 1 NOT NULL,
+	`created_at` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE INDEX `threads_by_jid_hot` ON `threads` (`target_jid`,`status`,`hotness`);--> statement-breakpoint
+CREATE INDEX `threads_by_due` ON `threads` (`enabled`,`status`,`next_review_at`);