@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/proxy/response-enrichment.js

@@ -0,0 +1,32 @@
+/**
+ * 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

@@ -0,0 +1,313 @@
+/**
+ * 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

@@ -0,0 +1,82 @@
+/**
+ * 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

@@ -0,0 +1,30 @@
+/**
+ * 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

@@ -0,0 +1,210 @@
+/**
+ * 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`;
+}