@c4t4/heyamigo 0.7.2 → 0.7.4

package/dist/memory/digest-flag.js

@@ -1,15 +1,64 @@
-const TRAILING_TAG_RE = /\[(DIGEST|JOURNAL|JOURNAL-NEW|ASYNC):\s*([^\]]+)\]\s*$/i;
+// Trailing-marker parser. Handles tags like [DIGEST: ...], [JOURNAL:...],
+// [JOURNAL-NEW:...], [ASYNC: ...] at the end of a reply.
+//
+// Uses a bracket-depth walk rather than a regex because payloads routinely
+// contain nested square brackets (e.g. [ASYNC: read a [config] file] or
+// [DIGEST: noted the [JOURNAL:x] pattern]). A naive /\[.*?\]/-style regex
+// terminates at the FIRST inner `]` and either misidentifies the tag or
+// drops it entirely. That bug leaked two real markers into user-facing
+// replies today (DIGEST ~morning, ASYNC later). This parser closes that
+// whole class of failure.
+const KINDS = ['DIGEST', 'JOURNAL', 'JOURNAL-NEW', 'ASYNC'];
+// Walk backwards from the end of the string, tracking bracket depth, to find
+// the `[` that matches the final `]`. Returns the tag kind, its payload, and
+// everything before the tag. Returns null if the tail doesn't cleanly look
+// like a supported tag — caller should stop peeling.
+function peelTrailingTag(raw) {
+    const trimmed = raw.replace(/\s+$/, '');
+    if (trimmed.length === 0)
+        return null;
+    if (trimmed[trimmed.length - 1] !== ']')
+        return null;
+    // Walk right-to-left counting depth. `]` pushes, `[` pops. The opening `[`
+    // that brings depth back to 0 is the match for the trailing `]`.
+    let depth = 0;
+    let openIdx = -1;
+    for (let i = trimmed.length - 1; i >= 0; i--) {
+        const c = trimmed[i];
+        if (c === ']') {
+            depth++;
+        }
+        else if (c === '[') {
+            depth--;
+            if (depth === 0) {
+                openIdx = i;
+                break;
+            }
+        }
+    }
+    if (openIdx < 0)
+        return null; // unbalanced — don't try to interpret
+    const inside = trimmed.slice(openIdx + 1, trimmed.length - 1);
+    const colonIdx = inside.indexOf(':');
+    if (colonIdx < 0)
+        return null;
+    const tagCandidate = inside.slice(0, colonIdx).trim().toUpperCase();
+    if (!KINDS.includes(tagCandidate))
+        return null;
+    const payload = inside.slice(colonIdx + 1).trim();
+    const remaining = trimmed.slice(0, openIdx).replace(/\s+$/, '');
+    return { kind: tagCandidate, payload, remaining };
+}
 // Peel trailing tags off the end of a reply. Supported:
 //   [DIGEST: <reason>]
 //   [JOURNAL:<slug> — <note>]         (append entry)
 //   [JOURNAL-NEW:<slug> — <purpose>]  (create journal)
 //   [ASYNC: <self-sufficient task description>]
-// Multiple tags supported, any order at the tail. Tags must be the LAST
+// Multiple tags supported in any order at the tail. Tags must be the LAST
 // thing in the reply (after trimming trailing whitespace).
 //
