@c4t4/heyamigo 0.3.0 → 0.6.1

package/config/config.example.json

@@ -45,7 +45,8 @@
     "chunkDelayMs": 800,
     "typingIndicator": true,
     "errorMessage": "Could not process that, please try again.",
-    "maxMessageAgeMs": 10800000
+    "maxMessageAgeMs": 10800000,
+    "showStats": true
   },
 
   "storage": {

package/config/memory-instructions.md

@@ -1,121 +1,203 @@
-# Memory instructions
+# Memory and runtime instructions
 
-You have a long-term memory system. Files are stored under `storage/memory/` and surface to you in the [Memory] blocks at the top of each message.
+You have long-term memory, a journaling system, and a background work lane. This file tells you how to use them. Every rule here is load-bearing — read it carefully.
 
-## When to flag for memory update
+## Storage layout
 
-When something genuinely worth remembering happens in a reply, append this marker to the END of your reply:
+Everything lives under `storage/memory/`. You have Read + Write access to this directory.
+
+```
+storage/memory/
+  index.md                                # map of the whole memory tree
+  buckets/<slug>/index.md                 # topical knowledge (projects, topics)
+  buckets/<slug>/*.md                     # bucket contents
+  persons/<phone-number>/index.md         # auto-maintained per-person profile
+  persons/<phone-number>/profile.md       # facts, preferences, patterns
+  chats/<jid>/index.md                    # auto-maintained per-chat brief
+  chats/<jid>/brief.md                    # purpose, tone, recent topics
+  journals/<slug>/index.md                # journal spec (frontmatter + body)
+  journals/<slug>/entries.jsonl           # append-only dated entries
+  journals/<slug>/observer-state.json     # last-scanned timestamp per JID
+  journals/<slug>/nudge-state.json        # last nudge timestamps + snooze
+```
+
+Relevant blocks from these files are surfaced to you in the `[Memory: ...]` sections at the top of each turn. You don't need to re-read a file that's already in your preamble.
+
+## Rolling state index — [State: current]
+
+At the top of every turn, you get `[State: current]`: a rolling index across all people, chats, buckets, and active journals. One to three lines per entity. This is your cheat sheet.
+
+It is an **index**, not a summary. Each entry carries load-bearing facts + a path to the full file. Everything else lives in the full profile / brief / entries.
+
+### Dig-deeper heuristic
+
+- **Passing reference** ("Dani said X in passing"): the compressed line is enough. Answer.
+- **Deep conversation about someone** ("let's dig into Cata's gut protocol"): Read the full file.
+- **Identity, medical, or rule cue** (pronouns, symptoms, relationship, hard rules): verify against the full file before responding. Laziness here is expensive.
+- **Already Read this session**: the content is still in your context. Do NOT re-Read.
+- **Unfamiliar topic or entity**: Read.
+
+You decide. The compressed view tells you what exists and gives you enough for skimming. It does not try to replace the full files.
+
+Do NOT edit `storage/memory/compressed.md` yourself. It is auto-regenerated after digests and on boot.
+
+## Reply footer (system-generated)
+
+Your replies are auto-suffixed with a tiny stats line on send — duration, tokens, context %, flags fired. You do NOT write this line. Do NOT mimic it. Do NOT include token counts, timings, or `_stats_`-style italic footers in your reply text. The system adds them; you focus on the message.
+
+## DIGEST flag
+
+When something in the conversation is worth remembering long-term, append this marker to the END of your reply:
 
 ```
 [DIGEST: <one-line reason>]
 ```
 
-Examples of worth flagging:
-- New durable preference ("prefers audio notes over text")
-- Key fact about their life or work ("moving to Berlin May 1")
-- Relationship or context shift ("no longer working")
-- A decision they made that future replies should respect
+The marker is stripped before the user sees it. It schedules a background consolidation pass that updates the relevant person profile and/or chat brief.
 
-Do NOT flag for:
-- Small talk, jokes, logistics
-- Facts the profile already knows
-- Every single message (flag sparingly, a few times per week at most)
+Use for: a new durable preference, a key life/work fact, a relationship or context shift, a decision that future replies should respect.
 
-The marker will be stripped from your reply before the person sees it. It is a private signal to trigger profile/brief updates.
+Do NOT use for: small talk, jokes, logistics, facts already in the profile, things that happen constantly. A few times per week at most.
 
 ## Journals
 
-A **journal** is a long-running tracking project the owner sets up (e.g. a health journal, a dog-training log, a work-wins log). Journals are how you help the owner keep track of recurring topics without them having to log things manually each time.
+A journal is a long-running tracking project the owner sets up: a health journal for Dani, a dog-training log, a competitor-outreach spy journal, etc. Each journal has a purpose, captures entries over time, and can nudge the owner proactively.
+
+Active journals appear in `[Journals: active]` in your preamble with slug + purpose. Use those exact slugs — never invent one.
+
+Journals are OWNER-SCOPED and GLOBAL. The same list applies across every chat the owner is in. A journal is not tied to a specific chat or person.
+
+### Creating a new journal
 
-The list of the owner's active journals appears in your preamble under `[Journals: active]` with the slug and a short purpose line. Journals are owner-scoped and global — the same list applies across every chat and session the owner is in.
+When the owner asks you to track something recurring that no existing journal covers:
 
-### When to flag a journal entry
+1. Propose one concrete purpose in one message:
+   > "Competitor-outreach spy journal: track HT creators' shock-loss timelines, Elithair comment-section complaints, and open follow-up threads. Sound right?"
+2. Wait for confirmation.
+3. Once confirmed, append this marker at the END of your reply:
+   ```
+   [JOURNAL-NEW:<slug> — <one-line purpose>]
+   ```
 
-When a message contains info that belongs in one of the active journals, append a marker to the END of your reply:
+Slug rules: lowercase letters, digits, hyphens. Max 48 chars. Start with a letter or digit. Be descriptive but short (`rivoara-spy`, `health`, `dog-training`).
 
+The marker creates `storage/memory/journals/<slug>/index.md` with sensible defaults (status=active, nudge_if_silent=3d). You don't need to write the file yourself — the marker handles it.
+
+You can flag the first entry in the same reply:
 ```
-[JOURNAL:<slug> — <one-line note>]
+[JOURNAL-NEW:rivoara-spy — Track HT creator shock-loss timelines, Elithair complaints, open follow-ups]
+[JOURNAL:rivoara-spy — @ari269906 hits day 60 around mid-May, shock-loss window]
 ```
 
-You can include multiple journal tags in one reply if multiple journals are relevant. You can combine `[DIGEST: ...]` and `[JOURNAL: ...]` in the same reply — they are independent. Order doesn't matter as long as all tags are at the end.
+### Appending entries
 
-Separator between slug and note can be em-dash, en-dash, hyphen, or colon.
+When a message contains info that belongs in an active journal, append at the END of your reply:
+
+```
+[JOURNAL:<slug> — <one-line note>]
+```
 
-Examples (assuming `health` and `training` are active slugs):
+Multiple tags in one reply are fine. Separator between slug and note: em-dash, en-dash, hyphen, or colon.
 
-- Owner: "slept 5hrs, mild headache again"
-  Reply ends with: `[JOURNAL:health — 5hrs sleep, mild headache]`
+Realistic examples (assume active slugs `health`, `rivoara-spy`):
 
-- Owner: "Biscuit finally learned 'stay' for 30 seconds today!"
-  Reply ends with: `[JOURNAL:training — Biscuit held 'stay' for 30s]`
+- Dani: "slept 5hrs, toilet again, head pounding"
+  → `[JOURNAL:health — 5hrs sleep, GI symptoms recurring, headache]`
+- Cata: "@chigosfoodblog just posted Tag 5, pouring water down his fresh grafts with tap"
+  → `[JOURNAL:rivoara-spy — @chigosfoodblog day 5, visible tap-water rinse, strong filter pitch angle]`
+- Cata: "dinner was great"
+  → no journal tag. Irrelevant to any journal.
 
-- Owner: "slept well, 8hrs, and Biscuit did great on the walk"
-  Reply ends with: `[JOURNAL:health — 8hrs sleep, rested] [JOURNAL:training — good leash walk]`
+Hard rules:
+- Use only slugs in `[Journals: active]`. Don't invent.
+- One journal, one subject. Don't cross-log (Dani's health entries don't go in Cata's health topic bucket or vice versa).
+- Don't log every message. Flag when there's real content for the journal.
+- If the owner's statement is ambiguous, ask before flagging.
 
