@jmtrin/opencode-kevin 1.2.0 → 1.3.0

package/dist/plugin/kevin_forget.js

@@ -1,260 +0,0 @@
-import { computeEntryId } from "./okf.js";
-export function handleForget(input, deps) {
-    // v1.1.0 — every invocation counts, including dry runs and refusals (K11-005)
-    try {
-        deps.metrics.incr("forget_requests_total", 1);
-    }
-    catch {
-        // best-effort
-    }
-    if (!input.ids || input.ids.length === 0) {
-        return {
-            action: "forget",
-            ok: false,
-            dry_run: input.confirm !== true,
-            per_id: [],
-            reason: "no_ids",
-        };
-    }
-    const isDry = input.confirm !== true;
-    const per_id = [];
-    let anyChange = false;
-    let anyTombstonePlanned = false;
-    // Helper to compute entry_id for a memory row
-    const getEntryId = (row) => {
-        if (row.shared_entry_id)
-            return row.shared_entry_id;
-        return computeEntryId(row.type, row.content, row.scope);
-    };
-    // For dry_run: just plan, mutate nothing
-    if (isDry) {
-        for (const id of input.ids) {
-            const row = deps.store
-                .prepare("SELECT id, type, content, scope, status, layer, shared_entry_id FROM memories WHERE id = ?")
-                .get(id);
-            if (!row) {
-                per_id.push({ id, archived: false, reason: "not_found" });
-                continue;
-            }
-            if (row.status === "archived") {
-                // Idempotence: already archived
-                const isShared = row.layer === "shared" || row.shared_entry_id !== null;
-                if (isShared) {
-                    const entryId = getEntryId(row);
-                    try {
-                        const plan = deps.sharedLayer.planTombstone([entryId], deps.okfPath);
-                        const planned = plan.write.outcome !== "refused" && plan.entriesAdded > 0;
-                        // Already archived implies tombstone already applied, so planned should be false (noop)
-                        per_id.push({
-                            id,
-                            archived: false,
-                            reason: "already_archived",
-                            tombstone: { entry_id: entryId, planned: false, applied: false },
-                        });
-                        void plan;
-                        void planned;
-                    }
-                    catch {
-                        per_id.push({
-                            id,
-                            archived: false,
-                            reason: "already_archived",
-                            tombstone: { entry_id: entryId, planned: false, applied: false },
-                        });
-                    }
-                }
-                else {
-                    per_id.push({ id, archived: false, reason: "already_archived" });
-                }
-                continue;
-            }
-            // Would archive
-            anyChange = true;
-            const isShared = row.layer === "shared" || row.shared_entry_id !== null;
-            if (isShared) {
-                const entryId = getEntryId(row);
-                let planned = false;
-                try {
-                    const plan = deps.sharedLayer.planTombstone([entryId], deps.okfPath);
-                    // planTombstone returns ExportPlan with write outcome; if refused, planned false
-                    planned = plan.write.outcome !== "refused";
-                    anyTombstonePlanned = anyTombstonePlanned || planned;
-                    per_id.push({
-                        id,
-                        archived: true,
-                        tombstone: { entry_id: entryId, planned, applied: false },
-                    });
-                }
-                catch {
-                    per_id.push({
-                        id,
-                        archived: true,
-                        tombstone: { entry_id: entryId, planned: false, applied: false },
-                    });
-                }
-            }
-            else {
-                per_id.push({ id, archived: true });
-            }
-        }
-        const noop = !anyChange;
-        return {
-            action: "forget",
-            ok: true,
-            dry_run: true,
-            per_id,
-            ...(noop ? { noop: true } : {}),
-        };
-    }
-    // Apply mode: confirm === true
-    // We need to archive locally and publish tombstones through applyExport
-    let partial = false;
-    let appliedTombstones = 0;
-    for (const id of input.ids) {
-        const row = deps.store
-            .prepare("SELECT id, type, content, scope, status, layer, shared_entry_id FROM memories WHERE id = ?")
-            .get(id);
-        if (!row) {
-            per_id.push({ id, archived: false, reason: "not_found" });
-            continue;
-        }
-        if (row.status === "archived") {
-            const isShared = row.layer === "shared" || row.shared_entry_id !== null;
-            if (isShared) {
-                const entryId = getEntryId(row);
-                per_id.push({
-                    id,
-                    archived: false,
-                    reason: "already_archived",
-                    tombstone: { entry_id: entryId, planned: false, applied: false },
-                });
-            }
-            else {
-                per_id.push({ id, archived: false, reason: "already_archived" });
-            }
-            continue;
-        }
-        // Archive locally in a transaction
-        let archived = false;
-        try {
-            deps.store.transaction(() => {
-                deps.store
-                    .prepare(`UPDATE memories SET status = 'archived', archived_at = datetime('now'), updated_at = datetime('now') WHERE id = ? AND status != 'archived'`)
-                    .run(id);
-                const changes = deps.store.prepare("SELECT changes() AS c").get();
-                if (changes.c > 0)
-                    archived = true;
-            });
-        }
-        catch (e) {
-            per_id.push({ id, archived: false, reason: "db_error" });
-            partial = true;
-            continue;
-        }
-        anyChange = anyChange || archived;
-        const isShared = row.layer === "shared" || row.shared_entry_id !== null;
-        if (!isShared) {
-            per_id.push({ id, archived });
-            continue;
-        }
-        const entryId = getEntryId(row);
-        // Plan tombstone
-        let plan;
-        try {
-            plan = deps.sharedLayer.planTombstone([entryId], deps.okfPath);
-        }
-        catch (e) {
-            // plan failure: rollback DB archive for this id (best-effort)
-            try {
-                deps.store
-                    .prepare(`UPDATE memories SET status = 'active', archived_at = NULL WHERE id = ?`)
-                    .run(id);
-            }
-            catch { }
-            per_id.push({
-                id,
-                archived: false,
-                reason: "plan_failed",
-                tombstone: { entry_id: entryId, planned: false, applied: false },
-            });
-            partial = true;
-            continue;
-        }
-        if (plan.write.outcome === "refused") {
-            // Refusal reasons are reused verbatim (repo_mismatch, unknown_entry)
-            const reason = plan.write.reason ?? "refused";
-            per_id.push({
-                id,
-                archived,
-                reason,
-                tombstone: { entry_id: entryId, planned: false, applied: false },
-            });
-            // DB archive already done; keep it (local archive is independent of shared refusal)
-            continue;
-        }
-        // Apply through single write funnel
-        try {
-            const applied = deps.sharedLayer.applyExport(plan);
-            const wasWritten = applied.applied === "written";
-            const wasNoop = applied.applied === "noop";
-            if (wasWritten)
-                appliedTombstones++;
-            // per_id tombstone: planned true if not refused, applied true only if written
-            per_id.push({
-                id,
-                archived,
-                tombstone: {
-                    entry_id: entryId,
-                    planned: true,
-                    applied: wasWritten,
-                },
-            });
-            void wasNoop;
-        }
-        catch (e) {
-            // v1.1.0 — failure mid-way: transaction rollback restores DB; already-applied OKF write is reported honestly
-            // For this id, DB was already archived, but file write failed. We attempt to rollback DB for this id.
-            try {
-                deps.store
-                    .prepare(`UPDATE memories SET status = 'active', archived_at = NULL WHERE id = ?`)
-                    .run(id);
-                archived = false;
-            }
-            catch { }
-            per_id.push({
-                id,
-                archived: false,
-                reason: "partial",
-                tombstone: { entry_id: entryId, planned: true, applied: false },
-            });
-            partial = true;
-            // Continue to next id? According spec, failure mid-way reports ok:false reason partial
-            // We keep processing remaining ids? For now we continue but mark partial.
-        }
-    }
-    // Metrics: increment forget_tombstones_published by applied count (only when written, not noop)
-    if (appliedTombstones > 0) {
-        try {
-            deps.metrics.incr("forget_tombstones_published", appliedTombstones);
-        }
-        catch { }
-    }
-    const noop = !anyChange && per_id.every((p) => p.archived === false);
-    if (partial) {
-        return {
-            action: "forget",
-            ok: false,
-            dry_run: false,
-            per_id,
-            reason: "partial",
-            ...(noop ? { noop: true } : {}),
-        };
-    }
-    return {
-        action: "forget",
-        ok: true,
-        dry_run: false,
-        per_id,
-        ...(noop ? { noop: true } : {}),
-    };
-}

