@unerr-ai/unerr 0.2.0 → 0.2.2

package/dist/proxy/response-enrichment.js

@@ -1,32 +0,0 @@
-/**
- * Intelligence Response Enrichment — populates the internal `meta` / `context`
- * carrier with risk, confidence, and convention data. These fields never reach
- * the wire — `buildSignalPrefix()` drains them into `ur|<tag>` prefix lines at
- * the wire boundary (MCP clients strip `_meta`/`_context` envelopes).
- *
- * P.9: Every intelligence query response carries (on the internal envelope):
- *   - meta.confidence: propagated confidence level
- *   - meta.risk_level: entity risk classification → `ur|rsk` when high
- *   - meta.resolution_ms: query execution time
- *   - context.conventions: applicable conventions → `ur|hnt` / `ur|fct` lines
- */
-import { confidenceToScore } from "../intelligence/confidence-propagation.js";
-/**
- * Enrich a query response with intelligence metadata.
- */
-export function enrichResponse(content, meta, context) {
-    const result = {
-        content,
-        _meta: {
-            confidence: meta.confidence,
-            confidence_score: confidenceToScore(meta.confidence),
-            risk_level: meta.riskLevel,
-            resolution_ms: Math.round(meta.resolutionMs * 100) / 100,
-            edge_sources: meta.edgeSources,
-        },
-    };
-    if (context && Object.keys(context).length > 0) {
-        result._context = context;
-    }
-    return result;
-}

package/dist/proxy/response-envelope.js

