@jmtrin/opencode-kevin 0.9.0 → 1.1.0

package/dist/plugin/RepoIdentity.js

@@ -298,4 +298,3 @@ export function initProjectFile(cwd, writer) {
         };
     }
 }
-//# sourceMappingURL=RepoIdentity.js.map

package/dist/plugin/RepoTruth.js

@@ -597,4 +597,3 @@ function normalizeBool(v) {
     return null;
 }
 export { MAX_FACTS_PER_PROJECT };
-//# sourceMappingURL=RepoTruth.js.map

package/dist/plugin/Retrospective.js

@@ -67,6 +67,17 @@ export const METRIC_KEY_LABELS = {
     injections_suppressed_dead_hook: "Inyecciones suprimidas (hook muerto)",
     native_registrations_total: "Registros nativos (totales)",
     native_registration_failures: "Fallos de registro nativo",
+    // v1.0.0 (K10-005 / plan §6) — the six keys seeded by migration 011 section 3.
+    perf_samples_recorded: "Muestras de rendimiento registradas",
+    perf_budget_breaches: "Brechas de presupuesto de rendimiento",
+    dispose_fires_total: "Disparos de dispose (totales)",
+    dispose_misses_total: "Misses de dispose",
+    contract_digest_changes: "Cambios de digest de contrato",
+    bench_runs_total: "Ejecuciones de benchmark (totales)",
+    // v1.1.0 (K11-001 / plan §4) — drift metrics; labels required by BUG-014 regression.
+    bench_regression_failures: "Fallos de regresion de benchmark",
+    forget_requests_total: "Solicitudes de olvido totales",
+    forget_tombstones_published: "Tombstones publicados por olvido",
 };
 function originLabel(origin) {
     if (origin === "reflector")
@@ -200,4 +211,3 @@ export class Retrospective {
         return lines.join("\n");
     }
 }
-//# sourceMappingURL=Retrospective.js.map

package/dist/plugin/SharedLayer.js

@@ -460,4 +460,3 @@ export class SharedLayer {
         return n;
     }
 }
-//# sourceMappingURL=SharedLayer.js.map

package/dist/plugin/Store.js

@@ -48,4 +48,3 @@ export class Store {
         return this.db;
     }
 }
-//# sourceMappingURL=Store.js.map

package/dist/plugin/ToolCallObserver.js

@@ -1,3 +1,4 @@
+import { hasColumn } from "./columns.js";
 import { fingerprint as computeFingerprint } from "./fingerprint.js";
 import { redactPaths, stripPrivate } from "./redact.js";
 import { uuidv7 } from "./uuid.js";
@@ -54,11 +55,23 @@ export class ToolCallObserver {
                 return;
             }
         }
