@jmtrin/kevin-core 1.3.0

package/dist/ToolCallObserver.js

@@ -0,0 +1,201 @@
+import { hasColumn } from "./columns.js";
+import { fingerprint as computeFingerprint } from "./fingerprint.js";
+import { redactPaths, stripPrivate } from "./redact.js";
+import { uuidv7 } from "./uuid.js";
+const SECRET_PATTERNS = [
+    /\b(API_KEY|SECRET|PASSWORD|TOKEN)\b\s*[=:]\s*\S+/gi,
+    /\bBearer\s+\S+/gi,
+    // BUG-013 — the old `\btoken\s+\S+/gi` mangled harmless phrasing
+    // ("token budget", "token count", "max token limit") that LLM tools
+    // emit routinely. Narrowed to credential contexts: named token
+    // variables WITH an assignment, and `token=<value>` / `token:
+    // <value>` assignments.
+    /\b(access_?token|auth_?token|api_?token)\b\s*[=:]\s*\S+/gi,
+    /\btoken\s*[=:]\s*\S+/gi,
+];
+export class ToolCallObserver {
+    store;
+    startTs = new Map();
+    metrics;
+    constructor(store, metrics) {
+        this.store = store;
+        this.metrics = metrics ?? null;
+    }
+    onBefore(input, _output) {
+        const key = this.key(input);
+        this.startTs.set(key, Date.now());
+    }
+    onAfter(input, output) {
+        const key = this.key(input);
+        const start = this.startTs.get(key) ?? Date.now();
+        this.startTs.delete(key);
+        const durationMs = Math.max(0, Date.now() - start);
+        const sessionId = input.sessionId ?? "unknown";
+        const argsSummary = this.summarizeArgs(input.args ?? {});
+        const success = output.success === true ? 1 : 0;
+        const agent = input.agent ?? null;
+        const stderr = stripPrivate(output.stderr ?? "");
+        const stdout = stripPrivate(output.stdout ?? "");
+        const errorType = output.success === false
+            ? this.inferErrorType(stderr, stdout, output.exitCode)
+            : null;
+        const metadata = JSON.stringify(this.redactArgs(input.args ?? {}));
+        const projectId = input.projectId ?? null;
+        const fp = computeFingerprint(`${input.tool}|${argsSummary}|${success}`, projectId ?? undefined);
+        if (this.isDedupEnabled()) {
+            const existing = this.store
+                .prepare(`SELECT 1 FROM tool_calls
+					 WHERE fingerprint = ?
+					   AND (project_id IS ? OR (project_id IS NULL AND ? IS NULL))
+					   AND strftime('%Y-%m-%d %H:%M', ts) = strftime('%Y-%m-%d %H:%M', 'now')
+					 LIMIT 1`)
+                .get(fp, projectId, projectId);
+            if (existing) {
+                this.metrics?.incr("tool_calls_deduped", 1);
+                return;
+            }
+        }
+        // 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 {
+            const row = this.store
+                .prepare("SELECT value FROM kevin_settings WHERE key = 'tool_calls_dedup_enabled'")
+                .get();
+            return row?.value === "1";
+        }
+        catch {
+            return false;
+        }
+    }
+    redactSecrets(text) {
+        let out = text;
+        for (const pat of SECRET_PATTERNS) {
+            out = out.replace(pat, (match) => {
+                // BUG-013 — preserve the original separator so
+                // `auth_token = abc123` keeps its spacing: only the
+                // value is replaced.
+                const m = match.match(/^(.+?)(\s*[=:]\s*)(\S+)$/);
+                if (m) {
+                    return `${m[1]}${m[2]}<redacted>`;
+                }
+                const parts = match.split(/\s+/);
+                return `${parts[0]} <redacted>`;
+            });
+        }
+        return out;
+    }
+    summarizeArgs(args) {
+        const interestingKeys = [
+            "filePath",
+            "path",
+            "cwd",
+            "command",
+            "cmd",
+            "file",
+            "directory",
+        ];
+        const parts = [];
+        for (const [k, v] of Object.entries(args)) {
+            if (interestingKeys.includes(k)) {
+                parts.push(`${k}: ${this.redactValue(v)}`);
+            }
+            else if (this.looksSecret(k)) {
+                parts.push(`${k}: <redacted>`);
+            }
+            else {
+                parts.push(`${k}: ${this.redactValue(v, 200)}`);
+            }
+        }
+        let summary = parts.join(", ");
+        if (summary.length > 500)
+            summary = `${summary.slice(0, 500)}...`;
+        return summary;
+    }
+    inferErrorType(stderr, stdout, exitCode) {
+        const combined = `${stderr}\n${stdout}`.toLowerCase();
+        if (exitCode === 124 ||
+            /timed out|timeout|etimedout|\bkilled\b|sigterm|sigkill/.test(combined)) {
+            return "timeout";
+        }
+        if (/error ts|tsc|\btypescript\b/.test(combined))
+            return "typecheck";
+        if (/\b(lint|biome|eslint)\b/.test(combined))
+            return "lint";
+        if (/\b(fail|vitest|jest|test failed)\b/.test(combined))
+            return "test";
+        if (/error:|typeerror|referenceerror|syntaxerror/.test(combined))
+            return "runtime";
+        if ((exitCode === undefined || exitCode === -1) &&
+            stderr.trim() === "" &&
+            stdout.trim() === "") {
+            return "timeout";
+        }
+        return "unknown";
+    }
+    key(input) {
+        if (input.callID)
+            return `callID::${input.callID}`;
+        const argsKey = JSON.stringify(input.args ?? {});
+        return `${input.sessionId ?? "unknown"}::${input.tool}::${argsKey}`;
+    }
+    looksSecret(key) {
+        const k = key.toLowerCase();
+        return /(key|secret|password|token|bearer)/.test(k);
+    }
+    redactArgs(args) {
+        const out = {};
+        for (const [k, v] of Object.entries(args)) {
+            if (this.looksSecret(k)) {
+                out[k] = "<redacted>";
+            }
+            else {
+                out[k] = this.redactValue(v);
+            }
+        }
+        return out;
+    }
+    redactValue(v, truncateAt) {
+        if (typeof v === "string") {
+            let s = stripPrivate(v);
+            s = redactPaths(s);
+            s = this.redactSecrets(s);
+            if (truncateAt !== undefined && s.length > truncateAt) {
+                s = `${s.slice(0, truncateAt)}...`;
+            }
+            return s;
+        }
+        if (Array.isArray(v)) {
+            return v.map((item) => this.redactValue(item));
+        }
+        if (v && typeof v === "object") {
+            const obj = {};
+            for (const [k, val] of Object.entries(v)) {
+                if (this.looksSecret(k)) {
+                    obj[k] = "<redacted>";
+                }
+                else {
+                    obj[k] = this.redactValue(val);
+                }
+            }
+            return obj;
+        }
+        return v;
+    }
+}

package/dist/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/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/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/TuiSnapshots.js

@@ -0,0 +1,159 @@
+// v1.3.0 (K13-002/K13-004) — snapshot flush moved to core (pure serialization + atomic write).
+// Was v1.2.0 (K12-003 / plan §4.2, D12-05); version fallback updated for Bedrock (B-002).
+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.3.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/capabilities.d.ts

@@ -0,0 +1,6 @@
+export interface Capabilities {
+    readonly skills: boolean;
+    readonly references: boolean;
+    readonly apiVersion: string | null;
+    readonly permissionAsk?: boolean;
+}

package/dist/capabilities.js

@@ -0,0 +1 @@
+export {};

package/dist/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/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;
+    }
+}