@@ -1,313 +0,0 @@
-/**
- * MCP Response Envelope — standardized wrapper for every tool response.
- *
- * Every MCP tool response is enriched with:
- *   _meta: { "dev.unerr/tokens_saved", "dev.unerr/latency_ms", "dev.unerr/version" }
- *   _context: { optional intelligence injections from blast-radius, conventions, etc. }
- *
- * The envelope pipeline is composable: injectors register themselves and
- * are invoked in order for each response. The session dedup layer sits
- * on top, filtering context that has already been delivered.
- *
- * Token estimation uses char/4 as a fast approximation.
- * Sprint G will replace this with a proper tiktoken-based engine.
- */
-import { estimateTokens } from "../intelligence/token-estimator.js";
-export { estimateTokens };
-const VERSION = "0.1.0";
-/**
- * Update notification state — set by the daemon's version checker.
- * When set, tool responses include `_meta["dev.unerr/update_available"]`.
- * Only injected when >2 minor versions behind (high signal, low noise).
- */
-let updateNotification = null;
-export function setUpdateNotification(latest, current) {
-    updateNotification = { latest, current };
-}
-export function clearUpdateNotification() {
-    updateNotification = null;
-}
-/**
- * Create a response envelope pipeline with registered context injectors.
- */
-export function createEnvelopePipeline(injectors = []) {
-    /**
-     * Wrap a raw tool response in the standard envelope.
-     *
-     * @param content - The original tool response content
-     * @param latencyMs - Time taken to execute the tool (ms)
-     * @param toolName - Name of the MCP tool that was called
-     * @param toolArgs - Arguments passed to the tool
-     * @param originalTokens - Token count of the raw input (for savings calculation)
-     */
-    async function wrapResponse(content, latencyMs, toolName = "", toolArgs = {}, originalTokens = 0) {
-        const responseTokens = estimateTokens(content);
-        const tokensSaved = Math.max(0, originalTokens - responseTokens);
-        const _meta = {
-            "dev.unerr/tokens_saved": tokensSaved,
-            "dev.unerr/latency_ms": Math.round(latencyMs * 100) / 100,
-            "dev.unerr/version": VERSION,
-        };
-        if (updateNotification) {
-            _meta["dev.unerr/update_available"] =
-                `${updateNotification.current} → ${updateNotification.latest}`;
-        }
-        const _context = {};
-        for (const injector of injectors) {
-            try {
-                const injected = await injector.inject({
-                    toolName,
-                    toolArgs,
-                    content,
-                    latencyMs,
-                });
-                if (injected) {
-                    for (const [k, v] of Object.entries(injected)) {
-                        _context[k] = v;
-                    }
-                }
-            }
-            catch {
-                /* injector failures are silently swallowed — never break the response */
-            }
-        }
-        const envelope = { content, _meta };
-        if (Object.keys(_context).length > 0) {
-            envelope._context = _context;
-        }
-        return envelope;
-    }
-    return { wrapResponse };
-}
-/**
- * Tier-2 strip: trim wire-only fields from `_meta` before serialization.
- *
- * Internal callers (proxy stats, eventBus, dashboard SSE) read meta BEFORE this
- * runs; the wire envelope drops fields the agent never acts on.
- *
- * Rules — silent by default, vocal only when actionable:
- *   - source / mode / mode_reason: always "local" in OSS → strip (mode kept when degraded)
- *   - latency_ms: stderr telemetry only → strip
- *   - format / columns / columnar_legend / output_format_legend: in-band
- *     `_fmt:columnar` body header is canonical; _meta duplicates → strip
- *   - tokens_budget: caller already knows what they asked for → strip
- *   - tokens_used / truncated: meaningful only when truncated:true → conditional
- */
-const WIRE_STRIP_ALWAYS = new Set([
-    "source",
-    "latency_ms",
-    "format",
-    "columns",
-    "columnar_legend",
-    "output_format_legend",
-    "tokens_budget",
-]);
-export function wireifyMeta(meta) {
-    if (!meta)
-        return meta;
-    const out = {};
-    const isLocalMode = meta.mode === "local";
-    const isTruncated = meta.truncated === true;
-    for (const [k, v] of Object.entries(meta)) {
-        if (WIRE_STRIP_ALWAYS.has(k))
-            continue;
-        if ((k === "mode" || k === "mode_reason") && isLocalMode)
-            continue;
-        if (k === "tokens_used" && !isTruncated)
-            continue;
-        if (k === "truncated" && !isTruncated)
-            continue;
-        if (v === undefined)
-            continue;
-        out[k] = v;
-    }
-    return out;
-}
-/**
- * Tier-3 strip: build a leading "ur|<tag>" signal block that goes INTO the
- * tool response body (`content[].text`).
- *
- * Why: per the MCP 2025-06-18 spec and confirmed in Claude Code / OpenAI Agents
- * SDK, `_meta` and custom envelope fields like `_context` are filtered by the
- * client and never reach the LLM context window. To keep anti-drift signals
- * actually visible to the model, we prepend them into the body.
- *
- * Token-optimized prefix format (no brackets/colons — minimal token cost):
- *   "ur|<tag> <message>"
- *
- * `ur|` is typically a single BPE token in modern tokenizers. The 3-char tag
- * is also one token. So the entire signal prefix costs ~2-3 tokens of overhead
- * vs ~5 with bracketed notation. Legend lives in agent instruction files
- * (CLAUDE.md, .cursor/rules/*, etc.) via instruction-writer.ts so the LLM
- * knows what each one means without paying for the full word every call.
- *
- *   hlt   halt   loop/circuit break — stop retrying
- *   dft   drift  file/entity changed — re-read before edit
- *   rsk   risk   high blast radius — verify callers
- *   wrn   warn   anti-pattern / negative fact
- *   hnt   hint   guidance / co-change suggestion
- *   fct   fact   surfaced project fact (procedural / convention / semantic)
- *   ctx          context already delivered — don't re-query
- *   hth   health session degraded — consider new session
- *   hst   hist   prior failures on this entity
- *   ur|          generic nudge (no tag)
- *
- * Only emitted when actionable. Marketing/metrics/"survived" causal histories
- * are dropped.
- */
-export const SIGNAL_PREFIX_LEGEND = `ur|<tag> is an unerr signal appended to MCP responses (as a footer). Tags:
-  hlt  halt — loop/circuit break: stop retrying this entity, mark_blocker and switch approach
-  dft  drift — file/entity changed: re-read with file_read/get_entity before edit
-  rsk  risk — high blast radius: call get_references({direction:'callers'}) before edit
-  wrn  warn — anti-pattern / negative fact: do not reintroduce the listed pattern
-  hnt  hint — guidance: apply the named pattern or co-modify the listed files
-  fct  fact — surfaced project fact (procedural / convention / semantic). Fact subtype is in [brackets] in the message.
-  hth  health — session degraded: start a new session before the next non-trivial task
-  hst  hist — prior failure modes: read each mode before retrying the same approach
-  pg   page — pagination/wire-cap: response was capped. Format: "ur|pg <tool> +<remaining> — <cursorArg>:<nextValue>". Paste <nextValue> back into the same arg to fetch the next slice; the values are concrete numbers, not placeholders.
-  ur|  generic nudge (no tag)`;
-/** Map signal-scorer types → 3-char wire tag. The scorer emits exactly 4
- * types (see SignalType in signal-scorer.ts): warning, guidance, context,
- * history. The fact_type ([procedural], [convention], etc.) is already
- * embedded in the message content by the scorer. */
-export function signalTag(type) {
-    switch (type) {
-        case "warning":
-            return "wrn";
-        case "guidance":
-            return "hnt";
-        case "context":
-            return "fct"; // surfaced fact (procedural / convention / semantic)
-        case "history":
-            return "hst";
-        // Direct fact-type passthrough (not currently emitted but reserved):
-        case "convention":
-            return "cnv";
-        case "procedural":
-            return "pro";
-        case "semantic":
-            return "sem";
-        case "episodic":
-            return "epi";
-        case "negative":
-            return "wrn";
-        default:
-            return (type ?? "inf").slice(0, 3);
-    }
-}
-/**
- * Hard caps applied AFTER per-tag dedup. The goal is "high-signal, low-noise":
- *   - MAX_LINES keeps the model from being drowned in stacked hints.
- *   - MAX_BYTES is a final safety net for pathological message payloads.
- */
-const MAX_SIGNAL_LINES = 2;
-const MAX_SIGNAL_BYTES = 240;
-import { getSignalDedup } from "./signal-dedup.js";
-export function buildSignalPrefix(meta, context, entityKey = null) {
-    const dedup = getSignalDedup();
-    const lines = [];
-    function tryPush(tag, scopeKey, body) {
-        if (lines.length >= MAX_SIGNAL_LINES)
-            return;
-        if (!dedup.shouldEmit(tag, scopeKey, body))
-            return;
-        lines.push(`ur|${tag} ${body}`);
-    }
-    if (meta?.circuit_breaker) {
-        const cb = meta.circuit_breaker;
-        // Build the message from whatever is concrete; if we have neither attempts
-        // nor entity AND no explicit message, the line would be "? failed attempts
-        // on entity" — useless. Suppress in that case rather than emit a sentinel.
-        let msg = null;
-        if (cb.message) {
-            msg = cb.message;
-        }
-        else if (typeof cb.attempts === "number" && cb.entity) {
-            msg = `${cb.attempts} failed attempts on ${cb.entity} — stop retrying; mark_blocker and switch approach`;
-        }
-        else if (cb.entity) {
-            msg = `repeated failures on ${cb.entity} — stop retrying; mark_blocker and switch approach`;
-        }
-        if (msg)
-            tryPush("hlt", cb.entity ?? entityKey, msg);
-    }
-    if (meta?.drift) {
-        const d = meta.drift;
-        if (d.entityStatus) {
-            const by = d.lastModifiedBy ? ` by ${d.lastModifiedBy}` : "";
-            const where = d.branch ? ` on ${d.branch}` : "";
-            tryPush("dft", entityKey, `${d.entityStatus}${where}${by} — re-read before edit`);
-        }
-    }
-    if (meta?.entity_risk) {
-        const r = meta.entity_risk;
-        if (r.risk_level === "high") {
-            // For array/envelope results (e.g. get_references), `r.entity_key` is the
-            // max-risk reference's key, NOT the queried entity. Scoping dedup on that
-            // key means each new high-risk neighbor re-fires `ur|rsk` instead of
-            // being suppressed by `on_change` against the queried entity.
-            const refKey = r.entity_key
-                ? `${entityKey ?? "?"}:ref:${r.entity_key}`
-                : entityKey;
-            // Table row #15 TRIM — replace vague "verify blast radius" imperative
-            // with a concrete next-call the agent can paste.
-            tryPush("rsk", refKey, `fan_in=${r.fan_in ?? 0} fan_out=${r.fan_out ?? 0} (high blast radius — get_references first)`);
-        }
-    }
-    if (meta?.causal_history) {
-        const ch = meta.causal_history;
-        const realFailures = (ch.failure_modes ?? []).filter((m) => m !== "survived");
-        if (realFailures.length > 0) {
-            tryPush("hst", entityKey, `${ch.interactions ?? 0} interactions, prior: ${realFailures.join(",")}`);
-        }
-    }
-    // Dropped: untagged value_guard (no tag → can't be deduped per-tag, low signal).
-    // Dropped: meta.context_complete ur|ctx — session-dedup already gates the
-    // underlying context keys; "ctx" line was pure noise.
-    if (meta?.session_health) {
-        const h = meta.session_health;
-        if (typeof h.health === "number" && h.health < 0.6) {
-            // Table row #20 TRIM — replace "consider new session" hedge with a
-            // concrete action the agent / user can execute.
-            tryPush("hth", null, `${(h.health * 100).toFixed(0)}% — ${h.recommendation ?? "start a new session before next task"}`);
-        }
-    }
-    if (context?.signals && Array.isArray(context.signals)) {
-        const signals = context.signals;
-        for (const s of signals) {
-            if (lines.length >= MAX_SIGNAL_LINES)
-                break;
-            if (!s.content)
-                continue;
-            const tag = signalTag(s.type);
-            const action = s.action ? ` — ${s.action}` : "";
-            tryPush(tag, s.entity ?? entityKey, `${s.content}${action}`);
-        }
-    }
-    // Dropped: context.tool_adoption.hint — appeared on every call regardless of
-    // whether tool was already adopted; the instruction-writer surfaces this at
-    // session boot.
-    if (lines.length === 0)
-        return "";
-    let block = `${lines.join("\n")}\n\n`;
-    if (block.length > MAX_SIGNAL_BYTES) {
-        // Trim from the tail; first signals are typically the most critical
-        // (hlt > dft > rsk > hst > hth > scorer signals).
-        const truncated = [];
-        let used = 0;
-        for (const line of lines) {
-            if (used + line.length + 1 > MAX_SIGNAL_BYTES - 2)
-                break;
-            truncated.push(line);
-            used += line.length + 1;
-        }
-        block = truncated.length > 0 ? `${truncated.join("\n")}\n\n` : "";
-    }
-    return block;
-}
-/**
- * Convenience: wrap a single response without a pipeline.
- */
-export async function wrapResponse(content, latencyMs, originalTokens = 0) {
-    return await createEnvelopePipeline().wrapResponse(content, latencyMs, "", {}, originalTokens);
-}