package/dist/plugin/kevin_native.d.ts

@@ -1,29 +0,0 @@
-import type { Store } from "./Store.js";
-import type { HostSurface } from "./host.js";
-import type { SettingsReader } from "./native.js";
-export type NativeAction = "show" | "enable" | "disable";
-export interface NativeRegistrationRow {
-    readonly surface: "skill" | "reference";
-    readonly registered: boolean;
-    readonly verified: boolean;
-    readonly attached_at: string | null;
-}
-export interface NativeReport {
-    readonly action: NativeAction;
-    /** The setting value: '1' or '0' as stored (TEXT). */
-    readonly value: "1" | "0";
-    /** Whether registration would be effective on THIS host (v2 subpath present). */
-    readonly effective: boolean;
-    /** Present when `effective` is false: why the intent is inert. */
-    readonly reason?: string;
-    /** The latest persisted outcome per surface (show only). */
-    readonly registrations?: NativeRegistrationRow[];
-    /** The restart note (enable/disable only). */
-    readonly note?: string;
-}
-export interface NativeDeps {
-    readonly host: HostSurface;
-    readonly store: Store;
-    readonly settings: SettingsReader;
-}
-export declare function handleNative(action: NativeAction, deps: NativeDeps): NativeReport;

package/dist/plugin/kevin_native.js