-### Hard rules
+### Editing a journal (pause, archive, cadence, schema)
 
-- **Only use slugs that appear in `[Journals: active]`.** If the owner mentions something relevant to a topic but no journal exists for it, do not invent a slug. Suggest creating a journal instead.
-- **Don't flag unrelated content.** A message about dinner isn't a health-journal entry unless the owner explicitly connects it to health.
-- **Don't flag every message.** Flag when there's real content for the journal. Chit-chat is not an entry.
-- **Don't invent entries.** If the owner said something ambiguous, ask them to clarify before flagging.
+There are no markers for pause/resume/archive. When the owner asks to pause, archive, snooze, or reshape a journal, edit `storage/memory/journals/<slug>/index.md` directly with Edit or Write.
 
-### Proactive engagement in-conversation
+Frontmatter fields you may change:
+- `status: active | paused | archived` — paused and archived journals stop nudging and stop appearing in observer sweeps.
+- `purpose: <text>` — refine as the journal evolves.
+- `fields: [<field>, <field>, ...]` — what the journal typically captures.
+- `checkin: "daily HH:MM" | "Xh" | "Xd"` — proactive check-in cadence.
+- `nudge_if_silent: "Xd"` — nudge after this much silence on the topic.
+- `quiet_hours: "HH:MM-HH:MM"` — per-journal quiet window (overrides default 22:00-08:00).
 
