@jmtrin/kevin-core 1.4.0 → 2.0.0

package/dist/ArtifactWriter.js

@@ -243,7 +243,7 @@ export class ArtifactWriter {
         // Rule 7 — write to `<path>.kevin.tmp` in the same directory (same
         // filesystem, so rename is atomic), fsync, close, then rename over the
         // target. Never write the target path directly, never truncate-then-write.
-        const tmpPath = `${plan.path}.kevin.tmp`;
+        const tmpPath = `${plan.path}.kevin.tmp.${uuidv7()}`;
         let fd;
         try {
             fd = openSync(tmpPath, "w");

package/dist/InjectionLedger.js

@@ -83,146 +83,148 @@ export class InjectionLedger {
 						   FROM kevin_injections
 						  WHERE session_id = ?
 						  ORDER BY injected_at ASC, id ASC`)).all(sessionId);
-        for (const inj of injections) {
-            // Same identity dimension CausalChain uses: the failing call's
-            // `error_fingerprint` (stamped by Reflector) or the legacy
-            // `fingerprint` hash.
-            // v1.1.0 — time comparison uses toMs helper (prefers _ms).
-            //
-            // BUG-003 — the exemption is now bounded to the lesson's OWN
-            // creating call (memories.metadata.origin_call_id, stamped by
-            // Reflector). The old code excluded the session's FIRST failing
-            // call of the fingerprint, which is only the creating call when
-            // the lesson was born in THIS session; a lesson created in an
-            // earlier session had its first in-session failure (a genuine
-            // post-injection recurrence) wrongly exempted, inflating
-            // precision. Memories without a tracked creating call (agent-
-            // saved, test fixtures) get no exemption: only the `ts >=
-            // injected_at` bound applies.
-            const metaRow = this.store
-                .prepare("SELECT metadata FROM memories WHERE id = ?")
-                .get(inj.memory_id);
-            const originCallId = readOriginCallId(metaRow?.metadata ?? null);
-            // v1.1.0 — heuristic: when legacy string and _ms diverge by >2s
-            // (manual UPDATE of injected_at in tests), trust the string
-            // because the ms reflects wall time at record, not the pinned
-            // fixture time. Real rows differ by <1s (second truncation).
-            const rawInjMs = inj.injected_at_ms ?? null;
-            const stringMs = inj.injected_at
-                ? Date.parse(`${inj.injected_at.replace(" ", "T")}Z`)
-                : null;
-            const injectedMs = rawInjMs !== null &&
-                stringMs !== null &&
-                !Number.isNaN(stringMs) &&
-                Math.abs(rawInjMs - stringMs) > 2000
-                ? stringMs
-                : toMs(inj.injected_at, rawInjMs);
-            // Fetch candidate failing calls for this fingerprint and filter by ms
-            const failRows = (hasToolMs
-                ? this.store.prepare(`SELECT id, ts, ts_ms FROM tool_calls
+        this.store.transaction(() => {
+            for (const inj of injections) {
+                // Same identity dimension CausalChain uses: the failing call's
+                // `error_fingerprint` (stamped by Reflector) or the legacy
+                // `fingerprint` hash.
+                // v1.1.0 — time comparison uses toMs helper (prefers _ms).
+                //
+                // BUG-003 — the exemption is now bounded to the lesson's OWN
+                // creating call (memories.metadata.origin_call_id, stamped by
+                // Reflector). The old code excluded the session's FIRST failing
+                // call of the fingerprint, which is only the creating call when
+                // the lesson was born in THIS session; a lesson created in an
+                // earlier session had its first in-session failure (a genuine
+                // post-injection recurrence) wrongly exempted, inflating
+                // precision. Memories without a tracked creating call (agent-
+                // saved, test fixtures) get no exemption: only the `ts >=
+                // injected_at` bound applies.
+                const metaRow = this.store
+                    .prepare("SELECT metadata FROM memories WHERE id = ?")
+                    .get(inj.memory_id);
+                const originCallId = readOriginCallId(metaRow?.metadata ?? null);
+                // v1.1.0 — heuristic: when legacy string and _ms diverge by >2s
+                // (manual UPDATE of injected_at in tests), trust the string
+                // because the ms reflects wall time at record, not the pinned
+                // fixture time. Real rows differ by <1s (second truncation).
+                const rawInjMs = inj.injected_at_ms ?? null;
+                const stringMs = inj.injected_at
+                    ? Date.parse(`${inj.injected_at.replace(" ", "T")}Z`)
+                    : null;
+                const injectedMs = rawInjMs !== null &&
+                    stringMs !== null &&
+                    !Number.isNaN(stringMs) &&
+                    Math.abs(rawInjMs - stringMs) > 2000
+                    ? stringMs
+                    : toMs(inj.injected_at, rawInjMs);
+                // Fetch candidate failing calls for this fingerprint and filter by ms
+                const failRows = (hasToolMs
+                    ? this.store.prepare(`SELECT id, ts, ts_ms FROM tool_calls
 							  WHERE session_id = ?
 							    AND success = 0
 							    AND COALESCE(error_fingerprint, fingerprint) = ?`)
-                : this.store.prepare(`SELECT id, ts FROM tool_calls
+                    : this.store.prepare(`SELECT id, ts FROM tool_calls
 							  WHERE session_id = ?
 							    AND success = 0
 							    AND COALESCE(error_fingerprint, fingerprint) = ?`)).all(sessionId, inj.fingerprint);
-            let n = 0;
-            for (const r of failRows) {
-                if (originCallId !== null && r.id === originCallId)
-                    continue;
-                const tsMs = toMs(r.ts, r.ts_ms ?? null);
-                if (injectedMs !== null && tsMs !== null) {
-                    if (tsMs < injectedMs)
-                        continue;
-                }
-                else {
-                    // fallback to string comparison when either side missing (legacy)
-                    if (r.ts < inj.injected_at)
+                let n = 0;
+                for (const r of failRows) {
+                    if (originCallId !== null && r.id === originCallId)
                         continue;
+                    const tsMs = toMs(r.ts, r.ts_ms ?? null);
+                    if (injectedMs !== null && tsMs !== null) {
+                        if (tsMs < injectedMs)
+                            continue;
+                    }
+                    else {
+                        // fallback to string comparison when either side missing (legacy)
+                        if (r.ts < inj.injected_at)
+                            continue;
+                    }
+                    n++;
                 }
-                n++;
-            }
-            // v0.5.0 (K5-005 / plan §5.1, D5-01) — three-way settlement:
-            //   recurrences >= 1 → ineffective  (existing side effects unchanged)
-            //   else fixes >= 1  → effective    (a linked fix was OBSERVED)
-            //   else             → inconclusive (new majority bucket; excluded
-            //                                    from the precision denominator)
-            if (n >= 1) {
-                if (inj.outcome === "unmeasured") {
-                    this.store
-                        .prepare(`UPDATE kevin_injections SET outcome = 'ineffective'
+                // v0.5.0 (K5-005 / plan §5.1, D5-01) — three-way settlement:
+                //   recurrences >= 1 → ineffective  (existing side effects unchanged)
+                //   else fixes >= 1  → effective    (a linked fix was OBSERVED)
+                //   else             → inconclusive (new majority bucket; excluded
+                //                                    from the precision denominator)
+                if (n >= 1) {
+                    if (inj.outcome === "unmeasured") {
+                        this.store
+                            .prepare(`UPDATE kevin_injections SET outcome = 'ineffective'
 							  WHERE id = ?`)
-                        .run(inj.id);
-                    this.metrics?.incr("injections_ineffective", 1);
-                }
-                this.store
-                    .prepare(`UPDATE memories
+                            .run(inj.id);
+                        this.metrics?.incr("injections_ineffective", 1);
+                    }
+                    this.store
+                        .prepare(`UPDATE memories
 						    SET recurrence_count = MAX(recurrence_count, ?),
 						        last_injected_at = CASE
 						          WHEN last_injected_at IS NULL
 						            OR ? > last_injected_at
 						            THEN ? ELSE last_injected_at END
 						  WHERE fingerprint = ? AND id = ?`)
-                    .run(n, inj.injected_at, inj.injected_at, inj.fingerprint, inj.memory_id);
-                // v0.4.0 (K4-025 / plan §5.1 rule 4, D4-06) — recurrence
-                // expels: a fingerprint at `recurrence_count >= 3` is
-                // demoted to `status='stale'` and never injected again
-                // (only a new causal pattern — from a linked fix —
-                // re-admits the lesson, not the stale error row).
-                this.store
-                    .prepare(`UPDATE memories SET status = 'stale'
+                        .run(n, inj.injected_at, inj.injected_at, inj.fingerprint, inj.memory_id);
+                    // v0.4.0 (K4-025 / plan §5.1 rule 4, D4-06) — recurrence
+                    // expels: a fingerprint at `recurrence_count >= 3` is
+                    // demoted to `status='stale'` and never injected again
+                    // (only a new causal pattern — from a linked fix —
+                    // re-admits the lesson, not the stale error row).
+                    this.store
+                        .prepare(`UPDATE memories SET status = 'stale'
 						  WHERE id = ? AND recurrence_count >= 3`)
-                    .run(inj.memory_id);
-            }
-            else if (inj.outcome === "unmeasured") {
-                // Mirror of the recurrence predicate with the success flag
-                // inverted and the fingerprint matched on
-                // `fix_for_fingerprint` (populated by CausalChain.onSuccess,
-                // indexed by idx_tool_calls_fix_fp since migration 004). The
-                // `ts >= injected_at` bound and `session_id = ?` filter are
-                // kept; there is no `origin_call_id` exemption for fixes —
-                // a fix is not the creating call.
-                // v1.1.0 — ms-aware: fetch and filter via toMs.
-                const fixCandidates = (hasToolMs
-                    ? this.store.prepare(`SELECT ts, ts_ms FROM tool_calls
+                        .run(inj.memory_id);
+                }
+                else if (inj.outcome === "unmeasured") {
+                    // Mirror of the recurrence predicate with the success flag
+                    // inverted and the fingerprint matched on
+                    // `fix_for_fingerprint` (populated by CausalChain.onSuccess,
+                    // indexed by idx_tool_calls_fix_fp since migration 004). The
+                    // `ts >= injected_at` bound and `session_id = ?` filter are
+                    // kept; there is no `origin_call_id` exemption for fixes —
+                    // a fix is not the creating call.
+                    // v1.1.0 — ms-aware: fetch and filter via toMs.
+                    const fixCandidates = (hasToolMs
+                        ? this.store.prepare(`SELECT ts, ts_ms FROM tool_calls
 								  WHERE session_id = ?
 								    AND success = 1
 								    AND fix_for_fingerprint = ?`)
-                    : this.store.prepare(`SELECT ts FROM tool_calls
+                        : this.store.prepare(`SELECT ts FROM tool_calls
 								  WHERE session_id = ?
 								    AND success = 1
 								    AND fix_for_fingerprint = ?`)).all(sessionId, inj.fingerprint);
-                let hasFix = false;
-                for (const fr of fixCandidates) {
-                    const tsMs = toMs(fr.ts, fr.ts_ms ?? null);
-                    if (injectedMs !== null && tsMs !== null) {
-                        if (tsMs >= injectedMs) {
+                    let hasFix = false;
+                    for (const fr of fixCandidates) {
+                        const tsMs = toMs(fr.ts, fr.ts_ms ?? null);
+                        if (injectedMs !== null && tsMs !== null) {
+                            if (tsMs >= injectedMs) {
+                                hasFix = true;
+                                break;
+                            }
+                        }
+                        else if (fr.ts >= inj.injected_at) {
                             hasFix = true;
                             break;
                         }
                     }
-                    else if (fr.ts >= inj.injected_at) {
-                        hasFix = true;
-                        break;
-                    }
-                }
-                if (hasFix) {
-                    this.store
-                        .prepare(`UPDATE kevin_injections SET outcome = 'effective'
+                    if (hasFix) {
+                        this.store
+                            .prepare(`UPDATE kevin_injections SET outcome = 'effective'
 							  WHERE id = ?`)
-                        .run(inj.id);
-                    this.metrics?.incr("injections_effective", 1);
-                }
-                else {
-                    this.store
-                        .prepare(`UPDATE kevin_injections SET outcome = 'inconclusive'
+                            .run(inj.id);
+                        this.metrics?.incr("injections_effective", 1);
+                    }
+                    else {
+                        this.store
+                            .prepare(`UPDATE kevin_injections SET outcome = 'inconclusive'
 							  WHERE id = ?`)
-                        .run(inj.id);
-                    this.metrics?.incr("injections_inconclusive", 1);
+                            .run(inj.id);
+                        this.metrics?.incr("injections_inconclusive", 1);
+                    }
                 }
             }
-        }
+        });
     }
     /**
      * Per-fingerprint failing tool-call counts for the session. Feeds

package/dist/Materializer.d.ts

@@ -59,6 +59,11 @@ export declare class Materializer {
     hasNativeRegistration(surface: NativeSurface): boolean;
     /** The curated, active memories — the knowledge the pull channels publish. */
     private curatedRows;
+    /** K15-003 — topic bundles for skill emit (deterministic) */
+    topicBundles(): Array<{
+        topic: string;
+        content: string;
+    }>;
     /** The rendered skill body over all curated memories; "" when empty. */
     skillBody(): string;
     /** Group rows by type, deriving each type's topic from its own content. */

package/dist/Materializer.js

@@ -86,6 +86,17 @@ export class Materializer {
 				 WHERE status = 'active' AND curated = 1`)
             .all();
     }
+    /** K15-003 — topic bundles for skill emit (deterministic) */
+    topicBundles() {
+        const rows = this.curatedRows();
+        const bundles = [];
+        for (const g of this.groupByTopic(rows)) {
+            const body = renderRows(g.rows);
+            if (body !== "")
+                bundles.push({ topic: g.topic, content: body });
+        }
+        return bundles;
+    }
     /** The rendered skill body over all curated memories; "" when empty. */
     skillBody() {
         return renderRows(this.curatedRows());

package/dist/MemoryService.js

@@ -301,99 +301,101 @@ export class MemoryService {
         // supersession a navigable audit trail. Guarded: pre-006 DBs lack
         // the column (same migration as `ignored`).
         const supersedableTypes = ["decision", "rule"];
-        if (fp !== null && supersedableTypes.includes(input.type)) {
-            const withSupersededBy = this.hasIgnoredColumn();
-            const setClause = withSupersededBy
-                ? "SET status = 'superseded', superseded_by = ?, updated_at = datetime('now')"
-                : "SET status = 'superseded', updated_at = datetime('now')";
-            // v0.8.0 (K8-007 / plan §5.7) — once the 009 column exists and an
-            // identity is resolved, supersession is scoped on repo_id (NULL
-            // rows are global); project_id stays as the pre-009 scope.
-            const scopedOnRepoId = this.hasRepoIdColumn() && this.repoId !== null;
-            const whereScope = scopedOnRepoId
-                ? "AND (repo_id IS ? OR repo_id IS NULL)"
-                : "AND (project_id IS ? OR (project_id IS NULL AND ? IS NULL))";
-            const scopeParams = scopedOnRepoId
-                ? [this.repoId]
-                : [projectId, projectId];
-            this.store
-                .prepare(`UPDATE memories
-					 ${setClause}
-					 WHERE fingerprint = ?
-					   AND type = ?
-					   AND status = 'active'
-					   ${whereScope}`)
-                .run(...(withSupersededBy
-                ? [id, fp, input.type, ...scopeParams]
-                : [fp, input.type, ...scopeParams]));
-            const after = this.store.prepare("SELECT changes() AS n").get();
-            if (after.n > 0) {
-                this.metrics?.incr("memories_superseded", 1);
-            }
-        }
         try {
-            // v0.4.0 (BUG-008) — recurrence_count is only persisted when the
-            // column exists (migration 005); pre-005 DBs get the legacy shape.
-            // v0.6.0 (K6-011 / plan §5.3) — the inferable verdict is persisted
-            // on insert when the column exists (migration 007). The column
-            // list is assembled so every migration level gets exactly its own
-            // shape: 005+ gains recurrence_count, 007+ gains inferable.
-            const withRecurrence = this.hasRecurrenceColumn();
-            const withCurated = this.hasCuratedColumn();
-            const columns = [
-                "id",
-                "type",
-                "content",
-                "scope",
-                "relevance_score",
-                "source_tool",
-                "source_session",
-                "metadata",
-                "expires_at",
-                "project_id",
-                "fingerprint",
-                "origin",
-                "evidence_count",
-                "last_verified_at",
-                "status",
-            ];
-            const params = [
-                id,
-                input.type,
-                input.content,
-                scope,
-                relevanceScore,
-                input.sourceTool ?? null,
-                input.sourceSession ?? null,
-                metadata,
-                expiresAt,
-                projectId,
-                fp,
-                origin,
-                input.evidenceCount ?? 0,
-                input.lastVerifiedAt ?? null,
-                status,
-            ];
-            if (withRecurrence) {
-                columns.push("recurrence_count");
-                params.push(input.recurrenceCount ?? 0);
-            }
-            if (withCurated) {
-                columns.push("inferable");
-                params.push(persistInferable(input.type, input.content, input.metadata));
-            }
-            // v0.8.0 (K8-007 / plan §5.7) — repo_id is persisted on every new
-            // memory (009 column). A NULL projectId stays NULL-scoped — the
-            // global rows PatternMiner's nullPid convention relies on — and a
-            // NULL repo_id row matches every scope. project_id remains written
-            // above: it is provenance now, not scope (D8-02).
-            if (this.hasRepoIdColumn()) {
-                columns.push("repo_id");
-                params.push(projectId !== null ? this.repoId : null);
-            }
-            const insert = `INSERT INTO memories (${columns.join(", ")})
+            this.store.transaction(() => {
+                if (fp !== null && supersedableTypes.includes(input.type)) {
+                    const withSupersededBy = this.hasIgnoredColumn();
+                    const setClause = withSupersededBy
+                        ? "SET status = 'superseded', superseded_by = ?, updated_at = datetime('now')"
+                        : "SET status = 'superseded', updated_at = datetime('now')";
+                    // v0.8.0 (K8-007 / plan §5.7) — once the 009 column exists and an
+                    // identity is resolved, supersession is scoped on repo_id (NULL
+                    // rows are global); project_id stays as the pre-009 scope.
+                    const scopedOnRepoId = this.hasRepoIdColumn() && this.repoId !== null;
+                    const whereScope = scopedOnRepoId
+                        ? "AND (repo_id IS ? OR repo_id IS NULL)"
+                        : "AND (project_id IS ? OR (project_id IS NULL AND ? IS NULL))";
+                    const scopeParams = scopedOnRepoId
+                        ? [this.repoId]
+                        : [projectId, projectId];
+                    this.store
+                        .prepare(`UPDATE memories
+						 ${setClause}
+						 WHERE fingerprint = ?
+						   AND type = ?
+						   AND status = 'active'
+						   ${whereScope}`)
+                        .run(...(withSupersededBy
+                        ? [id, fp, input.type, ...scopeParams]
+                        : [fp, input.type, ...scopeParams]));
+                    const after = this.store.prepare("SELECT changes() AS n").get();
+                    if (after.n > 0) {
+                        this.metrics?.incr("memories_superseded", 1);
+                    }
+                }
+                // v0.4.0 (BUG-008) — recurrence_count is only persisted when the
+                // column exists (migration 005); pre-005 DBs get the legacy shape.
+                // v0.6.0 (K6-011 / plan §5.3) — the inferable verdict is persisted
+                // on insert when the column exists (migration 007). The column
+                // list is assembled so every migration level gets exactly its own
+                // shape: 005+ gains recurrence_count, 007+ gains inferable.
+                const withRecurrence = this.hasRecurrenceColumn();
+                const withCurated = this.hasCuratedColumn();
+                const columns = [
+                    "id",
+                    "type",
+                    "content",
+                    "scope",
+                    "relevance_score",
+                    "source_tool",
+                    "source_session",
+                    "metadata",
+                    "expires_at",
+                    "project_id",
+                    "fingerprint",
+                    "origin",
+                    "evidence_count",
+                    "last_verified_at",
+                    "status",
+                ];
+                const params = [
+                    id,
+                    input.type,
+                    input.content,
+                    scope,
+                    relevanceScore,
+                    input.sourceTool ?? null,
+                    input.sourceSession ?? null,
+                    metadata,
+                    expiresAt,
+                    projectId,
+                    fp,
+                    origin,
+                    input.evidenceCount ?? 0,
+                    input.lastVerifiedAt ?? null,
+                    status,
+                ];
+                if (withRecurrence) {
+                    columns.push("recurrence_count");
+                    params.push(input.recurrenceCount ?? 0);
+                }
+                if (withCurated) {
+                    columns.push("inferable");
+                    params.push(persistInferable(input.type, input.content, input.metadata));
+                }
+                // v0.8.0 (K8-007 / plan §5.7) — repo_id is persisted on every new
+                // memory (009 column). A NULL projectId stays NULL-scoped — the
+                // global rows PatternMiner's nullPid convention relies on — and a
+                // NULL repo_id row matches every scope. project_id remains written
+                // above: it is provenance now, not scope (D8-02).
+                if (this.hasRepoIdColumn()) {
+                    columns.push("repo_id");
+                    params.push(projectId !== null ? this.repoId : null);
+                }
+                const insert = `INSERT INTO memories (${columns.join(", ")})
            VALUES (${params.map(() => "?").join(", ")})`;
-            this.store.prepare(insert).run(...params);
+                this.store.prepare(insert).run(...params);
+            });
             return id;
         }
         catch (err) {

package/dist/RepoIdentity.js

@@ -63,7 +63,7 @@ export function parseGitConfigRemote(text, name = "origin") {
             continue;
         const eq = line.indexOf("=");
         if (eq === -1)
-            return null;
+            continue;
         const key = line.slice(0, eq).trim();
         const value = line.slice(eq + 1).trim();
         if (key !== "url")

package/dist/Retrospective.js

@@ -87,6 +87,14 @@ export const METRIC_KEY_LABELS = {
     mcp_writes_accepted: "Escrituras MCP aceptadas",
     mcp_writes_refused: "Escrituras MCP rechazadas",
     mcp_errors_total: "Errores MCP totales",
+    // v1.5.0 (K15-001 / plan §4) — Diaspora metrics; labels required by BUG-014.
+    skills_emitted_total: "Skills emitidos (total)",
+    mif_exports_total: "Exportaciones MIF totales",
+    mif_imports_total: "Importaciones MIF totales",
+    // v2.0.0 (K16-012 / plan §4.4) — Commonwealth metrics
+    source_syncs_total: "Sincronizaciones de fuentes (total)",
+    source_dedup_skips_total: "Skips por dedup de fuentes (total)",
+    okf_v3_files_written: "Archivos OKF v3 escritos",
 };
 function originLabel(origin) {
     if (origin === "reflector")

package/dist/Store.d.ts

@@ -20,6 +20,7 @@ export interface StoreOptions {
 export declare class Store {
     private db;
     private closed;
+    private txDepth;
     constructor(options: StoreOptions);
     prepare(sql: string): ReturnType<SqliteAdapter["prepare"]>;
     transaction<T>(fn: () => T): T;

package/dist/Store.js

@@ -17,6 +17,7 @@ import { createDatabase } from "./sqlite-adapter.js";
 export class Store {
     db;
     closed = false;
+    txDepth = 0;
     constructor(options) {
         this.db = createDatabase(options.path);
         this.db.exec("PRAGMA journal_mode = WAL");
@@ -31,8 +32,19 @@ export class Store {
     transaction(fn) {
         if (this.closed)
             throw new Error("Store is closed");
-        const tx = this.db.transaction(fn);
-        return tx();
+        if (this.txDepth > 0)
+            return fn();
+        this.txDepth++;
+        try {
+            const tx = this.db.transaction(fn);
+            const result = tx();
+            this.txDepth--;
+            return result;
+        }
+        catch (e) {
+            this.txDepth--;
+            throw e;
+        }
     }
     exec(sql) {
         if (this.closed)

package/dist/contract.d.ts

@@ -8,7 +8,54 @@ import { type KevinEnv } from "./env.js";
  * core file allowed to call process cwd.
  */
 export declare function resolveScanRoots(env?: KevinEnv): string[];
-export declare const CONTRACT_VERSION = 1;
+export declare const CONTRACT_VERSION = 2;
+export declare const CONTRACT_CORE_EXPORTS: readonly {
+    name: string;
+    kind: string;
+}[];
+export declare const CONTRACT_MCP_TOOLS: readonly string[];
+export declare const CONTRACT_MCP_REFUSALS: readonly string[];
+export declare const CONTRACT_SKILLS_LAYOUT: {
+    readonly canonical_dir: ".agents/skills";
+    readonly skill_dir: "kevin-knowledge";
+    readonly files: readonly ["SKILL.md", "references/*.md"];
+    readonly frontmatter_fields: readonly ["name", "description", "metadata.generator", "metadata.repo_id"];
+    readonly mirror_policy: "copy (not symlink) to .claude/skills and .cursor/skills when enabled";
+};
+export declare const CONTRACT_MIF_PROFILE: {
+    readonly envelope_version: 1;
+    readonly format: "mif";
+    readonly field_mapping: {
+        readonly entry_id: "id";
+        readonly statement: "content";
+        readonly type: "type";
+        readonly scope: "metadata.scope";
+        readonly fingerprint: "metadata.fingerprint";
+        readonly confidence: "metadata.confidence";
+        readonly created_at: "timestamp";
+    };
+    readonly redaction: "SECRET_PATTERNS (PII)";
+    readonly dedup: "content-hash (fingerprint)";
+    readonly vendor_extensions_preserved: true;
+};
+export declare const CONTRACT_MEMORY_SOURCES: {
+    readonly sources: readonly [{
+        readonly name: "opencode-plugin";
+        readonly precedence: 10;
+    }, {
+        readonly name: "claude-memory";
+        readonly precedence: 20;
+    }, {
+        readonly name: "codex-memories";
+        readonly precedence: 30;
+    }, {
+        readonly name: "opencode-native";
+        readonly precedence: 40;
+    }];
+    readonly dedup_rule: "lower precedence wins attribution; losers counted in source_dedup_skips_total";
+    readonly conflict_kind: "source_pair";
+    readonly precedence_order: readonly [10, 20, 30, 40];
+};
 export type Stability = "frozen" | "forward-only";
 export interface ContractClause {
     readonly id: string;
@@ -58,6 +105,16 @@ export declare const CONTRACT_CONFIG_ADDITIONS: readonly {
     name: string;
     since: string;
 }[];
+/**
+ * v2.0.0 (K16-004 / plan §5.1) — removed settings (retirements)
+ * Each entry carries `since` 2.0.0 and optional replacement pointer.
+ * Succession test treats these as LEGITIMATE removals via `removed` annotation.
+ */
+export declare const CONTRACT_REMOVED_CONFIG_KEYS: readonly {
+    name: string;
+    since: string;
+    replacement?: 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