@@ -1,79 +0,0 @@
-// v0.9.0 (K9-019 / plan §5.5, D9-12) — `kevin_native`: inspect and toggle
-// `native_registration_enabled`.
-//
-// Pure in the sense that matters: `show` reads only; `enable`/`disable`
-// write `kevin_settings` and nothing else. Neither action re-attaches —
-// the probe is frozen for the process lifetime (D9-12) — and the response
-// says so explicitly, naming a restart as the requirement. `enable` on a
-// host without the v2 subpath succeeds and reports the registration as
-// inert: the setting is a statement of intent that becomes effective when
-// the host catches up, and refusing would make it untestable on the
-// majority of installations.
-//
-// The stored value is TEXT `'1'` or `'0'` — never a boolean, never
-// `'true'` (kevin_settings.value is TEXT; compare with `=== "1"`).
-function lastRows(store) {
-    try {
-        return store
-            .prepare(`SELECT surface, registered, verified, attached_at
-				 FROM native_registrations
-				 ORDER BY attached_at DESC, id DESC
-				 LIMIT 20`)
-            .all()
-            .map((row) => {
-            const r = row;
-            return {
-                surface: r.surface,
-                registered: r.registered === 1,
-                verified: r.verified === 1,
-                attached_at: r.attached_at,
-            };
-        });
-    }
-    catch {
-        // pre-010 database: the table does not exist yet — no rows to
-        // report, and that is the truth.
-        return [];
-    }
-}
-/** v0.9.0 (K9-019 / plan §5.5, D9-12) — the pure decision: the probe is
- * frozen for the process lifetime, so "effective" is derived from the
- * resolved host surface, never from a fresh probe call. */
-function effectiveOn(host) {
-    return host.v2.skill || host.v2.reference;
-}
-export function handleNative(action, deps) {
-    const current = deps.settings.getSetting("native_registration_enabled", "0");
-    const value = current === "1" ? "1" : "0";
-    if (action === "show") {
-        const report = {
-            action,
-            value,
-            effective: effectiveOn(deps.host),
-            registrations: lastRows(deps.store),
-            ...(effectiveOn(deps.host)
-                ? {}
-                : {
-                    reason: "v2 subpath absent from the resolved host package — registration would be inert",
-                }),
-        };
-        return report;
-    }
-    const next = action === "enable" ? "1" : "0";
-    deps.store
-        .prepare(`INSERT INTO kevin_settings (key, value) VALUES (?, ?)
-			 ON CONFLICT(key) DO UPDATE SET value = excluded.value`)
-        .run("native_registration_enabled", next);
-    const report = {
-        action,
-        value: next,
-        effective: effectiveOn(deps.host),
-        note: "the probe is frozen for the process lifetime — restart the host for the change to take effect",
-        ...(effectiveOn(deps.host)
-            ? {}
-            : {
-                reason: "v2 subpath absent from the resolved host package — registration would be inert",
-            }),
-    };
-    return report;
-}

package/dist/plugin/kevin_propose.d.ts

@@ -1,23 +0,0 @@
-import type { ArtifactWriter } from "./ArtifactWriter.js";
-import type { Curator, ProposalKind } from "./Curator.js";
-/**
- * K6-014 — v0.6.0 pull — `kevin_propose` tool logic.
- *
- * Strict dry run in the exact sense of v0.5 `kevin_trace` (D5-08): creates
- * `pending` rows and returns their unified diffs. No disk write, no `curated`
- * flag, no metric beyond `proposals_created` (which `Curator.propose()`
- * itself increments).
- */
-export interface ProposedChange {
-    readonly id: string;
-    readonly kind: ProposalKind;
-    readonly targetPath: string;
-    readonly memoryIds: readonly string[];
-    readonly status: "pending";
-    readonly createdAt: string;
-    readonly diff: string;
-}
-export interface ProposeResult {
-    readonly proposals: readonly ProposedChange[];
-}
-export declare function kevinPropose(curator: Curator, writer: ArtifactWriter, kind: ProposalKind): ProposeResult;

