akm-cli 0.9.0-rc.1 → 0.9.0-rc.13

package/dist/storage/repositories/outcome-repository.js

@@ -0,0 +1,119 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * Upsert one `asset_outcome` row. Extracted verbatim from the tail of
+ * `updateAssetOutcome` in outcome-loop.ts — same SQL text, same bind order;
+ * the business logic that computes these values (warm-start seed vs.
+ * differential update) stays in outcome-loop.ts and calls this function.
+ *
+ * `review_pressure` is intentionally omitted from both the INSERT column list
+ * and the ON CONFLICT SET clause: the column's DEFAULT 0 seeds fresh rows, and
+ * omitting it from SET leaves an existing row's value untouched on update
+ * (never written going forward). The column itself is dropped in migration 018.
+ */
+export function upsertAssetOutcome(db, values) {
+    db.prepare(`INSERT INTO asset_outcome
+       (asset_ref, last_retrieved_at, retrieval_count, expected_retrieval_rate,
+        negative_feedback_count, accepted_change_count,
+        outcome_score, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(asset_ref) DO UPDATE SET
+       last_retrieved_at      = excluded.last_retrieved_at,
+       retrieval_count        = excluded.retrieval_count,
+       expected_retrieval_rate= excluded.expected_retrieval_rate,
+       negative_feedback_count= excluded.negative_feedback_count,
+       accepted_change_count  = excluded.accepted_change_count,
+       outcome_score          = excluded.outcome_score,
+       updated_at             = excluded.updated_at`).run(values.ref, values.lastRetrievedAt, values.retrievalCount, values.expectedRetrievalRate, values.negativeFeedbackCount, values.acceptedChangeCount, values.outcomeScore, values.updatedAt);
+}
+/**
+ * Load the outcome row for one asset, or `undefined` if not yet written.
+ */
+export function getAssetOutcome(db, ref) {
+    const row = db
+        .prepare(`SELECT asset_ref, last_retrieved_at, retrieval_count, expected_retrieval_rate,
+              negative_feedback_count, accepted_change_count,
+              outcome_score, updated_at
+       FROM asset_outcome WHERE asset_ref = ?`)
+        .get(ref);
+    return row == null ? undefined : row;
+}
+/**
+ * Load ALL asset_outcome rows. Used for the proxy-adequacy tripwire computation.
+ */
+export function getAllAssetOutcomes(db) {
+    return db
+        .prepare(`SELECT asset_ref, last_retrieved_at, retrieval_count, expected_retrieval_rate,
+              negative_feedback_count, accepted_change_count,
+              outcome_score, updated_at
+       FROM asset_outcome ORDER BY asset_ref`)
+        .all();
+}
+/**
+ * Build a Map<ref, outcome_score> for a set of refs in one query.
+ * Used by `salience.ts` to populate `outcomeSalience`.
+ */
+export function getOutcomeScoresByRef(db, refs) {
+    const result = new Map();
+    if (refs.length === 0)
+        return result;
+    const CHUNK = 500;
+    for (let i = 0; i < refs.length; i += CHUNK) {
+        const chunk = refs.slice(i, i + CHUNK);
+        const placeholders = chunk.map(() => "?").join(",");
+        const rows = db
+            .prepare(`SELECT asset_ref, outcome_score FROM asset_outcome WHERE asset_ref IN (${placeholders})`)
+            .all(...chunk);
+        for (const row of rows) {
+            result.set(row.asset_ref, row.outcome_score);
+        }
+    }
+    return result;
+}
+/** List every `asset_outcome` ref with its current `missing_since` marker. */
+export function listAssetOutcomeMissingState(db) {
+    return db.prepare(`SELECT asset_ref, missing_since FROM asset_outcome`).all();
+}
+/**
+ * Stamp `missing_since = now` for the given refs, but ONLY where it is
+ * currently NULL — a ref already stamped keeps its original timestamp so the
+ * grace window measures from first sighting, not last. Refs with no row at
+ * all are silently skipped (0 rows affected). Returns the number of rows
+ * actually stamped.
+ */
+export function stampAssetOutcomeMissing(db, refs, now) {
+    if (refs.length === 0)
+        return 0;
+    const stmt = db.prepare(`UPDATE asset_outcome SET missing_since = ? WHERE asset_ref = ? AND missing_since IS NULL`);
+    let changed = 0;
+    for (const ref of refs)
+        changed += Number(stmt.run(now, ref).changes);
+    return changed;
+}
+/**
+ * Clear `missing_since` for refs that resolved again. Returns the number of
+ * rows actually cleared.
+ */
+export function clearAssetOutcomeMissing(db, refs) {
+    if (refs.length === 0)
+        return 0;
+    const stmt = db.prepare(`UPDATE asset_outcome SET missing_since = NULL WHERE asset_ref = ? AND missing_since IS NOT NULL`);
+    let changed = 0;
+    for (const ref of refs)
+        changed += Number(stmt.run(ref).changes);
+    return changed;
+}
+/**
+ * Delete `asset_outcome` rows whose `missing_since` is older than
+ * `cutoffMs`. A single DELETE — SQLite runs it as one implicit transaction.
+ * Returns the number of rows deleted.
+ */
+export function deleteAssetOutcomeMissingBefore(db, cutoffMs) {
+    return Number(db.prepare(`DELETE FROM asset_outcome WHERE missing_since IS NOT NULL AND missing_since < ?`).run(cutoffMs).changes);
+}
+/** Count `asset_outcome` rows currently marked missing (the live backlog size). */
+export function countAssetOutcomeMissing(db) {
+    const row = db.prepare(`SELECT COUNT(*) AS n FROM asset_outcome WHERE missing_since IS NOT NULL`).get();
+    return row.n;
+}

