@c4t4/heyamigo 0.3.0 → 0.6.1

package/dist/memory/compressed.js

@@ -0,0 +1,334 @@
+import { spawn } from 'child_process';
+import { existsSync, readFileSync, readdirSync, writeFileSync, } from 'fs';
+import { dirname, resolve } from 'path';
+import { mkdirSync } from 'fs';
+import { config } from '../config.js';
+import { logger } from '../logger.js';
+import { logPrompt } from '../promptlog.js';
+import { listJournals, readEntries } from './journals.js';
+import { memoryRoot, treeRoot, entityIndexPath } from './paths.js';
+// The compressed view is a rolling index across all memory: people, chats,
+// buckets, active journals. 1-3 lines per entity. Purpose: every fresh
+// session starts with enough state to respond to a passing mention without
+// re-reading any file. Deep context still lives in the full profile/brief/
+// entries files — Claude reads those on demand.
+//
+// Regenerated on: boot, and after any digest that edits a memory file
+// (marked dirty, lazily rebuilt on next access).
+export function compressedPath() {
+    return resolve(memoryRoot(), 'compressed.md');
+}
+function compressedStatePath() {
+    return resolve(memoryRoot(), 'compressed-state.json');
+}
+function loadState() {
+    const raw = readIfExists(compressedStatePath());
+    if (!raw)
+        return { lastBuiltAt: 0, dirty: true };
+    try {
+        const parsed = JSON.parse(raw);
+        return {
+            lastBuiltAt: parsed.lastBuiltAt ?? 0,
+            dirty: parsed.dirty ?? false,
+        };
+    }
+    catch {
+        return { lastBuiltAt: 0, dirty: true };
+    }
+}
+function saveState(state) {
+    const path = compressedStatePath();
+    ensureDirFor(path);
+    writeFileSync(path, JSON.stringify(state, null, 2) + '\n', 'utf-8');
+}
+function readIfExists(path) {
+    if (!existsSync(path))
+        return null;
+    return readFileSync(path, 'utf-8');
+}
+function ensureDirFor(path) {
+    mkdirSync(dirname(path), { recursive: true });
+}
+export function markCompressedDirty() {
+    const state = loadState();
+    state.dirty = true;
+    saveState(state);
+}
+export function readCompressed() {
+    return readIfExists(compressedPath());
+}
+// ---------- generator ----------
+function collectPersons() {
+    const dir = treeRoot('persons');
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    for (const d of readdirSync(dir, { withFileTypes: true })) {
+        if (!d.isDirectory())
+            continue;
+        const profilePath = resolve(dir, d.name, 'profile.md');
+        const profile = readIfExists(profilePath);
+        if (profile)
+            out.push({ number: d.name, profile });
+    }
+    return out;
+}
+function collectChats() {
+    const dir = treeRoot('chats');
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    for (const d of readdirSync(dir, { withFileTypes: true })) {
+        if (!d.isDirectory())
+            continue;
+        const briefPath = resolve(dir, d.name, 'brief.md');
+        const brief = readIfExists(briefPath);
+        if (brief)
+            out.push({ jid: d.name, brief });
+    }
+    return out;
+}
+function collectBuckets() {
+    const dir = treeRoot('buckets');
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    for (const d of readdirSync(dir, { withFileTypes: true })) {
+        if (!d.isDirectory())
+            continue;
+        const idx = readIfExists(entityIndexPath('buckets', d.name));
+        if (idx)
+            out.push({ slug: d.name, index: idx });
+    }
+    return out;
+}
+function collectJournals() {
+    return listJournals()
+        .filter((j) => j.status === 'active')
+        .map((j) => {
+        const cadenceBits = [];
+        if (j.cadence.checkin)
+            cadenceBits.push(`check-in ${j.cadence.checkin}`);
+        if (j.cadence.nudge_if_silent)
+            cadenceBits.push(`silent-nudge ${j.cadence.nudge_if_silent}`);
+        const recent = readEntries(j.slug, 2);
+        return {
+            slug: j.slug,
+            purpose: j.purpose,
+            status: j.status,
+            cadence: cadenceBits.join(', '),
+            lastEntries: recent.map((e) => {
+                const d = new Date(e.ts * 1000)
+                    .toISOString()
+                    .slice(0, 10);
+                return `[${d}] ${e.note}`;
+            }),
+        };
+    });
+}
+function buildInputForGenerator() {
+    const lines = [];
+    const persons = collectPersons();
+    if (persons.length) {
+        lines.push('## PEOPLE (raw profiles)');
+        for (const p of persons) {
+            lines.push(`### ${p.number}`);
+            lines.push(p.profile.trim());
+            lines.push('');
+        }
+    }
+    const chats = collectChats();
+    if (chats.length) {
+        lines.push('## CHATS (raw briefs)');
+        for (const c of chats) {
+            lines.push(`### ${c.jid}`);
+            lines.push(c.brief.trim());
+            lines.push('');
+        }
+    }
+    const buckets = collectBuckets();
+    if (buckets.length) {
+        lines.push('## BUCKETS (raw indexes)');
+        for (const b of buckets) {
+            lines.push(`### ${b.slug}`);
+            lines.push(b.index.trim());
+            lines.push('');
+        }
+    }
+    const journals = collectJournals();
+    if (journals.length) {
+        lines.push('## JOURNALS (active)');
+        for (const j of journals) {
+            lines.push(`### ${j.slug}`);
+            lines.push(`purpose: ${j.purpose}`);
+            if (j.cadence)
+                lines.push(`cadence: ${j.cadence}`);
+            if (j.lastEntries.length) {
+                lines.push('last entries:');
+                for (const e of j.lastEntries)
+                    lines.push(`  ${e}`);
+            }
+            lines.push('');
+        }
+    }
+    return lines.join('\n') || '(no memory yet)';
+}
+function generatorPrompt(raw) {
+    return `Write the line you'd want to see if you woke up with amnesia and were about to answer this person. That's the whole job.
+
+You are producing a rolling "state of the world" index. Every fresh Claude session starts by reading it. It is NOT a summary. It is an INDEX with load-bearing excerpts, pointing at full files for depth.
+
+RULES (enforce ruthlessly):
+- Every phrase must change a response. If removing it wouldn't change how you'd reply, cut it.
+- Staccato. No filler verbs (is, was, has, tends to). No hedges (maybe, usually, often).
+- Behavior-shifting facts only: identity (pronouns, name), hard rules ("always English", "don't X"), current state ("gut recovering", "bulk to 63kg"), key constraints.
+- NO biography. Age, location, occupation are NOT load-bearing unless they directly change a response.
+- Cap: one to three lines per entity. Closer to one is better.
+- High word/meaning ratio. "Trolls, verify." does the work of a paragraph.
+
+OUTPUT FORMAT (exact):
+
+# State: current
+
+## People
+
+- <name> (<number>): <phrase>. <phrase>. <phrase>.
+  → storage/memory/persons/<number>/profile.md
+
+(one entry per person, three phrases MAX)
+
+## Chats
+
+- <jid> "<chat name if known>": <one line of norms + current state>.
+  → storage/memory/chats/<jid>/brief.md
+
+## Buckets
+
+- <slug>: <one line — what this is + current status>.
+  → storage/memory/buckets/<slug>/index.md
+
+## Journals (active, open todos)
+
+- <slug>: <purpose, tight>.
+  last: <copy the most recent entry VERBATIM, do not paraphrase>
+  cadence: <check-in / silent-nudge as applicable>
+  → storage/memory/journals/<slug>/
+
+RAW SOURCES:
+
+${raw}
+
+Output ONLY the compressed index in the exact format above. No preamble, no explanation, no code fences.`;
+}
+async function spawnGenerator(prompt) {
+    const args = [
+        '-p',
+        '--output-format',
+        'json',
+        '--model',
+        config.claude.model,
+        '--permission-mode',
+        'acceptEdits',
+    ];
+    const startedAt = Date.now();
+    return new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn('claude', args, {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            cwd: process.cwd(),
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (c) => {
+            stdout += c.toString('utf-8');
+        });
+        child.stderr.on('data', (c) => {
+            stderr += c.toString('utf-8');
+        });
+        const logFail = (error) => void logPrompt({
+            ts: Math.floor(startedAt / 1000),
+            caller: 'compressed',
+            args,
+            input: prompt,
+            error,
+            durationMs: Date.now() - startedAt,
+        });
+        child.on('error', (err) => {
+            logFail(`spawn failed: ${err.message}`);
+            rejectPromise(err);
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                logFail(`exit ${code}: ${stderr.slice(0, 300)}`);
+                return rejectPromise(new Error(`compressed generator exit ${code}`));
+            }
+            try {
+                const parsed = JSON.parse(stdout);
+                if (parsed.is_error ||
+                    parsed.subtype !== 'success' ||
+                    !parsed.result) {
+                    logFail(`bad output: ${parsed.result ?? stderr.slice(0, 200)}`);
+                    return rejectPromise(new Error('compressed generator bad output'));
+                }
+                const output = parsed.result.trim();
+                void logPrompt({
+                    ts: Math.floor(startedAt / 1000),
+                    caller: 'compressed',
+                    args,
+                    input: prompt,
+                    output,
+                    durationMs: Date.now() - startedAt,
+                });
+                resolvePromise(output);
+            }
+            catch (err) {
+                logFail(`parse failed: ${err.message}`);
+                rejectPromise(err);
+            }
+        });
+        child.stdin.write(prompt);
+        child.stdin.end();
+    });
+}
+let buildInFlight = null;
+export async function rebuildCompressed() {
+    if (buildInFlight)
+        return buildInFlight;
+    buildInFlight = (async () => {
+        const raw = buildInputForGenerator();
+        if (raw === '(no memory yet)') {
+            const empty = '# State: current\n\n(no memory yet)\n';
+            const path = compressedPath();
+            ensureDirFor(path);
+            writeFileSync(path, empty, 'utf-8');
+            saveState({ lastBuiltAt: Math.floor(Date.now() / 1000), dirty: false });
+            logger.info('compressed: empty scaffold written (no memory yet)');
+            return;
+        }
+        const prompt = generatorPrompt(raw);
+        const output = await spawnGenerator(prompt);
+        const path = compressedPath();
+        ensureDirFor(path);
+        writeFileSync(path, output + '\n', 'utf-8');
+        saveState({ lastBuiltAt: Math.floor(Date.now() / 1000), dirty: false });
+        logger.info({ chars: output.length }, 'compressed: rebuilt');
+    })();
+    try {
+        await buildInFlight;
+    }
+    finally {
+        buildInFlight = null;
+    }
+}
+// Regenerate only if dirty or missing. Used in boot + lazy access paths.
+export async function ensureCompressedFresh() {
+    const state = loadState();
+    const exists = existsSync(compressedPath());
+    if (!state.dirty && exists)
+        return;
+    try {
+        await rebuildCompressed();
+    }
+    catch (err) {
+        logger.error({ err }, 'compressed: rebuild failed');
+    }
+}