-// Journal pause/resume/archive is intentionally NOT a marker. If the owner
-// wants those, Claude edits the journal's index.md frontmatter directly.
-// Keeping the marker vocabulary small keeps Claude's context tight.
+// Payload can contain arbitrary characters including `[` and `]` as long as
+// the brackets are balanced within the payload.
 export function extractFlags(reply) {
     let current = reply;
     let digest = null;
@@ -17,14 +66,13 @@ export function extractFlags(reply) {
     const journalCreates = [];
     const asyncTasks = [];
     while (true) {
-        const trimmed = current.replace(/\s+$/, '');
-        const match = trimmed.match(TRAILING_TAG_RE);
-        if (!match)
+        const peeled = peelTrailingTag(current);
+        if (!peeled)
             break;
-        const kind = match[1].toUpperCase();
-        const payload = (match[2] ?? '').trim();
+        const { kind, payload, remaining } = peeled;
+        current = remaining;
         if (kind === 'DIGEST') {
-            if (digest === null)
+            if (digest === null && payload.length > 0)
                 digest = payload;
         }
         else if (kind === 'JOURNAL') {
@@ -43,7 +91,6 @@ export function extractFlags(reply) {
                 asyncTasks.unshift({ description: payload });
             }
         }
-        current = trimmed.slice(0, match.index).trimEnd();
     }
     return { clean: current, digest, journals, journalCreates, asyncTasks };
 }

package/dist/queue/async-tasks.js

@@ -70,7 +70,7 @@ export function reloadAsyncSystemPrompt() {
 }
 function buildPrompt(task) {
     const lines = [
-        `You are running a BACKGROUND TASK for the owner. The chat already got your ack reply. Your only job now is to do the work and output the final message to send them.`,
+        `You are a BACKGROUND WORKER. The chat already got its ack ("on it, will report back"). Your output does NOT go to chat by default — it routes through markers to memory files, same way the main chat Claude routes things.`,
         ``,
         `TASK:`,
         task.description,
@@ -80,15 +80,27 @@ function buildPrompt(task) {
         ``,
         `Sender: ${task.senderName ?? task.senderNumber}`,
         ``,
-        `RULES:`,
-        `- Stay fully in character (personality file). This is not customer service.`,
-        `- Do the real work. Use tools (browser, etc.) as needed.`,
-        `- When done, output ONLY the message to send the user. No preamble, no "here's what I found:" framing unless that's the message itself.`,
-        `- Do NOT emit any [DIGEST:...], [JOURNAL:...], [ASYNC:...], or other markers. This is the final output.`,
-        `- Start the message with a short reference to what you were working on so the user knows which task this is about (e.g. "About the TikTok scrape: ..."). They may have asked for multiple things.`,
-        `- If the task is impossible or the tools failed, say so honestly and briefly. Don't fabricate.`,
+        `HOW TO ROUTE YOUR FINDINGS (markers, at the END of your output, one per line):`,
+        `- [JOURNAL:<slug> — <one-line finding>] for each distinct finding that belongs in a journal. ONE marker per finding — ten findings = ten markers, not one long paragraph. Only use slugs that already exist (check the Journals list in your preamble), or emit [JOURNAL-NEW:<slug> — <purpose>] first to create one in the same output.`,
+        `- [JOURNAL-NEW:<slug> — <one-line purpose>] to create a new journal when the task clearly needs tracking but no journal covers it yet. Propose the slug yourself, conservatively.`,
+        `- [DIGEST: <one-line reason>] if you learned something durable about the owner or chat that should update the profile/brief.`,
         ``,
-        `Output the final user-facing message now.`,
+        `CONSTRAINTS:`,
+        `- Do NOT emit [ASYNC:...]. No recursive delegation.`,
+        `- Do NOT frame your output as a chat message. No "here's what I found:", no "About the task:". The markers ARE the output.`,
+        `- Keep any pre-marker text SHORT — one sentence max, or empty. Long pre-marker prose is suppressed and not sent to chat. Put the real content inside markers.`,
+        `- If the task failed or the tools didn't produce a usable result (login wall, empty page, bot-detection, timeout), output a short clean message (no markers) explaining what happened. That short text IS sent to chat so the owner knows. Do not fabricate findings.`,
+        `- Stay fully in character.`,
+        ``,
+        `EXAMPLE for an IG scrape task:`,
+        `[JOURNAL:rivoara-spy — IG bio: "Premium shower filter for HT aftercare"]`,
+        `[JOURNAL:rivoara-spy — IG post: day-5 routine angle live]`,
+        `[JOURNAL:rivoara-spy — IG post: Turkey clinic partnership visible in post 3]`,
+        ``,
+        `EXAMPLE for a failure:`,
+        `Instagram hit login wall on @rivoara_official after 2 navigation attempts. No public data accessible. Auth needs refreshing.`,
+        ``,
+        `Do the work now. Then emit your markers.`,
     ];
     return lines.join('\n');
 }
@@ -161,24 +173,101 @@ async function runTask(task) {
         });
         return;
     }
