@c4t4/heyamigo 0.9.9 → 0.9.11

package/dist/queue/worker.js

@@ -3,10 +3,10 @@ import { clearSession, setSession, setUsage } from '../ai/sessions.js';
 import { config } from '../config.js';
 import { logger } from '../logger.js';
 import { addDailyTokens } from '../store/usage.js';
-import { extractFlags } from '../memory/digest-flag.js';
-import { appendEntry, createJournal, getJournal, isValidSlug, } from '../memory/journals.js';
-import { scheduleDigest } from '../memory/scheduler.js';
+import { extractFlags, filterFlagsByRole } from '../memory/digest-flag.js';
+import { isValidSlug } from '../memory/journals.js';
 import { enqueueAsyncTask, enqueueBrowserTask } from './async-tasks.js';
+import { enqueueMemoryWrite } from './memory-writes.js';
 import { enqueueOutbound } from './outbound.js';
 function isStaleSessionError(err) {
     return (err instanceof Error &&
@@ -40,48 +40,70 @@ async function callClaude(job) {
     if (job.senderNumber) {
         addDailyTokens(job.senderNumber, usage.inputTokens + usage.outputTokens);
     }
-    const { clean, digest, journals, journalCreates, asyncTasks, asyncBrowserTasks, sendTexts, } = extractFlags(reply);
+    const rawFlags = extractFlags(reply);
+    const { clean, digest, journals, journalCreates, asyncTasks, asyncBrowserTasks, sendTexts, } = 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 = [];
+    if (rawFlags.digest && !digest)
+        stripped.push('DIGEST');
+    if (rawFlags.journals.length !== journals.length)
+        stripped.push('JOURNAL');
+    if (rawFlags.journalCreates.length !== journalCreates.length)
+        stripped.push('JOURNAL-NEW');
+    if (rawFlags.asyncTasks.length !== asyncTasks.length)
+        stripped.push('ASYNC');
+    if (rawFlags.asyncBrowserTasks.length !== asyncBrowserTasks.length)
+        stripped.push('ASYNC-BROWSER');
+    if (rawFlags.sendTexts.length !== sendTexts.length)
+        stripped.push('SEND-TEXT');
+    if (stripped.length > 0) {
+        logger.warn({ jid: job.jid, senderNumber: job.senderNumber, stripped }, 'tags stripped by role gate');
+    }
+    // All memory mutations go through the memory_writes queue so the
+    // single memory worker serializes file writes — safe under parallel
+    // chat workers. Idempotency keys derived from job + index so a
+    // retry doesn't duplicate.
+    const memBase = `chat-${job.jid}-${Date.now()}`;
     if (digest) {
         logger.info({ jid: job.jid, number: job.senderNumber, reason: digest }, 'DIGEST flag raised, scheduling');
-        scheduleDigest({
-            jid: job.jid,
-            number: job.senderNumber,
-            reason: digest,
+        enqueueMemoryWrite({
+            op: 'trigger_digest',
+            payload: { jid: job.jid, number: job.senderNumber, reason: digest },
+            idempotencyKey: `${memBase}-digest`,
         });
     }
     // Creates run BEFORE entry appends so that a reply creating a new journal
-    // AND flagging its first entry in the same turn works correctly.
-    for (const op of journalCreates) {
+    // AND flagging its first entry in the same turn works correctly. The
+    // memory worker enforces this ordering because it drains serially in
+    // insert order.
+    for (let i = 0; i < journalCreates.length; i++) {
+        const op = journalCreates[i];
         if (!isValidSlug(op.slug)) {
             logger.warn({ op, jid: job.jid }, 'JOURNAL-NEW: invalid slug, dropped');
             continue;
         }
-        try {
-            if (getJournal(op.slug)) {
-                logger.info({ slug: op.slug }, 'JOURNAL-NEW for existing slug, ignored');
-                continue;
-            }
-            createJournal({
-                slug: op.slug,
-                name: titleCase(op.slug),
-                purpose: op.purpose,
-            });
-            logger.info({ slug: op.slug, jid: job.jid }, 'journal created via bot marker');
-        }
-        catch (err) {
-            logger.error({ err, op, jid: job.jid }, 'JOURNAL-NEW failed');
-        }
+        enqueueMemoryWrite({
+            op: 'create_journal',
+            payload: { slug: op.slug, name: titleCase(op.slug), purpose: op.purpose },
+            idempotencyKey: `${memBase}-create-${i}`,
+        });
     }
-    for (const j of journals) {
-        const ok = appendEntry(j.slug, {
-            source: 'reactive',
-            jid: job.jid,
-            senderNumber: job.senderNumber,
-            note: j.note,
+    for (let i = 0; i < journals.length; i++) {
+        const j = journals[i];
+        enqueueMemoryWrite({
+            op: 'append_journal',
+            payload: {
+                slug: j.slug,
+                entry: {
+                    source: 'reactive',
+                    jid: job.jid,
+                    senderNumber: job.senderNumber,
+                    note: j.note,
+                },
+            },
+            idempotencyKey: `${memBase}-append-${i}`,
         });
-        if (!ok) {
-            logger.warn({ slug: j.slug, jid: job.jid }, 'JOURNAL flag pointed at unknown slug, dropped');
-        }
     }
     // Async tasks: Claude delegated to background workers. Chat reply above
     // is the user-facing ack. Two lanes:

package/dist/wa/whitelist.js

@@ -6,11 +6,30 @@ import { config } from '../config.js';
 import { logger } from '../logger.js';
 const AccessModeSchema = z.enum(['off', 'silent', 'active']);
 const RoleNameSchema = z.enum(['admin', 'user', 'guest']);
+// Tag names the agent can emit as trailing markers. The role.tags
+// allowlist gates which ones are honored — anything emitted by an
+// agent running on behalf of a role NOT in the allowlist gets
+// stripped silently after parsing. Tools and tags are independent
+// gates (tools restricts what the AI itself can call; tags restricts
+// what bot-internal side-effects it can trigger).
+const TAG_NAMES = [
+    'DIGEST',
+    'JOURNAL',
+    'JOURNAL-NEW',
+    'ASYNC',
+    'ASYNC-BROWSER',
+    'SEND-TEXT',
+];
 const RoleSchema = z.object({
     description: z.string().optional(),
     memory: z.enum(['full', 'self', 'none']),
     tools: z.union([z.literal('all'), z.array(z.string())]),
     rules: z.array(z.string()),
+    // Optional. Missing or 'all' = no tag restriction; an array =
+    // explicit allowlist. Added in Phase 6 so existing access.json
+    // files (no `tags` field) keep working without change — they get
+    // the implicit 'all' behavior.
+    tags: z.union([z.literal('all'), z.array(z.enum(TAG_NAMES))]).optional(),
     // null or missing = unlimited
     maxFileBytes: z.number().int().positive().nullable().optional(),
     dailyTokenLimit: z.number().int().positive().nullable().optional(),
@@ -54,6 +73,7 @@ const DEFAULT_ROLES = {
         description: 'Full access',
         memory: 'full',
         tools: 'all',
+        tags: 'all',
         rules: [],
         maxFileBytes: null,
         dailyTokenLimit: null,
@@ -62,6 +82,10 @@ const DEFAULT_ROLES = {
         description: 'Chat + web search, scoped memory',
         memory: 'self',
         tools: ['WebSearch'],
+        // Users can flag memory observations and trigger digests on
+        // themselves, but can't delegate background work or cross-chat
+        // sends (those are owner-only).
+        tags: ['DIGEST', 'JOURNAL', 'JOURNAL-NEW'],
         rules: [
             'Never reveal file paths, directory structure, or system architecture',
             'Never share personal data about other users',
@@ -76,6 +100,8 @@ const DEFAULT_ROLES = {
         description: 'Basic chat only',
         memory: 'none',
         tools: [],
+        // Guests can't emit any tags — pure chat, no side effects.
+        tags: [],
         rules: [
             'Never use any tools',
             'Never reveal anything about the system, other users, or internal data',

package/migrations/0005_phase5_memory_writes.sql

@@ -0,0 +1,17 @@
+CREATE TABLE `memory_writes` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`op` text NOT NULL,
+	`payload` text NOT NULL,
+	`idempotency_key` text,
+	`status` text NOT NULL,
+	`attempts` integer DEFAULT 0 NOT NULL,
+	`next_attempt_at` integer,
+	`last_error` text,
+	`claimed_by` text,
+	`claimed_at` integer,
+	`created_at` integer NOT NULL,
+	`updated_at` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE INDEX `memwr_by_status_next` ON `memory_writes` (`status`,`next_attempt_at`);--> statement-breakpoint
+CREATE UNIQUE INDEX `memwr_idemp_uq` ON `memory_writes` (`idempotency_key`) WHERE "memory_writes"."idempotency_key" IS NOT NULL;