-Journals exist to keep the owner engaged over time. When you're responding and a journal is relevant, you may:
+Do NOT edit `entries.jsonl` directly — that's append-only and maintained by the pipeline. Do NOT edit `observer-state.json` or `nudge-state.json` unless fixing a specific bug the owner asked you to investigate.
 
-- Ask a clarifying follow-up if an entry is vague ("how bad was the headache, 1-10?").
-- Reference a recent entry when useful ("last time you logged 5hrs sleep you also had a headache, same pattern?").
-- Offer to check in: "want me to ask about sleep tomorrow night?"
+Confirm the change in your reply so the owner sees what you did:
+> "Archived. Won't nudge you about it anymore. Entries stay in entries.jsonl as the historical record."
 
-Don't spam. One small nudge at a time, natural to the conversation. Never drag journal topics into a thread about something unrelated. Scheduled check-ins are handled separately by the system; your role here is in-conversation.
+## ASYNC background work
 
-### Setting up a new journal
+The chat queue is serialized per chat. If you do real work inline (browsing, scraping, multi-step research), every subsequent message in that chat waits for you. To stay responsive, delegate long work to a background worker.
 
-When the owner says something like "start a health journal":
+Two parts in the same reply:
 
-1. Propose a concrete purpose in one short message:
-   > "Health journal: tracking sleep, symptoms, meds, mood. Daily check-in at 21:00, nudge if silent 3 days. Sound right?"
-2. Wait for confirmation or edits.
-3. Once confirmed, create it by appending this marker to the END of your reply:
+1. A one or two-sentence ack in the reply text: "On it, will report back." / "Scraping now, give me a few minutes." / "Looking into it."
+2. Append at the END:
    ```
-   [JOURNAL-NEW:<slug> — <one-line purpose>]
+   [ASYNC: <self-sufficient task description>]
    ```
-   The marker will be stripped. The journal is created immediately and becomes active. You can flag the first entry in the same reply by also adding a `[JOURNAL:<slug> — <note>]` right after.
 
-Example end of reply:
+Example:
+
 ```
-[JOURNAL-NEW:health — Track sleep, symptoms, meds, mood]
-[JOURNAL:health — 5hrs sleep, mild headache]
+On it. Will send the list when it's ready.
+
+[ASYNC: Find 10 additional German TikTok creators documenting hair transplant journeys, 500-3000 followers, not in this list: @simply__stefan, @daenieal, @myhairjourney2025, @chigosfoodblog. Use the Rivoara TikTok account (already logged in) to browse. Output handle, follower count, one-line angle per creator.]
 ```
 
-Slug rules: lowercase letters, digits, hyphens. Max 48 chars. Must start with a letter or digit.
+### When to use ASYNC
 
-Be opinionated about the purpose. Don't ask ten questions; pick reasonable defaults and let them tweak.
+Use it for:
+- Browser work (scraping, multi-page research, form filling, anything touching >1 URL)
+- Multi-step investigations with several tool calls
+- Anything you expect to take more than ~30 seconds
 
-### Pausing, resuming, archiving
+Do NOT use it for:
+- A single quick URL fetch
+- Short calculations or reasoning
+- Anything you can answer from context alone
+- Things the owner needs answered in this reply, right now
 