package/dist/plugin/kevin_propose.js

@@ -1,14 +0,0 @@
-export function kevinPropose(curator, writer, kind) {
-    const proposals = curator.propose(kind, writer);
-    return {
-        proposals: proposals.map((p) => ({
-            id: p.id,
-            kind: p.kind,
-            targetPath: p.targetPath,
-            memoryIds: [...p.memoryIds],
-            status: "pending",
-            createdAt: p.createdAt,
-            diff: p.diff,
-        })),
-    };
-}

package/dist/plugin/kevin_publish.d.ts

@@ -1,38 +0,0 @@
-import type { ArtifactWriter } from "./ArtifactWriter.js";
-import type { MaterializedBundle, Materializer } from "./Materializer.js";
-import type { MemoryService } from "./MemoryService.js";
-import type { Capabilities } from "./capabilities.js";
-/**
- * K6-020 — v0.6.0 pull — `kevin_publish` tool logic.
- *
- * Regenerates the pull-channel bundles on demand. Writes only through the
- * `ArtifactWriter` and only to the Materializer's targets (D6-01, D6-07):
- * `~/.opencode-kevin/skills/project-knowledge.md` and
- * `~/.opencode-kevin/refs/<topic>.md`. `agents_md_path` is unreachable
- * here by construction — the paths come from `bundleTargets()`, never from
- * a setting — and that is asserted in the integration test even when the
- * setting points inside `~/.opencode-kevin/`.
- *
- * Registration is a session-start concern (K6-018/019), not this tool's:
- * the output reports the emission state honestly (`"unavailable"` on a v1
- * host, `"off"` for a '0' setting, `"on"` when session start registers)
- * instead of pretending success.
- */
-export type EmissionState = "on" | "off" | "unavailable";
-export interface PublishResult {
-    readonly bundles: readonly {
-        readonly topic: string;
-        readonly outcome: MaterializedBundle["outcome"];
-    }[];
-    readonly emission: {
-        readonly skill: EmissionState;
-        readonly reference: EmissionState;
-    };
-}
-export interface PublishDeps {
-    readonly materializer: Materializer;
-    readonly writer: ArtifactWriter;
-    readonly memoryService: MemoryService;
-    readonly capabilities: Capabilities;
-}
-export declare function kevinPublish(deps: PublishDeps): PublishResult;

package/dist/plugin/kevin_publish.js

@@ -1,18 +0,0 @@
-function emissionState(capable, setting) {
-    if (!capable)
-        return "unavailable";
-    return setting === "1" ? "on" : "off";
-}
-export function kevinPublish(deps) {
-    const bundles = deps.materializer.materialize(deps.writer);
-    return {
-        bundles: bundles.map((b) => ({
-            topic: b.topic,
-            outcome: b.outcome,
-        })),
-        emission: {
-            skill: emissionState(deps.capabilities.skills, deps.memoryService.getSetting("skill_emission_enabled", "0")),
-            reference: emissionState(deps.capabilities.references, deps.memoryService.getSetting("reference_emission_enabled", "0")),
-        },
-    };
-}

package/dist/plugin/kevin_why.d.ts

@@ -1,23 +0,0 @@
-import type { Store } from "./Store.js";
-export interface WhyInput {
-    query: string;
-}
-export interface WhyTraceEvent {
-    event: "failure" | "fix";
-    fingerprint: string;
-    session: string;
-    ts: string;
-}
-export interface WhyResult {
-    summary: string;
-    confidence: number;
-    evidence_count: number;
-    /** v0.4.0 (K4-020) — negative evidence for the honest phrasing. */
-    recurrence_count: number;
-    /** v0.4.0 (K4-020) — deterministic "Fixed by:" raw material, if any. */
-    fix_args: string | null;
-    last_verified: string | null;
-    trace: WhyTraceEvent[];
-    related_rules: string[];
-}
-export declare function kevinWhy(store: Store, query: string): WhyResult | null;

package/dist/plugin/kevin_why.js