-        this.store
-            .prepare(`INSERT INTO tool_calls
-				 (id, session_id, ts, tool, args_summary, success, duration_ms, agent, error_type, metadata, project_id, fingerprint)
-				 VALUES (?, ?, datetime('now'), ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-            .run(input.callID ?? uuidv7(), sessionId, input.tool, argsSummary, success, durationMs, agent, errorType, metadata, projectId, fp);
+        // v1.1.0 (K11-002 / plan §5.2, D11-01/D11-07) — dual-write: legacy `ts`
+        // stays (`datetime('now')`), new `ts_ms` holds Date.now() when the
+        // column exists. Probe is cached via columns registry (K11-011).
+        if (hasColumn(this.store, "tool_calls", "ts_ms")) {
+            this.store
+                .prepare(`INSERT INTO tool_calls
+					 (id, session_id, ts, ts_ms, tool, args_summary, success, duration_ms, agent, error_type, metadata, project_id, fingerprint)
+					 VALUES (?, ?, datetime('now'), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(input.callID ?? uuidv7(), sessionId, Date.now(), input.tool, argsSummary, success, durationMs, agent, errorType, metadata, projectId, fp);
+        }
+        else {
+            this.store
+                .prepare(`INSERT INTO tool_calls
+					 (id, session_id, ts, tool, args_summary, success, duration_ms, agent, error_type, metadata, project_id, fingerprint)
+					 VALUES (?, ?, datetime('now'), ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(input.callID ?? uuidv7(), sessionId, input.tool, argsSummary, success, durationMs, agent, errorType, metadata, projectId, fp);
+        }
     }
     isDedupEnabled() {
         try {
@@ -186,4 +199,3 @@ export class ToolCallObserver {
         return v;
     }
 }
-//# sourceMappingURL=ToolCallObserver.js.map

package/dist/plugin/capabilities.js

@@ -39,4 +39,3 @@ export function probe(input) {
         return ALL_FALSE;
     }
 }
-//# sourceMappingURL=capabilities.js.map

package/dist/plugin/columns.d.ts

@@ -0,0 +1,11 @@
+import type { Store } from "./Store.js";
+export declare function hasColumn(store: Store, table: string, column: string): boolean;
+export declare function hasIgnoredColumn(store: Store): boolean;
+export declare function hasCuratedColumn(store: Store): boolean;
+export declare function hasTruthColumns(store: Store): boolean;
+export declare function hasRepoIdColumn(store: Store): boolean;
+export declare function hasLayerColumn(store: Store): boolean;
+export declare function hasRecurrenceColumn(store: Store): boolean;
+export declare function hasArchivedColumn(store: Store): boolean;
+export declare function hasFeedbackColumns(store: Store): boolean;
+export declare function hasFeedbackTable(store: Store): boolean;

package/dist/plugin/columns.js

@@ -0,0 +1,54 @@
+const cache = new WeakMap();
+export function hasColumn(store, table, column) {
+    const byStore = cache.get(store);
+    const key = `${table}.${column}`;
+    if (byStore?.get(key) === true)
+        return true;
+    try {
+        store.prepare(`SELECT ${column} FROM ${table} LIMIT 0`).get();
+        let m = byStore;
+        if (!m) {
+            m = new Map();
+            cache.set(store, m);
+        }
+        m.set(key, true);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// v1.1.0 (K11-011 / plan §5.5, D11-06) — named helpers delegating to the registry
+export function hasIgnoredColumn(store) {
+    return hasColumn(store, "memories", "ignored");
+}
+export function hasCuratedColumn(store) {
+    return hasColumn(store, "memories", "curated");
+}
+export function hasTruthColumns(store) {
+    return hasColumn(store, "memories", "truth_penalty");
+}
+export function hasRepoIdColumn(store) {
+    return hasColumn(store, "memories", "repo_id");
+}
+export function hasLayerColumn(store) {
+    return hasColumn(store, "memories", "layer");
+}
+export function hasRecurrenceColumn(store) {
+    return hasColumn(store, "memories", "recurrence_count");
+}
+export function hasArchivedColumn(store) {
+    return hasColumn(store, "memories", "archived_at");
+}
+export function hasFeedbackColumns(store) {
+    return hasColumn(store, "memories", "feedback_positive");
+}
+export function hasFeedbackTable(store) {
+    try {
+        store.prepare("SELECT COUNT(*) FROM memory_feedback LIMIT 0").get();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/plugin/confidence.js

@@ -32,4 +32,3 @@ export function computeConfidence(evidenceCount, recurrenceCount, positiveFeedba
         FEEDBACK_NEGATIVE_STEP * negativeFeedback;
     return Math.min(CONFIDENCE_MAX, Math.max(CONFIDENCE_MIN, raw));
 }
-//# sourceMappingURL=confidence.js.map

package/dist/plugin/contract.d.ts

@@ -0,0 +1,54 @@
+export declare const CONTRACT_VERSION = 1;
+export type Stability = "frozen" | "forward-only";
+export interface ContractClause {
+    readonly id: string;
+    readonly title: string;
+    readonly stability: Stability;
+    readonly since: string;
+    readonly deprecated?: string;
+    readonly replacement?: string;
+    readonly value: unknown;
+}
+export interface PublicContract {
+    readonly contractVersion: number;
+    readonly clauses: readonly ContractClause[];
+}
+export interface ContractInput {
+    readonly packageName?: string;
+    readonly packageVersion?: string;
+}
+export declare const CONTRACT_TOOL_NAMES: readonly string[];
+/**
+ * v1.0.0 (K10-018/K10-019 / plan §5.6) — tools added AFTER the initial
+ * freeze, each carrying the `since` the deprecation policy requires. A
+ * 1.x addition without an entry here fails the contract test as
+ * added_bare.
+ */
+export declare const CONTRACT_TOOL_ADDITIONS: readonly {
+    name: string;
+    since: string;
+}[];
+/**
+ * v1.1.0 (K11-007 / plan §5.1, D11-01) — metric keys added after the freeze,
+ * each carrying the `since` the deprecation policy requires (C-05).
+ */
+export declare const CONTRACT_METRIC_ADDITIONS: readonly {
+    name: string;
+    since: string;
+}[];
+/**
+ * v1.0.0 (K10-027 / plan §5.7) — the C-09 boundary addition. Stored is
+ * not trusted: anything reaching an artifact or a prompt is escaped at
+ * the single write path, according to its container.
+ */
+export declare const BOUNDARY_INVARIANT = "untrusted-input escaping at the single write path";
+export declare function describeContract(_input?: ContractInput): PublicContract;
+export declare function contractDigest(c: PublicContract): string;
+export type ContractDiffKind = "removed" | "changed" | "added_ok" | "added_bare";
+export interface ContractDiff {
+    readonly clauseId: string;
+    readonly path: string;
+    readonly kind: ContractDiffKind;
+    readonly remedy: string;
+}
+export declare function diffContract(golden: PublicContract, live: PublicContract): readonly ContractDiff[];

package/dist/plugin/contract.js

@@ -0,0 +1,383 @@
+// v1.0.0 (K10-006 / plan §5.1) — the surface, as data.
+import { MARKER_BEGIN, MARKER_END } from "./ArtifactWriter.js";
+import { METRIC_KEY_LABELS } from "./Retrospective.js";
+import { fnv1a64 } from "./fingerprint.js";
+import { KEVIN_CONFIG_KEYS } from "./index.js";
+import { MAX_ENTRIES, MAX_LINE_BYTES } from "./okf.js";
+export const CONTRACT_VERSION = 1;
+// Tool names — the live source of truth for C-03. Any rename here must
+// flow to the contract (K10-006 AC: renaming a tool changes C-03).
+// Keep this array adjacent to the actual tool registrations in index.ts
+// (checked by a test that parses both files).
+export const CONTRACT_TOOL_NAMES = [
+    "kevin_save",
+    "kevin_query",
+    "kevin_get",
+    "kevin_recall",
+    "kevin_status",
+    "kevin_project",
+    "kevin_audit",
+    "kevin_doctor",
+    "kevin_native",
+    "kevin_retrospective",
+    "kevin_why",
+    "kevin_feedback",
+    "kevin_trace",
+    "kevin_export",
+    "kevin_import",
+    "kevin_config",
+    "kevin_facts",
+    "kevin_conflicts",
+    "kevin_propose",
+    "kevin_publish",
+    "kevin_approve",
+    "kevin_share",
+    "kevin_sync",
+];
+/**
+ * v1.0.0 (K10-018/K10-019 / plan §5.6) — tools added AFTER the initial
+ * freeze, each carrying the `since` the deprecation policy requires. A
+ * 1.x addition without an entry here fails the contract test as
+ * added_bare.
+ */
+export const CONTRACT_TOOL_ADDITIONS = [
+    { name: "kevin_bench", since: "1.0.0" },
+    { name: "kevin_contract", since: "1.0.0" },
+    { name: "kevin_forget", since: "1.1.0" },
+];
+/**
+ * v1.1.0 (K11-007 / plan §5.1, D11-01) — metric keys added after the freeze,
+ * each carrying the `since` the deprecation policy requires (C-05).
+ */
+export const CONTRACT_METRIC_ADDITIONS = [
+    { name: "bench_regression_failures", since: "1.1.0" },
+    { name: "forget_requests_total", since: "1.1.0" },
+    { name: "forget_tombstones_published", since: "1.1.0" },
+];
+/**
+ * v1.0.0 (K10-027 / plan §5.7) — the C-09 boundary addition. Stored is
+ * not trusted: anything reaching an artifact or a prompt is escaped at
+ * the single write path, according to its container.
+ */
+export const BOUNDARY_INVARIANT = "untrusted-input escaping at the single write path";
+// For canonical JSON: sort keys recursively, no floats.
+function canonicalJson(value) {
+    if (value === null)
+        return "null";
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    if (typeof value === "number") {
+        if (!Number.isFinite(value) || !Number.isInteger(value))
+            throw new Error("contract: non-integer number in canonical JSON");
+        return String(value);
+    }
+    if (typeof value === "string")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (typeof value === "object") {
+        const obj = value;
+        const keys = Object.keys(obj).sort();
+        return `{${keys.map((k) => `${JSON.stringify(k)}:${canonicalJson(obj[k])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+export function describeContract(_input) {
+    // Derive clause values from live source wherever possible (plan §5.1).
+    // C-03 members added after the freeze carry their `since` as objects;
+    // the original frozen set stays plain strings.
+    const toolAdditions = [...CONTRACT_TOOL_ADDITIONS].sort((a, b) => a.name.localeCompare(b.name));
+    const toolValue = {
+        tools: [[...CONTRACT_TOOL_NAMES].sort(), toolAdditions].flat(),
+    };
+    const settingValue = { keys: [...KEVIN_CONFIG_KEYS].sort() };
+    // v1.1.0 — metric keys added after freeze carry `since` (C-05)
+    const metricAdditions = [...CONTRACT_METRIC_ADDITIONS].sort((a, b) => a.name.localeCompare(b.name));
+    const baseMetricKeys = Object.keys(METRIC_KEY_LABELS)
+        .filter((k) => !metricAdditions.some((a) => a.name === k))
+        .sort();
+    const metricValue = { keys: [...baseMetricKeys, ...metricAdditions].flat() };
+    const clauses = [
+        {
+            id: "C-01",
+            title: "AGENTS.md marker pair",
+            stability: "frozen",
+            since: "0.6.0",
+            value: {
+                markers: [MARKER_BEGIN, MARKER_END],
+                splice_rule: "bytes outside markers preserved verbatim",
+            },
+        },
+        {
+            id: "C-02",
+            title: "OKF v2 wire format",
+            stability: "frozen",
+            since: "0.8.0",
+            value: {
+                header_lines: 3,
+                field_order: ["entry_id", "type", "content", "scope", "created_at"],
+                entry_id_derivation: "fnv1a64 over canonical field ordering",
+                eol: "LF",
+                integers_only: true,
+                sort_order: "entry_id ascending",
+                max_line_bytes: MAX_LINE_BYTES,
+                max_entries: MAX_ENTRIES,
+            },
+        },
+        {
+            id: "C-03",
+            title: "Tool names and argument shapes",
+            stability: "frozen",
+            since: "0.2.0",
+            value: toolValue,
+        },
+        {
+            id: "C-04",
+            title: "Setting keys, types and defaults",
+            stability: "frozen",
+            since: "0.2.0",
+            value: settingValue,
+        },
+        {
+            id: "C-05",
+            title: "Metric key names",
+            stability: "frozen",
+            since: "0.2.0",
+            value: metricValue,
+        },
+        {
+            id: "C-06",
+            title: "Package entry points",
+            stability: "frozen",
+            since: "0.1.0",
+            value: {
+                name: "@jmtrin/opencode-kevin",
+                main: "dist/plugin/index.js",
+                types: "dist/plugin/index.d.ts",
+                exports_order: ["types", "import"],
+                engines: ">=22.5.0",
+            },
+        },
+        {
+            id: "C-07",
+            title: "Database schema",
+            stability: "forward-only",
+            since: "0.1.0",
+            value: {
+                schema_version: "012",
+                migrations_forward_only: true,
+            },
+        },
+        {
+            id: "C-08",
+            title: "Filesystem locations",
+            stability: "frozen",
+            since: "0.2.0",
+            value: {
+                db: "~/.opencode-kevin/kevin.db",
+                refs: "refs/",
+                skills: "skills/",
+                okf: ".kevin/knowledge.okf",
+            },
+        },
+        {
+            id: "C-09",
+            title: "Behavioural invariants",
+            stability: "frozen",
+            since: "0.8.0",
+            value: {
+                invariants: [
+                    "zero process spawns",
+                    "zero network calls",
+                    "no raw author email written",
+                    "single write path: ArtifactWriter is the only artifact writer",
+                ],
+                // v1.0.0 (K10-027 / plan §5.7) — the untrusted-input boundary
+                // joins the clause as an addition carrying its `since`; the
+                // frozen invariant strings above are untouched.
+                boundary: [{ name: BOUNDARY_INVARIANT, since: "1.0.0" }],
+            },
+        },
+    ];
+    return { contractVersion: CONTRACT_VERSION, clauses };
+}
+export function contractDigest(c) {
+    const payload = canonicalJson(c.clauses);
+    return fnv1a64(payload);
+}
+function valueMembers(value) {
+    // Normalize clause value into a flat member map for diffing.
+    // If value is { tools: [...] } => members are tool names.
+    // If { keys: [...] } => member per key.
+    // Otherwise flatten object keys.
+    if (value !== null && typeof value === "object") {
+        const obj = value;
+        if (Array.isArray(obj.tools)) {
+            const m = new Map();
+            for (const t of obj.tools) {
+                if (typeof t === "string")
+                    m.set(t, undefined);
+                else if (t !== null &&
+                    typeof t === "object" &&
+                    "name" in t)
+                    m.set(t.name, t);
+            }
+            return m;
+        }
+        if (Array.isArray(obj.keys)) {
+            const m = new Map();
+            for (const k of obj.keys) {
+                if (typeof k === "string")
+                    m.set(k, undefined);
+                else if (k !== null &&
+                    typeof k === "object" &&
+                    "name" in k)
+                    m.set(k.name, k);
+            }
+            return m;
+        }
+        if (Array.isArray(obj.markers) || Array.isArray(obj.invariants)) {
+            const arr = (obj.markers ?? obj.invariants);
+            const m = new Map();
+            for (const v of arr)
+                m.set(v, v);
+            // v1.0.0 (K10-027) — boundary additions sit beside the frozen
+            // invariant strings and carry their `since` like tool additions.
+            if (Array.isArray(obj.boundary)) {
+                for (const b of obj.boundary) {
+                    if (b !== null &&
+                        typeof b === "object" &&
+                        "name" in b)
+                        m.set(b.name, b);
+                }
+            }
+            return m;
+        }
+        // Generic object: each key is a member
+        const m = new Map();
+        for (const [k, v] of Object.entries(obj))
+            m.set(k, v);
+        return m;
+    }
+    return new Map([["value", value]]);
+}
+export function diffContract(golden, live) {
+    const diffs = [];
+    const goldenById = new Map(golden.clauses.map((c) => [c.id, c]));
+    const liveById = new Map(live.clauses.map((c) => [c.id, c]));
+    // Removed clauses
+    for (const g of golden.clauses) {
+        if (!liveById.has(g.id)) {
+            diffs.push({
+                clauseId: g.id,
+                path: g.id,
+                kind: "removed",
+                remedy: `Clause ${g.id} was removed. Revert, or open a 2.0.0.`,
+            });
+        }
+    }
+    // Added clauses — check since
+    for (const l of live.clauses) {
+        if (!goldenById.has(l.id)) {
+            const hasSince = typeof l.since === "string" &&
+                l.since.length > 0;
+            diffs.push({
+                clauseId: l.id,
+                path: l.id,
+                kind: hasSince ? "added_ok" : "added_bare",
+                remedy: hasSince
+                    ? `Clause ${l.id} was added with since. Allowed in 1.x.`
+                    : `Clause ${l.id} was added without since. Add since or revert, or open a 2.0.0.`,
+            });
+        }
+    }
+    // Within-clause diff
+    for (const g of golden.clauses) {
+        const l = liveById.get(g.id);
+        if (!l)
+            continue;
+        const gMembers = valueMembers(g.value);
+        const lMembers = valueMembers(l.value);
+        // Normalize members: for arrays we care about set equality
+        for (const [mem, _gv] of gMembers) {
+            if (!lMembers.has(mem)) {
+                diffs.push({
+                    clauseId: g.id,
+                    path: `${g.id}.${mem}`,
+                    kind: "removed",
+                    remedy: `Member ${mem} in ${g.id} was removed. Revert, or open a 2.0.0.`,
+                });
+            }
+            else {
+                const lv = lMembers.get(mem);
+                const gv = gMembers.get(mem);
+                if (JSON.stringify(lv) !== JSON.stringify(gv)) {
+                    // Member present on both sides but its value moved (e.g. an
+                    // addition object whose `since` was edited). Report it here,
+                    // at member granularity, instead of letting it fall through
+                    // to the coarser clause-level check below.
+                    diffs.push({
+                        clauseId: g.id,
+                        path: `${g.id}.${mem}`,
+                        kind: "changed",
+                        remedy: `Member ${mem} in ${g.id} changed. Revert, or open a 2.0.0.`,
+                    });
+                }
+            }
+        }
+        for (const [mem, _lv] of lMembers) {
+            if (!gMembers.has(mem)) {
+                const liveVal = l.value;
+                // Check if the live member carries `since` (additions may ride
+                // in the keys, tools or boundary arrays — K10-018/K10-027).
+                const lists = [liveVal.keys, liveVal.tools, liveVal.boundary];
+                let hasSince = false;
+                for (const list of lists) {
+                    if (!Array.isArray(list))
+                        continue;
+                    const entry = list.find((e) => {
+                        if (typeof e === "string")
+                            return e === mem;
+                        if (e !== null &&
+                            typeof e === "object" &&
+                            "name" in e)
+                            return e.name === mem;
+                        return false;
+                    });
+                    if (entry !== null &&
+                        typeof entry === "object" &&
+                        typeof entry.since === "string") {
+                        hasSince = true;
+                        break;
+                    }
+                }
+                diffs.push({
+                    clauseId: g.id,
+                    path: `${g.id}.${mem}`,
+                    kind: hasSince ? "added_ok" : "added_bare",
+                    remedy: hasSince
+                        ? `Member ${mem} in ${g.id} was added with since. Allowed in 1.x.`
+                        : `Member ${mem} in ${g.id} was added without since. Add since or revert, or open a 2.0.0.`,
+                });
+            }
+        }
+        // Also compare clause-level metadata that is not in valueMembers (e.g., package version in C-06)
+        // If the whole value JSON differs but members didn't capture it (e.g., name change), mark changed.
+        if (JSON.stringify(g.value) !== JSON.stringify(l.value)) {
+            // Only emit clause-level changed if no finer-grained diff already emitted for this clause
+            const hasFiner = diffs.some((d) => d.clauseId === g.id && d.path !== g.id);
+            if (!hasFiner) {
+                diffs.push({
+                    clauseId: g.id,
+                    path: g.id,
+                    kind: "changed",
+                    remedy: `Clause ${g.id} changed. Revert, or open a 2.0.0.`,
+                });
+            }
+        }
+    }
+    diffs.sort((a, b) => a.clauseId === b.clauseId
+        ? a.path.localeCompare(b.path)
+        : a.clauseId.localeCompare(b.clauseId));
+    return diffs;
+}

package/dist/plugin/diff.js

@@ -180,4 +180,3 @@ export function unifiedDiff(path, before, after) {
     const header = `--- a/${path}\n+++ b/${path}\n`;
     return `${header}${parts.join("\n")}\n`;
 }
-//# sourceMappingURL=diff.js.map

package/dist/plugin/escape.d.ts

@@ -0,0 +1,39 @@
+/**
+ * v1.0.0 (K10-027 / plan §5.7) — the untrusted-input boundary.
+ *
+ * One pure, total, idempotent escaping function per container Kevin
+ * writes stored text into. Every function here is a fixed point after
+ * one application — applying it twice equals applying it once — because
+ * a re-curated memory passes through the boundary on every regeneration
+ * and must not accumulate escaping.
+ *
+ * This module imports nothing and touches no filesystem. It is the
+ * boundary; the single enforcement point is ArtifactWriter (D6-01).
+ */
+/**
+ * Neutralise text destined for the AGENTS.md marker block: HTML-escape
+ * (the memory-format discipline, made idempotent) so the literal
+ * `<!-- kevin:end -->` marker sequence and every comment terminator
+ * lose their meaning inside the block. The line-level strip of anything
+ * containing `kevin:begin`/`kevin:end` stays in
+ * ArtifactWriter.sanitizeArtifactBody — it is a filter, not an escape.
+ */
+export declare function escapeForMarkerBlock(text: string): string;
+/**
+ * Neutralise fenced-code delimiters: any run of three or more backticks
+ * or tildes would close (or open) a markdown fence around the rendered
+ * block and let stored text masquerade as un-fenced document content.
+ * Each byte of the run becomes its numeric HTML entity, which renders
+ * identically but can never form a delimiter again.
+ */
+export declare function escapeForFence(text: string): string;
+/**
+ * Neutralise bytes that would terminate an OKF v2 line: newline,
+ * carriage return and every other C0 control character become their
+ * JSON-style escapes, so a statement can never split into a second
+ * line even if a future writer forgets JSON.stringify. Quotation marks
+ * and backslashes are deliberately NOT touched here — the OKF line is
+ * canonical JSON and re-escaping them would corrupt parsing; JSON
+ * already guarantees they stay inside the string.
+ */
+export declare function escapeForOkfLine(text: string): string;