alvin-bot 4.10.0 → 4.12.0

package/dist/platforms/slack.js

@@ -36,6 +36,8 @@ export class SlackAdapter {
     botUserId = "";
     botToken;
     appToken;
+    /** v4.12.0 — channelId → channelName cache, refreshed on miss via conversations.info */
+    channelNameCache = new Map();
     constructor(botToken, appToken) {
         this.botToken = botToken;
         this.appToken = appToken;
@@ -221,8 +223,9 @@ export class SlackAdapter {
         const chunks = text.length > 3800
             ? text.match(/.{1,3800}/gs) || [text]
             : [text];
+        let lastTs;
         for (const chunk of chunks) {
-            await this.app.client.chat.postMessage({
+            const result = await this.app.client.chat.postMessage({
                 token: this.botToken,
                 channel: chatId,
                 text: chunk,
@@ -231,7 +234,30 @@ export class SlackAdapter {
                 // Convert markdown bold/italic to Slack mrkdwn
                 mrkdwn: true,
             });
+            if (result?.ts)
+                lastTs = result.ts;
         }
+        return lastTs;
+    }
+    /** Edit a previously-sent message (for progress tickers on long queries).
+     *  Fail-silent: ticker UX shouldn't crash the query. */
+    async editMessage(chatId, messageId, newText) {
+        if (!this.app)
+            return messageId;
+        try {
+            const safeText = newText.length > 3800 ? newText.slice(0, 3800) + "..." : newText;
+            await this.app.client.chat.update({
+                token: this.botToken,
+                channel: chatId,
+                ts: messageId,
+                text: safeText,
+                mrkdwn: true,
+            });
+        }
+        catch {
+            // Silent failure — ticker UX shouldn't crash the query
+        }
+        return messageId;
     }
     async sendPhoto(chatId, photo, caption) {
         if (!this.app)
@@ -299,8 +325,46 @@ export class SlackAdapter {
         catch { /* ignore — emoji might not exist */ }
     }
     async setTyping(chatId) {
-        // Slack doesn't have a public typing indicator API for bots
-        // The closest is the "is typing" shown during Web API calls
+        if (!this.app)
+            return;
+        // v4.12.0 — Slack's official "is thinking" API for bots is
+        // assistant.threads.setStatus which shows "Alvin is thinking…" under
+        // the message. Only works in assistant-enabled channels (scope:
+        // assistant:write) — silently no-ops in channels where the bot
+        // isn't enabled as an assistant.
+        try {
+            await this.app.client.apiCall("assistant.threads.setStatus", {
+                channel_id: chatId,
+                status: "is thinking…",
+            });
+        }
+        catch {
+            // Not every channel supports assistant threads — that's fine
+        }
+    }
+    /** v4.12.0 — Look up a Slack channel's name by ID, using a small in-memory
+     *  cache. Used by platform-message.ts for workspace resolution. */
+    async getChannelName(channelId) {
+        if (!this.app)
+            return undefined;
+        const cached = this.channelNameCache.get(channelId);
+        if (cached)
+            return cached;
+        try {
+            const result = await this.app.client.conversations.info({
+                token: this.botToken,
+                channel: channelId,
+            });
+            const name = result?.channel?.name;
+            if (name) {
+                this.channelNameCache.set(channelId, name);
+                return name;
+            }
+        }
+        catch {
+            // IM channels return channel_not_found here — that's expected
+        }
+        return undefined;
     }
     async stop() {
         if (this.app) {

package/dist/services/compaction.js

@@ -65,6 +65,19 @@ export async function compactSession(session) {
     catch (err) {
         console.error("Compaction: failed to flush to memory:", err);
     }
+    // v4.11.0 P1 #5 — Auto-extract structured facts from the archived chunk
+    // and persist them to MEMORY.md. Experimental feature, opt-out via
+    // MEMORY_EXTRACTION_DISABLED=1. Safe wrapper — never throws.
+    try {
+        const { extractAndStoreFacts } = await import("./memory-extractor.js");
+        const result = await extractAndStoreFacts(summaryInput);
+        if (result.factsStored > 0) {
+            console.log(`🧠 memory-extractor: stored ${result.factsStored} new fact(s) in MEMORY.md`);
+        }
+    }
+    catch (err) {
+        console.warn("memory-extractor failed (non-fatal):", err instanceof Error ? err.message : err);
+    }
     // Try AI-powered summary
     let summaryText = null;
     try {

package/dist/services/memory-extractor.js

@@ -0,0 +1,178 @@
+/**
+ * Memory Extractor (v4.11.0, experimental)
+ *
+ * When the compaction service archives old conversation chunks, it normally
+ * dumps prose into the daily log. This extractor adds a structured pass that
+ * pulls user_facts, preferences, and decisions out of the chunk and appends
+ * them to MEMORY.md (de-duplicated by exact-string match).
+ *
+ * Pattern inspired by Mem0's auto-extraction. Designed to be safe:
+ *   - Opt-out via MEMORY_EXTRACTION_DISABLED=1
+ *   - Uses the active provider with effort=low
+ *   - Failures are swallowed; compaction continues regardless
+ *   - Dedup is exact-string only (no embedding-based semantic dedup yet)
+ */
+import fs from "fs";
+import { dirname } from "path";
+import { MEMORY_FILE } from "../paths.js";
+const EMPTY_FACTS = {
+    user_facts: [],
+    preferences: [],
+    decisions: [],
+};
+const EXTRACTION_PROMPT = `Extract structured facts from this conversation chunk. Return ONLY a JSON object with these keys:
+
+{
+  "user_facts": ["concrete facts about the user that should persist forever"],
+  "preferences": ["communication style or workflow preferences the user expressed"],
+  "decisions": ["explicit decisions made (e.g., 'use X instead of Y')"]
+}
+
+Rules:
+- Each entry must be ONE short, declarative sentence (max 100 chars).
+- Skip transient conversation details (questions, todos, ephemeral state).
+- Skip facts that are obvious from context (e.g., "user asked a question").
+- Empty arrays are fine — don't invent facts.
+- Output ONLY the JSON, no commentary.
+
+Conversation chunk:
+`;
+/**
+ * Parse the JSON output from the AI extractor. Tolerates markdown code-fence
+ * wrapping and surrounding prose. Returns empty arrays on any parse failure.
+ */
+export function parseExtractedFacts(text) {
+    if (!text || typeof text !== "string")
+        return { ...EMPTY_FACTS };
+    // Strip markdown code fences if present
+    let cleaned = text.trim();
+    const fenceMatch = cleaned.match(/^```(?:json)?\s*\n?([\s\S]*?)\n?```\s*$/);
+    if (fenceMatch)
+        cleaned = fenceMatch[1].trim();
+    // Try to find the first { ... } block if there's surrounding prose
+    const braceMatch = cleaned.match(/\{[\s\S]*\}/);
+    if (braceMatch)
+        cleaned = braceMatch[0];
+    try {
+        const parsed = JSON.parse(cleaned);
+        return {
+            user_facts: Array.isArray(parsed.user_facts)
+                ? parsed.user_facts.filter((s) => typeof s === "string")
+                : [],
+            preferences: Array.isArray(parsed.preferences)
+                ? parsed.preferences.filter((s) => typeof s === "string")
+                : [],
+            decisions: Array.isArray(parsed.decisions)
+                ? parsed.decisions.filter((s) => typeof s === "string")
+                : [],
+        };
+    }
+    catch {
+        return { ...EMPTY_FACTS };
+    }
+}
+/**
+ * Append extracted facts to MEMORY.md under structured headers, deduplicated
+ * by exact-string match against existing content.
+ */
+export async function appendFactsToMemoryFile(facts) {
+    const total = facts.user_facts.length + facts.preferences.length + facts.decisions.length;
+    if (total === 0)
+        return 0;
+    // Read existing content for dedup
+    let existing = "";
+    try {
+        existing = fs.readFileSync(MEMORY_FILE, "utf-8");
+    }
+    catch {
+        // File doesn't exist yet — that's fine, mkdir parent
+        fs.mkdirSync(dirname(MEMORY_FILE), { recursive: true });
+    }
+    const isDuplicate = (line) => existing.includes(line);
+    const newLines = [];
+    const todayIso = new Date().toISOString().slice(0, 10);
+    const sectionHeader = `\n\n## Auto-extracted (${todayIso})\n`;
+    let stored = 0;
+    if (facts.user_facts.length > 0) {
+        const newOnes = facts.user_facts.filter(f => !isDuplicate(f));
+        if (newOnes.length > 0) {
+            newLines.push("\n### User Facts");
+            for (const f of newOnes) {
+                newLines.push(`- ${f}`);
+                stored++;
+            }
+        }
+    }
+    if (facts.preferences.length > 0) {
+        const newOnes = facts.preferences.filter(p => !isDuplicate(p));
+        if (newOnes.length > 0) {
+            newLines.push("\n### Preferences");
+            for (const p of newOnes) {
+                newLines.push(`- ${p}`);
+                stored++;
+            }
+        }
+    }
+    if (facts.decisions.length > 0) {
+        const newOnes = facts.decisions.filter(d => !isDuplicate(d));
+        if (newOnes.length > 0) {
+            newLines.push("\n### Decisions");
+            for (const d of newOnes) {
+                newLines.push(`- ${d}`);
+                stored++;
+            }
+        }
+    }
+    if (stored > 0) {
+        const block = sectionHeader + newLines.join("\n") + "\n";
+        fs.appendFileSync(MEMORY_FILE, block, "utf-8");
+    }
+    return stored;
+}
+/**
+ * Extract facts from a conversation chunk and store them in MEMORY.md.
+ * Safe wrapper — never throws, always returns an ExtractionResult.
+ */
+export async function extractAndStoreFacts(conversationText) {
+    if (process.env.MEMORY_EXTRACTION_DISABLED === "1") {
+        return { disabled: true, factsStored: 0 };
+    }
+    if (!conversationText || conversationText.trim().length < 50) {
+        return { disabled: false, factsStored: 0 };
+    }
+    let extractedText = "";
+    try {
+        // Lazy-import the registry so test environments without an engine init
+        // don't crash on module load.
+        const { getRegistry } = await import("../engine.js");
+        const registry = getRegistry();
+        const opts = {
+            prompt: EXTRACTION_PROMPT + conversationText.slice(0, 8000),
+            systemPrompt: "You are a fact extractor. Output only valid JSON, no commentary.",
+            effort: "low",
+        };
+        for await (const chunk of registry.queryWithFallback(opts)) {
+            if (chunk.type === "text" && chunk.text) {
+                extractedText = chunk.text;
+            }
+            if (chunk.type === "error") {
+                // Provider failed — silent fallback
+                return { disabled: false, factsStored: 0 };
+            }
+        }
+    }
+    catch {
+        return { disabled: false, factsStored: 0 };
+    }
+    if (!extractedText)
+        return { disabled: false, factsStored: 0 };
+    const facts = parseExtractedFacts(extractedText);
+    let stored = 0;
+    try {
+        stored = await appendFactsToMemoryFile(facts);
+    }
+    catch {
+        // appendFactsToMemoryFile failed — non-fatal
+    }
+    return { disabled: false, factsStored: stored };
+}

package/dist/services/memory-layers.js

@@ -0,0 +1,147 @@
+/**
+ * Memory Layers Service (v4.11.0)
+ *
+ * Layered memory loader inspired by mempalace's L0–L3 stack:
+ *
+ *   L0 identity.md       always loaded, ~200 tokens (core user facts)
+ *   L1 preferences.md    always loaded (communication style)
+ *   L1 MEMORY.md         backwards-compat: monolithic curated knowledge
+ *   L2 projects/*.md     loaded on topic match against the user's query
+ *   L3 daily logs        only via vector search (handled by embeddings.ts)
+ *
+ * If neither identity.md nor preferences.md exists, this loader still works
+ * via the monolithic MEMORY.md fallback, so existing setups need no migration.
+ *
+ * Token budget: capped at ~5000 chars for L0+L1, +~3000 chars for matched L2.
+ */
+import fs from "fs";
+import path from "path";
+import { IDENTITY_FILE, PREFERENCES_FILE, PROJECTS_MEMORY_DIR, MEMORY_FILE, } from "../paths.js";
+const MAX_L0_L1_CHARS = 5000;
+const MAX_L2_PROJECT_CHARS = 1500;
+const MAX_L2_TOTAL_CHARS = 3000;
+function readSafe(file) {
+    try {
+        return fs.readFileSync(file, "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Load all memory layers from disk. Cheap — no API calls, just file reads.
+ */
+export function loadMemoryLayers() {
+    const identity = readSafe(IDENTITY_FILE);
+    const preferences = readSafe(PREFERENCES_FILE);
+    const longTerm = readSafe(MEMORY_FILE);
+    const projects = [];
+    try {
+        if (fs.existsSync(PROJECTS_MEMORY_DIR)) {
+            const entries = fs.readdirSync(PROJECTS_MEMORY_DIR);
+            for (const entry of entries) {
+                if (!entry.endsWith(".md") || entry.startsWith("."))
+                    continue;
+                const fullPath = path.resolve(PROJECTS_MEMORY_DIR, entry);
+                const content = readSafe(fullPath);
+                if (content.trim()) {
+                    projects.push({
+                        topic: entry.replace(/\.md$/, ""),
+                        content,
+                    });
+                }
+            }
+        }
+    }
+    catch {
+        // projects dir missing or unreadable — fine
+    }
+    return { identity, preferences, longTerm, projects };
+}
+/**
+ * Match L2 projects against the user query.
+ * Topic match is naive substring (case-insensitive) on filename + first 200 chars
+ * of the project content. For v4.11.0 this is intentionally simple — vector
+ * search via embeddings.ts handles the deep cases.
+ */
+function matchProjectsToQuery(projects, query) {
+    if (!query)
+        return [];
+    const q = query.toLowerCase();
+    const matched = [];
+    for (const p of projects) {
+        const topicLower = p.topic.toLowerCase();
+        if (q.includes(topicLower)) {
+            matched.push(p);
+            continue;
+        }
+        // Also check the first 200 chars of project content — this catches cases
+        // where the user mentions a project's headline term that isn't the
+        // filename (e.g., "VPS" matching alev-b.md which mentions "VPS:" upfront).
+        const head = p.content.slice(0, 200).toLowerCase();
+        const headWords = head.split(/[\s\W]+/).filter(w => w.length >= 4);
+        if (headWords.some(w => q.includes(w))) {
+            matched.push(p);
+        }
+    }
+    return matched;
+}
+/**
+ * Build a token-budgeted layered context string suitable for system prompt injection.
+ *
+ * @param query Optional user query. If provided, L2 projects matching the query
+ *              get included. If omitted, only L0+L1 are loaded (boot-up brief).
+ */
+export function buildLayeredContext(query) {
+    const layers = loadMemoryLayers();
+    const parts = [];
+    let l0l1Chars = 0;
+    if (layers.identity) {
+        const truncated = layers.identity.length > MAX_L0_L1_CHARS
+            ? layers.identity.slice(0, MAX_L0_L1_CHARS) + "\n[...truncated]"
+            : layers.identity;
+        parts.push("## Identity (L0)\n" + truncated);
+        l0l1Chars += truncated.length;
+    }
+    if (layers.preferences && l0l1Chars < MAX_L0_L1_CHARS) {
+        const remaining = MAX_L0_L1_CHARS - l0l1Chars;
+        const truncated = layers.preferences.length > remaining
+            ? layers.preferences.slice(0, remaining) + "\n[...truncated]"
+            : layers.preferences;
+        parts.push("## Preferences (L1)\n" + truncated);
+        l0l1Chars += truncated.length;
+    }
+    // Backwards-compat: if no identity AND no preferences, use the monolithic
+    // MEMORY.md as L1 fully (existing user setups). If split files exist,
+    // include MEMORY.md as a secondary L1 with tighter truncation.
+    if (!layers.identity && !layers.preferences && layers.longTerm) {
+        const truncated = layers.longTerm.length > MAX_L0_L1_CHARS
+            ? layers.longTerm.slice(0, MAX_L0_L1_CHARS) + "\n[...truncated]"
+            : layers.longTerm;
+        parts.push("## Long-term Memory (L1, monolithic)\n" + truncated);
+    }
+    else if (layers.longTerm) {
+        const SECONDARY_CAP = 1500;
+        const truncated = layers.longTerm.length > SECONDARY_CAP
+            ? layers.longTerm.slice(0, SECONDARY_CAP) + "\n[...truncated]"
+            : layers.longTerm;
+        parts.push("## Long-term Memory (L1, legacy MEMORY.md)\n" + truncated);
+    }
+    // L2: project-specific, only when a query is provided
+    if (query && layers.projects.length > 0) {
+        const matched = matchProjectsToQuery(layers.projects, query);
+        let l2TotalChars = 0;
+        for (const p of matched) {
+            if (l2TotalChars >= MAX_L2_TOTAL_CHARS)
+                break;
+            const remaining = MAX_L2_TOTAL_CHARS - l2TotalChars;
+            const cap = Math.min(MAX_L2_PROJECT_CHARS, remaining);
+            const content = p.content.length > cap
+                ? p.content.slice(0, cap) + "\n[...truncated]"
+                : p.content;
+            parts.push(`## Project: ${p.topic} (L2)\n${content}`);
+            l2TotalChars += content.length;
+        }
+    }
+    return parts.join("\n\n");
+}

package/dist/services/memory.js

@@ -11,6 +11,7 @@ import fs from "fs";
 import { resolve } from "path";
 import { MEMORY_DIR, MEMORY_FILE } from "../paths.js";
 import { reindexMemory } from "./embeddings.js";
+import { buildLayeredContext } from "./memory-layers.js";
 // Ensure dirs exist
 if (!fs.existsSync(MEMORY_DIR))
     fs.mkdirSync(MEMORY_DIR, { recursive: true });
@@ -65,16 +66,22 @@ export function appendDailyLog(entry) {
     reindexMemory().catch(() => { });
 }
 /**
- * Build memory context for injection into non-SDK prompts.
- * Returns relevant memory as a compact string.
+ * Build memory context for injection into prompts.
+ *
+ * v4.11.0 — Now uses the layered memory loader (memory-layers.ts) which
+ * combines L0 (identity.md), L1 (preferences.md + legacy MEMORY.md), and
+ * optional L2 (projects/*.md matched against the query). Falls back to the
+ * monolithic MEMORY.md alone if the split files don't exist.
+ *
+ * @param query Optional user query — when provided, L2 projects matching
+ *              the query get included. When omitted, only L0+L1 are loaded.
  */
-export function buildMemoryContext() {
+export function buildMemoryContext(query) {
     const parts = [];
-    // Long-term memory (truncate if too long)
-    const ltm = loadLongTermMemory();
-    if (ltm) {
-        const truncated = ltm.length > 2000 ? ltm.slice(0, 2000) + "\n[...truncated]" : ltm;
-        parts.push(`## Long-term Memory\n${truncated}`);
+    // L0+L1 (+ matched L2 if query) via layered loader
+    const layered = buildLayeredContext(query);
+    if (layered) {
+        parts.push(layered);
     }
     // Today's log
     const todayLog = loadDailyLog();

package/dist/services/personality.js

@@ -186,7 +186,7 @@ Always ask yourself first: "Can I solve this with my own intelligence?" If yes
  * @param isSDK Whether the active provider is the Claude SDK (has tool use)
  * @param language Preferred language ('de' or 'en')
  */
-export function buildSystemPrompt(isSDK, language = "en", chatId) {
+export function buildSystemPrompt(isSDK, language = "en", chatId, query, workspacePersona) {
     // The deep base prompt has only de/en variants (writing four full
     // personality templates is out of scope). For es/fr we fall back to
     // the English base — the LLM mirrors the user's conversational language
@@ -214,6 +214,12 @@ export function buildSystemPrompt(isSDK, language = "en", chatId) {
     if (standingOrders) {
         parts.push("## Standing Orders\n\n" + standingOrders);
     }
+    // v4.12.0 — Workspace persona: per-channel system prompt override from
+    // ~/.alvin-bot/workspaces/<name>.md body. Only injected when a workspace
+    // is resolved for the channel; default workspace passes empty string.
+    if (workspacePersona && workspacePersona.trim().length > 0) {
+        parts.push("## Workspace Persona\n\n" + workspacePersona.trim());
+    }
     if (isSDK) {
         parts.push(SDK_ADDON);
         // Stage 1 — teach Claude to use run_in_background for long-running
@@ -226,31 +232,59 @@ export function buildSystemPrompt(isSDK, language = "en", chatId) {
     if (chatId) {
         parts.push(`Current chat: Platform=telegram, ChatID=${chatId}. Use this ChatID when creating cron jobs that should send results to this chat.`);
     }
-    // Non-SDK providers get memory injected into system prompt
-    // (SDK provider reads memory files directly via tools)
-    if (!isSDK) {
-        const memoryCtx = buildMemoryContext();
-        if (memoryCtx) {
-            parts.push(memoryCtx);
-        }
+    // Memory context: ALL providers (SDK + non-SDK) get long-term memory
+    // injected (v4.11.0 P0 #2). Before v4.11.0 this was non-SDK only; the SDK
+    // was expected to read memory via tools but in practice rarely did, leading
+    // to "frickelig" UX after session restarts. The injected MEMORY.md gives
+    // Claude immediate context without spending a tool-call round-trip on Read.
+    //
+    // The optional `query` argument enables L2 project loading (v4.11.0 P1 #4):
+    // memory-layers.ts matches the user's question against project filenames
+    // in ~/.alvin-bot/memory/projects/ and only loads matching ones — keeping
+    // the system prompt small while still surfacing relevant per-project facts.
+    // See docs/superpowers/plans/2026-04-13-memory-persistence.md
+    const memoryCtx = buildMemoryContext(query);
+    if (memoryCtx) {
+        parts.push(memoryCtx);
     }
-    // Non-SDK: inject compact asset awareness
-    if (!isSDK) {
-        const assetMd = getAssetIndexMd();
-        if (assetMd) {
-            parts.push(assetMd);
-        }
+    // Asset awareness: also extended to SDK in v4.11.0 — same rationale as
+    // memory above. Cheap injection beats hoping Claude uses Glob/Read on
+    // ~/.alvin-bot/assets/ proactively.
+    const assetMd = getAssetIndexMd();
+    if (assetMd) {
+        parts.push(assetMd);
     }
     return parts.join("\n\n");
 }
 /**
  * Build a system prompt enhanced with semantically relevant memories.
  * Searches the vector index for context related to the user's message.
+ *
+ * @param isSDK         true → Claude SDK provider (has tool use)
+ * @param language      preferred UI language
+ * @param userMessage   the user's incoming message (used as the search query)
+ * @param chatId        Telegram chat id (for cron job context)
+ * @param isFirstTurn   v4.11.0 P0 #3 — whether this is the very first turn of
+ *                      a (rehydrated or fresh) session. SDK only runs the
+ *                      semantic search on first-turn to avoid spamming the
+ *                      embeddings API on every subsequent turn — once the
+ *                      session has resumed, Claude already has the recalled
+ *                      context in its conversation history. Non-SDK providers
+ *                      run the search on every turn (cheap, no resume).
  */
-export async function buildSmartSystemPrompt(isSDK, language = "en", userMessage, chatId) {
-    const base = buildSystemPrompt(isSDK, language, chatId);
-    // SDK providers read memory directly via tools — skip
-    if (isSDK || !userMessage)
+export async function buildSmartSystemPrompt(isSDK, language = "en", userMessage, chatId, isFirstTurn = false, workspacePersona) {
+    // Pass userMessage as query so L2 project memories matching the topic
+    // get loaded into the base prompt automatically. Workspace persona (v4.12.0)
+    // is also threaded through so per-channel personas land in the system prompt.
+    const base = buildSystemPrompt(isSDK, language, chatId, userMessage, workspacePersona);
+    if (!userMessage)
+        return base;
+    // Decide whether to run the semantic search:
+    //   non-SDK → always (cheap, no session resume to lean on)
+    //   SDK     → only on the first turn of a session (Claude carries context
+    //             across turns within the same session via SDK resume)
+    const shouldSearch = !isSDK || isFirstTurn;
+    if (!shouldSearch)
         return base;
     // Search for relevant memories
     try {