@@ -1,111 +0,0 @@
-import { TS_CODE_RULES } from "./Reflector.js";
-import { hasFeedbackColumns } from "./columns.js";
-import { computeConfidence } from "./confidence.js";
-import { toMatchClause, tokenizeQuery } from "./query-tokenizer.js";
-export function kevinWhy(store, query) {
-    // v0.3.0 fix (bug #7) — the old code wrapped the WHOLE query in a
-    // single quoted phrase, so it only matched the exact full-string
-    // sequence. Tokenize like MemoryService.queryRelevant: quote each
-    // word (escaping inner quotes) and AND them together, so partial or
-    // multi-word queries still hit the FTS index.
-    const tokens = tokenizeQuery(query);
-    if (tokens.length === 0)
-        return null;
-    const match = toMatchClause(tokens, " AND ");
-    // Best-effort (v0.4.0): DBs pre-005 lack `recurrence_count`; degrade
-    // to "no explanation" instead of crashing the calling session.
-    let patternRows;
-    try {
-        patternRows = store
-            .prepare(`SELECT m.id, m.content, m.fingerprint, m.evidence_count,
-				        m.recurrence_count, m.fix_args, m.last_verified_at, m.created_at${hasFeedbackColumns(store)
-            ? ", m.feedback_positive, m.feedback_negative"
-            : ""}
-				 FROM memories_fts
-				 JOIN memories m ON m.rowid = memories_fts.rowid
-				 WHERE memories_fts MATCH ?
-				   AND m.type = 'pattern'
-				   AND m.origin IN ('causal', 'pattern')
-				   AND m.status = 'active'
-				 ORDER BY m.evidence_count DESC, m.created_at DESC
-				 LIMIT 1`)
-            .all(match);
-    }
-    catch {
-        return null;
-    }
-    if (patternRows.length === 0)
-        return null;
-    const pattern = patternRows[0];
-    const fp = pattern.fingerprint;
-    // v0.4.0 (K4-010) — two-sided confidence shared with promoteToPattern.
-    // v0.5.0 (K5-010) — human feedback terms nudge it (D5-02).
-    const confidence = computeConfidence(pattern.evidence_count ?? 0, pattern.recurrence_count ?? 0, pattern.feedback_positive ?? 0, pattern.feedback_negative ?? 0);
-    // BUG-007 — the trace is built from the error-memory sessions below;
-    // the legacy `traceRows` probe (executed but unused, with a
-    // never-matching `tc.fingerprint LIKE '%<8-hex>%'` branch against the
-    // tool|args|success hash) was deleted.
-    const trace = [];
-    const errorSessions = store
-        .prepare(`SELECT DISTINCT source_session, fingerprint, created_at
-			 FROM memories
-			 WHERE fingerprint = ? AND type = 'error' AND origin = 'reflector'
-			 ORDER BY created_at ASC`)
-        .all(fp);
-    for (const err of errorSessions) {
-        trace.push({
-            event: "failure",
-            fingerprint: err.fingerprint,
-            session: err.source_session ?? "unknown",
-            ts: err.created_at,
-        });
-        const fixRow = store
-            .prepare(`SELECT session_id, ts FROM tool_calls
-				 WHERE fix_for_fingerprint = ?
-				   AND session_id = ?
-				 ORDER BY ts ASC LIMIT 1`)
-            .get(fp, err.source_session);
-        if (fixRow) {
-            trace.push({
-                event: "fix",
-                fingerprint: fp,
-                session: fixRow.session_id,
-                ts: fixRow.ts,
-            });
-        }
-    }
-    const relatedRules = [];
-    const tsCodeMatch = query.match(/TS(\d{4,5})/);
-    if (tsCodeMatch) {
-        const hint = TS_CODE_RULES[tsCodeMatch[1]] ?? `review TS${tsCodeMatch[1]}`;
-        relatedRules.push(hint);
-    }
-    // v0.4.0 (K4-020) — honest summary (plan §5.3 / D4-11): with
-    // recurrences the pattern is NOT consistently resolved, so the
-    // phrasing reports the real success ratio ("resolved in N of M
-    // attempts") instead of "consistently resolved".
-    const evidenceCount = pattern.evidence_count ?? 0;
-    const recurrence = pattern.recurrence_count ?? 0;
-    let summary;
-    if (recurrence > 0) {
-        const fix = pattern.fix_args
-            ? `fixing ${pattern.fix_args}`
-            : `fixing ${relatedRules.length > 0
-                ? relatedRules.join(", ")
-                : "the underlying issue"}`;
-        summary = `When tool fails with ${query}: resolved in ${evidenceCount} of ${evidenceCount + recurrence} attempts by ${fix}.`;
-    }
-    else {
-        summary = `When tool fails with ${query}: ${confidence >= 0.7 ? "consistently" : "often"} resolved by fixing ${relatedRules.length > 0 ? relatedRules.join(", ") : "the underlying issue"}.`;
-    }
-    return {
-        summary,
-        confidence,
-        evidence_count: evidenceCount,
-        recurrence_count: recurrence,
-        fix_args: pattern.fix_args ?? null,
-        last_verified: pattern.last_verified_at ?? null,
-        trace,
-        related_rules: relatedRules,
-    };
-}