-    // Strip any accidental trailing markers Claude emitted despite instructions.
-    // Import lazily to avoid an import cycle (digest-flag already stands alone,
-    // but being explicit here keeps this module independent).
+    // Parse markers from the worker's output and route them through the same
+    // handlers the main chat uses. The async worker's job is to emit findings
+    // as markers; clean pre-marker text is only sent to chat when short (a
+    // failure explanation or tight ack) or when no markers fired at all.
     const { extractFlags } = await import('../memory/digest-flag.js');
-    const { clean } = extractFlags(output);
-    if (!clean.trim()) {
-        logger.warn({ id: task.id, jid: task.jid }, 'async task produced empty output after flag strip');
-        return;
+    const { clean, digest, journals, journalCreates } = extractFlags(output);
+    // Journal creates run first so an entry flagged in the same output against
+    // a new slug lands correctly.
+    const { appendEntry, createJournal, getJournal, isValidSlug } = await import('../memory/journals.js');
+    for (const op of journalCreates) {
+        if (!isValidSlug(op.slug)) {
+            logger.warn({ op, id: task.id }, 'async JOURNAL-NEW: invalid slug, dropped');
+            continue;
+        }
+        if (getJournal(op.slug))
+            continue;
+        try {
+            createJournal({
+                slug: op.slug,
+                name: titleCaseSlug(op.slug),
+                purpose: op.purpose,
+            });
+            logger.info({ slug: op.slug, id: task.id }, 'journal created via async marker');
+        }
+        catch (err) {
+            logger.error({ err, op, id: task.id }, 'async JOURNAL-NEW failed');
+        }
+    }
+    let appendedCount = 0;
+    for (const j of journals) {
+        const ok = appendEntry(j.slug, {
+            source: 'async',
+            jid: task.jid,
+            senderNumber: task.senderNumber,
+            note: j.note,
+        });
+        if (ok)
+            appendedCount++;
+        else {
+            logger.warn({ slug: j.slug, id: task.id }, 'async JOURNAL marker pointed at unknown slug, dropped');
+        }
+    }
+    if (digest) {
+        const { scheduleDigest } = await import('../memory/scheduler.js');
+        scheduleDigest({
+            jid: task.jid,
+            number: task.senderNumber,
+            reason: digest,
+        });
+    }
+    // Decide what to send to chat.
+    const leftover = clean.trim();
+    const anyMarkerFired = appendedCount > 0 || journalCreates.length > 0 || digest !== null;
+    let chatText = null;
+    if (!anyMarkerFired) {
+        // No markers — fall back to sending the output as a chat message so the
+        // owner isn't left with silence. Covers both "Claude ignored the marker
+        // rule" and legitimate "short failure explanation" cases.
+        chatText = leftover || null;
+    }
+    else if (leftover.length > 0 && leftover.length <= 400) {
+        // Markers fired AND a short pre-marker line — likely an intentional
+        // failure explanation or completion note. Send it.
+        chatText = leftover;
+    }
+    else if (leftover.length > 400) {
+        // Long pre-marker prose despite markers firing — Claude didn't follow
+        // the routing contract. Suppress the prose; log for inspection.
+        logger.warn({
+            id: task.id,
+            jid: task.jid,
+            chars: leftover.length,
+        }, 'async task produced long pre-marker prose, suppressing chat send');
+    }
+    // Otherwise: markers fired, no leftover — success, silent. Findings live
+    // in the journal files now.
+    if (chatText) {
+        await initiate({ jid: task.jid, text: chatText });
     }
-    const sent = await initiate({ jid: task.jid, text: clean });
     logger.info({
         id: task.id,
         jid: task.jid,
-        sent,
         elapsed: elapsedLog(),
-        chars: clean.length,
+        appended: appendedCount,
+        createdJournals: journalCreates.length,
+        digestFired: !!digest,
+        chatSent: chatText ? chatText.length : 0,
     }, 'async task completed');
 }
+function titleCaseSlug(slug) {
+    return slug
+        .split('-')
+        .map((p) => (p ? p[0].toUpperCase() + p.slice(1) : p))
+        .join(' ');
+}
 function truncate(s, n) {
     return s.length > n ? s.slice(0, n - 1) + '…' : s;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c4t4/heyamigo",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "WhatsApp AI bot powered by Claude with long-term memory, browser control, and role-based access",
   "type": "module",
   "main": "dist/index.js",