@jmtrin/opencode-kevin 1.0.0 → 1.2.0

package/dist/plugin/MemoryService.js

@@ -1,4 +1,5 @@
 import { deterministicFixLine } from "./LessonFixer.js";
+import { hasCuratedColumn as columnsHasCurated, hasIgnoredColumn as columnsHasIgnored, hasLayerColumn as columnsHasLayer, hasRecurrenceColumn as columnsHasRecurrence, hasRepoIdColumn as columnsHasRepoId, hasTruthColumns as columnsHasTruth, } from "./columns.js";
 import { computeConfidence } from "./confidence.js";
 import { fingerprint as computeFingerprint } from "./fingerprint.js";
 import { classify } from "./inferability.js";
@@ -82,106 +83,21 @@ const MEMORY_ROW_SELECT = `id, type, content, scope, relevance_score, source_too
                 metadata, created_at, updated_at, expires_at,
                 project_id, fingerprint, origin,
                 evidence_count, recurrence_count, last_verified_at, status, fix_args`;
-/**
- * v0.5.0 (K5-008/009 / plan §5.6) — cached per-store probe for the 006-only
- * `ignored` column (pre-006 DBs must not reference it). Shared by the
- * retrieval filter, the row SELECT, and the save() ignored stamp.
- * v0.6.0 (K6-001a) — positive-only caching: a successful probe is cached,
- * a failed probe is NOT. A Store migrated in place heals on the next call.
- */
-const ignoredColumnCache = new WeakMap();
+// v1.1.0 (K11-011 / plan §5.5, D11-06) — probes delegate to columns registry
 function hasIgnoredColumn(store) {
-    const cached = ignoredColumnCache.get(store);
-    if (cached === true)
-        return true;
-    try {
-        store.prepare("SELECT ignored FROM memories LIMIT 1").get();
-        ignoredColumnCache.set(store, true);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return columnsHasIgnored(store);
 }
-/**
- * v0.6.0 (K6-011 / plan §5.4) — cached per-store probe for the 007-only
- * `curated` column (pre-007 DBs must not reference it). Same positive-only
- * caching discipline as `ignored` (K6-001a): a successful probe is cached,
- * a failed probe is NOT.
- */
-const curatedColumnCache = new WeakMap();
 function hasCuratedColumn(store) {
-    const cached = curatedColumnCache.get(store);
-    if (cached === true)
-        return true;
-    try {
-        store.prepare("SELECT curated FROM memories LIMIT 1").get();
-        curatedColumnCache.set(store, true);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return columnsHasCurated(store);
 }
-/**
- * v0.7.0 (K7-008 / migration 008) — cached per-store probe for the 008-only
- * `truth_penalty` column (pre-008 DBs must not reference it). Same
- * positive-only caching discipline as `curated` (K6-001a).
- */
-const truthColumnsCache = new WeakMap();
 function hasTruthColumns(store) {
-    const cached = truthColumnsCache.get(store);
-    if (cached === true)
-        return true;
-    try {
-        store.prepare("SELECT truth_penalty FROM memories LIMIT 1").get();
-        truthColumnsCache.set(store, true);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return columnsHasTruth(store);
 }
-/**
- * v0.8.0 (K8-007 / plan §5.7) — cached per-store probe for the 009-only
- * `repo_id` column (pre-009 DBs must not reference it). Same positive-only
- * caching discipline as `ignored` (K6-001a): a successful probe is cached,
- * a failed probe is NOT. Exported so `kevin_audit`'s rollups scope on the
- * same column.
- */
-const repoIdColumnCache = new WeakMap();
 export function hasRepoIdColumn(store) {
-    const cached = repoIdColumnCache.get(store);
-    if (cached === true)
-        return true;
-    try {
-        store.prepare("SELECT repo_id FROM memories LIMIT 1").get();
-        repoIdColumnCache.set(store, true);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return columnsHasRepoId(store);
 }
-/**
- * v0.8.0 (K8-018 / plan §5.2) — cached per-store probe for the 009-only
- * `layer` column (pre-009 DBs must not reference it). Same positive-only
- * caching discipline: pre-009 databases have no shared layer, so the
- * immutability refusal in `update()` is skipped there entirely.
- */
-const layerColumnCache = new WeakMap();
 function hasLayerColumn(store) {
-    const cached = layerColumnCache.get(store);
-    if (cached === true)
-        return true;
-    try {
-        store.prepare("SELECT layer FROM memories LIMIT 1").get();
-        layerColumnCache.set(store, true);
-        return true;
-    }
-    catch {
-        return false;
-    }
+    return columnsHasLayer(store);
 }
 /**
  * v0.5.0 (K5-009 / plan §5.3) — the 006-only columns are appended when the
@@ -204,7 +120,7 @@ function rowSelect(store) {
         : withCurated;
     return hasLayerColumn(store) ? `${withTruth}, layer` : withTruth;
 }
-function mapRow(row, score) {
+export function mapRow(row, score) {
     const mem = {
         id: row.id,
         type: row.type,
@@ -320,21 +236,10 @@ export class MemoryService {
     }
     // v0.4.0 (BUG-008) — cached column probe for pre-005 DBs (which lack
     // `recurrence_count`); save() must not reference the column there.
+    // v1.1.0 (K11-011) — delegates to columns registry
     hasRecurrenceColumn() {
-        if (this._hasRecurrenceColumn === undefined) {
-            try {
-                this.store
-                    .prepare("SELECT recurrence_count FROM memories LIMIT 1")
-                    .get();
-                this._hasRecurrenceColumn = true;
-            }
-            catch {
-                this._hasRecurrenceColumn = false;
-            }
-        }
-        return this._hasRecurrenceColumn;
+        return columnsHasRecurrence(this.store);
     }
-    _hasRecurrenceColumn;
     // v0.5.0 (K5-008 / plan §5.6) — cached column probe for pre-006 DBs
     // (which lack `ignored`); the retrieval filter must not reference the
     // column there.
@@ -1246,8 +1151,10 @@ function originBoost(mem) {
  * (when available) so the feedback loop can exclude the original call
  * from the recurrence count. Returns null when metadata is absent,
  * malformed, or lacks the field.
+ * // v1.1.0 (K11-003 / plan §5.5, D11-05) — single source for origin lookup;
+ * // InjectionLedger reuses this implementation (K11-013).
  */
-function readOriginCallId(metadata) {
+export function readOriginCallId(metadata) {
     if (!metadata)
         return null;
     try {

package/dist/plugin/Migrate.js

@@ -247,6 +247,11 @@ export class Migrate {
             applied: pending.map((m) => m.version),
         };
     }
+    // v1.1.0 (K11-015) — lexicographic ordering is valid through "999" because
+    // versions are zero-padded 3-digit strings ("001" … "999"). Any future
+    // migration beyond 999 must use a 4-digit prefix and this comparison must
+    // become numeric (parseInt). Until then, string > works and keeps the
+    // migration idempotency simple (plan §5.5, D11-??).
     listPending(current) {
         let files = [];
         try {

package/dist/plugin/Retrospective.js

@@ -74,6 +74,13 @@ export const METRIC_KEY_LABELS = {
     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",
+    // v1.2.0 (K12-001 / plan §4) — surface metrics; labels required by BUG-014 regression.
+    tui_snapshots_flushed: "Snapshots TUI generados",
+    tui_actions_invoked: "Acciones TUI invocadas",
 };
 function originLabel(origin) {
     if (origin === "reflector")

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 {

package/dist/plugin/TuiActions.d.ts

@@ -0,0 +1,43 @@
+import type { ActionResult, TuiAction } from "./tui-types.js";
+export interface MailboxReadResult {
+    readonly actions: readonly TuiAction[];
+    readonly warnings: readonly string[];
+}
+/**
+ * Read `join(root,"tui","actions.json")` tolerant.
+ * - missing file → {actions:[], warnings:[]}
+ * - malformed JSON → {actions:[], warnings:["malformed_json"]}
+ * - non-object or missing/non-array actions → {actions:[], warnings:["invalid_shape"]}
+ * - unknown type values are dropped with warning per entry
+ * Never deletes the file here.
+ */
+export declare function readMailbox(root: string): MailboxReadResult;
+export declare function proposalToken(proposalId: string, proposedText: string): string;
+export interface PendingProposal {
+    readonly id: string;
+    readonly proposedText: string;
+}
+export declare function verifyFresh(action: TuiAction, currentPending: readonly PendingProposal[]): {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+export type ActionStatus = ActionResult["status"];
+export interface ProcessDeps {
+    readonly getPending: () => readonly PendingProposal[];
+    readonly approve: (proposalId: string) => unknown;
+    readonly reject: (proposalId: string, note?: string) => unknown;
+    readonly acknowledge: (conflictId: string) => unknown;
+    readonly metrics?: {
+        incr: (key: "tui_actions_invoked", by?: number) => void;
+    } | null;
+}
+export declare function processActions(actions: readonly TuiAction[], deps: ProcessDeps): ActionResult[];
+export declare function writeResults(root: string, results: readonly ActionResult[]): void;
+export declare function deleteMailbox(root: string): void;
+/**
+ * Convenience: read → process → write results → delete queue.
+ * Returns results (empty if no actions). Mirrors idle-chain usage.
+ */
+export declare function consumeMailbox(root: string, deps: ProcessDeps): ActionResult[];

package/dist/plugin/TuiActions.js

@@ -0,0 +1,181 @@
+// v1.2.0 (K12-005 / plan §4.3) — mailbox tolerant parser (phase F1).
+// v1.2.0 (K12-006 / plan §4.3, D12-04) — token scheme + stale detection
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { join } from "node:path";
+function isRecord(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isValidAction(raw) {
+    if (!isRecord(raw))
+        return null;
+    const t = raw.type;
+    if (t === "approve") {
+        if (typeof raw.proposalId === "string" && typeof raw.token === "string") {
+            return { type: "approve", proposalId: raw.proposalId, token: raw.token };
+        }
+        return null;
+    }
+    if (t === "reject") {
+        if (typeof raw.proposalId === "string" && typeof raw.token === "string") {
+            const note = typeof raw.note === "string" ? raw.note : undefined;
+            return note !== undefined
+                ? { type: "reject", proposalId: raw.proposalId, token: raw.token, note }
+                : { type: "reject", proposalId: raw.proposalId, token: raw.token };
+        }
+        return null;
+    }
+    if (t === "acknowledge") {
+        if (typeof raw.conflictId === "string") {
+            return { type: "acknowledge", conflictId: raw.conflictId };
+        }
+        return null;
+    }
+    return null;
+}
+/**
+ * Read `join(root,"tui","actions.json")` tolerant.
+ * - missing file → {actions:[], warnings:[]}
+ * - malformed JSON → {actions:[], warnings:["malformed_json"]}
+ * - non-object or missing/non-array actions → {actions:[], warnings:["invalid_shape"]}
+ * - unknown type values are dropped with warning per entry
+ * Never deletes the file here.
+ */
+export function readMailbox(root) {
+    const path = join(root, "tui", "actions.json");
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === "ENOENT")
+            return { actions: [], warnings: [] };
+        return { actions: [], warnings: ["read_error"] };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return { actions: [], warnings: ["malformed_json"] };
+    }
+    if (!isRecord(parsed)) {
+        return { actions: [], warnings: ["invalid_shape"] };
+    }
+    const maybeActions = parsed.actions;
+    if (!Array.isArray(maybeActions)) {
+        return { actions: [], warnings: ["invalid_shape"] };
+    }
+    const actions = [];
+    const warnings = [];
+    for (const entry of maybeActions) {
+        if (!isRecord(entry)) {
+            warnings.push("dropped_invalid_entry");
+            continue;
+        }
+        const type = entry.type;
+        if (type !== "approve" && type !== "reject" && type !== "acknowledge") {
+            warnings.push(`dropped_unknown_type:${String(type)}`);
+            continue;
+        }
+        const valid = isValidAction(entry);
+        if (!valid) {
+            warnings.push(`dropped_invalid_${String(type)}`);
+            continue;
+        }
+        actions.push(valid);
+    }
+    return { actions, warnings };
+}
+// v1.2.0 (K12-006 / D12-04) — first 16 hex of SHA-256(proposalId + "\0" + proposedText)
+export function proposalToken(proposalId, proposedText) {
+    return createHash("sha256")
+        .update(`${proposalId}\0${proposedText}`, "utf8")
+        .digest("hex")
+        .slice(0, 16);
+}
+export function verifyFresh(action, currentPending) {
+    if (action.type === "acknowledge")
+        return { ok: true };
+    const pending = currentPending.find((p) => p.id === action.proposalId);
+    if (!pending) {
+        return { ok: false, reason: "content_changed_or_absent" };
+    }
+    const expected = proposalToken(pending.id, pending.proposedText);
+    if (expected !== action.token) {
+        return { ok: false, reason: "content_changed_or_absent" };
+    }
+    return { ok: true };
+}
+export function processActions(actions, deps) {
+    const results = [];
+    const pendingSnapshot = deps.getPending();
+    for (const action of actions) {
+        // Stale check for approve/reject
+        if (action.type === "approve" || action.type === "reject") {
+            const fresh = verifyFresh(action, pendingSnapshot);
+            if (!fresh.ok) {
+                results.push({ action, status: "stale_skipped", detail: fresh.reason });
+                try {
+                    deps.metrics?.incr("tui_actions_invoked", 1);
+                }
+                catch { }
+                continue;
+            }
+        }
+        try {
+            if (action.type === "approve") {
+                deps.approve(action.proposalId);
+                results.push({ action, status: "applied" });
+            }
+            else if (action.type === "reject") {
+                deps.reject(action.proposalId, action.note);
+                results.push({ action, status: "rejected" });
+            }
+            else if (action.type === "acknowledge") {
+                deps.acknowledge(action.conflictId);
+                results.push({ action, status: "applied" });
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            results.push({ action, status: "error", detail: msg });
+        }
+        try {
+            deps.metrics?.incr("tui_actions_invoked", 1);
+        }
+        catch { }
+    }
+    return results;
+}
+export function writeResults(root, results) {
+    const dir = join(root, "tui");
+    mkdirSync(dir, { recursive: true });
+    const payload = JSON.stringify({ generatedAt: new Date().toISOString(), results }, null, 2);
+    const target = join(dir, "results.json");
+    const tmp = `${target}.tmp`;
+    writeFileSync(tmp, payload, "utf8");
+    renameSync(tmp, target);
+}
+export function deleteMailbox(root) {
+    try {
+        unlinkSync(join(root, "tui", "actions.json"));
+    }
+    catch {
+        // missing is fine
+    }
+}
+/**
+ * Convenience: read → process → write results → delete queue.
+ * Returns results (empty if no actions). Mirrors idle-chain usage.
+ */
+export function consumeMailbox(root, deps) {
+    const { actions } = readMailbox(root);
+    if (actions.length === 0)
+        return [];
+    const results = processActions(actions, deps);
+    writeResults(root, results);
+    deleteMailbox(root);
+    return results;
+}

package/dist/plugin/TuiSnapshots.d.ts

@@ -0,0 +1,24 @@
+import type { Metrics } from "./metrics.js";
+import type { ConflictView, HealthView, ProposalView } from "./tui-types.js";
+export interface FlushInput {
+    readonly root: string;
+    readonly proposals: readonly ProposalView[];
+    readonly conflicts: readonly ConflictView[];
+    readonly health: HealthView;
+    readonly metrics?: Metrics | null;
+    readonly version?: string;
+}
+export interface FlushResult {
+    readonly written: string[];
+    readonly skipped: string[];
+}
+export declare function flushSnapshots(input: FlushInput): FlushResult;
+/**
+ * Tolerant JSON reader used by tests and (duplicated) by the TUI.
+ * Returns {data} on success, {error} on missing/corrupt.
+ */
+export declare function readJsonSafe(path: string): {
+    data: unknown;
+} | {
+    error: "missing" | "corrupt";
+};

package/dist/plugin/TuiSnapshots.js

@@ -0,0 +1,158 @@
+// v1.2.0 (K12-003 / plan §4.2, D12-05) — snapshot flush (pure serialization + atomic write).
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+const CAP_BYTES = 512 * 1024;
+const SNAP_FILES = [
+    "proposals.json",
+    "conflicts.json",
+    "health.json",
+    "meta.json",
+];
+function byteLen(s) {
+    return Buffer.byteLength(s, "utf8");
+}
+function atomicWrite(target, content) {
+    const tmp = `${target}.tmp`;
+    writeFileSync(tmp, content, "utf8");
+    renameSync(tmp, target);
+}
+function truncateProposals(proposals, cap) {
+    // Estimate JSON overhead without diffs to compute available budget.
+    // We truncate diff fields proportionally to fit cap.
+    const serialized = JSON.stringify(proposals);
+    if (byteLen(serialized) <= cap)
+        return proposals;
+    // Compute total diff length
+    const totalDiff = proposals.reduce((acc, p) => acc + byteLen(p.diff), 0);
+    if (totalDiff === 0)
+        return proposals;
+    const overhead = byteLen(serialized) - totalDiff;
+    const budget = Math.max(0, cap - overhead - 1024); // leave margin
+    // Distribute budget proportionally
+    const out = [];
+    for (let i = 0; i < proposals.length; i++) {
+        const p = proposals[i];
+        const diffBytes = byteLen(p.diff);
+        const share = Math.floor((diffBytes / totalDiff) * budget);
+        // Ensure at least 100 bytes per entry if possible, else share
+        const sliceBytes = Math.min(diffBytes, Math.max(share, 100));
+        // Slice diff by bytes approximated via string length; diff is ascii mostly
+        // so byte length ~ char length. Use char slice.
+        const approxChars = Math.floor((sliceBytes / Math.max(diffBytes, 1)) * p.diff.length);
+        const truncatedDiff = p.diff.slice(0, Math.max(0, approxChars));
+        const needsTrunc = truncatedDiff.length < p.diff.length;
+        out.push({
+            ...p,
+            diff: needsTrunc ? `${truncatedDiff}\n…[truncated]` : p.diff,
+            truncated: needsTrunc ? true : p.truncated,
+        });
+    }
+    // If still over cap after proportional truncation, iteratively trim more
+    let result = out;
+    let ser = JSON.stringify(result);
+    let iter = 0;
+    while (byteLen(ser) > cap && iter < 5) {
+        result = result.map((p) => {
+            if (!p.diff || p.diff.length < 200)
+                return p;
+            const half = Math.floor(p.diff.length / 2);
+            return {
+                ...p,
+                diff: `${p.diff.slice(0, half)}\n…[truncated]`,
+                truncated: true,
+            };
+        });
+        ser = JSON.stringify(result);
+        iter++;
+    }
+    return result;
+}
+export function flushSnapshots(input) {
+    const { root, proposals, conflicts, health, metrics, version } = input;
+    const dir = join(root, "tui");
+    mkdirSync(dir, { recursive: true });
+    const generatedAt = new Date().toISOString();
+    const written = [];
+    const skipped = [];
+    // Proposals — cap with truncation
+    let propToWrite = proposals;
+    let propJson = JSON.stringify(propToWrite, null, 2);
+    if (byteLen(propJson) > CAP_BYTES) {
+        propToWrite = truncateProposals(proposals, CAP_BYTES - 1024);
+        propJson = JSON.stringify(propToWrite, null, 2);
+        if (byteLen(propJson) > CAP_BYTES) {
+            // Still over after truncation: truncate further by dropping diffs entirely
+            const minimal = propToWrite.map((p) => ({
+                ...p,
+                diff: `${p.diff.slice(0, 500)}\n…[truncated]`,
+                truncated: true,
+            }));
+            propJson = JSON.stringify(minimal, null, 2);
+        }
+    }
+    atomicWrite(join(dir, "proposals.json"), propJson);
+    written.push("proposals.json");
+    // Conflicts
+    let conflictsJson = JSON.stringify(conflicts, null, 2);
+    if (byteLen(conflictsJson) > CAP_BYTES) {
+        // Truncate summaries if needed
+        const truncated = conflicts.map((c) => ({
+            ...c,
+            a_summary: c.a_summary.slice(0, 500),
+            b_summary: c.b_summary.slice(0, 500),
+        }));
+        conflictsJson = JSON.stringify(truncated, null, 2);
+    }
+    atomicWrite(join(dir, "conflicts.json"), conflictsJson);
+    written.push("conflicts.json");
+    // Health
+    let healthJson = JSON.stringify(health, null, 2);
+    if (byteLen(healthJson) > CAP_BYTES) {
+        // Health should never exceed cap, but truncate counters if it does
+        const truncatedHealth = {
+            ...health,
+            counters: {},
+        };
+        healthJson = JSON.stringify(truncatedHealth, null, 2);
+    }
+    atomicWrite(join(dir, "health.json"), healthJson);
+    written.push("health.json");
+    // Meta
+    const meta = {
+        generatedAt,
+        version: version ?? "1.2.0",
+        files: SNAP_FILES.slice(0, 3),
+    };
+    atomicWrite(join(dir, "meta.json"), JSON.stringify(meta, null, 2));
+    written.push("meta.json");
+    if (metrics) {
+        try {
+            metrics.incr("tui_snapshots_flushed");
+        }
+        catch {
+            // best-effort
+        }
+    }
+    return { written, skipped };
+}
+/**
+ * Tolerant JSON reader used by tests and (duplicated) by the TUI.
+ * Returns {data} on success, {error} on missing/corrupt.
+ */
+export function readJsonSafe(path) {
+    try {
+        const raw = readFileSync(path, "utf8");
+        try {
+            return { data: JSON.parse(raw) };
+        }
+        catch {
+            return { error: "corrupt" };
+        }
+    }
+    catch (err) {
+        const code = err?.code;
+        if (code === "ENOENT")
+            return { error: "missing" };
+        return { error: "corrupt" };
+    }
+}

package/dist/plugin/capabilities.d.ts

@@ -11,5 +11,7 @@ export interface Capabilities {
     readonly skills: boolean;
     readonly references: boolean;
     readonly apiVersion: string | null;
+    /** v1.2.0 (K12-012 / plan D12-03) — additive probe for permission.ask. */
+    readonly permissionAsk?: boolean;
 }
 export declare function probe(input: unknown): Capabilities;

package/dist/plugin/capabilities.js

@@ -11,6 +11,7 @@ const ALL_FALSE = {
     skills: false,
     references: false,
     apiVersion: null,
+    permissionAsk: false,
 };
 function hasCallable(input, domainKey, memberKey) {
     const domain = input[domainKey];
@@ -27,10 +28,12 @@ export function probe(input) {
         const apiVersion = typeof record.apiVersion === "string"
             ? record.apiVersion
             : null;
+        const permissionAsk = hasCallable(record, "permission", "ask");
         return {
             skills: hasCallable(record, "skill", "source"),
             references: hasCallable(record, "reference", "add"),
             apiVersion,
+            permissionAsk,
         };
     }
     catch {

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;