@c4t4/heyamigo 0.9.25 → 0.10.0

package/config/memory-instructions.md

@@ -15,10 +15,9 @@ storage/memory/
   journals/<slug>/index.md          # journal spec (frontmatter+body)
   journals/<slug>/entries.jsonl     # append-only (do NOT edit)
   journals/<slug>/observer-state.json
-  journals/<slug>/nudge-state.json
 ```
 
-Relevant blocks appear in `[State]`, `[Map]`, `[Trees]`, `[Entities]`, `[Journals]` at top of each turn. Don't re-Read what's already in your preamble.
+Relevant blocks appear in `[State]`, `[Map]`, `[Trees]`, `[Entities]`, `[Journals]`, `[Live threads]` at top of each turn. Don't re-Read what's already in your preamble.
 
 ## State + dig-deeper
 
@@ -51,11 +50,61 @@ Don't cross-log subjects (Dani's health ≠ Cata's). Ask if ambiguous.
 
 ### Create: `[JOURNAL-NEW:<slug> — <purpose>]`
 
-When owner asks to track something no existing journal covers: propose purpose in one message, wait for confirmation, then emit the tag. Slug: lowercase letters/digits/hyphens, max 48 chars, starts with letter/digit. Creates `journals/<slug>/index.md` with defaults (`status=active`, `nudge_if_silent=3d`). Can flag first entry in same reply with a separate `[JOURNAL:<slug> — ...]` tag.
+When owner asks to track something no existing journal covers: propose purpose in one message, wait for confirmation, then emit the tag. Slug: lowercase letters/digits/hyphens, max 48 chars, starts with letter/digit. Creates `journals/<slug>/index.md` with defaults. Can flag first entry in same reply with a separate `[JOURNAL:<slug> — ...]` tag.
 
-### Edit (pause/archive/cadence)
+### Edit (pause/archive)
 
-No marker — Edit `journals/<slug>/index.md` directly. Frontmatter fields: `status` (active|paused|archived), `purpose`, `fields`, `checkin`, `nudge_if_silent`, `quiet_hours`. Never touch `entries.jsonl`, `observer-state.json`, `nudge-state.json` unless the owner asked you to fix a specific bug. Confirm the change in reply.
+No marker — Edit `journals/<slug>/index.md` directly. Frontmatter fields: `status` (active|paused|archived), `purpose`, `fields`. Never touch `entries.jsonl` or `observer-state.json` unless the owner asked you to fix a specific bug. Confirm the change in reply.
+
+For recurring proactive check-ins on a journal, use a CRON (`[CRON: 0 9 * * 1 PROMPT — ...]`) or open a thread (`[THREAD-NEW: ...]`) — not journal frontmatter.
+
+## Threads — your watchlist
+
+A *thread* is an open loop you're tracking: a question, a waiting-on, an intent the owner mentioned in passing. Threads sit between cold memory (journals/profiles/buckets) and live conversation. You curate them.
+
+You can see live threads for this chat in the `[Live threads]` preamble block. Bring them up naturally if relevant; don't force them. User voice always wins — if they drop a thread, learn from it.
+
+### Lifecycle tags (all end-of-reply)
+
+| Tag | When |
+|---|---|
+| `[THREAD-NEW: title="..." summary="..." hotness=70 linked_memory=... category=...]` | open a new loop |
+| `[THREAD-UPDATE:<id> summary="..." hotness=80]` | refine what you know |
+| `[THREAD-TOUCH:<id>]` | you mentioned it naturally in reply |
+| `[THREAD-COOL:<id> — wait Nd]` | not now, check back later |
+| `[THREAD-RESOLVE:<id> — note]` | answer arrived, close it |
+| `[THREAD-DROP:<id> — reason]` | stale, no longer relevant |
+| `[THREAD-COMPRESS:<id> — note]` | stabilized fact — move to journal/profile via [DIGEST:] in same reply |
+| `[THREAD-WEIGHT: <category> <0-100>]` | rare manual override on a category's default hotness |
+
+### Rules
+
+- Open threads sparingly. Only when the owner mentioned something with a future resolution point that they'd plausibly want to hear back on. Not for jokes, opinions, or things you'd hear about anyway.
+- Hotness 0-100. AI-curated. Drop hotness with COOL, raise with TOUCH or UPDATE.
+- Always RESOLVE/DROP/COMPRESS when the loop closes — don't leave stale threads accumulating.
+- Compressing = thread stabilized into a durable fact. Pair `[THREAD-COMPRESS:<id> — ...]` with `[DIGEST: ...]` in the same reply so the fact actually gets written somewhere.
+- One thread per loop. Don't open duplicates — check `[Live threads]` first.
+
+### Examples
+
+Owner says "waiting on Jana to confirm Tuesday's meeting":
+```
+Got it, fingers crossed she replies.
+[THREAD-NEW: title="Jana meeting confirm" summary="owner waiting on confirmation for Tue meeting" hotness=70]
+```
+
+Owner mentions Jana confirmed:
+```
+Nice, locked in for Tuesday 10am.
+[THREAD-RESOLVE:42 — confirmed Tue 10am]
+[DIGEST: Jana meeting confirmed Tue 10am]
+```
+
+Owner brings up something unrelated, but thread #51 ("5 DMs to creators") is still hot and matches the moment:
+```
+quick reminder, the 5 DMs were on for today — how'd it go?
+[THREAD-TOUCH:51]
+```
 
 ## Two parallel tracks
 

package/dist/config.js

@@ -117,6 +117,27 @@ const ConfigSchema = z.object({
         level: z.enum(['trace', 'debug', 'info', 'warn', 'error', 'fatal']),
         promptRetentionDays: z.number(),
     }),
+    // Threads — AI-curated relevance watchlist. See src/queue/threads.ts.
+    // Off by default; flip enabled=true to allow the AI to open/track
+    // loops via [THREAD-*:] tags. Reactive surface only in v1 — proactive
+    // review tick (silent-chat check-ins) deferred.
+    threads: z
+        .object({
+        enabled: z.boolean().default(false),
+        preamblePerChat: z.number().int().positive().default(5),
+        // Soft caps used by future cleanup jobs; the worker doesn't read
+        // these yet but they're here so config.json can be authored once.
+        maxActivePerChat: z.number().int().positive().default(10),
+        hotnessCapOnCreate: z.number().int().min(0).max(100).default(70),
+        decayPerDay: z.number().int().min(0).default(2),
+    })
+        .default({
+        enabled: false,
+        preamblePerChat: 5,
+        maxActivePerChat: 10,
+        hotnessCapOnCreate: 70,
+        decayPerDay: 2,
+    }),
 });
 function loadJsonIfExists(path) {
     try {

package/dist/db/schema.js

@@ -141,6 +141,61 @@ export const crons = sqliteTable('crons', {
         .where(sql `${t.recurrence} IS NOT NULL`),
 }));
 // ──────────────────────────────────────────────────────────────────
+// Threads — AI-curated relevance watchlist
+// ──────────────────────────────────────────────────────────────────
+//
+// A "thread" is an open loop the AI is tracking on behalf of the user
+// — the layer between cold memory (journals/profiles/buckets) and
+// live conversation. Each row is "this is currently load-bearing for
+// this chat." The AI promotes things here, updates hotness as signals
+// arrive, brings them up naturally during conversation, and either
+// resolves them (answer found), drops them (stale), or compresses
+// them into cold memory (stabilized into a fact).
+//
+// Hotness (0-100) is the AI's running judgment of how relevant a
+// thread is right now. The user's voice always wins — explicit
+// resolves/drops + manual /threads commands override anything the
+// AI inferred. Implicit signals (user touching the topic, ignoring
+// surfaced threads) nudge the score by smaller amounts.
+//
+// Status: live (active), resolved (answer arrived), dropped (stale),
+// compressed (moved into a journal/profile/bucket).
+export const threads = sqliteTable('threads', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    targetJid: text('target_jid').notNull(), // WA JID this thread lives in
+    title: text('title').notNull(), // short label, AI-written
+    summary: text('summary').notNull(), // 1-2 line context
+    hotness: integer('hotness').notNull().default(50), // 0-100
+    status: text('status').notNull().default('live'), // live|resolved|dropped|compressed
+    linkedMemory: text('linked_memory'), // optional path to cold memory anchor
+    openedAt: integer('opened_at').notNull(),
+    lastTouchedAt: integer('last_touched_at').notNull(),
+    nextReviewAt: integer('next_review_at').notNull(),
+    resolutionNote: text('resolution_note'),
+    // Token cost attribution — when a thread review burns AI inferences
+    // (proactive tick, future feature) the cost lands here. Visible via
+    // /threads so the user can see which threads are expensive.
+    totalInputTokens: integer('total_input_tokens').notNull().default(0),
+    totalOutputTokens: integer('total_output_tokens').notNull().default(0),
+    enabled: integer('enabled').notNull().default(1),
+    createdAt: integer('created_at').notNull(),
+}, t => ({
+    byJidHot: index('threads_by_jid_hot').on(t.targetJid, t.status, t.hotness),
+    byDue: index('threads_by_due').on(t.enabled, t.status, t.nextReviewAt),
+}));
+// Owner-global learned weights per category. A thread's category is
+// derived from its linked_memory or title (e.g. "health", "jana",
+// "work"). The weight is the AI's prior for "how much does the user
+// care about this category" — used as the starting hotness when
+// creating new threads in the same category, and nudged up/down by
+// implicit signals (user engaging with / dropping threads).
+export const threadCategoryWeights = sqliteTable('thread_category_weights', {
+    category: text('category').primaryKey(), // e.g. 'health', 'jana', 'work-dms'
+    weight: integer('weight').notNull().default(50), // 0-100
+    samples: integer('samples').notNull().default(0), // signal count, for confidence
+    updatedAt: integer('updated_at').notNull(),
+});
+// ──────────────────────────────────────────────────────────────────
 // Inbound queue (Phase 4)
 // ──────────────────────────────────────────────────────────────────
 // Messages received on any channel, waiting to be processed by a

package/dist/gateway/commands.js

@@ -12,7 +12,10 @@ export async function tryCommand(ctx) {
     const trimmed = ctx.text.trim();
     if (!trimmed.startsWith(prefix))
         return false;
-    const cmd = trimmed.slice(prefix.length).split(/\s+/)[0]?.toLowerCase() ?? '';
+    const afterPrefix = trimmed.slice(prefix.length);
+    const tokens = afterPrefix.split(/\s+/);
+    const cmd = tokens[0]?.toLowerCase() ?? '';
+    const args = tokens.slice(1);
     if (!cmd)
         return false;
     if (config.commands.reset.includes(cmd)) {
@@ -79,5 +82,14 @@ export async function tryCommand(ctx) {
         await sendText(ctx.sock, ctx.jid, formatScheduleList(items, tz, onlyKind), ctx.quoted);
         return true;
     }
+    if (cmd === 'threads') {
+        if (!config.threads?.enabled) {
+            await sendText(ctx.sock, ctx.jid, 'threads are disabled in config. Set `threads.enabled: true` to turn on.', ctx.quoted);
+            return true;
+        }
+        const { handleThreadsCommand } = await import('../queue/thread-list.js');
+        await sendText(ctx.sock, ctx.jid, handleThreadsCommand(ctx.jid, args), ctx.quoted);
+        return true;
+    }
     return false;
 }

package/dist/gateway/outgoing.js

@@ -232,6 +232,18 @@ export function formatStatsFooter(stats, extras) {
         parts.push('+digest');
     if (stats.sendTextCount > 0)
         parts.push(plus('send-text', stats.sendTextCount));
+    // Thread watchlist — loud events only. Updates/cools are intentional
+    // no-ops in the footer (would clutter normal conversation).
+    if (stats.threadNewCount > 0)
+        parts.push(plus('thread-new', stats.threadNewCount));
+    if (stats.threadTouchCount > 0)
+        parts.push(plus('thread-touch', stats.threadTouchCount));
+    if (stats.threadResolveCount > 0)
+        parts.push(plus('thread-resolve', stats.threadResolveCount));
+    if (stats.threadDropCount > 0)
+        parts.push(plus('thread-drop', stats.threadDropCount));
+    if (stats.threadCompressCount > 0)
+        parts.push(plus('thread-compress', stats.threadCompressCount));
     // Media — counted per-kind from the file list. e.g. +2 image, +video.
     // 'document' shortened to 'doc' to keep the footer tight.
     const mediaKinds = extras?.mediaKinds ?? [];

package/dist/memory/digest-flag.js

@@ -19,6 +19,14 @@ const KINDS = [
     'SEND-TEXT',
     'CRON',
     'REMIND',
+    'THREAD-NEW',
+    'THREAD-UPDATE',
+    'THREAD-TOUCH',
+    'THREAD-COOL',
+    'THREAD-RESOLVE',
+    'THREAD-DROP',
+    'THREAD-COMPRESS',
+    'THREAD-WEIGHT',
 ];
 // 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
@@ -82,6 +90,14 @@ export function extractFlags(reply) {
     const sendTexts = [];
     const crons = [];
     const reminds = [];
+    const threadNews = [];
+    const threadUpdates = [];
+    const threadTouches = [];
+    const threadCools = [];
+    const threadResolves = [];
+    const threadDrops = [];
+    const threadCompresses = [];
+    const threadWeights = [];
     while (true) {
         const peeled = peelTrailingTag(current);
         if (!peeled)
@@ -134,6 +150,62 @@ export function extractFlags(reply) {
             else
                 logger.warn({ payload }, 'REMIND tag dropped: unparseable payload');
         }
+        else if (kind === 'THREAD-NEW') {
+            const parsed = parseThreadNewPayload(payload);
+            if (parsed)
+                threadNews.unshift(parsed);
+            else
+                logger.warn({ payload }, 'THREAD-NEW tag dropped: unparseable payload');
+        }
+        else if (kind === 'THREAD-UPDATE') {
+            const parsed = parseThreadUpdatePayload(payload);
+            if (parsed)
+                threadUpdates.unshift(parsed);
+            else
+                logger.warn({ payload }, 'THREAD-UPDATE tag dropped: unparseable payload');
+        }
+        else if (kind === 'THREAD-TOUCH') {
+            const id = parseThreadId(payload);
+            if (id !== null)
+                threadTouches.unshift({ id });
+            else
+                logger.warn({ payload }, 'THREAD-TOUCH tag dropped: unparseable id');
+        }
+        else if (kind === 'THREAD-COOL') {
+            const parsed = parseThreadCoolPayload(payload);
+            if (parsed)
+                threadCools.unshift(parsed);
+            else
+                logger.warn({ payload }, 'THREAD-COOL tag dropped: unparseable payload');
+        }
+        else if (kind === 'THREAD-RESOLVE') {
+            const parsed = parseThreadIdNotePayload(payload);
+            if (parsed)
+                threadResolves.unshift(parsed);
+            else
+                logger.warn({ payload }, 'THREAD-RESOLVE tag dropped: unparseable payload');
+        }
+        else if (kind === 'THREAD-DROP') {
+            const parsed = parseThreadIdNotePayload(payload);
+            if (parsed)
+                threadDrops.unshift(parsed);
+            else
+                logger.warn({ payload }, 'THREAD-DROP tag dropped: unparseable payload');
+        }
+        else if (kind === 'THREAD-COMPRESS') {
+            const parsed = parseThreadIdNotePayload(payload);
+            if (parsed)
+                threadCompresses.unshift(parsed);
+            else
+                logger.warn({ payload }, 'THREAD-COMPRESS tag dropped: unparseable payload');
+        }
+        else if (kind === 'THREAD-WEIGHT') {
+            const parsed = parseThreadWeightPayload(payload);
+            if (parsed)
+                threadWeights.unshift(parsed);
+            else
+                logger.warn({ payload }, 'THREAD-WEIGHT tag dropped: unparseable payload');
+        }
     }
     return {
         clean: current,
@@ -145,6 +217,14 @@ export function extractFlags(reply) {
         sendTexts,
         crons,
         reminds,
+        threadNews,
+        threadUpdates,
+        threadTouches,
+        threadCools,
+        threadResolves,
+        threadDrops,
+        threadCompresses,
+        threadWeights,
     };
 }
 // Strip flags that the sender's role isn't permitted to emit. The
@@ -154,6 +234,9 @@ export function filterFlagsByRole(flags, allowedTags) {
     if (allowedTags === 'all' || allowedTags === undefined)
         return flags;
     const allowed = new Set(allowedTags);
+    // 'THREAD' acts as a single allow-all-thread-ops bucket so role
+    // configs don't have to list all 8 THREAD-* variants individually.
+    const threadOk = allowed.has('THREAD');
     return {
         clean: flags.clean,
         digest: allowed.has('DIGEST') ? flags.digest : null,
@@ -164,6 +247,14 @@ export function filterFlagsByRole(flags, allowedTags) {
         sendTexts: allowed.has('SEND-TEXT') ? flags.sendTexts : [],
         crons: allowed.has('CRON') ? flags.crons : [],
         reminds: allowed.has('REMIND') ? flags.reminds : [],
+        threadNews: threadOk ? flags.threadNews : [],
+        threadUpdates: threadOk ? flags.threadUpdates : [],
+        threadTouches: threadOk ? flags.threadTouches : [],
+        threadCools: threadOk ? flags.threadCools : [],
+        threadResolves: threadOk ? flags.threadResolves : [],
+        threadDrops: threadOk ? flags.threadDrops : [],
+        threadCompresses: threadOk ? flags.threadCompresses : [],
+        threadWeights: threadOk ? flags.threadWeights : [],
     };
 }
 // Legacy helper kept so existing callers still compile.
@@ -251,3 +342,134 @@ function parseJournalPayload(payload) {
         return null;
     return { slug, note };
 }
+// ──────────────────────────────────────────────────────────────────
+// THREAD-* payload parsers
+// ──────────────────────────────────────────────────────────────────
+//
+// Two payload shapes:
+//   [THREAD-NEW: key="quoted" key=value]          key/value form
+//   [THREAD-RESOLVE:42 — note]                    id-and-note form
+// Pull `key="quoted-value"` and `key=word-value` pairs out of a
+// payload. Returns a map. Supports backslash-escaped quotes inside
+// quoted values.
+function parseKeyValuePayload(payload) {
+    const out = {};
+    // Quoted values first (greedy enough to capture spaces, escaped quotes)
+    const quotedRe = /\b([a-z_]+)\s*=\s*"((?:[^"\\]|\\.)*)"/gi;
+    let rest = payload;
+    for (const m of payload.matchAll(quotedRe)) {
+        const key = m[1].toLowerCase();
+        const val = m[2].replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+        out[key] = val;
+        rest = rest.replace(m[0], '');
+    }
+    // Then unquoted single-word values
+    const wordRe = /\b([a-z_]+)\s*=\s*(\S+)/gi;
+    for (const m of rest.matchAll(wordRe)) {
+        const key = m[1].toLowerCase();
+        if (key in out)
+            continue;
+        out[key] = m[2];
+    }
+    return out;
+}
+function parseThreadNewPayload(payload) {
+    const kv = parseKeyValuePayload(payload);
+    const title = kv['title']?.trim();
+    const summary = kv['summary']?.trim();
+    if (!title || !summary)
+        return null;
+    const out = { title, summary };
+    if (kv['hotness'] !== undefined) {
+        const n = parseInt(kv['hotness'], 10);
+        if (Number.isFinite(n))
+            out.hotness = n;
+    }
+    if (kv['linked_memory'])
+        out.linkedMemory = kv['linked_memory'];
+    if (kv['category'])
+        out.category = kv['category'].toLowerCase();
+    return out;
+}
+function parseThreadUpdatePayload(payload) {
+    // Leading id, then key=value pairs
+    const idMatch = payload.match(/^\s*(\d+)\b/);
+    if (!idMatch)
+        return null;
+    const id = parseInt(idMatch[1], 10);
+    if (!Number.isFinite(id) || id <= 0)
+        return null;
+    const rest = payload.slice(idMatch[0].length);
+    const kv = parseKeyValuePayload(rest);
+    const out = { id };
+    if (kv['title'])
+        out.title = kv['title'].trim();
+    if (kv['summary'])
+        out.summary = kv['summary'].trim();
+    if (kv['hotness'] !== undefined) {
+        const n = parseInt(kv['hotness'], 10);
+        if (Number.isFinite(n))
+            out.hotness = n;
+    }
+    if (kv['linked_memory'])
+        out.linkedMemory = kv['linked_memory'];
+    return out;
+}
+// `<id>` alone — for TOUCH.
+function parseThreadId(payload) {
+    const m = payload.match(/^\s*(\d+)\s*$/);
+    if (!m)
+        return null;
+    const id = parseInt(m[1], 10);
+    return Number.isFinite(id) && id > 0 ? id : null;
+}
+// `<id> — <note>` shape used by RESOLVE / DROP / COMPRESS. Note is
+// the rest of the payload after the first em/en/hyphen separator.
+const ID_NOTE_SEP_RE = /\s+[—–-]\s+/;
+function parseThreadIdNotePayload(payload) {
+    const idMatch = payload.match(/^\s*(\d+)\b/);
+    if (!idMatch)
+        return null;
+    const id = parseInt(idMatch[1], 10);
+    if (!Number.isFinite(id) || id <= 0)
+        return null;
+    const rest = payload.slice(idMatch[0].length);
+    const sep = rest.match(ID_NOTE_SEP_RE);
+    if (!sep || sep.index === undefined)
+        return { id, note: '' };
+    const note = rest.slice(sep.index + sep[0].length).trim();
+    return { id, note };
+}
+// `<id>` or `<id> — wait Nd|Nh` for COOL.
+function parseThreadCoolPayload(payload) {
+    const idMatch = payload.match(/^\s*(\d+)\b/);
+    if (!idMatch)
+        return null;
+    const id = parseInt(idMatch[1], 10);
+    if (!Number.isFinite(id) || id <= 0)
+        return null;
+    const rest = payload.slice(idMatch[0].length).trim();
+    if (!rest)
+        return { id };
+    // Look for "wait <N><d|h>" anywhere in the rest
+    const waitMatch = rest.match(/wait\s+(\d+)\s*([dh])/i);
+    if (!waitMatch)
+        return { id };
+    const n = parseInt(waitMatch[1], 10);
+    const unit = waitMatch[2].toLowerCase();
+    if (!Number.isFinite(n) || n <= 0)
+        return { id };
+    const deferDays = unit === 'h' ? n / 24 : n;
+    return { id, deferDays };
+}
+// `<category> <weight>` for WEIGHT.
+function parseThreadWeightPayload(payload) {
+    const m = payload.match(/^\s*([a-z0-9][a-z0-9_-]*)\s+(\d+)\s*$/i);
+    if (!m)
+        return null;
+    const category = m[1].toLowerCase();
+    const weight = parseInt(m[2], 10);
+    if (!Number.isFinite(weight))
+        return null;
+    return { category, weight };
+}

package/dist/memory/journals.js

@@ -22,9 +22,6 @@ function journalsIndexPath() {
 function journalObserverStatePath(slug) {
     return resolve(journalDir(slug), 'observer-state.json');
 }
-function journalNudgeStatePath(slug) {
-    return resolve(journalDir(slug), 'nudge-state.json');
-}
 // ---------- low-level fs ----------
 function ensureDirFor(path) {
     mkdirSync(dirname(path), { recursive: true });
@@ -283,24 +280,6 @@ export function setLastScannedTs(slug, jid, ts) {
     state.jids[jid] = { lastScannedTs: ts };
     saveObserverState(slug, state);
 }
-export function loadNudgeState(slug) {
-    const raw = readIfExists(journalNudgeStatePath(slug));
-    if (!raw)
-        return { lastCheckinTs: 0, lastSilentNudgeTs: 0, snoozedUntilTs: 0 };
-    try {
-        const parsed = JSON.parse(raw);
-        return {
-            lastCheckinTs: parsed.lastCheckinTs ?? 0,
-            lastSilentNudgeTs: parsed.lastSilentNudgeTs ?? 0,
-            snoozedUntilTs: parsed.snoozedUntilTs ?? 0,
-        };
-    }
-    catch {
-        return { lastCheckinTs: 0, lastSilentNudgeTs: 0, snoozedUntilTs: 0 };
-    }
-}
-export function saveNudgeState(slug, state) {
-    const path = journalNudgeStatePath(slug);
-    ensureDirFor(path);
-    writeFileSync(path, JSON.stringify(state, null, 2) + '\n', 'utf-8');
-}
+// Nudge-state APIs removed — replaced by the threads watchlist
+// (see src/queue/threads.ts). Existing storage/memory/journals/*/
+// nudge-state.json files become orphaned and can be safely deleted.

package/dist/memory/preamble.js

@@ -2,6 +2,7 @@ import { existsSync, readFileSync } from 'fs';
 import { config } from '../config.js';
 import { getTimezoneForSenderNumber } from '../db/identity-sync.js';
 import { listAsyncTasks } from '../queue/async-tasks.js';
+import { listLiveThreads } from '../queue/threads.js';
 import { readCompressed } from './compressed.js';
 import { buildJournalsPreambleBlock, ensureJournalsScaffold, } from './journals.js';
 import { masterIndexPath, treeIndexPath } from './paths.js';
@@ -14,6 +15,7 @@ import { getRoleForContext } from '../wa/whitelist.js';
 const DIGEST_REMINDER = `[DIGEST: <reason>] at end of reply for durable facts. Sparingly.`;
 const JOURNAL_REMINDER = `[JOURNAL:<slug> — <note>] at end of reply when content fits an active journal. Use listed slugs only.`;
 const ASYNC_REMINDER = `Never call browser_* / mcp__*playwright* tools. Delegate via [ASYNC-BROWSER: <task>]. Non-browser long work → [ASYNC: <task>]. Irreversible writes: gather → confirm → act.`;
+const THREADS_REMINDER = `Threads = your active watchlist. Open new ones with [THREAD-NEW: title="..." summary="..."]. Close with [THREAD-RESOLVE:<id> — note] / [THREAD-DROP:<id> — reason] / [THREAD-COMPRESS:<id> — note]. Touch (mention naturally) with [THREAD-TOUCH:<id>]. Cool/defer with [THREAD-COOL:<id> — wait Nd]. User voice always wins.`;
 // Buildable per-turn so the agent always sees the SENDER's current
 // time. Grammar reference is in cached memory-instructions.md;
 // this is just the live time + format pointer.
@@ -139,6 +141,25 @@ export function buildMemoryPreamble(params) {
         hour12: false,
     }).format(new Date());
     instructions.push(buildSchedulingReminder(nowLocal, senderTz));
+    // Threads — AI-curated relevance watchlist. Off by default; turn on
+    // via config.threads.enabled. Loads up to N hottest live threads
+    // for this chat (default 5) plus a terse pointer to the grammar
+    // (full docs are in cached memory-instructions.md).
+    if (config.threads?.enabled) {
+        const cap = config.threads.preamblePerChat ?? 5;
+        const live = listLiveThreads(params.jid, cap);
+        if (live.length > 0) {
+            const now = Math.floor(Date.now() / 1000);
+            const lines = ['[Live threads — bring up if naturally relevant; don\'t force]'];
+            for (const t of live) {
+                const age = formatAge(Math.max(0, now - t.openedAt));
+                lines.push(`- #${t.id} (hot ${t.hotness}, ${age} ago): ${t.title}`);
+                lines.push(`    ${t.summary}`);
+            }
+            sections.push(lines.join('\n'));
+            instructions.push(THREADS_REMINDER);
+        }
+    }
     // Async tasks in progress for this chat — so the agent doesn't re-promise
     // or contradict work already running. Don't emit another [ASYNC:] for
     // these.

