aiden-runtime 4.1.1 → 4.1.3

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,
+    };
+}

package/dist/core/v4/promptBuilder.js

@@ -38,11 +38,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptBuilder = void 0;
 exports.shouldInjectLlama33ToolHint = shouldInjectLlama33ToolHint;
+exports.shouldInjectExecutionDiscipline = shouldInjectExecutionDiscipline;
 const node_fs_1 = require("node:fs");
 const node_os_1 = __importDefault(require("node:os"));
 // When SOUL.md is missing or whitespace-only the bundled default takes
 // over so a fresh install still has a working identity.
 const defaultSoul_1 = require("../../cli/v4/defaultSoul");
+// Phase v4.1.2-followup: runtime-injected version + capabilities slot.
+const capabilities_1 = require("./capabilities");
 // ── Section header / sentinel string contract ─────────────────────────
 //
 // Every literal here is part of the API contract pinned by tests. Header
@@ -59,6 +62,74 @@ const NOTE_USER_LIVE = '[System note: Treat as live identity, not past conversat
 const NOTE_MEMORY_LIVE = '[System note: Treat as live working memory, not past conversation.]';
 const SKILLS_LOAD_NOTE = 'You MUST load it first via the `skill_view` tool before invoking ' +
     'the underlying capability. Skills carry the procedure the tools alone don\'t.';
