wyrm-mcp 7.3.2 → 7.3.3

package/dist/vectors.js

@@ -1,4 +1,34 @@
-import{createProvider as u,NoneProvider as l}from"./providers/embedding-provider.js";class _{provider;db;constructor(e,t){this.provider=e,this.db=t||null,this.db&&this.ensureTable()}ensureTable(){this.db&&this.db.exec(`
+/**
+ * Wyrm Vector Embeddings — Semantic Search Support
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ *
+ * Features:
+ * - Provider-agnostic embeddings (local, OpenAI, Ollama)
+ * - SQLite-backed vector storage (no external DB needed)
+ * - Cosine similarity search with content-hash deduplication
+ * - Graceful degradation when no provider is configured
+ */
+import { createProvider, NoneProvider, } from './providers/embedding-provider.js';
+/**
+ * SQLite-backed vector store with pluggable embedding providers.
+ */
+export class VectorStore {
+    provider;
+    db;
+    constructor(provider, db) {
+        this.provider = provider;
+        this.db = db || null;
+        if (this.db) {
+            this.ensureTable();
+        }
+    }
+    /** Create the vectors table if it doesn't exist */
+    ensureTable() {
+        if (!this.db)
+            return;
+        this.db.exec(`
       CREATE TABLE IF NOT EXISTS vectors (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         project_id INTEGER,
@@ -14,11 +44,162 @@ import{createProvider as u,NoneProvider as l}from"./providers/embedding-provider
       CREATE INDEX IF NOT EXISTS idx_vectors_project ON vectors(project_id);
       CREATE INDEX IF NOT EXISTS idx_vectors_content ON vectors(content_type, content_id);
       CREATE INDEX IF NOT EXISTS idx_vectors_hash ON vectors(content_hash);
-    `)}hashContent(e){let t=0;for(let n=0;n<e.length;n++){const o=e.charCodeAt(n);t=(t<<5)-t+o,t=t&t}return Math.abs(t).toString(16)}async addVector(e,t,n,o){if(this.provider instanceof l)return null;const i=this.hashContent(e);if(this.db&&this.db.prepare("SELECT id FROM vectors WHERE content_type = ? AND content_id = ? AND model = ? AND content_hash = ?").get(t,n,this.provider.model,i))return i;let r;try{r=await this.provider.embed(e)}catch{return null}return r.length===0?null:(this.db&&this.db.prepare(`
+    `);
+    }
+    /**
+     * Hash content for deduplication — same hash means same content, skip re-embedding.
+     */
+    hashContent(content) {
+        let hash = 0;
+        for (let i = 0; i < content.length; i++) {
+            const char = content.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash;
+        }
+        return Math.abs(hash).toString(16);
+    }
+    /**
+     * Add or update a vector entry.
+     * Returns the content hash, or null if the provider is disabled.
+     */
+    async addVector(content, contentType, contentId, projectId) {
+        if (this.provider instanceof NoneProvider)
+            return null;
+        const contentHash = this.hashContent(content);
+        // Skip if content unchanged (same hash + same model already stored)
+        if (this.db) {
+            const existing = this.db.prepare('SELECT id FROM vectors WHERE content_type = ? AND content_id = ? AND model = ? AND content_hash = ?').get(contentType, contentId, this.provider.model, contentHash);
+            if (existing)
+                return contentHash;
+        }
+        let embedding;
+        try {
+            embedding = await this.provider.embed(content);
+        }
+        catch {
+            return null;
+        }
+        if (embedding.length === 0)
+            return null;
+        if (this.db) {
+            // Upsert: replace if same content_type + content_id + model
+            this.db.prepare(`
         INSERT INTO vectors (project_id, content_type, content_id, content_hash, embedding, model, dimensions)
         VALUES (?, ?, ?, ?, ?, ?, ?)
         ON CONFLICT(content_type, content_id, model) DO UPDATE SET
           content_hash = excluded.content_hash,
           embedding = excluded.embedding,
           created_at = datetime('now')
-      `).run(o,t,n,i,Buffer.from(r.buffer),this.provider.model,this.provider.dimensions),i)}cosineSimilarity(e,t){if(e.length!==t.length)return 0;let n=0,o=0,i=0;for(let s=0;s<e.length;s++)n+=e[s]*t[s],o+=e[s]*e[s],i+=t[s]*t[s];const r=Math.sqrt(o)*Math.sqrt(i);return r>0?n/r:0}async search(e,t=10,n,o){if(this.provider instanceof l||!this.db)return[];let i;try{i=await this.provider.embed(e)}catch{return[]}if(i.length===0)return[];let r="SELECT * FROM vectors WHERE model = ?";const s=[this.provider.model];n!==void 0&&(r+=" AND project_id = ?",s.push(n)),o&&o.length>0&&(r+=` AND content_type IN (${o.map(()=>"?").join(",")})`,s.push(...o));const E=this.db.prepare(r).all(...s),c=[];for(const d of E){const h=new Float32Array(d.embedding.buffer,d.embedding.byteOffset,d.dimensions),p=this.cosineSimilarity(i,h);c.push({content_type:d.content_type,content_id:d.content_id,project_id:d.project_id,similarity:p,content_hash:d.content_hash})}return c.sort((d,h)=>h.similarity-d.similarity),c.slice(0,t)}removeVector(e){return this.db?this.db.prepare("DELETE FROM vectors WHERE content_hash = ?").run(e).changes>0:!1}clearProjectVectors(e){return this.db?this.db.prepare("DELETE FROM vectors WHERE project_id = ?").run(e).changes:0}getStats(){const e={},t={};let n=0;if(this.db){const o=this.db.prepare("SELECT content_type, COUNT(*) as cnt FROM vectors GROUP BY content_type").all();for(const r of o)e[r.content_type]=r.cnt,n+=r.cnt;const i=this.db.prepare("SELECT project_id, COUNT(*) as cnt FROM vectors GROUP BY project_id").all();for(const r of i)t[r.project_id]=r.cnt}return{total:n,byType:e,byProject:t,provider:this.provider.name,model:this.provider.model}}getProvider(){return this.provider}}function m(a,e){const t=u(a);return new _(t,e)}export{_ as VectorStore,m as createVectorStore};
+      `).run(projectId, contentType, contentId, contentHash, Buffer.from(embedding.buffer), this.provider.model, this.provider.dimensions);
+        }
+        return contentHash;
+    }
+    /**
+     * Cosine similarity between two vectors.
+     */
+    cosineSimilarity(a, b) {
+        if (a.length !== b.length)
+            return 0;
+        let dotProduct = 0;
+        let magnitudeA = 0;
+        let magnitudeB = 0;
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            magnitudeA += a[i] * a[i];
+            magnitudeB += b[i] * b[i];
+        }
+        const magnitude = Math.sqrt(magnitudeA) * Math.sqrt(magnitudeB);
+        return magnitude > 0 ? dotProduct / magnitude : 0;
+    }
+    /**
+     * Search for similar content by embedding the query and comparing.
+     */
+    async search(query, limit = 10, projectId, contentTypes) {
+        if (this.provider instanceof NoneProvider || !this.db)
+            return [];
+        let queryEmbedding;
+        try {
+            queryEmbedding = await this.provider.embed(query);
+        }
+        catch {
+            return [];
+        }
+        if (queryEmbedding.length === 0)
+            return [];
+        // Load all matching vectors from SQLite
+        let sql = 'SELECT * FROM vectors WHERE model = ?';
+        const params = [this.provider.model];
+        if (projectId !== undefined) {
+            sql += ' AND project_id = ?';
+            params.push(projectId);
+        }
+        if (contentTypes && contentTypes.length > 0) {
+            sql += ` AND content_type IN (${contentTypes.map(() => '?').join(',')})`;
+            params.push(...contentTypes);
+        }
+        const rows = this.db.prepare(sql).all(...params);
+        const results = [];
+        for (const row of rows) {
+            const storedEmbedding = new Float32Array(row.embedding.buffer, row.embedding.byteOffset, row.dimensions);
+            const similarity = this.cosineSimilarity(queryEmbedding, storedEmbedding);
+            results.push({
+                content_type: row.content_type,
+                content_id: row.content_id,
+                project_id: row.project_id,
+                similarity,
+                content_hash: row.content_hash,
+            });
+        }
+        results.sort((a, b) => b.similarity - a.similarity);
+        return results.slice(0, limit);
+    }
+    /**
+     * Remove vector by content hash.
+     */
+    removeVector(contentHash) {
+        if (!this.db)
+            return false;
+        const result = this.db.prepare('DELETE FROM vectors WHERE content_hash = ?').run(contentHash);
+        return result.changes > 0;
+    }
+    /**
+     * Clear all vectors for a project.
+     */
+    clearProjectVectors(projectId) {
+        if (!this.db)
+            return 0;
+        const result = this.db.prepare('DELETE FROM vectors WHERE project_id = ?').run(projectId);
+        return result.changes;
+    }
+    /**
+     * Get stats about the vector store.
+     */
+    getStats() {
+        const byType = {};
+        const byProject = {};
+        let total = 0;
+        if (this.db) {
+            const typeRows = this.db.prepare('SELECT content_type, COUNT(*) as cnt FROM vectors GROUP BY content_type').all();
+            for (const r of typeRows) {
+                byType[r.content_type] = r.cnt;
+                total += r.cnt;
+            }
+            const projRows = this.db.prepare('SELECT project_id, COUNT(*) as cnt FROM vectors GROUP BY project_id').all();
+            for (const r of projRows) {
+                byProject[r.project_id] = r.cnt;
+            }
+        }
+        return { total, byType, byProject, provider: this.provider.name, model: this.provider.model };
+    }
+    /** Get the active embedding provider */
+    getProvider() { return this.provider; }
+}
+/**
+ * Create a vector store instance with config.
+ * Accepts an optional SQLite database for persistent storage.
+ */
+export function createVectorStore(config, db) {
+    const provider = createProvider(config);
+    return new VectorStore(provider, db);
+}
+//# sourceMappingURL=vectors.js.map