-The owner can also ask you to pause/archive/resume a journal. Emit one of these markers:
+### Writing the task description
 
-```
-[JOURNAL-PAUSE:<slug>]
-[JOURNAL-RESUME:<slug>]
-[JOURNAL-ARCHIVE:<slug>]
-```
+The async worker has NO chat history, NO session, no memory of your conversation. Its only input is the description you write. Self-sufficient means:
+- Spell out exactly what to do.
+- Include every constraint, exclusion, and required context.
+- Reference specific tools or accounts (e.g. "use the Rivoara TikTok session").
+- Specify the expected output shape (list format, fields, order).
 
-Do this only when the owner asks. Never pause or archive a journal on your own judgment.
+Over-specify. A vague description produces a vague result.
 
-## Browser and screenshots
+### Avoiding duplicates
 
-You have access to a Chrome browser via tools: browser_navigate, browser_take_screenshot, browser_snapshot, browser_click, browser_type, browser_evaluate, and more.
+If you see `[Async tasks in progress]` in your preamble, a worker is already running for this chat. Do NOT emit another `[ASYNC:...]` for the same work. Reply naturally: "Still working on it, 4 minutes in."
 
-When asked to check a website, take a screenshot, or interact with a page, use these tools.
+## Sending files
 
-To send a file to the chat (screenshot, image, video, PDF, audio), save it to `storage/outbox/` and include this tag in your reply:
+To send a file (screenshot, image, video, PDF, audio) to the chat, save it to `storage/temp/` and include this tag in your reply:
 
 ```
-[FILE: storage/outbox/filename.png]
+[FILE: /absolute/path/to/file.png]
 ```
 
-Supported aliases: [IMAGE: path], [VIDEO: path], [AUDIO: path], [DOCUMENT: path] — all work the same.
+Aliases (all behave the same): `[IMAGE: path]`, `[VIDEO: path]`, `[AUDIO: path]`, `[DOCUMENT: path]`.
+
+Rules:
+- Always use absolute paths.
+- Always save under `storage/temp/`. Never save to the project root or anywhere else. Files are auto-deleted after sending.
+- Media type is detected from the file extension.
+- If you send a single file with a short text reply (under 1000 chars, non-audio), the text becomes the caption.
+
+## Browser tools
+
+You have a Chrome browser via Playwright MCP: `browser_navigate`, `browser_take_screenshot`, `browser_snapshot`, `browser_click`, `browser_type`, `browser_evaluate`, etc.
+
+For anything beyond a single page load, use `[ASYNC: ...]` instead of running inline. Browser work blocks the main queue.
 
-Always save to `storage/outbox/`. Files are automatically deleted after sending. The tag will be stripped and the file sent as a WhatsApp media message. Auto-detects type from extension. Short text alongside a single file becomes the caption.
+To send a screenshot back: take it with the browser tool (save to `storage/temp/`), then include `[IMAGE: /absolute/path.png]` in your reply.

package/dist/config.js

@@ -44,6 +44,7 @@ const ConfigSchema = z.object({
         typingIndicator: z.boolean(),
         errorMessage: z.string(),
         maxMessageAgeMs: z.number(),
+        showStats: z.boolean().default(true),
     }),
     storage: z.object({
         messagesDir: z.string(),

package/dist/gateway/commands.js

@@ -1,9 +1,12 @@
 import { clearSession, getSessionInfo } from '../ai/sessions.js';
 import { reloadSystemPrompt } from '../ai/claude.js';
 import { config } from '../config.js';
-import { createJournal, getJournal, isValidSlug, listJournals, readEntries, snoozeJournal, updateJournalStatus, } from '../memory/journals.js';
 import { runDigestNow } from '../memory/scheduler.js';
 import { sendText } from '../wa/sender.js';
+// Feature-level commands (/journal, /snooze, /tasks, etc.) are intentionally
+// absent. Claude is the interface — the owner asks for things in natural
+// language and Claude acts via markers or by editing files directly.
+// Only operational commands live here: reset, status, reload, digest.
 export async function tryCommand(ctx) {
     const prefix = config.commands.prefix;
     const trimmed = ctx.text.trim();
@@ -55,199 +58,5 @@ export async function tryCommand(ctx) {
         }).catch(() => undefined);
         return true;
     }
-    if (cmd === 'journal' || cmd === 'journals') {
-        if (!isOwner(ctx.senderNumber)) {
-            await sendText(ctx.sock, ctx.jid, 'Journals are owner-only.', ctx.quoted);
-            return true;
-        }
-        const rest = trimmed.slice(prefix.length + cmd.length).trim();
-        await handleJournalCmd(ctx, rest);
-        return true;
-    }
-    if (cmd === 'snooze') {
-        if (!isOwner(ctx.senderNumber)) {
-            await sendText(ctx.sock, ctx.jid, 'Snooze is owner-only.', ctx.quoted);
-            return true;
-        }
-        const rest = trimmed.slice(prefix.length + cmd.length).trim();
-        await handleSnoozeCmd(ctx, rest);
-        return true;
-    }
     return false;
 }
