aiden-runtime 4.1.0 → 4.1.2

package/dist/core/v4/distillationIndex.js

@@ -0,0 +1,167 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/distillationIndex.ts — Phase v4.1.2-memory-C.
+ *
+ * Pure ranking + filtering over an in-memory list of
+ * `SessionDistillation` records. The tool handler
+ * (`tools/v4/sessions/recallSession.ts`) reads JSON files off disk
+ * and passes them in here; this module has no I/O.
+ *
+ * Ranking rules (per slice's Q3):
+ *   - No query → recency-only: sort by `ended_at` desc, take top N.
+ *   - Query present → score by total keyword-substring matches across:
+ *       keywords[], bullets[], decisions[], open_items[],
+ *       tools_used[].name
+ *     Recency breaks ties.
+ *   - `days` window filters out anything with
+ *     `now - ended_at > days * 86_400_000` BEFORE scoring.
+ *
+ * No hybrid weighting, no LLM call, no embeddings — those are Phase E
+ * concerns. Today's ranking stays debuggable: the user can read why a
+ * result ranked where it did from `relevance` + the match field
+ * listed in each candidate.
+ *
+ * Index strategy: scan-all. Expected file count is <1000 per user;
+ * the tool handler reads every file from disk per query (sub-100ms at
+ * that scale). When real usage shows query latency >500ms, migrate
+ * directly to SQLite FTS5 — skip a JSON-index intermediate step.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rankDistillations = rankDistillations;
+exports.scoreMatch = scoreMatch;
+// ── Constants ─────────────────────────────────────────────────────────────
+const DEFAULT_LIMIT = 5;
+const MAX_LIMIT = 25;
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+// ── Pure ranking ──────────────────────────────────────────────────────────
+/**
+ * Rank + filter distillations against a query. Pure: no I/O, no
+ * side effects, no clock-reads other than `nowMs` for the recency
+ * window (injectable for deterministic tests).
+ *
+ * @param dists  Every distillation read from disk. Scan-all per slice's
+ *               index strategy — caller owns the I/O.
+ * @param query  User-supplied recall query.
+ * @param nowMs  Reference time for the days window. Defaults to
+ *               `Date.now()`; tests inject a fixed value.
+ */
+function rankDistillations(dists, query = {}, nowMs = Date.now()) {
+    const scanned = dists.length;
+    const limit = clampLimit(query.limit);
+    const keyword = (query.query ?? '').trim().toLowerCase();
+    // 1. Days window filter.
+    let pool;
+    if (typeof query.days === 'number' && query.days > 0) {
+        const cutoff = nowMs - query.days * ONE_DAY_MS;
+        pool = dists.filter((d) => {
+            const t = Date.parse(d.ended_at);
+            return Number.isFinite(t) && t >= cutoff;
+        });
+    }
+    else {
+        pool = [...dists];
+    }
+    // 2. Score + filter.
+    let scored;
+    let relevance;
+    if (keyword.length === 0) {
+        // Recency-only: every survivor passes; score by inverse end-time
+        // so the sort below is identical to "newest first".
+        scored = pool.map((d) => ({
+            d,
+            score: 0,
+            ended: safeEndedMs(d),
+        }));
+        relevance = 'recency';
+    }
+    else {
+        scored = [];
+        for (const d of pool) {
+            const score = scoreMatch(d, keyword);
+            if (score > 0)
+                scored.push({ d, score, ended: safeEndedMs(d) });
+        }
+        relevance = 'keyword';
+    }
+    // 3. Sort. Keyword path: score desc, recency tiebreak. Recency
+    // path: ended desc.
+    scored.sort((a, b) => {
+        if (keyword.length > 0 && a.score !== b.score)
+            return b.score - a.score;
+        return b.ended - a.ended;
+    });
+    const total_found = scored.length;
+    const matches = scored
+        .slice(0, limit)
+        .map(({ d }) => toRecallMatch(d, relevance, query.include_full === true));
+    return { matches, total_found, scanned };
+}
+// ── Helpers ───────────────────────────────────────────────────────────────
+function clampLimit(raw) {
+    if (typeof raw !== 'number' || !Number.isFinite(raw))
+        return DEFAULT_LIMIT;
+    return Math.max(1, Math.min(MAX_LIMIT, Math.floor(raw)));
+}
+function safeEndedMs(d) {
+    const t = Date.parse(d.ended_at);
+    return Number.isFinite(t) ? t : 0;
+}
+/**
+ * Compute the keyword-match score for one distillation. Counts every
+ * field-string that contains the keyword as a substring (case-fold).
+ * Each hit = 1 point — simple and debuggable. Multi-occurrence inside
+ * one string still counts as 1 hit (we score field presence, not
+ * frequency).
+ *
+ * Fields scanned (per slice's explicit list):
+ *   - keywords[]
+ *   - bullets[]
+ *   - decisions[]
+ *   - open_items[]
+ *   - tools_used[].name
+ */
+function scoreMatch(d, keyword) {
+    let score = 0;
+    for (const k of d.keywords)
+        if (k.toLowerCase().includes(keyword))
+            score += 1;
+    for (const b of d.bullets)
+        if (b.toLowerCase().includes(keyword))
+            score += 1;
+    for (const dc of d.decisions)
+        if (dc.toLowerCase().includes(keyword))
+            score += 1;
+    for (const o of d.open_items)
+        if (o.toLowerCase().includes(keyword))
+            score += 1;
+    for (const t of d.tools_used)
+        if (t.name.toLowerCase().includes(keyword))
+            score += 1;
+    return score;
+}
+function toRecallMatch(d, relevance, includeFull) {
+    const out = {
+        session_id: d.session_id,
+        started_at: d.started_at,
+        ended_at: d.ended_at,
+        exit_path: d.exit_path,
+        relevance,
+        bullets: d.bullets,
+        decisions: d.decisions,
+        open_items: d.open_items,
+        files_touched: d.files_touched,
+    };
+    if (includeFull) {
+        out.tools_used = d.tools_used;
+        out.keywords = d.keywords;
+    }
+    if (d.partial)
+        out.partial = true;
+    return out;
+}

package/dist/core/v4/distillationStore.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/distillationStore.ts — Phase v4.1.2-memory-AB.
+ *
+ * On-disk persistence for `SessionDistillation` objects. One JSON file
+ * per session at `<dir>/<session_id>.json`. Atomic writes via tempfile
+ * + rename (same pattern as slice4's SkillOutcomeTracker).
+ *
+ * Disk layout intentionally flat — Phase C's retrieval surface will
+ * scan this directory and index the results. No subdirectories,
+ * no sharding; sessions are bounded enough that a single dir works
+ * (the typical user produces tens to low-hundreds of sessions/year).
+ *
+ * Failures are caught + surfaced via a slice3 SubsystemHealthTracker
+ * when one is wired; the write resolves anyway so the caller (chat
+ * session exit path) is never stuck on a disk failure.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeDistillation = writeDistillation;
+exports.readDistillation = readDistillation;
+exports.listDistillationIds = listDistillationIds;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Write one distillation file under `dir/<session_id>.json`. Atomic:
+ * writes to `<file>.tmp` then renames. Returns the final path on
+ * success, throws when the rename can't complete.
+ *
+ * @param healthTracker  Optional — if provided, success/failure is
+ *                       recorded for `aiden doctor` surfacing.
+ */
+async function writeDistillation(dir, dist, healthTracker) {
+    const file = node_path_1.default.join(dir, `${dist.session_id}.json`);
+    const tmp = `${file}.tmp`;
+    try {
+        await node_fs_1.promises.mkdir(dir, { recursive: true });
+        await node_fs_1.promises.writeFile(tmp, JSON.stringify(dist, null, 2) + '\n', 'utf-8');
+        await node_fs_1.promises.rename(tmp, file);
+        healthTracker?.recordSuccess();
+        return file;
+    }
+    catch (err) {
+        healthTracker?.recordFailure(err);
+        // Clean up any orphaned tempfile — best-effort.
+        try {
+            await node_fs_1.promises.unlink(tmp);
+        }
+        catch { /* ignore */ }
+        throw err;
+    }
+}
+/**
+ * Read one distillation by session id. Returns `null` when the file
+ * doesn't exist; throws on parse / permission errors.
+ *
+ * Caller is responsible for validating `schema_version` if it cares
+ * about future migrations. No version coercion in v1.
+ */
+async function readDistillation(dir, sessionId) {
+    const file = node_path_1.default.join(dir, `${sessionId}.json`);
+    try {
+        const raw = await node_fs_1.promises.readFile(file, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+}
+/**
+ * List session ids that have a distillation on disk. Returns the
+ * basenames (without `.json` extension), sorted lexicographically.
+ * Used by Phase C's retrieval index.
+ */
+async function listDistillationIds(dir) {
+    try {
+        const entries = await node_fs_1.promises.readdir(dir);
+        return entries
+            .filter((e) => e.endsWith('.json') && !e.endsWith('.tmp.json'))
+            .map((e) => e.slice(0, -'.json'.length))
+            .sort();
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return [];
+        throw err;
+    }
+}

package/dist/core/v4/logger/logger.js

@@ -33,11 +33,6 @@ exports.LOG_LEVEL_ORDER = {
     warn: 30,
     error: 40,
 };
-/**
- * Default `Logger` implementation. Holds a list of sinks and the
- * current scope; child loggers share the same sink list (so updating
- * the level / detaching at the root affects everything).
- */
 class CoreLogger {
     /**
      * Construct a root logger. Use `child(segment)` for sub-loggers.
@@ -47,7 +42,11 @@ class CoreLogger {
         this.scope = opts.scope ?? '';
         this.sinks = opts.sinks;
         this.level = opts.level ?? 'debug';
-        this.sinksOwner = { sinks: this.sinks, level: this.level };
+        this.sinksOwner = {
+            sinks: this.sinks,
+            level: this.level,
+            counters: opts.sinks.map(() => ({ totalWrites: 0, failures: 0 })),
+        };
     }
     /** Internal — used by `child()` to share state with the root. */
     static childOf(parent, segment) {
@@ -73,6 +72,21 @@ class CoreLogger {
     }
     detachAll() {
         this.sinksOwner.sinks.length = 0;
+        this.sinksOwner.counters.length = 0;
+    }
+    getSinkHealth() {
+        const out = [];
+        for (let i = 0; i < this.sinksOwner.sinks.length; i += 1) {
+            const sink = this.sinksOwner.sinks[i];
+            const counter = this.sinksOwner.counters[i] ?? { totalWrites: 0, failures: 0 };
+            out.push({
+                name: sink.name ?? `sink:${i}`,
+                totalWrites: counter.totalWrites,
+                failures: counter.failures,
+                ...(counter.lastError ? { lastError: counter.lastError } : {}),
+            });
+        }
+        return out;
     }
     debug(msg, ctx) { this.write('debug', msg, ctx); }
     info(msg, ctx) { this.write('info', msg, ctx); }
@@ -89,12 +103,29 @@ class CoreLogger {
             ctx,
         };
         // Sinks must not throw — the helpers in ./sinks/* all wrap their
-        // I/O in try/catch. Be defensive anyway.
-        for (const s of this.sinksOwner.sinks) {
+        // I/O in try/catch. Be defensive anyway. Phase v4.1.2-slice3:
+        // bump the per-sink counter and capture the most recent failure
+        // message so `aiden doctor` can render it. The counter itself is
+        // never logged through this logger (would recurse).
+        for (let i = 0; i < this.sinksOwner.sinks.length; i += 1) {
+            const s = this.sinksOwner.sinks[i];
+            const c = this.sinksOwner.counters[i];
+            if (c)
+                c.totalWrites += 1;
             try {
                 s.write(record);
             }
-            catch { /* logging must not break callers */ }
+            catch (err) {
+                if (c) {
+                    c.failures += 1;
+                    const msg = err instanceof Error ? err.message : String(err);
+                    c.lastError = {
+                        message: msg.length > 200 ? msg.slice(0, 197) + '...' : msg,
+                        at: new Date(),
+                    };
+                }
+                /* logging must not break callers */
+            }
         }
     }
 }

package/dist/core/v4/promotionCandidates.js

@@ -0,0 +1,234 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/promotionCandidates.ts — Phase v4.1.2-memory-D.
+ *
+ * Pure module that builds the list of "should we promote this to
+ * MEMORY.md `## Durable facts`?" candidates at session-end. The CLI
+ * surface (`cli/v4/promotionPrompt.ts`) reads the candidates, asks
+ * the user, and writes the approved subset.
+ *
+ * Sources combined (per Phase D's Q1 decision — A + B, defer C):
+ *
+ *   A. Explicit user signals — regex over `history` user messages.
+ *      "remember that X", "save this", "for next time", "don't forget"
+ *      → the captured phrase becomes the candidate text. The
+ *      surrounding user message is kept as `context` so the user can
+ *      verify what they're promoting before approving.
+ *
+ *   B. Distillation `decisions[]` + `open_items[]` — Phase A+B's
+ *      structured output. Decisions are "X was chosen over Y"; open
+ *      items are unfinished work / next-time prompts. Both are
+ *      durable-worthy.
+ *
+ *   C. Recurring facts across sessions — DEFERRED. Substring matching
+ *      alone produces false positives ("any session mentioning Aiden"
+ *      matches every other one). Semantic similarity belongs in Phase E
+ *      alongside embeddings; lands when that slice ships.
+ *
+ * Priority ordering (drives the rendered list AND dedup-precedence):
+ *   1 — explicit (user EXPLICITLY asked to remember)
+ *   2 — decision  (model identified as a settled decision)
+ *   3 — open_item (unfinished work — actionable next time)
+ *
+ * Dedup rules:
+ *   - Within the candidate list: same-text (case-fold substring)
+ *     candidates from multiple sources fold to highest priority.
+ *   - Against existing durable body: substring-match every candidate
+ *     against the caller's `existingDurableBody` (case-fold). Skipped
+ *     candidates count toward `dedupedAgainstExisting` so the caller
+ *     can surface the dim "N candidates already in durable facts"
+ *     line per Phase D's Q5 first-run UX.
+ *
+ * Output cap: 10 candidates max (per Q3). Forces intentionality —
+ * sessions with 20+ durable-worthy items signal the user should
+ * reconsider what's actually durable.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_CANDIDATES = void 0;
+exports.extractExplicitSignals = extractExplicitSignals;
+exports.extractDistillationCandidates = extractDistillationCandidates;
+exports.extractCandidates = extractCandidates;
+exports.MAX_CANDIDATES = 10;
+// ── Source A: explicit signals ────────────────────────────────────────────
+/**
+ * Regex set for explicit promotion signals. Each pattern's capture
+ * group `[1]` is the phrase the user wants remembered. Anchored on
+ * word boundaries so partial-word matches don't fire ("remembering" ≠
+ * "remember").
+ *
+ * Capture semantics — Phase v4.1.2-bug-Z:
+ *
+ *   Previous: capture terminated at any `[.!?\n]` (sentence boundary).
+ *   That truncated common payloads with periods:
+ *     - version strings: "gpt-5.5" → captured as "gpt-5"
+ *     - URLs: "https://api.example.com/v1" → "https://api"
+ *     - semver: "v1.2.3" → "v1"
+ *     - filenames: "config.test.ts" → "config"
+ *
+ *   Current: capture rest-of-payload until BLANK-LINE BOUNDARY
+ *   (`\n\s*\n`) or end-of-string. Regex detects intent (the user said
+ *   "remember"), not meaning (what counts as a sentence). The `s` flag
+ *   makes `.` match newlines so multi-line payloads survive a single
+ *   capture.
+ *
+ *   Trade-off: when multiple markers fire within one sentence-run
+ *   (no blank-line boundaries), the first-marker capture extends to
+ *   end-of-payload and the second marker's narrower capture is
+ *   dedup-folded into it. One candidate covers both facts. Cleanly
+ *   paragraph-separated multi-markers still split because the
+ *   blank-line boundary terminates the first capture before the
+ *   second marker's position. The promotion prompt shows the full
+ *   capture so the user approves knowingly.
+ */
+// Separator tolerance: between the verb-phrase ("remember that",
+// "save this", "don't forget to") and the fact, accept whitespace
+// AND optional punctuation (`:`, `,`). Some users naturally write
+// "remember that: the port is 4200" or "save this — we use X".
+const SEP = '[\\s:,—-]+';
+// Capture-end: blank line (`\n` + optional whitespace + `\n`) OR
+// end-of-string. The `s` flag lets `.` match newlines so single-marker
+// multi-line payloads stay in one capture.
+const END = '(?:\\n\\s*\\n|$)';
+const EXPLICIT_SIGNAL_PATTERNS = Object.freeze([
+    new RegExp(`\\bremember${SEP}(?:that|this)${SEP}(.+?)${END}`, 'gis'),
+    new RegExp(`\\bsave${SEP}(?:this|that)${SEP}(?:to memory${SEP})?(.+?)${END}`, 'gis'),
+    new RegExp(`\\bfor next time${SEP}(.+?)${END}`, 'gis'),
+    new RegExp(`\\bdon'?t forget${SEP}(?:that|to)${SEP}(.+?)${END}`, 'gis'),
+]);
+/**
+ * Strip leading filler that often slips past the regex's "that|this"
+ * anchor ("that the", "this — "), and trim. Empty / too-short results
+ * are signalled by returning the empty string; caller drops them.
+ */
+function cleanCandidateText(raw) {
+    let s = raw.trim();
+    // Drop leading "that ", "this ", "to " (the regex caught them
+    // sometimes when they sat between the verb and the fact).
+    s = s.replace(/^(?:that|this|to)\s+/i, '').trim();
+    // Drop trailing punctuation noise.
+    s = s.replace(/[\s,;:]+$/, '');
+    return s;
+}
+function extractExplicitSignals(history) {
+    const out = [];
+    for (const msg of history) {
+        if (msg.role !== 'user')
+            continue;
+        const text = typeof msg.content === 'string' ? msg.content : '';
+        if (!text)
+            continue;
+        for (const pat of EXPLICIT_SIGNAL_PATTERNS) {
+            // Recreate per-message so the global flag resets.
+            const re = new RegExp(pat.source, pat.flags);
+            let m;
+            while ((m = re.exec(text)) !== null) {
+                const cleaned = cleanCandidateText(m[1] ?? '');
+                if (cleaned.length < 4)
+                    continue; // 1-3 char hits are noise
+                out.push({
+                    text: cleaned,
+                    source: 'explicit',
+                    context: text.trim(),
+                    priority: 1,
+                });
+            }
+        }
+    }
+    return out;
+}
+// ── Source B: distillation decisions + open_items ─────────────────────────
+function extractDistillationCandidates(dist) {
+    const out = [];
+    for (const d of dist.decisions) {
+        const t = d.trim();
+        if (t.length >= 4) {
+            out.push({ text: t, source: 'decision', priority: 2 });
+        }
+    }
+    for (const o of dist.open_items) {
+        const t = o.trim();
+        if (t.length >= 4) {
+            out.push({ text: t, source: 'open_item', priority: 3 });
+        }
+    }
+    return out;
+}
+// ── Dedup + ranking ───────────────────────────────────────────────────────
+function normalize(s) {
+    return s.toLowerCase().replace(/\s+/g, ' ').trim();
+}
+/**
+ * Within-session dedup: when the same fact surfaces from multiple
+ * sources, keep the highest-priority one. Substring-match in both
+ * directions so "Aiden runs on port 4200" and "Port 4200 for Aiden"
+ * collide on the longer-containing case.
+ */
+function dedupWithinSession(input) {
+    const sorted = [...input].sort((a, b) => a.priority - b.priority);
+    const kept = [];
+    let dropped = 0;
+    for (const c of sorted) {
+        const normC = normalize(c.text);
+        const collision = kept.some((k) => {
+            const normK = normalize(k.text);
+            return normK.includes(normC) || normC.includes(normK);
+        });
+        if (collision) {
+            dropped += 1;
+            continue;
+        }
+        kept.push(c);
+    }
+    return { kept, dropped };
+}
+/**
+ * Dedup against existing `## Durable facts` body. Substring-match
+ * each candidate against the body (case-fold). Skipped candidates
+ * count toward the returned `dropped` so the caller can render the
+ * "N already in durable facts" dim line.
+ */
+function dedupAgainstExisting(input, existing) {
+    if (!existing.trim())
+        return { kept: [...input], dropped: 0 };
+    const normExisting = normalize(existing);
+    const kept = [];
+    let dropped = 0;
+    for (const c of input) {
+        if (normExisting.includes(normalize(c.text))) {
+            dropped += 1;
+            continue;
+        }
+        kept.push(c);
+    }
+    return { kept, dropped };
+}
+// ── Public entry point ────────────────────────────────────────────────────
+/**
+ * Build the full candidate list. Combines source A + source B,
+ * dedups within session, dedups against existing durable body, sorts
+ * by priority (stable within priority by source order — explicit
+ * signals before decisions before open items), and caps at 10.
+ */
+function extractCandidates(history, distillation, existingDurableBody) {
+    const rawA = extractExplicitSignals(history);
+    const rawB = extractDistillationCandidates(distillation);
+    const totalBeforeDedup = rawA.length + rawB.length;
+    const within = dedupWithinSession([...rawA, ...rawB]);
+    const against = dedupAgainstExisting(within.kept, existingDurableBody);
+    // Stable sort by priority — within a priority tier, preserve insertion
+    // order so explicit signals land in chronological message order and
+    // decisions land in distillation order.
+    const sorted = [...against.kept].sort((a, b) => a.priority - b.priority);
+    return {
+        candidates: sorted.slice(0, exports.MAX_CANDIDATES),
+        dedupedAgainstExisting: against.dropped,
+        dedupedWithinSession: within.dropped,
+        totalBeforeDedup,
+    };
+}