package/dist/storage/repositories/proposals-repository.js

@@ -1,29 +1,195 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * Repository for the state.db `proposals` table. Extracted verbatim from
+ * core/state-db.ts — queries and row-mapping unchanged, only relocated behind
+ * the repository boundary. Re-exported by core/state-db.ts so existing importers
+ * resolve.
+ *
+ * @module proposals-repository
+ */
+import path from "node:path";
+import { stashDirFor } from "../../core/asset/asset-placement.js";
+import { bundleRefToString, isBundleSlug, parseBundleRef } from "../../core/asset/asset-ref.js";
+/** Serialize `Proposal.changes` for `metadata_json` (see {@link StoredFileChange}). */
+function changesToStored(changes) {
+    return changes.map((c, i) => ({
+        path: c.path,
+        op: c.op,
+        ...(i > 0 && c.after !== undefined ? { after: c.after } : {}),
+    }));
+}
+/**
+ * Reconstruct `Proposal.changes` from `metadata_json.changes` + the `content`
+ * column.
+ */
+function storedToChanges(stored, content) {
+    if (!Array.isArray(stored) || stored.length === 0) {
+        throw new Error("Proposal metadata is missing changes.");
+    }
+    return stored.map((value, i) => {
+        if (typeof value !== "object" || value === null)
+            throw new Error("Proposal metadata has invalid changes.");
+        const c = value;
+        if (typeof c.path !== "string" ||
+            (c.op !== "create" && c.op !== "update" && c.op !== "delete") ||
+            (c.after !== undefined && typeof c.after !== "string") ||
+            (c.op === "delete" && c.after !== undefined) ||
+            (i > 0 && c.op !== "delete" && typeof c.after !== "string")) {
+            throw new Error("Proposal metadata has invalid changes.");
+        }
+        return {
+            path: c.path,
+            op: c.op,
+            ...(i === 0 ? (c.op === "delete" ? {} : { after: content }) : c.after !== undefined ? { after: c.after } : {}),
+        };
+    });
+}
+function currentProposalRef(ref, requireQualified = false) {
+    let parsed;
+    try {
+        parsed = parseBundleRef(ref);
+    }
+    catch (error) {
+        throw new Error(`Proposal row has an invalid current ref: ${ref}`, { cause: error });
+    }
+    const colon = parsed.conceptId.indexOf(":");
+    if (colon > 0 && stashDirFor(parsed.conceptId.slice(0, colon)) !== undefined) {
+        throw new Error(`Proposal row has an invalid current ref: ${ref}`);
+    }
+    if (parsed.fragment !== undefined)
+        throw new Error(`Proposal row ref contains a fragment: ${ref}`);
+    if (requireQualified && parsed.bundle === undefined)
+        throw new Error(`Proposal ref is not bundle-qualified: ${ref}`);
+    const canonical = bundleRefToString(parsed);
+    if (canonical !== ref)
+        throw new Error(`Proposal row ref is not canonical: ${ref}`);
+    return canonical;
+}
+function currentProposalTarget(value) {
+    if (typeof value !== "object" || value === null)
+        throw new Error("Proposal metadata is missing proposedTarget.");
+    const target = value;
+    if (typeof target.source !== "string" ||
+        !isBundleSlug(target.source) ||
+        typeof target.root !== "string" ||
+        !path.isAbsolute(target.root)) {
+        throw new Error("Proposal metadata has an invalid proposedTarget.");
+    }
+    return { source: target.source, root: path.resolve(target.root) };
+}
+function invalidPresentField(name) {
+    throw new Error(`Proposal metadata has an invalid ${name}.`);
+}
+const GATE_OUTCOMES = {
+    "auto-accepted": true,
+    deferred: true,
+    staged: true,
+    "auto-rejected": true,
+};
+function validatePresentMetadata(meta) {
+    const stringFields = ["sourceRun", "beforeHash", "backupContent"];
+    for (const field of stringFields) {
+        if (Object.hasOwn(meta, field) && typeof meta[field] !== "string")
+            invalidPresentField(field);
+    }
+    if (Object.hasOwn(meta, "confidence") &&
+        (typeof meta.confidence !== "number" ||
+            !Number.isFinite(meta.confidence) ||
+            meta.confidence < 0 ||
+            meta.confidence > 1)) {
+        invalidPresentField("confidence");
+    }
+    if (Object.hasOwn(meta, "review")) {
+        const review = meta.review;
+        if (typeof review !== "object" ||
+            review === null ||
+            (review.outcome !== "accepted" && review.outcome !== "rejected") ||
+            typeof review.decidedAt !== "string" ||
+            (review.reason !== undefined && typeof review.reason !== "string")) {
+            invalidPresentField("review");
+        }
+    }
+    if (Object.hasOwn(meta, "gateDecision")) {
+        const gate = meta.gateDecision;
+        if (typeof gate !== "object" ||
+            gate === null ||
+            typeof gate.outcome !== "string" ||
+            !Object.hasOwn(GATE_OUTCOMES, gate.outcome) ||
+            typeof gate.reason !== "string" ||
+            typeof gate.decidedAt !== "string" ||
+            (gate.measured !== undefined && (typeof gate.measured !== "number" || !Number.isFinite(gate.measured))) ||
+            (gate.contentHash !== undefined && typeof gate.contentHash !== "string") ||
+            (gate.gate !== undefined && typeof gate.gate !== "string")) {
+            invalidPresentField("gateDecision");
+        }
+        if (gate.thresholds !== undefined) {
+            const thresholds = gate.thresholds;
+            if (typeof thresholds !== "object" ||
+                thresholds === null ||
+                [thresholds.maxDiffLines, thresholds.minContentLines].some((value) => value !== undefined && (typeof value !== "number" || !Number.isFinite(value)))) {
+                invalidPresentField("gateDecision");
+            }
+        }
+    }
+    if (Object.hasOwn(meta, "acceptedTarget")) {
+        const target = meta.acceptedTarget;
+        if (typeof target !== "object" ||
+            target === null ||
+            typeof target.source !== "string" ||
+            !isBundleSlug(target.source) ||
+            typeof target.root !== "string" ||
+            !path.isAbsolute(target.root) ||
+            typeof target.path !== "string" ||
+            !path.isAbsolute(target.path) ||
+            typeof target.contentHash !== "string") {
+            invalidPresentField("acceptedTarget");
+        }
+    }
+    if (Object.hasOwn(meta, "eligibilitySource") && typeof meta.eligibilitySource !== "string") {
+        invalidPresentField("eligibilitySource");
+    }
+}
 /**
  * Convert a raw `ProposalRow` to the public `Proposal` shape.
  */
 export function proposalRowToProposal(row) {
+    if (!["pending", "accepted", "rejected", "reverted"].includes(row.status)) {
+        throw new Error(`Proposal row has invalid status: ${row.status}`);
+    }
     let frontmatter;
-    if (row.frontmatter_json) {
+    if (row.frontmatter_json !== null) {
         try {
-            frontmatter = JSON.parse(row.frontmatter_json);
+            const parsed = JSON.parse(row.frontmatter_json);
+            if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+                throw new Error("Proposal frontmatter_json must contain an object.");
+            }
+            frontmatter = parsed;
         }
-        catch {
-            /* ignore corrupt frontmatter JSON */
+        catch (error) {
+            throw new Error("Proposal row has invalid frontmatter_json.", { cause: error });
         }
     }
     let meta = {};
     try {
-        meta = JSON.parse(row.metadata_json);
+        const parsed = JSON.parse(row.metadata_json);
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            throw new Error("Proposal metadata_json must contain an object.");
+        }
+        meta = parsed;
     }
-    catch {
-        /* ignore */
+    catch (error) {
+        throw new Error("Proposal row has invalid metadata_json.", { cause: error });
     }
+    validatePresentMetadata(meta);
+    const changes = Object.hasOwn(meta, "changes")
+        ? storedToChanges(meta.changes, row.content)
+        : [{ path: "", op: "update", after: row.content }];
+    const proposedTarget = Object.hasOwn(meta, "proposedTarget") ? currentProposalTarget(meta.proposedTarget) : undefined;
     return {
         id: row.id,
-        ref: row.ref,
+        ref: currentProposalRef(row.ref),
         status: row.status,
         source: row.source,
         ...(typeof meta.sourceRun === "string" ? { sourceRun: meta.sourceRun } : {}),
@@ -33,15 +199,123 @@ export function proposalRowToProposal(row) {
             content: row.content,
             ...(frontmatter !== undefined ? { frontmatter } : {}),
         },
+        changes,
+        ...(proposedTarget !== undefined ? { proposedTarget } : {}),
+        ...(typeof meta.beforeHash === "string" ? { beforeHash: meta.beforeHash } : {}),
         ...(meta.review !== undefined ? { review: meta.review } : {}),
         ...(typeof meta.confidence === "number" ? { confidence: meta.confidence } : {}),
         ...(meta.gateDecision !== undefined ? { gateDecision: meta.gateDecision } : {}),
         ...(typeof meta.backupContent === "string" ? { backupContent: meta.backupContent } : {}),
+        ...(meta.acceptedTarget !== undefined ? { acceptedTarget: meta.acceptedTarget } : {}),
         ...(typeof meta.eligibilitySource === "string"
             ? { eligibilitySource: meta.eligibilitySource }
             : {}),
     };
 }
+/**
+ * Lenient counterpart to {@link proposalRowToProposal} for the terminal-status
+ * (reject/archive) read paths (repository.ts `archiveProposal` /
+ * `rejectProposalDurably`). Those paths must succeed even on legacy rows
+ * minted before a field was required — e.g. 0.8-era rows missing
+ * `proposedTarget` and/or carrying empty/missing `changes[].path` metadata —
+ * so an operator can reject them instead of resorting to manual SQL.
+ *
+ * Per-field decode failures are swallowed: the offending field degrades to a
+ * safe placeholder (matching the strict decoder's own "no changes recorded"
+ * fallback) and the failure is appended to `decodeWarnings` instead of
+ * throwing. `id` / `status` / timestamps / `source` are trusted verbatim (the
+ * schema guarantees they're non-null strings). The strict decoder remains the
+ * default everywhere else, including every other read of a `pending` or
+ * `accepted` proposal (accept/revert must keep failing exactly as today on a
+ * malformed row).
+ */
+export function proposalRowToProposalLenient(row) {
+    const warnings = [];
+    let meta = {};
+    try {
+        const parsed = JSON.parse(row.metadata_json);
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            throw new Error("metadata_json must contain an object.");
+        }
+        meta = parsed;
+        validatePresentMetadata(meta);
+    }
+    catch (error) {
+        warnings.push(`metadata_json is invalid (${error instanceof Error ? error.message : String(error)}); optional fields dropped.`);
+        meta = {};
+    }
+    let frontmatter;
+    if (row.frontmatter_json !== null) {
+        try {
+            const parsed = JSON.parse(row.frontmatter_json);
+            if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+                throw new Error("frontmatter_json must contain an object.");
+            }
+            frontmatter = parsed;
+        }
+        catch (error) {
+            warnings.push(`frontmatter_json is invalid (${error instanceof Error ? error.message : String(error)}); frontmatter dropped.`);
+        }
+    }
+    let ref;
+    try {
+        ref = currentProposalRef(row.ref);
+    }
+    catch (error) {
+        warnings.push(`ref is invalid (${error instanceof Error ? error.message : String(error)}); keeping the raw stored value.`);
+        ref = row.ref;
+    }
+    let changes;
+    try {
+        changes = Object.hasOwn(meta, "changes")
+            ? storedToChanges(meta.changes, row.content)
+            : [{ path: "", op: "update", after: row.content }];
+    }
+    catch (error) {
+        warnings.push(`changes metadata is invalid (${error instanceof Error ? error.message : String(error)}); degraded to a single placeholder change.`);
+        changes = [{ path: "", op: "update", after: row.content }];
+    }
+    let proposedTarget;
+    if (Object.hasOwn(meta, "proposedTarget")) {
+        try {
+            proposedTarget = currentProposalTarget(meta.proposedTarget);
+        }
+        catch (error) {
+            warnings.push(`proposedTarget is invalid (${error instanceof Error ? error.message : String(error)}); omitted.`);
+        }
+    }
+    else {
+        warnings.push("proposedTarget is missing (pre-WI-6.2 legacy row).");
+    }
+    if (!["pending", "accepted", "rejected", "reverted"].includes(row.status)) {
+        warnings.push(`status "${row.status}" is not a recognized value.`);
+    }
+    return {
+        id: row.id,
+        ref,
+        status: row.status,
+        source: row.source,
+        ...(typeof meta.sourceRun === "string" ? { sourceRun: meta.sourceRun } : {}),
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        payload: {
+            content: row.content,
+            ...(frontmatter !== undefined ? { frontmatter } : {}),
+        },
+        changes,
+        ...(proposedTarget !== undefined ? { proposedTarget } : {}),
+        ...(typeof meta.beforeHash === "string" ? { beforeHash: meta.beforeHash } : {}),
+        ...(meta.review !== undefined ? { review: meta.review } : {}),
+        ...(typeof meta.confidence === "number" ? { confidence: meta.confidence } : {}),
+        ...(meta.gateDecision !== undefined ? { gateDecision: meta.gateDecision } : {}),
+        ...(typeof meta.backupContent === "string" ? { backupContent: meta.backupContent } : {}),
+        ...(meta.acceptedTarget !== undefined ? { acceptedTarget: meta.acceptedTarget } : {}),
+        ...(typeof meta.eligibilitySource === "string"
+            ? { eligibilitySource: meta.eligibilitySource }
+            : {}),
+        ...(warnings.length > 0 ? { decodeWarnings: warnings } : {}),
+    };
+}
 /**
  * Convert a public `Proposal` to column values ready for an INSERT/UPDATE.
  * The `stash_dir` comes from the call site (proposals.ts has it in scope).
@@ -49,6 +323,19 @@ export function proposalRowToProposal(row) {
 export function proposalToRowValues(proposal, stashDir) {
     // Fields that have no dedicated column live in metadata_json.
     const metaObj = {};
+    if (!Array.isArray(proposal.changes) || proposal.changes.length === 0) {
+        throw new Error(`Proposal ${proposal.id} has no file changes.`);
+    }
+    if (proposal.changes.some((change) => typeof change.path !== "string" ||
+        change.path.length === 0 ||
+        !["create", "update", "delete"].includes(change.op) ||
+        (change.op === "delete" ? change.after !== undefined : typeof change.after !== "string"))) {
+        throw new Error(`Proposal ${proposal.id} has invalid file changes.`);
+    }
+    metaObj.changes = changesToStored(proposal.changes);
+    metaObj.proposedTarget = currentProposalTarget(proposal.proposedTarget);
+    if (proposal.beforeHash !== undefined)
+        metaObj.beforeHash = proposal.beforeHash;
     if (proposal.sourceRun !== undefined)
         metaObj.sourceRun = proposal.sourceRun;
     if (proposal.review !== undefined)
@@ -59,12 +346,15 @@ export function proposalToRowValues(proposal, stashDir) {
         metaObj.gateDecision = proposal.gateDecision;
     if (proposal.backupContent !== undefined)
         metaObj.backupContent = proposal.backupContent;
+    if (proposal.acceptedTarget !== undefined)
+        metaObj.acceptedTarget = proposal.acceptedTarget;
     if (proposal.eligibilitySource !== undefined)
         metaObj.eligibilitySource = proposal.eligibilitySource;
+    validatePresentMetadata(metaObj);
     return {
         id: proposal.id,
         stash_dir: stashDir,
-        ref: proposal.ref,
+        ref: currentProposalRef(proposal.ref, true),
         status: proposal.status,
         source: proposal.source,
         created_at: proposal.createdAt,
@@ -123,38 +413,12 @@ export function listStateProposals(db, options = {}) {
               content, frontmatter_json, metadata_json
        FROM proposals ${where} ORDER BY created_at ASC, rowid ASC`)
         .all(...params);
-    return rows.map(proposalRowToProposal);
-}
-/**
- * Read every proposal's `gateDecision` record across all stashes (#612).
- *
- * Calibration reads the auto-accept gate's per-proposal decisions regardless of
- * the proposal's current lifecycle status — a proposal that was auto-accepted
- * is now `accepted`, an auto-rejected one stays `pending`, so filtering by
- * status would drop half the join. Rows without a `gateDecision` (created
- * before #577, or never gated) are skipped. The result is ordered by
- * `decidedAt ASC` for deterministic downstream aggregation, falling back to
- * `created_at` ordering from the SQL layer for rows with equal/missing
- * timestamps.
- */
-export function listProposalGateDecisions(db) {
-    const rows = db.prepare("SELECT metadata_json FROM proposals ORDER BY created_at ASC, rowid ASC").all();
-    const decisions = [];
-    for (const row of rows) {
-        let meta;
-        try {
-            meta = JSON.parse(row.metadata_json);
-        }
-        catch {
-            continue;
-        }
-        const decision = meta.gateDecision;
-        if (decision && typeof decision === "object" && typeof decision.outcome === "string") {
-            decisions.push(decision);
-        }
-    }
-    decisions.sort((a, b) => new Date(a.decidedAt).getTime() - new Date(b.decidedAt).getTime());
-    return decisions;
+    // Archived rows (accepted/rejected/reverted) decode leniently so a
+    // terminal-status row that was rejected via the lenient path (or predates
+    // a required field) remains listable — a strict throw here would defeat
+    // the point of tolerating it at reject/archive time. Pending rows keep the
+    // strict decoder; nothing about the live queue changes here.
+    return rows.map((row) => (row.status === "pending" ? proposalRowToProposal(row) : proposalRowToProposalLenient(row)));
 }
 /**
  * Look up a single proposal by id, optionally scoped to one stash root.
@@ -167,6 +431,18 @@ export function getStateProposal(db, id, stashDir) {
     const row = (stashDir ? db.prepare(sql).get(id, stashDir) : db.prepare(sql).get(id));
     return row ? proposalRowToProposal(row) : undefined;
 }
+/**
+ * Lenient counterpart to {@link getStateProposal} — used ONLY by the
+ * terminal-status (reject/archive) read paths in repository.ts that must
+ * tolerate a malformed row (see {@link proposalRowToProposalLenient}).
+ */
+export function getStateProposalLenient(db, id, stashDir) {
+    const sql = `SELECT id, stash_dir, ref, status, source, created_at, updated_at,
+              content, frontmatter_json, metadata_json
+       FROM proposals WHERE id = ?${stashDir ? " AND stash_dir = ?" : ""}`;
+    const row = (stashDir ? db.prepare(sql).get(id, stashDir) : db.prepare(sql).get(id));
+    return row ? proposalRowToProposalLenient(row) : undefined;
+}
 /**
  * Find PENDING proposal ids in one stash whose id starts with `idPrefix`.
  * Backs the UUID-prefix form of `akm proposal show/accept/... <prefix>` —
@@ -184,37 +460,3 @@ export function listStateProposalIdsByPrefix(db, stashDir, idPrefix) {
         .all(stashDir, `${escaped}%`);
     return rows.map((r) => r.id);
 }
-/**
- * Whether the legacy filesystem proposal import has already run for `stashDir`.
- * See migration 005 (`proposal_fs_imports`).
- */
-export function hasImportedFsProposals(db, stashDir) {
-    // Drivers disagree on the no-row sentinel (bun:sqlite → null,
-    // better-sqlite3 → undefined) — Boolean() covers both.
-    return Boolean(db.prepare("SELECT 1 FROM proposal_fs_imports WHERE stash_dir = ?").get(stashDir));
-}
-/**
- * Record that the legacy filesystem proposal import completed for `stashDir`
- * so subsequent invocations skip the directory walk. INSERT OR REPLACE keeps
- * the call idempotent.
- */
-export function recordFsProposalsImport(db, stashDir, importedCount) {
-    db.prepare("INSERT OR REPLACE INTO proposal_fs_imports (stash_dir, imported_at, imported_count) VALUES (?, ?, ?)").run(stashDir, new Date().toISOString(), importedCount);
-}
-/**
- * Insert a proposal row ONLY when the id is not already present (used by the
- * legacy filesystem import so re-runs never clobber rows that have since been
- * mutated through the canonical store). Returns true when a row was inserted.
- */
-export function insertProposalIfAbsent(db, proposal, stashDir) {
-    const v = proposalToRowValues(proposal, stashDir);
-    const result = db
-        .prepare(`
-      INSERT OR IGNORE INTO proposals
-        (id, stash_dir, ref, status, source, created_at, updated_at, content, frontmatter_json, metadata_json)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `)
-        .run(v.id, v.stash_dir, v.ref, v.status, v.source, v.created_at, v.updated_at, v.content, v.frontmatter_json, v.metadata_json);
-    const changes = result.changes ?? 0;
-    return Number(changes) > 0;
-}

package/dist/storage/repositories/registry-cache.js

@@ -2,7 +2,7 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { rethrowIfTestIsolationError } from "../../core/errors.js";
-import { closeDatabase, openIndexDatabase } from "../../indexer/db/db.js";
+import { closeDatabase, openIndexDatabase } from "./index-connection.js";
 import { getRegistryIndexCache, upsertRegistryIndexCache } from "./registry-index-cache-repository.js";
 /**
  * RAII-style lifecycle helper for the registry cache DB. Opens the DB (treating