@c4t4/heyamigo 0.1.18 → 0.5.0

package/dist/memory/journals.js

@@ -0,0 +1,306 @@
+import { appendFileSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, } from 'fs';
+import { dirname, resolve } from 'path';
+import { logger } from '../logger.js';
+import { parseFrontmatter, serializeFrontmatter, } from './frontmatter.js';
+import { memoryRoot } from './paths.js';
+// ---------- paths ----------
+function journalsRoot() {
+    return resolve(memoryRoot(), 'journals');
+}
+function journalDir(slug) {
+    return resolve(journalsRoot(), slug);
+}
+function journalIndexPath(slug) {
+    return resolve(journalDir(slug), 'index.md');
+}
+function journalEntriesPath(slug) {
+    return resolve(journalDir(slug), 'entries.jsonl');
+}
+function journalsIndexPath() {
+    return resolve(journalsRoot(), 'index.md');
+}
+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 });
+}
+function readIfExists(path) {
+    if (!existsSync(path))
+        return null;
+    return readFileSync(path, 'utf-8');
+}
+// ---------- scaffold ----------
+export function ensureJournalsScaffold() {
+    mkdirSync(journalsRoot(), { recursive: true });
+    if (!existsSync(journalsIndexPath())) {
+        writeFileSync(journalsIndexPath(), '# journals\n\n(empty)\n', 'utf-8');
+    }
+}
+// ---------- slug rules ----------
+const SLUG_RE = /^[a-z0-9][a-z0-9-]{0,47}$/;
+export function isValidSlug(slug) {
+    return SLUG_RE.test(slug);
+}
+// ---------- parse / serialize ----------
+function parseJournal(slug, raw) {
+    const { data, body } = parseFrontmatter(raw);
+    const name = typeof data.name === 'string' ? data.name : slug;
+    const purpose = typeof data.purpose === 'string' ? data.purpose : '';
+    const fields = Array.isArray(data.fields)
+        ? data.fields.map(String)
+        : [];
+    const status = data.status === 'paused' || data.status === 'archived'
+        ? data.status
+        : 'active';
+    const cadence = {
+        checkin: pickString(data.checkin),
+        followup_after: pickString(data.followup_after),
+        nudge_if_silent: pickString(data.nudge_if_silent),
+    };
+    const created_at = typeof data.created_at === 'string' ? data.created_at : '';
+    const updated_at = typeof data.updated_at === 'string' ? data.updated_at : created_at;
+    return {
+        slug,
+        name,
+        purpose,
+        fields,
+        cadence,
+        status,
+        quiet_hours: pickString(data.quiet_hours),
+        created_at,
+        updated_at,
+        body,
+    };
+}
+function pickString(v) {
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+function journalToFrontmatter(j) {
+    const fm = {
+        slug: j.slug,
+        name: j.name,
+        purpose: j.purpose,
+        fields: j.fields,
+        status: j.status,
+        created_at: j.created_at,
+        updated_at: j.updated_at,
+    };
+    if (j.cadence.checkin)
+        fm.checkin = j.cadence.checkin;
+    if (j.cadence.followup_after)
+        fm.followup_after = j.cadence.followup_after;
+    if (j.cadence.nudge_if_silent)
+        fm.nudge_if_silent = j.cadence.nudge_if_silent;
+    if (j.quiet_hours)
+        fm.quiet_hours = j.quiet_hours;
+    return fm;
+}
+// ---------- CRUD ----------
+export function listJournals() {
+    const root = journalsRoot();
+    if (!existsSync(root))
+        return [];
+    const slugs = readdirSync(root, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name)
+        .sort();
+    const out = [];
+    for (const slug of slugs) {
+        const raw = readIfExists(journalIndexPath(slug));
+        if (!raw)
+            continue;
+        const j = parseJournal(slug, raw);
+        if (j)
+            out.push(j);
+    }
+    return out;
+}
+export function getJournal(slug) {
+    if (!isValidSlug(slug))
+        return null;
+    const raw = readIfExists(journalIndexPath(slug));
+    if (!raw)
+        return null;
+    return parseJournal(slug, raw);
+}
+export function journalExists(slug) {
+    return isValidSlug(slug) && existsSync(journalIndexPath(slug));
+}
+export function createJournal(input) {
+    if (!isValidSlug(input.slug)) {
+        throw new Error(`Invalid journal slug "${input.slug}". Use lowercase letters, digits, and hyphens (max 48 chars, must start with letter/digit).`);
+    }
+    if (journalExists(input.slug)) {
+        throw new Error(`Journal "${input.slug}" already exists.`);
+    }
+    const now = new Date().toISOString().slice(0, 10);
+    // Default cadence: nudge after 3 days of silence on this topic. No daily
+    // check-in by default — that would be too pushy for most journals. Owner
+    // can tune by editing the journal's index.md frontmatter directly.
+    const cadence = input.cadence ?? {
+        nudge_if_silent: '3d',
+    };
+    const journal = {
+        slug: input.slug,
+        name: input.name,
+        purpose: input.purpose,
+        fields: input.fields ?? [],
+        cadence,
+        status: 'active',
+        quiet_hours: input.quiet_hours,
+        created_at: now,
+        updated_at: now,
+        body: input.body ??
+            `# ${input.name}\n\n${input.purpose}\n\n## How this journal is used\n\nEntries are captured by the assistant when topics relevant to this journal come up. See entries.jsonl for the log.\n`,
+    };
+    writeJournal(journal);
+    refreshJournalsIndex();
+    logger.info({ slug: journal.slug }, 'journal created');
+    return journal;
+}
+export function writeJournal(j) {
+    const content = serializeFrontmatter(journalToFrontmatter(j), j.body);
+    const path = journalIndexPath(j.slug);
+    ensureDirFor(path);
+    writeFileSync(path, content, 'utf-8');
+}
+export function updateJournalStatus(slug, status) {
+    const j = getJournal(slug);
+    if (!j)
+        return null;
+    j.status = status;
+    j.updated_at = new Date().toISOString().slice(0, 10);
+    writeJournal(j);
+    refreshJournalsIndex();
+    return j;
+}
+// ---------- entries ----------
+export function appendEntry(slug, entry) {
+    if (!journalExists(slug)) {
+        logger.warn({ slug }, 'journal append ignored: unknown slug');
+        return false;
+    }
+    const full = {
+        ts: entry.ts ?? Math.floor(Date.now() / 1000),
+        source: entry.source,
+        jid: entry.jid,
+        senderNumber: entry.senderNumber,
+        note: entry.note,
+    };
+    const path = journalEntriesPath(slug);
+    ensureDirFor(path);
+    appendFileSync(path, JSON.stringify(full) + '\n', 'utf-8');
+    logger.info({ slug, source: full.source, jid: full.jid }, 'journal entry appended');
+    return true;
+}
+export function readEntries(slug, limit = 100) {
+    const raw = readIfExists(journalEntriesPath(slug));
+    if (!raw)
+        return [];
+    const lines = raw.trim().split(/\r?\n/).filter(Boolean);
+    const tail = limit > 0 ? lines.slice(-limit) : lines;
+    const out = [];
+    for (const line of tail) {
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch {
+            // skip malformed line
+        }
+    }
+    return out;
+}
+// ---------- index ----------
+export function refreshJournalsIndex() {
+    const journals = listJournals();
+    const lines = ['# journals', ''];
+    if (journals.length === 0) {
+        lines.push('(empty)');
+    }
+    else {
+        for (const j of journals) {
+            lines.push(`- ${j.slug}/ [${j.status}] — ${j.purpose || j.name}`);
+        }
+    }
+    lines.push('');
+    const path = journalsIndexPath();
+    ensureDirFor(path);
+    writeFileSync(path, lines.join('\n'), 'utf-8');
+}
+// ---------- preamble helper ----------
+// Short one-liner per active journal for the [Journals: active] preamble block.
+// Only returns active journals (not paused/archived).
+export function buildJournalsPreambleBlock() {
+    const journals = listJournals().filter((j) => j.status === 'active');
+    if (journals.length === 0)
+        return null;
+    const lines = [];
+    for (const j of journals) {
+        const cadence = summarizeCadence(j.cadence);
+        const cadenceSuffix = cadence ? ` (${cadence})` : '';
+        lines.push(`- ${j.slug}: ${j.purpose || j.name}${cadenceSuffix}`);
+    }
+    return lines.join('\n');
+}
+function summarizeCadence(c) {
+    const bits = [];
+    if (c.checkin)
+        bits.push(`check-in ${c.checkin}`);
+    if (c.followup_after)
+        bits.push(`follow-up ${c.followup_after}`);
+    if (c.nudge_if_silent)
+        bits.push(`nudge if silent ${c.nudge_if_silent}`);
+    return bits.join('; ');
+}
+export function loadObserverState(slug) {
+    const raw = readIfExists(journalObserverStatePath(slug));
+    if (!raw)
+        return { jids: {} };
+    try {
+        const parsed = JSON.parse(raw);
+        return { jids: parsed.jids ?? {} };
+    }
+    catch {
+        return { jids: {} };
+    }
+}
+export function saveObserverState(slug, state) {
+    const path = journalObserverStatePath(slug);
+    ensureDirFor(path);
+    writeFileSync(path, JSON.stringify(state, null, 2) + '\n', 'utf-8');
+}
+export function getLastScannedTs(slug, jid) {
+    const state = loadObserverState(slug);
+    return state.jids[jid]?.lastScannedTs ?? 0;
+}
+export function setLastScannedTs(slug, jid, ts) {
+    const state = loadObserverState(slug);
+    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');
+}

package/dist/memory/preamble.js

@@ -1,11 +1,14 @@
 import { existsSync, readFileSync } from 'fs';
 import { resolve } from 'path';
 import { config } from '../config.js';
+import { listAsyncTasks } from '../queue/async-tasks.js';
+import { buildJournalsPreambleBlock, ensureJournalsScaffold, } from './journals.js';
 import { masterIndexPath, treeIndexPath } from './paths.js';
 import { routeIndexes } from './router.js';
 import { ensureScaffold } from './store.js';
 import { getRoleForContext } from '../wa/whitelist.js';
 const DIGEST_REMINDER = `When something worth remembering happens (new preference, key fact, life event, changed plan), append [DIGEST: <one-line reason>] to the END of your reply. It will be stripped before sending. Flag sparingly.`;
+const JOURNAL_REMINDER = `When a message contains info for one of the journals above, append [JOURNAL:<slug> — <one-line note>] to the END of your reply. Multiple tags OK. Only use slugs listed; never invent. Full rules are in your memory instructions.`;
 function buildCriticalSection(params) {
     const { senderNumber, roleName, role, userName } = params;
     const who = userName
@@ -34,6 +37,7 @@ function buildCriticalSection(params) {
 }
 export function buildMemoryPreamble(params) {
     ensureScaffold();
+    ensureJournalsScaffold();
     const { name: roleName, role, userName } = getRoleForContext(params.senderNumber, params.isGroup ?? params.jid.endsWith('@g.us'));
     const sections = [];
     // Identity — tell Claude its name
@@ -108,7 +112,28 @@ export function buildMemoryPreamble(params) {
     if (entityBlocks.length) {
         sections.push(`${label}\n${entityBlocks.join('\n\n')}`);
     }
-    sections.push(`[Instruction]\n${DIGEST_REMINDER}`);
+    // Journals — owner-scoped, shown globally across all chats.
+    const isOwner = !!config.owner.number && params.senderNumber === config.owner.number;
+    const journalsBlock = isOwner ? buildJournalsPreambleBlock() : null;
+    const instructions = [DIGEST_REMINDER];
+    if (journalsBlock) {
+        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');
 }
 function readIfExists(path) {
@@ -116,6 +141,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

@@ -62,8 +62,20 @@ async function sweep() {
                 .catch((err) => logger.error({ err, jid }, 'sweep digest push failed'));
         }
     }
+    // Journal observer pass: scans recent messages per active journal for
+    // entries Claude missed (i.e. when the bot wasn't mentioned). Runs once
+    // per sweep cycle; each journal maintains its own last-scanned-ts.
+    try {
+        const { runJournalObserverSweep } = await import('./journal-observer.js');
+        await runJournalObserverSweep();
+    }
+    catch (err) {
+        logger.error({ err }, 'journal observer sweep failed');
+    }
 }
 let sweepTimer = null;
+let nudgeTimer = null;
+const NUDGE_TICK_MS = 5 * 60 * 1000; // 5 minutes
 export function startScheduler() {
     if (sweepTimer)
         return;
@@ -72,13 +84,36 @@ export function startScheduler() {
     sweepTimer = setInterval(() => {
         void sweep().catch((err) => logger.error({ err }, 'sweep failed'));
     }, config.memory.sweepIntervalMs);
-    logger.info({ intervalMs: config.memory.sweepIntervalMs }, 'memory scheduler started');
+    // Faster tick just for proactive journal nudges (check-ins, silent-nudges).
+    // The memory-sweep cycle (default 3h) is too coarse for a "daily 21:00"
+    // check-in. This tick is cheap: it only spawns Claude when something is
+    // actually due for a journal.
+    nudgeTimer = setInterval(() => {
+        void runNudgeTickSafe();
+    }, NUDGE_TICK_MS);
+    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');
+    }
 }
 export function stopScheduler() {
     if (sweepTimer) {
         clearInterval(sweepTimer);
         sweepTimer = null;
     }
+    if (nudgeTimer) {
+        clearInterval(nudgeTimer);
+        nudgeTimer = null;
+    }
     for (const t of pendingTimers.values())
         clearTimeout(t);
     pendingTimers.clear();

package/dist/queue/async-tasks.js

@@ -0,0 +1,215 @@
+import { spawn } from 'child_process';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import { config } from '../config.js';
+import fastq from 'fastq';
+import { initiate } from '../gateway/outgoing.js';
+import { logger } from '../logger.js';
+import { logPrompt } from '../promptlog.js';
+// Concurrency: how many async Claude workers can run simultaneously.
+// Start conservative — each process is expensive (Playwright, multi-minute runs).
+// Tune via config.asyncTasks.concurrency once we have real usage data.
+const CONCURRENCY = 3;
+// In-memory registry of tasks currently executing. Not persisted across
+// restarts — on reboot, any in-flight async work is silently dropped.
+// We expose listInProgress() so the chat preamble can show "in progress"
+// hints to the main Claude.
+const inProgress = new Map();
+const queue = fastq.promise(async (task) => {
+    inProgress.set(task.id, task);
+    try {
+        await runTask(task);
+    }
+    catch (err) {
+        logger.error({ err, id: task.id, jid: task.jid }, 'async task failed unexpectedly');
+    }
+    finally {
+        inProgress.delete(task.id);
+    }
+}, CONCURRENCY);
+export function enqueueAsyncTask(input) {
+    const task = {
+        ...input,
+        id: `async-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        startedAt: Math.floor(Date.now() / 1000),
+    };
+    logger.info({
+        id: task.id,
+        jid: task.jid,
+        description: task.description.slice(0, 200),
+    }, 'async task enqueued');
+    queue.push(task).catch((err) => logger.error({ err, id: task.id }, 'async queue push failed'));
+    return task;
+}
+export function listAsyncTasks(jid) {
+    const all = Array.from(inProgress.values());
+    if (!jid)
+        return all;
+    return all.filter((t) => t.jid === jid);
+}
+// ---------- task runner ----------
+let cachedSystemPrompt = null;
+function systemPrompt() {
+    if (cachedSystemPrompt !== null)
+        return cachedSystemPrompt;
+    const personality = readFileSync(resolve(process.cwd(), config.claude.personalityFile), 'utf-8');
+    let memoryInstructions = '';
+    try {
+        memoryInstructions = readFileSync(resolve(process.cwd(), config.memory.instructionsFile), 'utf-8');
+    }
+    catch {
+        // optional
+    }
+    cachedSystemPrompt = memoryInstructions
+        ? `${personality}\n\n---\n\n${memoryInstructions}`
+        : personality;
+    return cachedSystemPrompt;
+}
+export function reloadAsyncSystemPrompt() {
+    cachedSystemPrompt = null;
+}
+function buildPrompt(task) {
+    const lines = [
+        `You are running a BACKGROUND TASK for the owner. The chat already got your ack reply. Your only job now is to do the work and output the final message to send them.`,
+        ``,
+        `TASK:`,
+        task.description,
+        ``,
+        `ORIGINAL USER MESSAGE (for reference):`,
+        task.originatingMessage,
+        ``,
+        `Sender: ${task.senderName ?? task.senderNumber}`,
+        ``,
+        `RULES:`,
+        `- Stay fully in character (personality file). This is not customer service.`,
+        `- Do the real work. Use tools (browser, etc.) as needed.`,
+        `- When done, output ONLY the message to send the user. No preamble, no "here's what I found:" framing unless that's the message itself.`,
+        `- Do NOT emit any [DIGEST:...], [JOURNAL:...], [ASYNC:...], or other markers. This is the final output.`,
+        `- Start the message with a short reference to what you were working on so the user knows which task this is about (e.g. "About the TikTok scrape: ..."). They may have asked for multiple things.`,
+        `- If the task is impossible or the tools failed, say so honestly and briefly. Don't fabricate.`,
+        ``,
+        `Output the final user-facing message now.`,
+    ];
+    return lines.join('\n');
+}
+function buildArgs(task) {
+    const args = [
+        '-p',
+        '--output-format',
+        'json',
+        '--model',
+        config.claude.model,
+        '--permission-mode',
+        'acceptEdits',
+        '--append-system-prompt',
+        systemPrompt(),
+    ];
+    for (const dir of config.claude.addDirs) {
+        args.push('--add-dir', resolve(process.cwd(), dir));
+    }
+    args.push('--add-dir', resolve(process.cwd(), config.memory.dir));
+    args.push('--add-dir', resolve(process.cwd(), config.storage.mediaDir));
+    if (task.allowedTools &&
+        task.allowedTools !== 'all' &&
+        task.allowedTools.length > 0) {
+        args.push('--allowedTools', task.allowedTools.join(','));
+    }
+    return args;
+}
+async function spawnClaudeForTask(task, prompt) {
+    const args = buildArgs(task);
+    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: 'async-task',
+            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(`async task 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('async task bad output'));
+                }
+                const output = parsed.result.trim();
+                void logPrompt({
+                    ts: Math.floor(startedAt / 1000),
+                    caller: 'async-task',
+                    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();
+    });
+}
+async function runTask(task) {
+    const prompt = buildPrompt(task);
+    const elapsedLog = () => `${Math.round((Date.now() - task.startedAt * 1000) / 1000)}s`;
+    let output;
+    try {
+        output = await spawnClaudeForTask(task, prompt);
+    }
+    catch (err) {
+        logger.error({ err, id: task.id, jid: task.jid, elapsed: elapsedLog() }, 'async task claude call failed');
+        await initiate({
+            jid: task.jid,
+            text: `Heads up: the background task "${truncate(task.description, 80)}" failed. Ask me again and I'll retry.`,
+        });
+        return;
+    }
+    // Strip any accidental trailing markers Claude emitted despite instructions.
+    // Import lazily to avoid an import cycle (digest-flag already stands alone,
+    // but being explicit here keeps this module independent).
+    const { extractFlags } = await import('../memory/digest-flag.js');
+    const { clean } = extractFlags(output);
+    if (!clean.trim()) {
+        logger.warn({ id: task.id, jid: task.jid }, 'async task produced empty output after flag strip');
+        return;
+    }
+    const sent = await initiate({ jid: task.jid, text: clean });
+    logger.info({
+        id: task.id,
+        jid: task.jid,
+        sent,
+        elapsed: elapsedLog(),
+        chars: clean.length,
+    }, 'async task completed');
+}
+function truncate(s, n) {
+    return s.length > n ? s.slice(0, n - 1) + '…' : s;
+}