package/dist/memory/scheduler.js

@@ -75,7 +75,6 @@ async function sweep() {
         logger.error({ err }, 'journal observer sweep failed');
     }
 }
-const NUDGE_TICK_MS = 5 * 60 * 1000; // 5 minutes
 let started = false;
 export function startScheduler() {
     if (started)
@@ -111,30 +110,12 @@ export function startScheduler() {
         payload: { handler: 'memory-sweep' },
         recurrence: `@every ${Math.floor(config.memory.sweepIntervalMs / 1000)}s`,
     });
-    // Proactive journal nudges (check-ins, silent-nudges). Migrated from
-    // setInterval to a cron row → orchestrator. Same cadence, same body;
-    // benefits are: survives restarts, visible in `crons` table, can be
-    // paused via control row without code change.
-    registerInternalCronHandler('journal-nudge-tick', runNudgeTickSafe);
-    enqueueCron({
-        name: 'journal-nudge-tick',
-        enqueueInto: 'internal',
-        payload: { handler: 'journal-nudge-tick' },
-        recurrence: `@every ${Math.floor(NUDGE_TICK_MS / 1000)}s`,
-    });
-    logger.info({
-        intervalMs: config.memory.sweepIntervalMs,
-        nudgeTickMs: NUDGE_TICK_MS,
-    }, 'memory scheduler started');
-}
-async function runNudgeTickSafe() {
-    try {
-        const { runNudgeTick } = await import('./journal-nudger.js');
-        await runNudgeTick();
-    }
-    catch (err) {
-        logger.error({ err }, 'nudge tick failed');
-    }
+    // Drop the legacy journal-nudge-tick cron row if it survives from a
+    // pre-threads install. The handler is no longer registered, so any
+    // row left in the table would log warnings every tick. Safe to call
+    // even if the row doesn't exist.
+    deleteCron('journal-nudge-tick');
+    logger.info({ intervalMs: config.memory.sweepIntervalMs }, 'memory scheduler started');
 }
 export function stopScheduler() {
     // All recurring work is now in the crons table; orchestrator handles
@@ -145,10 +126,3 @@ export function stopScheduler() {
     pendingTimers.clear();
     started = false;
 }
-// Exported for callers (CLI, /nudge command) that want to surgically
-// disable nudges without editing config. Use `setCronEnabled` from
-// crons.ts for the on/off switch; this is a hard delete (regenerated
-// on next startScheduler call).
-export function deleteNudgeCron() {
-    return deleteCron('journal-nudge-tick');
-}