package/dist/proxy/session-dedup.js

@@ -1,82 +0,0 @@
-/**
- * Session-Aware Context Deduplication — tracks which _context keys have been
- * delivered in this session and filters out repeats.
- *
- * Design: in-memory only (no persistence across sessions — that's Sprint H).
- * Bounded to MAX_TRACKED_KEYS to prevent memory leaks in long sessions.
- *
- * Temporal intelligence note: the dedup window corresponds to the episodic
- * memory tier (Section 13.2). Within a session, repeated context has near-zero
- * value. Cross-session dedup requires the warm/cold tier architecture (Sprint H).
- */
-const MAX_TRACKED_KEYS = 10_000;
-/**
- * Create a session dedup tracker.
- * Filters context keys that have already been delivered for a given entity.
- */
-export function createSessionDedup() {
-    const delivered = new Map();
-    let totalKeys = 0;
-    function compoundKey(entityKey, contextKey) {
-        return `${entityKey}::${contextKey}`;
-    }
-    function hasDelivered(entityKey, contextKey) {
-        const entitySet = delivered.get(entityKey);
-        return entitySet?.has(contextKey) ?? false;
-    }
-    function markDelivered(entityKey, contextKeys) {
-        let entitySet = delivered.get(entityKey);
-        if (!entitySet) {
-            entitySet = new Set();
-            delivered.set(entityKey, entitySet);
-        }
-        for (const key of contextKeys) {
-            if (!entitySet.has(key)) {
-                entitySet.add(key);
-                totalKeys++;
-            }
-        }
-        if (totalKeys > MAX_TRACKED_KEYS) {
-            evictOldest();
-        }
-    }
-    function evictOldest() {
-        const iterator = delivered.keys();
-        let evicted = 0;
-        const target = Math.floor(MAX_TRACKED_KEYS * 0.2);
-        while (evicted < target) {
-            const result = iterator.next();
-            if (result.done)
-                break;
-            const entityKey = result.value;
-            const entitySet = delivered.get(entityKey);
-            if (entitySet) {
-                evicted += entitySet.size;
-                totalKeys -= entitySet.size;
-                delivered.delete(entityKey);
-            }
-        }
-    }
-    function filter(entityKey, context) {
-        const filtered = {};
-        const newKeys = [];
-        for (const [key, value] of Object.entries(context)) {
-            if (!hasDelivered(entityKey, key)) {
-                filtered[key] = value;
-                newKeys.push(key);
-            }
-        }
-        if (newKeys.length > 0) {
-            markDelivered(entityKey, newKeys);
-        }
-        return filtered;
-    }
-    function getDeliveredCount() {
-        return totalKeys;
-    }
-    function reset() {
-        delivered.clear();
-        totalKeys = 0;
-    }
-    return { filter, hasDelivered, markDelivered, getDeliveredCount, reset };
-}

