@c4t4/heyamigo 0.9.25 → 0.10.0

package/dist/queue/thread-list.js

@@ -0,0 +1,167 @@
+// /threads chat command handler. Formats listings + handles
+// subcommands: delete, pause, resume, resolve, drop, compress,
+// touch, weight.
+//
+// Phone-readable plain text — same shape as schedule-list.ts.
+import { compressThread, deleteThread, dropThread, getThread, listAllThreads, resolveThread, setThreadEnabled, touchThread, } from './threads.js';
+import { listCategoryWeights, setCategoryWeight, } from './thread-weights.js';
+export function handleThreadsCommand(jid, args) {
+    const sub = args[0]?.toLowerCase();
+    if (!sub) {
+        return formatList(listAllThreads(jid));
+    }
+    // Subcommand: weight <category> <0-100>
+    if (sub === 'weight') {
+        if (args.length === 1)
+            return formatWeights(listCategoryWeights());
+        const category = args[1]?.toLowerCase();
+        const weight = parseInt(args[2] ?? '', 10);
+        if (!category || !Number.isFinite(weight) || weight < 0 || weight > 100) {
+            return 'Usage: /threads weight <category> <0-100>';
+        }
+        setCategoryWeight(category, weight);
+        return `Category "${category}" weight set to ${weight}.`;
+    }
+    // All remaining subcommands take an id as args[1] and optional note as
+    // the rest joined.
+    const id = parseInt(args[1] ?? '', 10);
+    if (!Number.isFinite(id) || id <= 0) {
+        return `Usage: /threads ${sub} <id> [note]`;
+    }
+    const noteTokens = args.slice(2);
+    const note = noteTokens.join(' ').trim();
+    if (sub === 'delete') {
+        return deleteThread(id) ? `Thread #${id} deleted.` : `Thread #${id} not found.`;
+    }
+    if (sub === 'pause') {
+        return setThreadEnabled(id, false)
+            ? `Thread #${id} paused.`
+            : `Thread #${id} not found.`;
+    }
+    if (sub === 'resume') {
+        return setThreadEnabled(id, true)
+            ? `Thread #${id} resumed.`
+            : `Thread #${id} not found.`;
+    }
+    if (sub === 'resolve') {
+        const row = resolveThread(id, note || 'manual');
+        return row
+            ? `Thread #${id} resolved: ${row.resolutionNote}`
+            : `Thread #${id} not found.`;
+    }
+    if (sub === 'drop') {
+        const row = dropThread(id, note || 'manual');
+        return row
+            ? `Thread #${id} dropped: ${row.resolutionNote}`
+            : `Thread #${id} not found.`;
+    }
+    if (sub === 'compress') {
+        const row = compressThread(id, note || 'manual');
+        return row
+            ? `Thread #${id} compressed: ${row.resolutionNote}`
+            : `Thread #${id} not found.`;
+    }
+    if (sub === 'touch') {
+        const row = touchThread(id);
+        return row
+            ? `Thread #${id} touched (hotness now ${row.hotness}).`
+            : `Thread #${id} not found.`;
+    }
+    if (sub === 'show') {
+        const row = getThread(id);
+        return row ? formatOne(row) : `Thread #${id} not found.`;
+    }
+    return [
+        'Usage:',
+        '  /threads                          list all threads in this chat',
+        '  /threads show <id>                show one thread in detail',
+        '  /threads resolve <id> <note>      mark resolved (answer found)',
+        '  /threads drop <id> <reason>       mark dropped (stale)',
+        '  /threads compress <id> <note>     mark moved into cold memory',
+        '  /threads touch <id>               bump hotness manually',
+        '  /threads pause <id>               disable (hide from preamble)',
+        '  /threads resume <id>              re-enable',
+        '  /threads delete <id>              permanent delete',
+        '  /threads weight                   list category weights',
+        '  /threads weight <category> <0-100>  override category weight',
+    ].join('\n');
+}
+function formatList(rows) {
+    if (rows.length === 0)
+        return 'No threads in this chat yet.';
+    const live = rows.filter((r) => r.status === 'live');
+    const closed = rows.filter((r) => r.status !== 'live');
+    const lines = [];
+    if (live.length > 0) {
+        lines.push('*Live threads*');
+        for (const r of live)
+            lines.push(formatRow(r));
+    }
+    if (closed.length > 0) {
+        lines.push('');
+        lines.push('*Closed*');
+        for (const r of closed.slice(0, 10))
+            lines.push(formatRow(r));
+        if (closed.length > 10)
+            lines.push(`  …and ${closed.length - 10} older`);
+    }
+    return lines.join('\n');
+}
+function formatRow(r) {
+    const age = formatAge(Math.floor(Date.now() / 1000) - r.openedAt);
+    const status = r.status === 'live' ? `hot ${r.hotness}` : r.status;
+    const en = r.enabled ? '' : ' [paused]';
+    const cost = formatCost(r.totalInputTokens, r.totalOutputTokens);
+    const costSuffix = cost ? ` · ${cost}` : '';
+    const lines = [`  #${r.id}  ${status}  ${age} ago${en}  ${r.title}${costSuffix}`];
+    if (r.summary)
+        lines.push(`       ${r.summary}`);
+    if (r.resolutionNote)
+        lines.push(`       → ${r.resolutionNote}`);
+    return lines.join('\n');
+}
+function formatOne(r) {
+    const age = formatAge(Math.floor(Date.now() / 1000) - r.openedAt);
+    const lines = [
+        `*Thread #${r.id}* — ${r.title}`,
+        `Status: ${r.status}${r.enabled ? '' : ' (paused)'}`,
+        `Hotness: ${r.hotness}`,
+        `Opened: ${age} ago`,
+        `Last touched: ${formatAge(Math.floor(Date.now() / 1000) - r.lastTouchedAt)} ago`,
+        `Summary: ${r.summary}`,
+    ];
+    if (r.linkedMemory)
+        lines.push(`Linked: ${r.linkedMemory}`);
+    if (r.resolutionNote)
+        lines.push(`Resolution: ${r.resolutionNote}`);
+    const cost = formatCost(r.totalInputTokens, r.totalOutputTokens);
+    if (cost)
+        lines.push(`Cost: ${cost}`);
+    return lines.join('\n');
+}
+function formatWeights(rows) {
+    if (rows.length === 0)
+        return 'No category weights learned yet.';
+    const sorted = [...rows].sort((a, b) => b.weight - a.weight);
+    const lines = ['*Category weights* (higher = AI surfaces more)'];
+    for (const r of sorted) {
+        lines.push(`  ${r.category.padEnd(20)} ${r.weight} (${r.samples} samples)`);
+    }
+    return lines.join('\n');
+}
+function formatAge(seconds) {
+    if (seconds < 60)
+        return `${seconds}s`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m`;
+    if (seconds < 86400)
+        return `${Math.floor(seconds / 3600)}h`;
+    return `${Math.floor(seconds / 86400)}d`;
+}
+function formatCost(input, output) {
+    const total = input + output;
+    if (total === 0)
+        return '';
+    const compact = (n) => n < 1000 ? `${n}` : n < 10_000 ? `${(n / 1000).toFixed(1)}k` : `${Math.round(n / 1000)}k`;
+    return `${compact(input)}↑ ${compact(output)}↓`;
+}

package/dist/queue/thread-weights.js

@@ -0,0 +1,142 @@
+// Owner-global learned weights for thread categories. A category is
+// the AI's coarse classification of what a thread is about — derived
+// from linked_memory (e.g. 'journals/health' → 'health') or set
+// explicitly by the AI when opening the thread.
+//
+// The weight (0-100) is used as the starting hotness when the AI
+// creates a new thread in this category. Implicit signals nudge it
+// over time:
+//   - user engages with a surfaced thread        → weight up
+//   - user explicitly drops a thread             → weight down
+//   - user manually overrides via /threads weight → set absolute
+//
+// Aggregate, not per-thread. The point is the AI learns that "Jana
+// stuff" matters to this owner, so future Jana-related threads start
+// hot. Or "general work threads" don't matter much, so they start
+// quiet and need real signal to climb.
+//
+// User voice always wins — the manual override (/threads weight) sets
+// an absolute value and bumps samples high so subsequent implicit
+// nudges have less effect (already-confident weight is harder to
+// move).
+import { eq, sql } from 'drizzle-orm';
+import { getDb } from '../db/index.js';
+import { threadCategoryWeights } from '../db/schema.js';
+const DEFAULT_WEIGHT = 50;
+const MAX_WEIGHT = 100;
+const MIN_WEIGHT = 0;
+export function getCategoryWeight(category) {
+    if (!category)
+        return DEFAULT_WEIGHT;
+    const db = getDb();
+    const row = db
+        .select({ weight: threadCategoryWeights.weight })
+        .from(threadCategoryWeights)
+        .where(eq(threadCategoryWeights.category, category))
+        .get();
+    return row?.weight ?? DEFAULT_WEIGHT;
+}
+// Implicit signal — small delta, learns over many samples. Caller
+// passes a delta like +5 (engagement) or -10 (explicit drop). Clamps
+// to [0,100]. Insert-or-update so a brand-new category starts at
+// DEFAULT_WEIGHT before the first nudge.
+export function nudgeCategoryWeight(category, delta) {
+    if (!category || delta === 0)
+        return;
+    const db = getDb();
+    const now = Math.floor(Date.now() / 1000);
+    const existing = db
+        .select()
+        .from(threadCategoryWeights)
+        .where(eq(threadCategoryWeights.category, category))
+        .get();
+    if (existing) {
+        const next = clamp(existing.weight + delta);
+        db.update(threadCategoryWeights)
+            .set({
+            weight: next,
+            samples: sql `${threadCategoryWeights.samples} + 1`,
+            updatedAt: now,
+        })
+            .where(eq(threadCategoryWeights.category, category))
+            .run();
+        return;
+    }
+    db.insert(threadCategoryWeights)
+        .values({
+        category,
+        weight: clamp(DEFAULT_WEIGHT + delta),
+        samples: 1,
+        updatedAt: now,
+    })
+        .run();
+}
+// Manual override from /threads weight <category> <0-100>. Sets the
+// absolute value, bumps samples so this manual value carries
+// confidence and isn't immediately drowned out.
+export function setCategoryWeight(category, weight) {
+    if (!category)
+        return;
+    const w = clamp(weight);
+    const db = getDb();
+    const now = Math.floor(Date.now() / 1000);
+    const existing = db
+        .select()
+        .from(threadCategoryWeights)
+        .where(eq(threadCategoryWeights.category, category))
+        .get();
+    if (existing) {
+        db.update(threadCategoryWeights)
+            .set({
+            weight: w,
+            samples: sql `${threadCategoryWeights.samples} + 10`, // manual override = high confidence
+            updatedAt: now,
+        })
+            .where(eq(threadCategoryWeights.category, category))
+            .run();
+        return;
+    }
+    db.insert(threadCategoryWeights)
+        .values({ category, weight: w, samples: 10, updatedAt: now })
+        .run();
+}
+export function listCategoryWeights() {
+    const db = getDb();
+    return db
+        .select()
+        .from(threadCategoryWeights)
+        .all()
+        .map((r) => ({ category: r.category, weight: r.weight, samples: r.samples }));
+}
+// Derive a coarse category from a linked_memory path or fall back to
+// extracting the first word of the title. Used when the AI doesn't
+// pass a category explicitly.
+//   'journals/health/entries.jsonl' → 'health'
+//   'persons/5491234567890/profile.md' → 'jana' (no — we'd need
+//     identity resolution; for now → 'persons')
+//   'buckets/work-dms/index.md'    → 'work-dms'
+//   no link → first word of title, lowercased
+export function deriveCategory(linkedMemory, title) {
+    if (linkedMemory) {
+        const segments = linkedMemory.split('/').filter(Boolean);
+        if (segments.length >= 2) {
+            // 'journals/health/...' → 'health'
+            // 'buckets/work-dms/...' → 'work-dms'
+            // 'persons/<phone>/...' → 'persons' (don't leak phone numbers
+            //   into category names; the AI can pass an explicit category
+            //   for per-person tracking)
+            if (segments[0] === 'persons')
+                return 'persons';
+            return segments[1];
+        }
+        return segments[0] ?? 'general';
+    }
+    // Fall back: first token of the title, lowercased.
+    const firstWord = title.trim().split(/\s+/)[0]?.toLowerCase();
+    return firstWord || 'general';
+}
+function clamp(n) {
+    if (!Number.isFinite(n))
+        return DEFAULT_WEIGHT;
+    return Math.max(MIN_WEIGHT, Math.min(MAX_WEIGHT, Math.round(n)));
+}

package/dist/queue/threads.js

@@ -0,0 +1,271 @@
+// Threads — the AI-curated relevance watchlist. See schema.ts header
+// comment for the conceptual model. This module is the CRUD surface
+// the worker calls when processing THREAD-* tags.
+//
+// Hotness invariants:
+//   - 0-100, clamped on every write
+//   - new threads start at min(category_weight, hotnessCapOnCreate)
+//     (default cap 70) so the AI can't open a brand-new thread at
+//     full hotness without an established category prior
+//   - explicit user signals (resolve/drop, /threads commands) win
+//     over implicit AI-emitted updates
+//
+// Status transitions are one-way: live → resolved | dropped |
+// compressed. Once non-live, the row stays for /threads history but
+// is filtered out of the live preamble.
+import { and, asc, desc, eq, inArray, sql } from 'drizzle-orm';
+import { getDb } from '../db/index.js';
+import { logger } from '../logger.js';
+import { threads } from '../db/schema.js';
+import { deriveCategory, getCategoryWeight, nudgeCategoryWeight, } from './thread-weights.js';
+const HOTNESS_MIN = 0;
+const HOTNESS_MAX = 100;
+const HOTNESS_CAP_ON_CREATE = 70;
+const DEFAULT_NEXT_REVIEW_DAYS = 1;
+// Implicit signal deltas — small per-event, AI/system-triggered.
+const DELTA_TOUCH = +5;
+const DELTA_COOL = -10;
+const CATEGORY_NUDGE_TOUCH = +3;
+const CATEGORY_NUDGE_DROP = -5;
+export function createThread(input) {
+    const db = getDb();
+    const now = Math.floor(Date.now() / 1000);
+    const category = input.category ?? deriveCategory(input.linkedMemory, input.title);
+    // Default starting hotness = category weight, capped. AI can pass a
+    // higher value but it's clamped to the cap so brand-new threads
+    // can't open at 95 without history.
+    const proposed = input.hotness ?? getCategoryWeight(category);
+    const hotness = clampHotness(Math.min(proposed, HOTNESS_CAP_ON_CREATE));
+    const nextReview = input.nextReviewAt ?? now + DEFAULT_NEXT_REVIEW_DAYS * 86400;
+    const row = db
+        .insert(threads)
+        .values({
+        targetJid: input.targetJid,
+        title: input.title,
+        summary: input.summary,
+        hotness,
+        status: 'live',
+        linkedMemory: input.linkedMemory ?? null,
+        openedAt: now,
+        lastTouchedAt: now,
+        nextReviewAt: nextReview,
+        createdAt: now,
+    })
+        .returning()
+        .get();
+    logger.info({ id: row.id, jid: row.targetJid, title: row.title, hotness, category }, 'thread opened');
+    return row;
+}
+export function updateThread(input) {
+    const db = getDb();
+    const existing = db.select().from(threads).where(eq(threads.id, input.id)).get();
+    if (!existing)
+        return null;
+    const now = Math.floor(Date.now() / 1000);
+    const next = {
+        title: input.title ?? existing.title,
+        summary: input.summary ?? existing.summary,
+        hotness: input.hotness !== undefined ? clampHotness(input.hotness) : existing.hotness,
+        linkedMemory: input.linkedMemory ?? existing.linkedMemory,
+        nextReviewAt: input.nextReviewAt ?? existing.nextReviewAt,
+        lastTouchedAt: now,
+    };
+    const row = db
+        .update(threads)
+        .set(next)
+        .where(eq(threads.id, input.id))
+        .returning()
+        .get();
+    return row ?? null;
+}
+// TOUCH — small hotness bump + category-weight nudge. Called when the
+// AI brings up a thread naturally or the user references its topic.
+export function touchThread(id) {
+    const db = getDb();
+    const existing = db.select().from(threads).where(eq(threads.id, id)).get();
+    if (!existing)
+        return null;
+    const now = Math.floor(Date.now() / 1000);
+    const next = clampHotness(existing.hotness + DELTA_TOUCH);
+    const row = db
+        .update(threads)
+        .set({ hotness: next, lastTouchedAt: now })
+        .where(eq(threads.id, id))
+        .returning()
+        .get();
+    const category = deriveCategory(existing.linkedMemory, existing.title);
+    nudgeCategoryWeight(category, CATEGORY_NUDGE_TOUCH);
+    return row ?? null;
+}
+// COOL — drop hotness + push next review out. Tag form:
+//   [THREAD-COOL:<id> — wait 3d]
+// Pass deferDays explicitly when the AI specifies a wait; otherwise
+// just lowers hotness without rescheduling.
+export function coolThread(id, deferDays) {
+    const db = getDb();
+    const existing = db.select().from(threads).where(eq(threads.id, id)).get();
+    if (!existing)
+        return null;
+    const now = Math.floor(Date.now() / 1000);
+    const next = clampHotness(existing.hotness + DELTA_COOL);
+    const review = deferDays && deferDays > 0
+        ? now + deferDays * 86400
+        : existing.nextReviewAt;
+    const row = db
+        .update(threads)
+        .set({ hotness: next, nextReviewAt: review, lastTouchedAt: now })
+        .where(eq(threads.id, id))
+        .returning()
+        .get();
+    return row ?? null;
+}
+export function resolveThread(id, note) {
+    const db = getDb();
+    const existing = db.select().from(threads).where(eq(threads.id, id)).get();
+    if (!existing)
+        return null;
+    const now = Math.floor(Date.now() / 1000);
+    const row = db
+        .update(threads)
+        .set({
+        status: 'resolved',
+        resolutionNote: note,
+        lastTouchedAt: now,
+    })
+        .where(eq(threads.id, id))
+        .returning()
+        .get();
+    // Strong positive signal — user got an answer / closed the loop.
+    const category = deriveCategory(existing.linkedMemory, existing.title);
+    nudgeCategoryWeight(category, CATEGORY_NUDGE_TOUCH);
+    logger.info({ id, note }, 'thread resolved');
+    return row ?? null;
+}
+export function dropThread(id, reason) {
+    const db = getDb();
+    const existing = db.select().from(threads).where(eq(threads.id, id)).get();
+    if (!existing)
+        return null;
+    const now = Math.floor(Date.now() / 1000);
+    const row = db
+        .update(threads)
+        .set({
+        status: 'dropped',
+        resolutionNote: reason,
+        lastTouchedAt: now,
+    })
+        .where(eq(threads.id, id))
+        .returning()
+        .get();
+    // Negative signal — AI thought this mattered, user (or AI realizing
+    // it doesn't) decided otherwise. Pull the category down so future
+    // threads in this area start cooler.
+    const category = deriveCategory(existing.linkedMemory, existing.title);
+    nudgeCategoryWeight(category, CATEGORY_NUDGE_DROP);
+    logger.info({ id, reason }, 'thread dropped');
+    return row ?? null;
+}
+// COMPRESS — thread has stabilized into a fact and the AI is moving
+// it into cold memory (typically via a [DIGEST:] or direct write in
+// the same reply). We just flip the status here; the actual file
+// write is the caller's responsibility.
+export function compressThread(id, note) {
+    const db = getDb();
+    const existing = db.select().from(threads).where(eq(threads.id, id)).get();
+    if (!existing)
+        return null;
+    const now = Math.floor(Date.now() / 1000);
+    const row = db
+        .update(threads)
+        .set({
+        status: 'compressed',
+        resolutionNote: note,
+        lastTouchedAt: now,
+    })
+        .where(eq(threads.id, id))
+        .returning()
+        .get();
+    logger.info({ id, note }, 'thread compressed to cold memory');
+    return row ?? null;
+}
+// Preamble loader — live threads in this chat, ordered hot-first.
+// `limit` caps the preamble size (default 5). Threads below
+// hotness `minHotness` are excluded (so cold threads don't clutter).
+export function listLiveThreads(targetJid, limit = 5, minHotness = 10) {
+    const db = getDb();
+    return db
+        .select()
+        .from(threads)
+        .where(and(eq(threads.targetJid, targetJid), eq(threads.status, 'live'), eq(threads.enabled, 1)))
+        .orderBy(desc(threads.hotness), desc(threads.lastTouchedAt))
+        .limit(limit)
+        .all()
+        .filter((r) => r.hotness >= minHotness);
+}
+// /threads — all threads (any status) in a chat. Used by the chat
+// command for full listing.
+export function listAllThreads(targetJid) {
+    const db = getDb();
+    return db
+        .select()
+        .from(threads)
+        .where(eq(threads.targetJid, targetJid))
+        .orderBy(asc(threads.status), desc(threads.hotness))
+        .all();
+}
+export function getThread(id) {
+    const db = getDb();
+    return db.select().from(threads).where(eq(threads.id, id)).get() ?? null;
+}
+export function setThreadEnabled(id, enabled) {
+    const db = getDb();
+    const result = db
+        .update(threads)
+        .set({ enabled: enabled ? 1 : 0 })
+        .where(eq(threads.id, id))
+        .returning({ id: threads.id })
+        .all();
+    return result.length > 0;
+}
+export function deleteThread(id) {
+    const db = getDb();
+    const result = db
+        .delete(threads)
+        .where(eq(threads.id, id))
+        .returning({ id: threads.id })
+        .all();
+    return result.length > 0;
+}
+// Cost attribution — called when a future proactive review tick burns
+// AI inferences. Mirrors addCronUsage in crons.ts.
+export function addThreadUsage(id, inputTokens, outputTokens) {
+    if (!id || (inputTokens <= 0 && outputTokens <= 0))
+        return;
+    const db = getDb();
+    db.update(threads)
+        .set({
+        totalInputTokens: sql `${threads.totalInputTokens}  + ${inputTokens}`,
+        totalOutputTokens: sql `${threads.totalOutputTokens} + ${outputTokens}`,
+    })
+        .where(eq(threads.id, id))
+        .run();
+}
+function clampHotness(n) {
+    if (!Number.isFinite(n))
+        return 0;
+    return Math.max(HOTNESS_MIN, Math.min(HOTNESS_MAX, Math.round(n)));
+}
+// Helper for the worker to filter out tags targeting threads in
+// other chats (which shouldn't happen — AI shouldn't have IDs from
+// other chats in preamble — but defense-in-depth).
+export function threadsBelongToJid(ids, targetJid) {
+    if (ids.length === 0)
+        return new Set();
+    const db = getDb();
+    const rows = db
+        .select({ id: threads.id })
+        .from(threads)
+        .where(and(inArray(threads.id, ids), eq(threads.targetJid, targetJid)))
+        .all();
+    return new Set(rows.map((r) => r.id));
+}