package/dist/memory/digest-flag.js

@@ -1,18 +1,21 @@
-const TRAILING_TAG_RE = /\[(DIGEST|JOURNAL|JOURNAL-NEW|JOURNAL-PAUSE|JOURNAL-RESUME|JOURNAL-ARCHIVE):\s*([^\]]+)\]\s*$/i;
+const TRAILING_TAG_RE = /\[(DIGEST|JOURNAL|JOURNAL-NEW|ASYNC):\s*([^\]]+)\]\s*$/i;
 // Peel trailing tags off the end of a reply. Supported:
 //   [DIGEST: <reason>]
 //   [JOURNAL:<slug> — <note>]         (append entry)
 //   [JOURNAL-NEW:<slug> — <purpose>]  (create journal)
-//   [JOURNAL-PAUSE:<slug>]
-//   [JOURNAL-RESUME:<slug>]
-//   [JOURNAL-ARCHIVE:<slug>]
-// Multiple tags are supported and can appear in any order at the tail.
-// Tags must be the LAST thing in the reply (after trimming trailing whitespace).
+//   [ASYNC: <self-sufficient task description>]
+// Multiple tags supported, 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.
 export function extractFlags(reply) {
     let current = reply;
     let digest = null;
     const journals = [];
-    const lifecycleOps = [];
+    const journalCreates = [];
+    const asyncTasks = [];
     while (true) {
         const trimmed = current.replace(/\s+$/, '');
         const match = trimmed.match(TRAILING_TAG_RE);
@@ -32,29 +35,17 @@ export function extractFlags(reply) {
         else if (kind === 'JOURNAL-NEW') {
             const parsed = parseJournalPayload(payload);
             if (parsed) {
-                lifecycleOps.unshift({
-                    kind: 'new',
-                    slug: parsed.slug,
-                    purpose: parsed.note,
-                });
+                journalCreates.unshift({ slug: parsed.slug, purpose: parsed.note });
             }
         }
-        else if (kind === 'JOURNAL-PAUSE' ||
-            kind === 'JOURNAL-RESUME' ||
-            kind === 'JOURNAL-ARCHIVE') {
-            const slug = payload.trim().toLowerCase();
-            if (/^[a-z0-9][a-z0-9-]*$/.test(slug)) {
-                const op = kind === 'JOURNAL-PAUSE'
-                    ? 'pause'
-                    : kind === 'JOURNAL-RESUME'
-                        ? 'resume'
-                        : 'archive';
-                lifecycleOps.unshift({ kind: op, slug });
+        else if (kind === 'ASYNC') {
+            if (payload.length >= 8) {
+                asyncTasks.unshift({ description: payload });
             }
         }
         current = trimmed.slice(0, match.index).trimEnd();
     }
-    return { clean: current, digest, journals, lifecycleOps };
+    return { clean: current, digest, journals, journalCreates, asyncTasks };
 }
 // Legacy helper kept so existing callers still compile.
 export function extractDigestFlag(reply) {

package/dist/memory/digest.js

@@ -3,6 +3,7 @@ import { config } from '../config.js';
 import { logger } from '../logger.js';
 import { logPrompt } from '../promptlog.js';
 import { readLast } from '../store/messages.js';
+import { markCompressedDirty } from './compressed.js';
 import { readBrief, readProfile, setLastDigestedAt, writeBrief, writeProfile, } from './store.js';
 /**
  * Run a stateless Claude call to consolidate memory.
@@ -199,4 +200,7 @@ export async function runDigest(params) {
             logger.error({ err, number }, 'profile digest failed');
         }
     }
+    // A profile or brief changed. Mark compressed view dirty so the next
+    // session boot or ensureCompressedFresh() call regenerates it.
+    markCompressedDirty();
 }

package/dist/memory/journals.js

@@ -304,11 +304,3 @@ export function saveNudgeState(slug, state) {
     ensureDirFor(path);
     writeFileSync(path, JSON.stringify(state, null, 2) + '\n', 'utf-8');
 }
-export function snoozeJournal(slug, untilTs) {
-    if (!journalExists(slug))
-        return false;
-    const state = loadNudgeState(slug);
-    state.snoozedUntilTs = untilTs;
-    saveNudgeState(slug, state);
-    return true;
-}

package/dist/memory/preamble.js

@@ -1,6 +1,8 @@
 import { existsSync, readFileSync } from 'fs';
 import { resolve } from 'path';
 import { config } from '../config.js';
+import { listAsyncTasks } from '../queue/async-tasks.js';
+import { readCompressed } from './compressed.js';
 import { buildJournalsPreambleBlock, ensureJournalsScaffold, } from './journals.js';
 import { masterIndexPath, treeIndexPath } from './paths.js';
 import { routeIndexes } from './router.js';
@@ -74,6 +76,14 @@ export function buildMemoryPreamble(params) {
         sections.push(`[Instruction]\n${DIGEST_REMINDER}`);
         return sections.join('\n\n');
     }
+    // Rolling state index: people + chats + buckets + active journals, 1-3
+    // lines each with path pointers. This is the primary memory surface.
+    // Tree indexes + routed entity indexes remain below as a secondary layer
+    // for Claude when the compressed view doesn't carry enough.
+    const compressed = readCompressed();
+    if (compressed) {
+        sections.push(`[State: current]\n${compressed.trim()}`);
+    }
     // Full or self: load master + tree indexes
     const master = readIfExists(masterIndexPath());
     if (master)
@@ -119,6 +129,19 @@ export function buildMemoryPreamble(params) {
         sections.push(`[Journals: active]\n${journalsBlock}`);
         instructions.push(JOURNAL_REMINDER);
     }
+    // Async tasks in progress for this chat — so Claude doesn't re-promise or
+    // contradict work already running in the background.
+    const asyncTasks = listAsyncTasks(params.jid);
+    if (asyncTasks.length > 0) {
+        const now = Math.floor(Date.now() / 1000);
+        const lines = ['You have background tasks currently running for this chat:'];
+        for (const t of asyncTasks) {
+            const ageSec = Math.max(0, now - t.startedAt);
+            lines.push(`- "${t.description}" (started ${formatAge(ageSec)} ago)`);
+        }
+        lines.push('', 'Do NOT re-start or re-promise these. Reply referencing that they are in progress if relevant, but do not emit another [ASYNC:...] for the same work.');
+        sections.push(`[Async tasks in progress]\n${lines.join('\n')}`);
+    }
     sections.push(`[Instruction]\n${instructions.join('\n\n')}`);
     return sections.join('\n\n');
 }
@@ -127,6 +150,13 @@ function readIfExists(path) {
         return null;
     return readFileSync(path, 'utf-8');
 }
+function formatAge(seconds) {
+    if (seconds < 60)
+        return `${seconds}s`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m`;
+    return `${Math.floor(seconds / 3600)}h${Math.floor((seconds % 3600) / 60)}m`;
+}
 function buildTimeLine(timezone) {
     const now = new Date();
     const fmt = new Intl.DateTimeFormat('en-GB', {

package/dist/memory/scheduler.js

@@ -81,6 +81,17 @@ export function startScheduler() {
         return;
     ensureScaffold();
     void prunePrompts(); // run once on boot
+    // Rebuild the compressed memory view on boot so every session starts with
+    // current state. Runs in background, don't block scheduler startup.
+    void (async () => {
+        try {
+            const { ensureCompressedFresh } = await import('./compressed.js');
+            await ensureCompressedFresh();
+        }
+        catch (err) {
+            logger.error({ err }, 'compressed: boot rebuild failed');
+        }
+    })();
     sweepTimer = setInterval(() => {
         void sweep().catch((err) => logger.error({ err }, 'sweep failed'));
     }, config.memory.sweepIntervalMs);