+/**
+ * Phase v4.1.2 alive-core: when the user has authored a real SOUL.md
+ * (not the bundled default), prepend a one-line embodiment directive
+ * to its content. The directive tells the model to *be* the identity,
+ * not narrate about it — closes the most common "stiff generic reply"
+ * failure mode where the model paraphrases SOUL.md back at the user.
+ *
+ * Intentionally suppressed when the identity slot falls back to
+ * DEFAULT_SOUL_MD: that text is generic by design and the directive
+ * would coach the model to perform a flat persona.
+ */
+const EMBODIMENT_DIRECTIVE = 'Embody this identity and tone. Speak as Aiden, not about Aiden. ' +
+    'Avoid generic, stiff replies.';
+/**
+ * Phase v4.1.2 alive-core: tool-conditional guidance blocks. Each one
+ * is injected only when the corresponding toolset tag is in
+ * `opts.toolsetsLoaded`. Replaces the "fixed slot order regardless of
+ * capability" assumption — persona shape-shifts per available
+ * capability (prior-art pattern surfaced during v4.2 recon).
+ *
+ * Key match strings:
+ *   - 'memory'         → MEMORY_GUIDANCE
+ *   - 'session-search' → SESSION_SEARCH_GUIDANCE
+ *   - 'skills'         → SKILLS_GUIDANCE
+ *
+ * Match the strings in `ToolHandler.toolset` on the registered tools
+ * (tools/v4/memory/*.ts ships `toolset: 'memory'`,
+ * tools/v4/sessions/sessionSearch.ts ships `toolset: 'session-search'`,
+ * skill tools ship `toolset: 'skills'`).
+ */
+const MEMORY_GUIDANCE = [
+    '## Persistent memory',
+    '',
+    'You have persistent memory across sessions. Save durable facts using `memory_add`:',
+    'user preferences, environment details, stable conventions. Memory is injected into',
+    'every turn; keep it compact and focused on facts that will still matter later.',
+    'Prioritize what reduces future user steering.',
+].join('\n');
+const SESSION_SEARCH_GUIDANCE = [
+    '## Session recall',
+    '',
+    'When the user references something from a past conversation or you suspect',
+    'relevant cross-session context exists, use `session_search` to recall it before',
+    'asking them to repeat themselves.',
+].join('\n');
+const SKILLS_GUIDANCE = [
+    '## Skill upkeep',
+    '',
+    'After completing a complex task (5+ tool calls), fixing a tricky error, or',
+    'discovering a non-trivial workflow, save it as a skill so you can reuse it next',
+    'time. When using an existing skill and finding it outdated, patch it immediately',
+    '— don\'t wait to be asked.',
+].join('\n');
+/**
+ * Phase v4.1.2 alive-core: execution-discipline prose. Counters the
+ * "I'll run the tests" → no tool call → end-of-turn failure mode by
+ * making the contract explicit. Injected when
+ * `shouldInjectExecutionDiscipline(modelId)` is true (currently always).
+ */
+const EXECUTION_DISCIPLINE_PROSE = [
+    '## Tool use enforcement',
+    '',
+    'When you say you will perform an action ("I\'ll run the tests", "let me check the',
+    'file"), you MUST immediately make the corresponding tool call in the same response.',
+    'Never end your turn with a promise of future action — execute it now. Every',
+    'response should either contain tool calls that make progress, or deliver a final',
+    'result. Responses that only describe intentions without acting are not acceptable.',
+].join('\n');
 /**
  * Llama-3.3-specific tool-call format guard. Adapter-side recovery picks
  * up failures, but we'd rather avoid the 400 round-trip.
@@ -73,6 +144,16 @@ function shouldInjectLlama33ToolHint(modelId) {
         return false;
     return /llama-?3\.3/i.test(modelId);
 }
+/**
+ * Phase v4.1.2: predicate for the execution-discipline prose slot.
+ * Currently always-on — the "act, don't narrate" directive helps every
+ * tool-using model we route through. Narrow this if a specific model
+ * proves counter-productive; better to over-apply a useful prompt than
+ * guess incorrectly which models need it.
+ */
+function shouldInjectExecutionDiscipline(_modelId) {
+    return true;
+}
 // ── Internal helpers ──────────────────────────────────────────────────
 function detectPlatform() {
     const p = node_os_1.default.platform();
@@ -171,9 +252,16 @@ class PromptBuilder {
         if (!opts.skipFilesystem) {
             identity = await readNonEmpty(opts.paths.soulMd);
         }
+        // Phase v4.1.2: track whether the identity came from a real
+        // user-authored SOUL.md so the embodiment directive only fires
+        // when there's a meaningful persona to embody.
+        const identityFromDisk = identity !== null;
         if (!identity)
             identity = defaultSoul_1.DEFAULT_SOUL_MD;
-        slots.push({ name: 'identity', content: identity.trim(), optional: false });
+        const identityContent = identityFromDisk
+            ? `${EMBODIMENT_DIRECTIVE}\n\n${identity.trim()}`
+            : identity.trim();
+        slots.push({ name: 'identity', content: identityContent, optional: false });
         // ── 2. Personality overlay ────────────────────────────────────────
         const overlay = opts.personalityOverlay?.trim();
         if (overlay) {
@@ -197,6 +285,51 @@ class PromptBuilder {
                 optional: true,
             });
         }
+        // ── 4.25. Runtime manifest (self-awareness) ───────────────────────
+        // High-signal facts about what Aiden actually has loaded right now:
+        // version, tool count, skill count, channel/surface list, current
+        // provider/model. Always present so "what version are you" /
+        // "what tools do you have" answers come from facts in context,
+        // not from whatever stale text used to live in SOUL.md.
+        const runtimeManifest = (0, capabilities_1.buildRuntimeManifest)({
+            toolCount: opts.toolCount ?? 0,
+            skillCount: opts.skillsList?.length ?? 0,
+            providerId: opts.providerId,
+            modelId: opts.modelId,
+        });
+        slots.push({
+            name: 'runtime',
+            content: (0, capabilities_1.renderRuntimeSlot)(runtimeManifest),
+            optional: false,
+        });
+        // ── 4.5. Tool-conditional guidance ────────────────────────────────
+        // Each block fires only when its corresponding toolset is loaded.
+        // Order is deterministic so the prefix cache stays stable across
+        // turns with the same toolset set.
+        const toolsets = opts.toolsetsLoaded;
+        if (toolsets && toolsets.size > 0) {
+            if (toolsets.has('memory')) {
+                slots.push({
+                    name: 'guidance.memory',
+                    content: MEMORY_GUIDANCE,
+                    optional: true,
+                });
+            }
+            if (toolsets.has('session-search')) {
+                slots.push({
+                    name: 'guidance.sessionSearch',
+                    content: SESSION_SEARCH_GUIDANCE,
+                    optional: true,
+                });
+            }
+            if (toolsets.has('skills')) {
+                slots.push({
+                    name: 'guidance.skills',
+                    content: SKILLS_GUIDANCE,
+                    optional: true,
+                });
+            }
+        }
         // ── 5. Skills ─────────────────────────────────────────────────────
         if (opts.skillsList && opts.skillsList.length > 0) {
             slots.push({
@@ -213,6 +346,17 @@ class PromptBuilder {
                 optional: true,
             });
         }
+        // ── 6.5. Execution discipline ─────────────────────────────────────
+        // Phase v4.1.2: closes the "promise without acting" failure mode.
+        // Model-conditional via shouldInjectExecutionDiscipline so we can
+        // narrow later if a specific model proves counter-productive.
+        if (shouldInjectExecutionDiscipline(opts.modelId)) {
+            slots.push({
+                name: 'executionDiscipline',
+                content: EXECUTION_DISCIPLINE_PROSE,
+                optional: true,
+            });
+        }
         // ── 7. Iteration budget ───────────────────────────────────────────
         if (opts.initialBudget) {
             const { used, max } = opts.initialBudget;