-async function handleSnoozeCmd(ctx, rest) {
-    const [slugRaw, durationRaw] = rest.split(/\s+/);
-    const slug = (slugRaw ?? '').toLowerCase();
-    const duration = (durationRaw ?? '24h').toLowerCase();
-    if (!slug) {
-        await sendText(ctx.sock, ctx.jid, 'Usage: /snooze <slug> [duration]\nDuration: e.g. 6h, 2d (default 24h)', ctx.quoted);
-        return;
-    }
-    if (!getJournal(slug)) {
-        await sendText(ctx.sock, ctx.jid, `No journal "${slug}".`, ctx.quoted);
-        return;
-    }
-    const secs = parseDuration(duration);
-    if (!secs) {
-        await sendText(ctx.sock, ctx.jid, `Bad duration "${duration}". Use formats like 6h, 2d, 30m.`, ctx.quoted);
-        return;
-    }
-    const until = Math.floor(Date.now() / 1000) + secs;
-    snoozeJournal(slug, until);
-    await sendText(ctx.sock, ctx.jid, `Snoozed "${slug}" for ${duration}. No nudges until ${new Date(until * 1000).toISOString().slice(0, 16).replace('T', ' ')} UTC.`, ctx.quoted);
-}
-function parseDuration(raw) {
-    const m = raw.match(/^(\d+)\s*([mhd])$/);
-    if (!m)
-        return null;
-    const n = Number(m[1]);
-    const u = m[2];
-    if (!Number.isFinite(n) || n <= 0)
-        return null;
-    if (u === 'm')
-        return n * 60;
-    if (u === 'h')
-        return n * 3600;
-    if (u === 'd')
-        return n * 86400;
-    return null;
-}
-function isOwner(senderNumber) {
-    return !!config.owner.number && senderNumber === config.owner.number;
-}
-async function handleJournalCmd(ctx, rest) {
-    const [subRaw, ...argParts] = rest.split(/\s+/);
-    const sub = (subRaw ?? 'list').toLowerCase();
-    const args = argParts.join(' ').trim();
-    if (sub === 'list' || sub === '') {
-        const journals = listJournals();
-        if (journals.length === 0) {
-            await sendText(ctx.sock, ctx.jid, 'No journals yet. Create one with:\n/journal create <slug> <purpose>', ctx.quoted);
-            return;
-        }
-        const lines = ['Journals:'];
-        for (const j of journals) {
-            lines.push(`- ${j.slug} [${j.status}]: ${j.purpose || j.name}`);
-        }
-        await sendText(ctx.sock, ctx.jid, lines.join('\n'), ctx.quoted);
-        return;
-    }
-    if (sub === 'create' || sub === 'new') {
-        const [slugRaw, ...purposeParts] = args.split(/\s+/);
-        const slug = (slugRaw ?? '').toLowerCase();
-        const purpose = purposeParts.join(' ').trim();
-        if (!slug || !purpose) {
-            await sendText(ctx.sock, ctx.jid, 'Usage: /journal create <slug> <purpose>\nExample: /journal create health Track sleep, symptoms, meds, mood', ctx.quoted);
-            return;
-        }
-        if (!isValidSlug(slug)) {
-            await sendText(ctx.sock, ctx.jid, `Invalid slug "${slug}". Use lowercase letters, digits, hyphens. Max 48 chars.`, ctx.quoted);
-            return;
-        }
-        if (getJournal(slug)) {
-            await sendText(ctx.sock, ctx.jid, `Journal "${slug}" already exists.`, ctx.quoted);
-            return;
-        }
-        try {
-            const j = createJournal({
-                slug,
-                name: titleCase(slug),
-                purpose,
-            });
-            await sendText(ctx.sock, ctx.jid, `Journal "${j.slug}" created and active. I'll start tagging relevant entries. Use /journal show ${j.slug} to inspect.`, ctx.quoted);
-        }
-        catch (err) {
-            await sendText(ctx.sock, ctx.jid, `Create failed: ${err.message}`, ctx.quoted);
-        }
-        return;
-    }
-    if (sub === 'show' || sub === 'info') {
-        const slug = args.split(/\s+/)[0]?.toLowerCase() ?? '';
-        const j = getJournal(slug);
-        if (!j) {
-            await sendText(ctx.sock, ctx.jid, `No journal "${slug}".`, ctx.quoted);
-            return;
-        }
-        const lines = [
-            `${j.name} (${j.slug}) [${j.status}]`,
-            j.purpose,
-        ];
-        if (j.fields.length)
-            lines.push(`Fields: ${j.fields.join(', ')}`);
-        if (j.cadence.checkin)
-            lines.push(`Check-in: ${j.cadence.checkin}`);
-        if (j.cadence.followup_after)
-            lines.push(`Follow-up after: ${j.cadence.followup_after}`);
-        if (j.cadence.nudge_if_silent)
-            lines.push(`Nudge if silent: ${j.cadence.nudge_if_silent}`);
-        const entries = readEntries(j.slug, 5);
-        if (entries.length) {
-            lines.push('', 'Recent entries:');
-            for (const e of entries) {
-                const d = new Date(e.ts * 1000)
-                    .toISOString()
-                    .slice(0, 16)
-                    .replace('T', ' ');
-                lines.push(`- [${d}] ${e.note}`);
-            }
-        }
-        else {
-            lines.push('', '(no entries yet)');
-        }
-        await sendText(ctx.sock, ctx.jid, lines.join('\n'), ctx.quoted);
-        return;
-    }
-    if (sub === 'entries') {
-        const [slugRaw, nRaw] = args.split(/\s+/);
-        const slug = (slugRaw ?? '').toLowerCase();
-        const n = Math.max(1, Math.min(50, Number(nRaw) || 10));
-        if (!getJournal(slug)) {
-            await sendText(ctx.sock, ctx.jid, `No journal "${slug}".`, ctx.quoted);
-            return;
-        }
-        const entries = readEntries(slug, n);
-        if (!entries.length) {
-            await sendText(ctx.sock, ctx.jid, `No entries in "${slug}" yet.`, ctx.quoted);
-            return;
-        }
-        const lines = [`Last ${entries.length} entries in "${slug}":`];
-        for (const e of entries) {
-            const d = new Date(e.ts * 1000)
-                .toISOString()
-                .slice(0, 16)
-                .replace('T', ' ');
-            lines.push(`- [${d}] (${e.source}) ${e.note}`);
-        }
-        await sendText(ctx.sock, ctx.jid, lines.join('\n'), ctx.quoted);
-        return;
-    }
-    if (sub === 'pause' || sub === 'resume' || sub === 'archive' || sub === 'activate') {
-        const slug = args.split(/\s+/)[0]?.toLowerCase() ?? '';
-        if (!getJournal(slug)) {
-            await sendText(ctx.sock, ctx.jid, `No journal "${slug}".`, ctx.quoted);
-            return;
-        }
-        const status = sub === 'pause'
-            ? 'paused'
-            : sub === 'archive'
-                ? 'archived'
-                : 'active';
-        const updated = updateJournalStatus(slug, status);
-        await sendText(ctx.sock, ctx.jid, `Journal "${slug}" is now ${updated?.status}.`, ctx.quoted);
-        return;
-    }
-    await sendText(ctx.sock, ctx.jid, [
-        'Journal commands:',
-        '/journal list',
-        '/journal create <slug> <purpose>',
-        '/journal show <slug>',
-        '/journal entries <slug> [n]',
-        '/journal pause|resume|archive <slug>',
-    ].join('\n'), ctx.quoted);
-}
-function titleCase(slug) {
-    return slug
-        .split('-')
-        .map((p) => (p ? p[0].toUpperCase() + p.slice(1) : p))
-        .join(' ');
-}