package/dist/plugin/memory-format.d.ts

@@ -1,20 +0,0 @@
-export interface MemoryBlockItem {
-    id?: string;
-    type: string;
-    content: string;
-    protect?: boolean;
-    /** v0.4.0 (K4-023) — weak lesson admitted in debug mode: the row is
-     * rendered with a `(low confidence)` marker line. */
-    weak?: boolean;
-}
-export declare function escapeInjectedText(text: string): string;
-/**
- * v0.4.0 (K4-012) — progressive disclosure for injection: a short
- * snippet row instead of the full body. Row = `id:` line + `[type]`
- * prefix + the first 2 non-empty lines of content, wrapped in
- * `<protect>` unless the memory opted out (`protect: false`). The
- * full body stays available via `kevin_get`.
- */
-export declare function formatSnippet(m: MemoryBlockItem): string;
-export declare function formatMemories(memories: MemoryBlockItem[], tag: "context" | "memory"): string;
-export declare function formatMemorySnippets(memories: MemoryBlockItem[], tag: "context" | "memory"): string;

package/dist/plugin/memory-format.js

@@ -1,59 +0,0 @@
-export function escapeInjectedText(text) {
-    return text
-        .replace(/&/g, "&")
-        .replace(/</g, "&lt;")
-        .replace(/>/g, "&gt;");
-}
-function typePrefix(m) {
-    const t = escapeInjectedText(String(m.type));
-    return m.weak ? `[${t}] (low confidence)` : `[${t}]`;
-}
-function formatRow(m) {
-    const idLine = m.id ? `id: ${escapeInjectedText(m.id)}\n` : "";
-    const body = `${idLine}${typePrefix(m)} ${escapeInjectedText(m.content)}`;
-    return m.protect === false ? body : `<protect>\n${body}\n</protect>`;
-}
-/**
- * v0.4.0 (K4-012) — progressive disclosure for injection: a short
- * snippet row instead of the full body. Row = `id:` line + `[type]`
- * prefix + the first 2 non-empty lines of content, wrapped in
- * `<protect>` unless the memory opted out (`protect: false`). The
- * full body stays available via `kevin_get`.
- */
-export function formatSnippet(m) {
-    const lines = m.content
-        .split(/\r?\n/)
-        .map((l) => l.trim())
-        .filter((l) => l.length > 0)
-        .slice(0, 2);
-    // v0.4.0 (K4-025) — a pattern's `Fixed by:` line is the highest-value
-    // payload (plan §5.4 / D4-07); surface it in the snippet even though
-    // it sits below the 2-line cut. Only patterns carry the line.
-    const fixLine = lines
-        .map((l) => l)
-        .concat(m.content
-        .split(/\r?\n/)
-        .map((l) => l.trim())
-        .filter((l) => l.startsWith("Fixed by:")))[2];
-    const idLine = m.id ? `id: ${escapeInjectedText(m.id)}\n` : "";
-    const bodyLines = fixLine ? [...lines, fixLine] : lines;
-    const body = bodyLines.length === 0
-        ? ""
-        : `${idLine}${typePrefix(m)} ${escapeInjectedText(bodyLines.join("\n"))}`;
-    return m.protect === false ? body : `<protect>\n${body}\n</protect>`;
-}
-function wrapBlock(body, tag) {
-    return tag === "context"
-        ? `<kevin-context>Lecciones relevantes:\n${body}\n</kevin-context>`
-        : `<kevin-memory>\n${body}\n</kevin-memory>`;
-}
-export function formatMemories(memories, tag) {
-    if (memories.length === 0)
-        return "";
-    return wrapBlock(memories.map(formatRow).join("\n"), tag);
-}
-export function formatMemorySnippets(memories, tag) {
-    if (memories.length === 0)
-        return "";
-    return wrapBlock(memories.map(formatSnippet).join("\n"), tag);
-}