package/dist/version-check.js

@@ -1,16 +1,148 @@
-import{logger as h}from"./logger.js";const p="https://registry.npmjs.org/wyrm-mcp/latest",T=1440*60*1e3,_=1e4;function u(e){e.exec(`
+/**
+ * Version check — quietly polls the npm registry once per day to see if a
+ * newer wyrm-mcp is available, caches the result in the Wyrm database, and
+ * exposes it to both the MCP startup banner and the AI (via the
+ * `wyrm_check_update` tool).
+ *
+ * Design notes:
+ * - Cache TTL: 24 h. We don't want to ping registry every MCP server start
+ *   (which can be per-session-restart for some clients).
+ * - Cache lives in a single-row `update_check` table so it survives restarts.
+ * - Network errors are non-fatal — we just log debug and keep going.
+ * - `fetch` is the Node 22+ global; no extra deps.
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+import { logger } from './logger.js';
+const REGISTRY_URL = 'https://registry.npmjs.org/wyrm-mcp/latest';
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const FETCH_TIMEOUT_MS = 10_000; // generous for mobile / slow networks; startup is async anyway
+function ensureSchema(db) {
+    db.exec(`
     CREATE TABLE IF NOT EXISTS update_check (
       id INTEGER PRIMARY KEY CHECK (id = 1),
       checked_at TEXT NOT NULL,
       latest_version TEXT,
       check_succeeded INTEGER NOT NULL DEFAULT 0
     );
-  `)}function m(e){u(e);const t=e.prepare("SELECT checked_at, latest_version, check_succeeded FROM update_check WHERE id = 1").get();return t?{checkedAt:new Date(t.checked_at).getTime(),latest:t.latest_version,ok:t.check_succeeded===1}:null}function E(e,t,c){u(e),e.prepare(`
+  `);
+}
+function readCache(db) {
+    ensureSchema(db);
+    const row = db
+        .prepare('SELECT checked_at, latest_version, check_succeeded FROM update_check WHERE id = 1')
+        .get();
+    if (!row)
+        return null;
+    return {
+        checkedAt: new Date(row.checked_at).getTime(),
+        latest: row.latest_version,
+        ok: row.check_succeeded === 1,
+    };
+}
+function writeCache(db, latest, ok) {
+    ensureSchema(db);
+    db.prepare(`
     INSERT INTO update_check (id, checked_at, latest_version, check_succeeded)
     VALUES (1, ?, ?, ?)
     ON CONFLICT(id) DO UPDATE SET
       checked_at = excluded.checked_at,
       latest_version = excluded.latest_version,
       check_succeeded = excluded.check_succeeded
-  `).run(new Date().toISOString(),t,c?1:0)}function d(e,t){const c=l=>l.split(".").map(f=>parseInt(f,10)),[r,n,s]=c(e),[a,o,i]=c(t);return[r,n,s,a,o,i].some(l=>Number.isNaN(l))?0:r!==a?r<a?-1:1:n!==o?n<o?-1:1:s!==i?s<i?-1:1:0}async function k(){if(typeof fetch!="function")return null;const e=new AbortController,t=setTimeout(()=>e.abort(),_);try{const c=await fetch(p,{headers:{Accept:"application/json"},signal:e.signal});if(!c.ok)return null;const r=await c.json();return typeof r.version=="string"?r.version:null}catch{return null}finally{clearTimeout(t)}}async function S(e,t,c={}){if(u(e),!(c.force===!0)){const a=m(e);if(a&&Date.now()-a.checkedAt<T){const o=a.latest;return{current:t,latest:o,updateAvailable:o!=null&&d(t,o)<0,checkedAt:new Date(a.checkedAt).toISOString(),source:"cache"}}}const n=await k(),s=n!==null;return E(e,n,s),s||h.debug("version-check: registry fetch failed (offline or rate-limited)"),{current:t,latest:n,updateAvailable:n!=null&&d(t,n)<0,checkedAt:new Date().toISOString(),source:s?"live":"offline"}}async function w(e,t){try{const c=await S(e,t);c.updateAvailable&&process.stderr.write(`\u{F115D} wyrm-mcp ${c.latest} is available (you have ${t}). Run "wyrm update" from a shell, or "npm install -g wyrm-mcp@latest" manually.
-`)}catch{}}export{w as emitStartupVersionBanner,S as getUpdateStatus};
+  `).run(new Date().toISOString(), latest, ok ? 1 : 0);
+}
+/**
+ * Semver comparison — only handles the standard X.Y.Z (no prerelease tags).
+ * Returns: -1 if a<b, 0 if a==b, +1 if a>b. Anything unparseable returns 0.
+ */
+function semverCompare(a, b) {
+    const parse = (s) => s.split('.').map((p) => parseInt(p, 10));
+    const [a1, a2, a3] = parse(a);
+    const [b1, b2, b3] = parse(b);
+    if ([a1, a2, a3, b1, b2, b3].some((n) => Number.isNaN(n)))
+        return 0;
+    if (a1 !== b1)
+        return a1 < b1 ? -1 : 1;
+    if (a2 !== b2)
+        return a2 < b2 ? -1 : 1;
+    if (a3 !== b3)
+        return a3 < b3 ? -1 : 1;
+    return 0;
+}
+async function fetchLatestFromRegistry() {
+    if (typeof fetch !== 'function')
+        return null; // very old Node
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+        const res = await fetch(REGISTRY_URL, {
+            headers: { Accept: 'application/json' },
+            signal: controller.signal,
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return typeof data.version === 'string' ? data.version : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Returns the current update status. By default uses the cache when fresh.
+ * Pass `force: true` to bypass the cache (used by `wyrm_check_update`).
+ */
+export async function getUpdateStatus(db, current, opts = {}) {
+    ensureSchema(db);
+    const force = opts.force === true;
+    // Use cache if fresh and not forced.
+    if (!force) {
+        const cached = readCache(db);
+        if (cached && Date.now() - cached.checkedAt < CACHE_TTL_MS) {
+            const latest = cached.latest;
+            return {
+                current,
+                latest,
+                updateAvailable: latest != null && semverCompare(current, latest) < 0,
+                checkedAt: new Date(cached.checkedAt).toISOString(),
+                source: 'cache',
+            };
+        }
+    }
+    const latest = await fetchLatestFromRegistry();
+    const ok = latest !== null;
+    writeCache(db, latest, ok);
+    if (!ok) {
+        logger.debug('version-check: registry fetch failed (offline or rate-limited)');
+    }
+    return {
+        current,
+        latest,
+        updateAvailable: latest != null && semverCompare(current, latest) < 0,
+        checkedAt: new Date().toISOString(),
+        source: ok ? 'live' : 'offline',
+    };
+}
+/**
+ * Startup banner — log a single line to stderr if a newer version is out.
+ * Stderr (not stdout) so it never pollutes the MCP stdio protocol.
+ */
+export async function emitStartupVersionBanner(db, current) {
+    try {
+        const status = await getUpdateStatus(db, current);
+        if (status.updateAvailable) {
+            // T032 findings pass: T023 hard-exiled wyrm_self_update off MCP (its
+            // alias returns a WYRM_CLI_EXILE redirect, never updates) — the banner
+            // must name the real path, the `wyrm update` CLI replacement.
+            process.stderr.write(`󱅝 wyrm-mcp ${status.latest} is available (you have ${current}). Run "wyrm update" from a shell, or "npm install -g wyrm-mcp@latest" manually.\n`);
+        }
+    }
+    catch {
+        // Never crash startup on a version check.
+    }
+}
+//# sourceMappingURL=version-check.js.map

package/dist/visibility.js

@@ -1,29 +1,163 @@
-import{ICON as r}from"./icons.js";const m={today:{days:1,label:"today"},week:{days:7,label:"this week"},month:{days:30,label:"this month"},quarter:{days:90,label:"this quarter"},year:{days:365,label:"this year"},all:{days:36500,label:"all time"}};function W(a,i="week"){const o=Object.hasOwn(m,i)?m[i]:m.week,s=`datetime('now', '-${o.days} days')`,t=n=>{try{return a.prepare(n).get()?.n??0}catch{return 0}};return{period:o,toolCalls:t(`SELECT COUNT(*) AS n FROM tool_call_log WHERE called_at >= ${s}`),topTools:(()=>{try{return a.prepare(`
+/**
+ * Visibility tools (5.9.0).
+ *
+ * Wyrm's value tends to be invisible — users don't realise the AI is
+ * remembering things, blocking failed patterns, injecting truths, citing
+ * past sessions. This module surfaces what Wyrm is actually doing so the
+ * operator can see the work product, and AI helpers can attribute their
+ * answers to Wyrm sources rather than silently using them.
+ *
+ * Two tools:
+ *  - wyrm_intro:  plain-English explanation of what Wyrm is + can do.
+ *                 Aimed at humans new to Wyrm, not at AI agents.
+ *  - wyrm_digest: "what Wyrm did for you this period" — counts and
+ *                 highlights from the operator's actual usage data.
+ *
+ * @copyright 2026 Ghost Protocol (Pvt) Ltd.
+ * @license Proprietary — (c) 2026 Ghost Protocol (Pvt) Ltd. All rights reserved. See LICENSE.
+ */
+import { ICON } from './icons.js';
+export const DIGEST_PRESETS = {
+    today: { days: 1, label: 'today' },
+    week: { days: 7, label: 'this week' },
+    month: { days: 30, label: 'this month' },
+    quarter: { days: 90, label: 'this quarter' },
+    year: { days: 365, label: 'this year' },
+    all: { days: 36500, label: 'all time' },
+};
+export function gatherDigest(db, periodKey = 'week') {
+    // Use hasOwn() to defeat prototype-pollution probes (`__proto__`,
+    // `toString`, `constructor`, etc. would otherwise resolve to
+    // Object.prototype, bypass the `??` fallback, and produce `undefined`
+    // when we access `.days`.)
+    const period = Object.hasOwn(DIGEST_PRESETS, periodKey)
+        ? DIGEST_PRESETS[periodKey]
+        : DIGEST_PRESETS.week;
+    const since = `datetime('now', '-${period.days} days')`;
+    const num = (sql) => {
+        try {
+            const row = db.prepare(sql).get();
+            return row?.n ?? 0;
+        }
+        catch {
+            return 0;
+        }
+    };
+    return {
+        period,
+        toolCalls: num(`SELECT COUNT(*) AS n FROM tool_call_log WHERE called_at >= ${since}`),
+        topTools: (() => {
+            try {
+                const rows = db.prepare(`
           SELECT tool_name AS name, COUNT(*) AS count
           FROM tool_call_log
-          WHERE called_at >= ${s}
+          WHERE called_at >= ${since}
           GROUP BY tool_name
           ORDER BY count DESC
           LIMIT 5
-        `).all()}catch{return[]}})(),sessions:t(`SELECT COUNT(*) AS n FROM sessions WHERE date >= date('now', '-${o.days} days')`),questsCompleted:t(`SELECT COUNT(*) AS n FROM quests WHERE status='completed' AND completed_at >= ${s}`),questsAdded:t(`SELECT COUNT(*) AS n FROM quests WHERE created_at >= ${s}`),failuresBlocked:t(`SELECT COALESCE(SUM(occurrences), 0) AS n FROM failure_patterns WHERE last_seen_at >= ${s}`),truthsSet:t(`SELECT COUNT(*) AS n FROM ground_truths WHERE created_at >= ${s} OR last_verified_at >= ${s}`),referencesAdded:t(`SELECT COUNT(*) AS n FROM design_references WHERE captured_at >= ${s}`),memoryArtifactsAdded:t(`SELECT COUNT(*) AS n FROM memory_artifacts WHERE created_at >= ${s}`),hoursLogged:(()=>{try{return a.prepare(`SELECT COALESCE(SUM(hours), 0) AS n FROM hour_entries WHERE date >= date('now', '-${o.days} days')`).get().n}catch{return 0}})(),projectsActive:(()=>{try{return a.prepare(`
+        `).all();
+                return rows;
+            }
+            catch {
+                return [];
+            }
+        })(),
+        sessions: num(`SELECT COUNT(*) AS n FROM sessions WHERE date >= date('now', '-${period.days} days')`),
+        questsCompleted: num(`SELECT COUNT(*) AS n FROM quests WHERE status='completed' AND completed_at >= ${since}`),
+        questsAdded: num(`SELECT COUNT(*) AS n FROM quests WHERE created_at >= ${since}`),
+        failuresBlocked: num(`SELECT COALESCE(SUM(occurrences), 0) AS n FROM failure_patterns WHERE last_seen_at >= ${since}`),
+        truthsSet: num(`SELECT COUNT(*) AS n FROM ground_truths WHERE created_at >= ${since} OR last_verified_at >= ${since}`),
+        referencesAdded: num(`SELECT COUNT(*) AS n FROM design_references WHERE captured_at >= ${since}`),
+        memoryArtifactsAdded: num(`SELECT COUNT(*) AS n FROM memory_artifacts WHERE created_at >= ${since}`),
+        hoursLogged: (() => {
+            try {
+                const row = db.prepare(`SELECT COALESCE(SUM(hours), 0) AS n FROM hour_entries WHERE date >= date('now', '-${period.days} days')`).get();
+                return row.n;
+            }
+            catch {
+                return 0;
+            }
+        })(),
+        projectsActive: (() => {
+            try {
+                return db.prepare(`
           SELECT p.id, p.name
           FROM projects p
           JOIN sessions s ON s.project_id = p.id
-          WHERE s.date >= date('now', '-${o.days} days')
+          WHERE s.date >= date('now', '-${period.days} days')
           GROUP BY p.id, p.name
           ORDER BY MAX(s.date) DESC
           LIMIT 10
-        `).all()}catch{return[]}})()}}function w(a){const{period:i,toolCalls:o,topTools:s,sessions:t,questsCompleted:n,questsAdded:u,failuresBlocked:l,truthsSet:h,referencesAdded:y,memoryArtifactsAdded:c,hoursLogged:p,projectsActive:f}=a,e=[];if(e.push(`# ${r.brand} What Wyrm did ${i.label}`),e.push(""),o===0&&t===0)return e.push("_Wyrm was idle \u2014 no recorded activity in this period._"),e.push(""),e.push(`If your AI helper is connected to Wyrm but you see nothing here, it means it hasn't been calling Wyrm's tools. Try asking it: *"summarize my current project using wyrm_session_prime"* or *"what failures has Wyrm recorded on this project?"* \u2014 that'll get the loop going.`),e.join(`
-`);if(e.push("## The numbers"),e.push(""),t>0&&e.push(`- ${r.session}  **${t}** session${t===1?"":"s"} tracked`),o>0&&e.push(`- ${r.toolCall}  **${o}** Wyrm tool call${o===1?"":"s"} (your AI reached for Wyrm this many times)`),n>0&&e.push(`- ${r.questDone}  **${n}** quest${n===1?"":"s"} completed`),u>0&&e.push(`- ${r.questOpen}  **${u}** quest${u===1?"":"s"} added`),l>0&&e.push(`- ${r.blocked}  **${l}** repeated-failure block${l===1?"":"s"} \u2014 Wyrm refused to suggest something that didn't work before`),h>0&&e.push(`- ${r.truth}  **${h}** ground truth${h===1?"":"s"} set or re-verified`),c>0&&e.push(`- ${r.memory}  **${c}** memory artifact${c===1?"":"s"} stored (patterns, lessons, anti-patterns)`),y>0&&e.push(`- ${r.reference}  **${y}** design reference${y===1?"":"s"} clipped`),p>0&&e.push(`- ${r.bullet}  **${p.toFixed(1)}h** logged across sessions`),s.length>0){e.push(""),e.push("## Wyrm tools your AI reached for most"),e.push("");for(const d of s)e.push(`- \`${d.name}\` \u2014 ${d.count}\xD7`)}if(f.length>0){e.push(""),e.push("## Projects Wyrm tracked"),e.push("");for(const d of f)e.push(`- ${d.name}`)}return e.push(""),e.push("---"),e.push("_If this is the first time you're seeing what Wyrm does \u2014 that's the point. It works in the background. Every quest you completed, every failed approach your AI didn't repeat, every ground truth it cited \u2014 Wyrm made that happen. Without Wyrm your AI would have re-explored the same ground every session._"),e.join(`
-`)}function E(a){return`# ${r.brand} What is Wyrm?
-
-You're running **Wyrm ${a}** \u2014 a memory system that makes your AI assistant *much* better at working on your stuff.
+        `).all();
+            }
+            catch {
+                return [];
+            }
+        })(),
+    };
+}
+export function renderDigest(data) {
+    const { period, toolCalls, topTools, sessions, questsCompleted, questsAdded, failuresBlocked, truthsSet, referencesAdded, memoryArtifactsAdded, hoursLogged, projectsActive } = data;
+    const lines = [];
+    lines.push(`# ${ICON.brand} What Wyrm did ${period.label}`);
+    lines.push('');
+    if (toolCalls === 0 && sessions === 0) {
+        lines.push('_Wyrm was idle — no recorded activity in this period._');
+        lines.push('');
+        lines.push('If your AI helper is connected to Wyrm but you see nothing here, it means it hasn\'t been calling Wyrm\'s tools. Try asking it: *"summarize my current project using wyrm_session_prime"* or *"what failures has Wyrm recorded on this project?"* — that\'ll get the loop going.');
+        return lines.join('\n');
+    }
+    lines.push('## The numbers');
+    lines.push('');
+    if (sessions > 0)
+        lines.push(`- ${ICON.session}  **${sessions}** session${sessions === 1 ? '' : 's'} tracked`);
+    if (toolCalls > 0)
+        lines.push(`- ${ICON.toolCall}  **${toolCalls}** Wyrm tool call${toolCalls === 1 ? '' : 's'} (your AI reached for Wyrm this many times)`);
+    if (questsCompleted > 0)
+        lines.push(`- ${ICON.questDone}  **${questsCompleted}** quest${questsCompleted === 1 ? '' : 's'} completed`);
+    if (questsAdded > 0)
+        lines.push(`- ${ICON.questOpen}  **${questsAdded}** quest${questsAdded === 1 ? '' : 's'} added`);
+    if (failuresBlocked > 0)
+        lines.push(`- ${ICON.blocked}  **${failuresBlocked}** repeated-failure block${failuresBlocked === 1 ? '' : 's'} — Wyrm refused to suggest something that didn't work before`);
+    if (truthsSet > 0)
+        lines.push(`- ${ICON.truth}  **${truthsSet}** ground truth${truthsSet === 1 ? '' : 's'} set or re-verified`);
+    if (memoryArtifactsAdded > 0)
+        lines.push(`- ${ICON.memory}  **${memoryArtifactsAdded}** memory artifact${memoryArtifactsAdded === 1 ? '' : 's'} stored (patterns, lessons, anti-patterns)`);
+    if (referencesAdded > 0)
+        lines.push(`- ${ICON.reference}  **${referencesAdded}** design reference${referencesAdded === 1 ? '' : 's'} clipped`);
+    if (hoursLogged > 0)
+        lines.push(`- ${ICON.bullet}  **${hoursLogged.toFixed(1)}h** logged across sessions`);
+    if (topTools.length > 0) {
+        lines.push('');
+        lines.push('## Wyrm tools your AI reached for most');
+        lines.push('');
+        for (const t of topTools) {
+            lines.push(`- \`${t.name}\` — ${t.count}×`);
+        }
+    }
+    if (projectsActive.length > 0) {
+        lines.push('');
+        lines.push('## Projects Wyrm tracked');
+        lines.push('');
+        for (const p of projectsActive) {
+            lines.push(`- ${p.name}`);
+        }
+    }
+    lines.push('');
+    lines.push('---');
+    lines.push('_If this is the first time you\'re seeing what Wyrm does — that\'s the point. It works in the background. Every quest you completed, every failed approach your AI didn\'t repeat, every ground truth it cited — Wyrm made that happen. Without Wyrm your AI would have re-explored the same ground every session._');
+    return lines.join('\n');
+}
+export function renderIntro(version) {
+    return `# ${ICON.brand} What is Wyrm?
+
+You're running **Wyrm ${version}** — a memory system that makes your AI assistant *much* better at working on your stuff.
 
 ## The simplest explanation
 
 Without Wyrm: every time you start a new conversation with Claude / Copilot / Cursor / Windsurf, the AI starts from nothing. It doesn't remember what you worked on yesterday, what decisions you made, what didn't work last time.
 
-With Wyrm: your AI **remembers**. Across every session, every tool, every project. You don't have to re-explain. The AI picks up where you left off \u2014 *with all the context*.
+With Wyrm: your AI **remembers**. Across every session, every tool, every project. You don't have to re-explain. The AI picks up where you left off — *with all the context*.
 
 ## What Wyrm specifically does
 
@@ -31,25 +165,27 @@ It's not just "memory" in the file-write sense. Wyrm solves four specific proble
 
 **1. Amnesia.** Wyrm assembles a complete briefing at every session start. Your AI inherits the prior state instead of starting from zero.
 
-**2. Repeated mistakes.** When an approach fails, Wyrm records it. Next time, your AI is *blocked* from suggesting the same failed thing again. Other memory tools learn only from success \u2014 Wyrm learns from failure too.
+**2. Repeated mistakes.** When an approach fails, Wyrm records it. Next time, your AI is *blocked* from suggesting the same failed thing again. Other memory tools learn only from success — Wyrm learns from failure too.
 
 **3. Lost rationale.** When you make a decision ("we use Postgres, not Mongo"), Wyrm stores it as a *ground truth* linked to the reasoning. When something downstream changes, Wyrm cascades the impact so you don't accidentally violate decisions you forgot you made.
 
-**4. Tool-call sprawl.** The agent loop turns goals into autonomous tool sequences. Say *"keep my dependencies up to date weekly"* \u2014 Wyrm's daemon does it.
+**4. Tool-call sprawl.** The agent loop turns goals into autonomous tool sequences. Say *"keep my dependencies up to date weekly"* — Wyrm's daemon does it.
 
 ## What to try first
 
 If you've never used Wyrm directly, ask your AI:
 
-- *"What's the state of this project?"* \u2014 your AI will call \`wyrm_session_prime\` and brief you.
-- *"What have we learned about [topic]?"* \u2014 your AI will search Wyrm's memory.
-- *"Save this as a ground truth: [fact]"* \u2014 your AI will store it for future sessions.
-- *"What did Wyrm do for me this week?"* \u2014 run \`wyrm_digest\` to see the work product.
-- *"Show me everything Wyrm can do"* \u2014 call \`wyrm_capabilities\` to get the full tool catalogue.
+- *"What's the state of this project?"* — your AI will call \`wyrm_session_prime\` and brief you.
+- *"What have we learned about [topic]?"* — your AI will search Wyrm's memory.
+- *"Save this as a ground truth: [fact]"* — your AI will store it for future sessions.
+- *"What did Wyrm do for me this week?"* — run \`wyrm_digest\` to see the work product.
+- *"Show me everything Wyrm can do"* — call \`wyrm_capabilities\` to get the full tool catalogue.
 
 ## The 30-second pitch for skeptics
 
 You know that feeling when your AI says *"Could you remind me what we decided about X?"* on session three of the same project? Wyrm exists so that never happens. It's the layer between you and AI amnesia.
 
-If you've been using Claude Code / Cursor / Windsurf with Wyrm installed, **Wyrm has already been working** \u2014 silently, in the background, every session. \`wyrm_digest\` shows you the receipts.
-`}export{m as DIGEST_PRESETS,W as gatherDigest,w as renderDigest,E as renderIntro};
+If you've been using Claude Code / Cursor / Windsurf with Wyrm installed, **Wyrm has already been working** — silently, in the background, every session. \`wyrm_digest\` shows you the receipts.
+`;
+}
+//# sourceMappingURL=visibility.js.map