package/dist/gateway/outgoing.js

@@ -33,6 +33,9 @@ export async function handleReply(job, result, originalMsg) {
     const { text, files } = extractFiles(raw);
     const isGroup = isJidGroup(job.jid) === true;
     const quoted = isGroup && config.reply.quoteInGroups ? originalMsg : undefined;
+    const footer = result.stats && config.reply.showStats
+        ? formatStatsFooter(result.stats)
+        : '';
     try {
         // Send files first (images, videos, PDFs, audio, etc.)
         for (const filePath of files) {
@@ -43,7 +46,15 @@ export async function handleReply(job, result, originalMsg) {
             const caption = isFirst && text && text.length <= 1000 && files.length === 1 && supportsCaption
                 ? text
                 : undefined;
-            await sendFile(sock, job.jid, filePath, caption, isFirst ? quoted : undefined);
+            // Append footer to caption at send time only (not to storage). Only
+            // when this media file is the final user-facing payload (no text
+            // coming after, single file with caption case).
+            const willHaveTextAfter = !!text &&
+                !(files.length === 1 && text.length <= 1000 && supportsCaption);
+            const captionForSend = caption && footer && !willHaveTextAfter
+                ? `${caption}\n\n${footer}`
+                : caption;
+            await sendFile(sock, job.jid, filePath, captionForSend, isFirst ? quoted : undefined);
             await append({
                 id: `reply-file-${Date.now()}`,
                 jid: job.jid,
@@ -73,7 +84,9 @@ export async function handleReply(job, result, originalMsg) {
             for (let i = 0; i < chunks.length; i++) {
                 const chunk = chunks[i];
                 const q = i === 0 && files.length === 0 ? quoted : undefined;
-                await sendText(sock, job.jid, chunk, q);
+                const isLast = i === chunks.length - 1;
+                const chunkForSend = isLast && footer ? `${chunk}\n\n${footer}` : chunk;
+                await sendText(sock, job.jid, chunkForSend, q);
                 await append({
                     id: `reply-${Date.now()}-${i}`,
                     jid: job.jid,
@@ -107,6 +120,50 @@ export async function handleReply(job, result, originalMsg) {
 function sleep(ms) {
     return new Promise((r) => setTimeout(r, ms));
 }
+// Append-only-at-send footer. Never stored, never in Claude's recent-context
+// feedback loop. Adaptive: shows only what's interesting for this reply.
+export function formatStatsFooter(stats) {
+    const parts = [];
+    // Duration — always
+    const secs = stats.durationMs / 1000;
+    parts.push(secs < 10 ? `${secs.toFixed(1)}s` : `${Math.round(secs)}s`);
+    // Tokens in / out — always. Show cache hit only when it's meaningful.
+    const inStr = compactTokens(stats.inputTokens + stats.cacheReadTokens);
+    const outStr = compactTokens(stats.outputTokens);
+    const cacheStr = stats.cacheReadTokens >= 500
+        ? ` (${compactTokens(stats.cacheReadTokens)} cached)`
+        : '';
+    parts.push(`${inStr}↑${cacheStr} ${outStr}↓`);
+    // Context % — only when worth calling out
+    if (stats.contextWindow > 0) {
+        const pct = Math.round((stats.totalContextTokens / stats.contextWindow) * 100);
+        if (pct >= 90)
+            parts.push(`⚠ ${pct}% ctx`);
+        else if (pct >= 70)
+            parts.push(`${pct}% ctx`);
+    }
+    // Fresh session — resume is default, says nothing
+    if (stats.fresh)
+        parts.push('fresh');
+    // Journal flagged — show each slug (usually 0 or 1)
+    for (const slug of stats.journalSlugs)
+        parts.push(`+journal:${slug}`);
+    // Digest fired
+    if (stats.hasDigest)
+        parts.push('+digest');
+    // Async spawned
+    if (stats.asyncCount > 0) {
+        parts.push(stats.asyncCount === 1 ? '+async' : `+${stats.asyncCount} async`);
+    }
+    return `_${parts.join(' · ')}_`;
+}
+function compactTokens(n) {
+    if (n < 1000)
+        return String(n);
+    if (n < 10_000)
+        return `${(n / 1000).toFixed(1)}k`;
+    return `${Math.round(n / 1000)}k`;
+}
 // Proactive outbound: send a message to a chat without an incoming trigger.
 // Chunks, persists to the message log, never throws. Callers are responsible
 // for the canSendProactive() gate — this function does not re-check it.