package/dist/proxy/session-legend.js

@@ -1,30 +0,0 @@
-/**
- * Layer 6 Sprint FE-E — session-scoped legend delivery (columnar protocol + output format).
- * Legends attach once per session until invalidated (e.g. retry detected).
- */
-/** One-time output format legend text (~30 tokens). */
-export const OUTPUT_FORMAT_LEGEND = "Output conventions: use unified diff (---/+++/@@ hunks) for edits. " +
-    "When a response begins with `ur|ctx`, all context for this entity was already delivered — skip restatement. " +
-    "Prefer file path references over content repetition.";
-export function createSessionLegendTracker() {
-    let columnarSent = false;
-    let outputFormatSent = false;
-    return {
-        consumeColumnarLegend() {
-            if (columnarSent)
-                return false;
-            columnarSent = true;
-            return true;
-        },
-        consumeOutputFormatLegend() {
-            if (outputFormatSent)
-                return false;
-            outputFormatSent = true;
-            return true;
-        },
-        invalidateAll() {
-            columnarSent = false;
-            outputFormatSent = false;
-        },
-    };
-}

package/dist/proxy/session-persistence.js

@@ -1,210 +0,0 @@
-/**
- * Session Persistence — cross-session continuity for --mcp mode.
- *
- * Layer 9 PI-4: On reconnect, loads the previous session's summary and
- * generates a targeted resume context that includes:
- *   - What was in progress (hot files, incomplete entities)
- *   - Relevant facts from facts.db for those hot files
- *   - Session metrics (duration, tools used, revert count)
- *
- * Staleness rule: sessions older than 24h are considered too stale.
- * The agent gets fresh fact recall but no session continuity context.
- *
- * Graceful degradation: if any step fails, returns null (no crash).
- */
-// ── Constants ────────────────────────────────────────────────────────
-const STALENESS_THRESHOLD_MS = 24 * 60 * 60 * 1000; // 24 hours
-const WARM_THRESHOLD_MS = 4 * 60 * 60 * 1000; // 4 hours
-// ── Public API ───────────────────────────────────────────────────────
-/**
- * Generate a session resume payload from the last session's summary.
- * Integrates with facts.db if a fact store is available.
- *
- * Returns null if:
- *   - No prior session exists
- *   - Last session is older than 24h (too stale)
- *   - Any error occurs (graceful degradation)
- */
-export async function generateSessionResumePayload(unerrDir, factStore) {
-    try {
-        const { readLastSession } = await import("../tracking/session-summary-writer.js");
-        const lastSession = readLastSession(unerrDir);
-        if (!lastSession)
-            return null;
-        const endedAt = new Date(lastSession.ended_at).getTime();
-        const elapsed = Date.now() - endedAt;
-        if (elapsed > STALENESS_THRESHOLD_MS)
-            return null;
-        const staleness = elapsed < WARM_THRESHOLD_MS ? "fresh" : "warm";
-        const hotFiles = computeHotFiles(lastSession);
-        const incompleteHint = generateIncompleteHint(lastSession);
-        const recalledFacts = await recallFactsForSession(lastSession, factStore);
-        // Query facts that recently decayed below recall threshold
-        let decayedFacts = [];
-        if (factStore?.recallDecaying) {
-            try {
-                const decaying = await factStore.recallDecaying(0.05, 0.2);
-                decayedFacts = decaying.slice(0, 5).map((f) => ({
-                    fact_id: f.fact_id,
-                    type: f.fact_type,
-                    content: f.content,
-                    confidence: Math.round(f.effective_confidence * 100) / 100,
-                }));
-            }
-            catch {
-                // Non-critical
-            }
-        }
-        return {
-            session_resumed: true,
-            previous_session: {
-                session_id: lastSession.session_id,
-                duration_ms: lastSession.duration_ms,
-                tool_calls: lastSession.tool_calls,
-                chains: lastSession.chains,
-                files_modified: lastSession.files_modified.slice(0, 10),
-                entities_touched: lastSession.entities_touched.slice(0, 10),
-                tools_used: lastSession.tools_used,
-                feature_areas: lastSession.feature_areas,
-                revert_count: lastSession.revert_count,
-                facts_recorded: lastSession.facts_recorded,
-                branch: lastSession.branch,
-                ended_at: lastSession.ended_at,
-            },
-            continuity: {
-                hot_files: hotFiles,
-                incomplete_hint: incompleteHint,
-                staleness,
-            },
-            recalled_facts: recalledFacts,
-            decayed_since_last_session: decayedFacts,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-// ── Internal Helpers ─────────────────────────────────────────────────
-/**
- * Compute the "hot files" — files most likely to be worked on again.
- * Prioritizes files that appeared most frequently in tool calls.
- */
-function computeHotFiles(session) {
-    return session.files_modified.slice(0, 5);
-}
-/**
- * Generate a human-readable hint about what was incomplete.
- */
-function generateIncompleteHint(session) {
-    const parts = [];
-    if (session.revert_count > 0) {
-        parts.push(`${session.revert_count} revert(s) in last session — approach may need rethinking`);
-    }
-    if (session.files_modified.length > 5) {
-        parts.push(`Large change set (${session.files_modified.length} files) — verify consistency`);
-    }
-    const highUseTools = Object.entries(session.tools_used)
-        .filter(([_, count]) => count > 10)
-        .map(([tool]) => tool);
-    if (highUseTools.length > 0) {
-        parts.push(`Heavy usage: ${highUseTools.join(", ")}`);
-    }
-    if (parts.length === 0) {
-        return session.files_modified.length > 0
-            ? `Continuing work on ${session.files_modified.slice(0, 3).join(", ")}`
-            : "No specific continuity context";
-    }
-    return parts.join(". ");
-}
-/**
- * Recall facts relevant to the previous session's hot files.
- * Returns up to 5 facts with highest effective confidence.
- */
-async function recallFactsForSession(session, factStore) {
-    if (!factStore)
-        return [];
-    try {
-        const allFacts = [];
-        for (const file of session.files_modified.slice(0, 5)) {
-            const facts = await factStore.recallByScope(file);
-            for (const f of facts) {
-                if (!allFacts.some((existing) => existing.fact_id === f.fact_id)) {
-                    allFacts.push(f);
-                }
-            }
-        }
-        const projectFacts = await factStore.recallByScope("project");
-        for (const f of projectFacts) {
-            if (f.fact_type === "negative" &&
-                !allFacts.some((existing) => existing.fact_id === f.fact_id)) {
-                allFacts.push(f);
-            }
-        }
-        return allFacts
-            .sort((a, b) => b.effective_confidence - a.effective_confidence)
-            .slice(0, 5)
-            .map((f) => ({
-            fact_id: f.fact_id,
-            type: f.fact_type,
-            content: f.content,
-            confidence: Math.round(f.effective_confidence * 100) / 100,
-            source: f.source,
-        }));
-    }
-    catch {
-        return [];
-    }
-}
-// ── Visible Resume Block ────────────────────────────────────────────
-/**
- * Format session resume payload as a visible text block that agents will read.
- * This is prepended to the first tool response content so it's impossible to miss.
- * Keeps total output under 500 chars.
- */
-export function formatSessionResumeBlock(payload) {
-    if (!payload)
-        return "";
-    const parts = [];
-    // Elapsed time
-    const endedMs = new Date(payload.previous_session.ended_at).getTime();
-    const elapsedMs = Date.now() - endedMs;
-    const elapsed = formatElapsed(elapsedMs);
-    // Hot files
-    const hotFiles = payload.continuity.hot_files.slice(0, 3);
-    const filesStr = hotFiles.length > 0 ? hotFiles.join(", ") : "various files";
-    parts.push(`[unerr:session-resume] Previous session (${elapsed} ago): worked on ${filesStr}.`);
-    // High-confidence recalled facts
-    const importantFacts = payload.recalled_facts
-        .filter((f) => f.confidence >= 0.5)
-        .slice(0, 3);
-    for (const f of importantFacts) {
-        const pct = Math.round(f.confidence * 100);
-        parts.push(`▸ ${f.content} (${pct}%).`);
-    }
-    // Decayed facts warning
-    if (payload.decayed_since_last_session.length > 0) {
-        const n = payload.decayed_since_last_session.length;
-        const subjects = payload.decayed_since_last_session
-            .slice(0, 2)
-            .map((f) => `"${f.content.slice(0, 40)}"`);
-        parts.push(`⚠ ${n} fact(s) expired since last session: ${subjects.join(", ")}. Use record_fact to re-record if still relevant.`);
-    }
-    // Incomplete hint if meaningful
-    if (payload.continuity.incomplete_hint &&
-        payload.continuity.incomplete_hint !== "No specific continuity context") {
-        parts.push(`▸ ${payload.continuity.incomplete_hint}`);
-    }
-    const result = parts.join("\n");
-    // Truncate to 500 chars max
-    return result.length > 500 ? `${result.slice(0, 497)}...` : result;
-}
-function formatElapsed(ms) {
-    const minutes = Math.floor(ms / 60000);
-    if (minutes < 60)
-        return `${minutes}m`;
-    const hours = Math.floor(minutes / 60);
-    if (hours < 24)
-        return `${hours}h`;
-    const days = Math.floor(hours / 24);
-    return `${days}d`;
-}