autosnippet 3.3.7 → 3.3.8

package/dist/lib/repository/search/SearchRepoAdapter.js

@@ -0,0 +1,124 @@
+/**
+ * SearchRepoAdapter — SearchEngine 用的轻量级仓储适配器
+ *
+ * 当完整的 KnowledgeRepositoryImpl / RecipeSourceRefRepositoryImpl 不可用时
+ * （例如单元测试中只传入 raw db），SearchEngine 自动使用这些适配器。
+ * 放在 lib/repository/ 下，允许使用 raw SQL（lint 白名单目录）。
+ */
+/** 解包 DatabaseConnection → raw SearchDb（若已是 raw db 则直接返回） */
+export function unwrapSearchDb(db) {
+    return typeof db.getDb === 'function' ? db.getDb() : db;
+}
+/**
+ * 通用 db 解包：接受 raw db 或 { getDb() } wrapper，返回 raw db。
+ * 可用于 SearchDb、DatabaseLike 等不同 db 类型的构造函数。
+ */
+export function unwrapRawDb(db) {
+    if (db !== null &&
+        db !== undefined &&
+        typeof db === 'object' &&
+        'getDb' in db &&
+        typeof db.getDb === 'function') {
+        return db.getDb();
+    }
+    return db;
+}
+/**
+ * Raw-db 适配器：实现 SearchKnowledgeRepo 接口
+ * 仅在 KnowledgeRepositoryImpl 不可用时降级使用。
+ */
+export class RawDbKnowledgeAdapter {
+    #db;
+    constructor(db) {
+        this.#db = db;
+    }
+    findNonDeprecatedSync() {
+        return this.#db
+            .prepare(`SELECT id, title, description, language, category, knowledgeType, kind,
+                content, lifecycle, tags, trigger, difficulty, quality, stats,
+                updatedAt, createdAt
+         FROM knowledge_entries WHERE lifecycle != 'deprecated'`)
+            .all();
+    }
+    keywordSearchSync(pattern, limit) {
+        return this.#db
+            .prepare(`SELECT id, title, description, language, category, knowledgeType, kind, lifecycle as status, content, trigger, headers, moduleName, 'knowledge' as type
+         FROM knowledge_entries
+         WHERE lifecycle != 'deprecated' AND (title LIKE ? ESCAPE '\\' OR description LIKE ? ESCAPE '\\' OR trigger LIKE ? ESCAPE '\\' OR content LIKE ? ESCAPE '\\')
+         LIMIT ?`)
+            .all(pattern, pattern, pattern, pattern, limit);
+    }
+    findByIdsDetailSync(ids) {
+        if (ids.length === 0) {
+            return [];
+        }
+        const placeholders = ids.map(() => '?').join(',');
+        return this.#db
+            .prepare(`SELECT id, content, description, trigger, headers, moduleName,
+                tags, language, category, updatedAt, createdAt, quality, stats, difficulty,
+                whenClause, doClause
+         FROM knowledge_entries WHERE id IN (${placeholders})`)
+            .all(...ids);
+    }
+    findUpdatedSinceSync(sinceIso) {
+        return this.#db
+            .prepare(`SELECT id, title, description, language, category, knowledgeType, kind,
+                content, lifecycle, tags, trigger, difficulty, quality, stats,
+                updatedAt, createdAt
+         FROM knowledge_entries WHERE updatedAt > ?`)
+            .all(sinceIso);
+    }
+}
+/**
+ * Raw-db 适配器：实现 SearchSourceRefRepo 接口
+ * 仅在 RecipeSourceRefRepositoryImpl 不可用时降级使用。
+ */
+export class RawDbSourceRefAdapter {
+    #db;
+    constructor(db) {
+        this.#db = db;
+    }
+    findActiveByRecipeIds(ids) {
+        if (ids.length === 0) {
+            return [];
+        }
+        const placeholders = ids.map(() => '?').join(',');
+        return this.#db
+            .prepare(`SELECT recipe_id, source_path, status, new_path
+         FROM recipe_source_refs
+         WHERE recipe_id IN (${placeholders}) AND status != 'stale'`)
+            .all(...ids);
+    }
+}
+/**
+ * Raw-db 适配器：实现 GuardKnowledgeRepo 接口
+ * 仅在 KnowledgeRepositoryImpl 不可用时降级使用。
+ */
+export class RawDbGuardAdapter {
+    #db;
+    constructor(db) {
+        this.#db = db;
+    }
+    findGuardRulesSync(lifecycles) {
+        const placeholders = lifecycles.map(() => '?').join(',');
+        return this.#db
+            .prepare(`SELECT id, title, description, language, scope, constraints, lifecycle
+         FROM knowledge_entries WHERE kind = 'rule' AND lifecycle IN (${placeholders})`)
+            .all(...lifecycles);
+    }
+    incrementGuardHitsSync(id, hits) {
+        this.#db
+            .prepare(`UPDATE knowledge_entries
+         SET stats = json_set(COALESCE(stats, '{}'), '$.guardHits', COALESCE(json_extract(stats, '$.guardHits'), 0) + ?),
+             updatedAt = strftime('%s', 'now')
+         WHERE id = ?`)
+            .run(hits, id);
+    }
+}
+/* ═══ Vector Sync 适配器 ═══════════════════════════════════ */
+/** 从 raw db 查询非 deprecated 的基本条目信息（SyncCoordinator 对账用） */
+export function queryNonDeprecatedEntries(db) {
+    return db
+        .prepare(`SELECT id, title, content, kind FROM knowledge_entries WHERE lifecycle != 'deprecated'`)
+        .all();
+}

package/dist/lib/repository/session/SessionRepository.d.ts

@@ -0,0 +1,46 @@
+/**
+ * SessionRepository — 会话管理的仓储实现
+ *
+ * 操作 sessions 表，负责会话的 CRUD 和过期清理。
+ * 使用 Drizzle 类型安全 API。
+ */
+import { sessions } from '../../infrastructure/database/drizzle/schema.js';
+import { RepositoryBase } from '../base/RepositoryBase.js';
+export interface SessionEntity {
+    id: string;
+    scope: string;
+    scopeId: string | null;
+    context: Record<string, unknown>;
+    metadata: Record<string, unknown>;
+    actor: string | null;
+    createdAt: number;
+    lastActiveAt: number | null;
+    expiredAt: number | null;
+}
+export interface SessionInsert {
+    id: string;
+    scope: string;
+    scopeId?: string | null;
+    context?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    actor?: string | null;
+    createdAt: number;
+    lastActiveAt?: number | null;
+}
+export declare class SessionRepositoryImpl extends RepositoryBase<typeof sessions, SessionEntity> {
+    #private;
+    constructor(drizzle: ConstructorParameters<typeof RepositoryBase<typeof sessions, SessionEntity>>[0]);
+    findById(id: string): Promise<SessionEntity | null>;
+    create(data: SessionInsert): Promise<SessionEntity>;
+    delete(id: string): Promise<boolean>;
+    /** 按 scope 查询所有会话 */
+    findByScope(scope: string): Promise<SessionEntity[]>;
+    /** 按 actor 查询 */
+    findByActor(actor: string): Promise<SessionEntity[]>;
+    /** 更新最后活跃时间 */
+    updateLastActivity(id: string, timestamp?: number): Promise<void>;
+    /** 过期清理 — 删除 expiredAt < now 的会话 */
+    cleanup(now?: number): Promise<number>;
+    /** 会话总数 */
+    count(scope?: string): Promise<number>;
+}

package/dist/lib/repository/session/SessionRepository.js

@@ -0,0 +1,110 @@
+/**
+ * SessionRepository — 会话管理的仓储实现
+ *
+ * 操作 sessions 表，负责会话的 CRUD 和过期清理。
+ * 使用 Drizzle 类型安全 API。
+ */
+import { and, count, desc, eq, lt, sql } from 'drizzle-orm';
+import { sessions } from '../../infrastructure/database/drizzle/schema.js';
+import { RepositoryBase } from '../base/RepositoryBase.js';
+/* ═══ 仓储实现 ═══ */
+export class SessionRepositoryImpl extends RepositoryBase {
+    constructor(drizzle) {
+        super(drizzle, sessions);
+    }
+    /* ═══ CRUD ═══ */
+    async findById(id) {
+        const row = this.drizzle.select().from(sessions).where(eq(sessions.id, id)).get();
+        return row ? SessionRepositoryImpl.#toEntity(row) : null;
+    }
+    async create(data) {
+        this.drizzle
+            .insert(sessions)
+            .values({
+            id: data.id,
+            scope: data.scope,
+            scopeId: data.scopeId ?? null,
+            context: JSON.stringify(data.context ?? {}),
+            metadata: JSON.stringify(data.metadata ?? {}),
+            actor: data.actor ?? null,
+            createdAt: data.createdAt,
+            lastActiveAt: data.lastActiveAt ?? data.createdAt,
+        })
+            .run();
+        const entity = await this.findById(data.id);
+        if (!entity) {
+            throw new Error(`Failed to create session: ${data.id}`);
+        }
+        return entity;
+    }
+    async delete(id) {
+        const result = this.drizzle.delete(sessions).where(eq(sessions.id, id)).run();
+        return (result.changes ?? 0) > 0;
+    }
+    /* ═══ 查询 ═══ */
+    /** 按 scope 查询所有会话 */
+    async findByScope(scope) {
+        const rows = this.drizzle
+            .select()
+            .from(sessions)
+            .where(eq(sessions.scope, scope))
+            .orderBy(desc(sessions.createdAt))
+            .all();
+        return rows.map(SessionRepositoryImpl.#toEntity);
+    }
+    /** 按 actor 查询 */
+    async findByActor(actor) {
+        const rows = this.drizzle
+            .select()
+            .from(sessions)
+            .where(eq(sessions.actor, actor))
+            .orderBy(desc(sessions.lastActiveAt))
+            .all();
+        return rows.map(SessionRepositoryImpl.#toEntity);
+    }
+    /** 更新最后活跃时间 */
+    async updateLastActivity(id, timestamp) {
+        this.drizzle
+            .update(sessions)
+            .set({ lastActiveAt: timestamp ?? Math.floor(Date.now() / 1000) })
+            .where(eq(sessions.id, id))
+            .run();
+    }
+    /** 过期清理 — 删除 expiredAt < now 的会话 */
+    async cleanup(now) {
+        const threshold = now ?? Math.floor(Date.now() / 1000);
+        const result = this.drizzle
+            .delete(sessions)
+            .where(and(sql `${sessions.expiredAt} IS NOT NULL`, lt(sessions.expiredAt, threshold)))
+            .run();
+        return result.changes ?? 0;
+    }
+    /** 会话总数 */
+    async count(scope) {
+        const condition = scope ? eq(sessions.scope, scope) : undefined;
+        const [row] = this.drizzle.select({ cnt: count() }).from(sessions).where(condition).all();
+        return row?.cnt ?? 0;
+    }
+    /* ═══ Private ═══ */
+    static #toEntity(row) {
+        return {
+            id: row.id,
+            scope: row.scope,
+            scopeId: row.scopeId ?? null,
+            context: SessionRepositoryImpl.#safeJson(row.context),
+            metadata: SessionRepositoryImpl.#safeJson(row.metadata),
+            actor: row.actor ?? null,
+            createdAt: row.createdAt,
+            lastActiveAt: row.lastActiveAt ?? null,
+            expiredAt: row.expiredAt ?? null,
+        };
+    }
+    static #safeJson(str) {
+        try {
+            return str ? JSON.parse(str) : {};
+        }
+        catch {
+            return {};
+        }
+    }
+}

package/dist/lib/repository/sourceref/RecipeSourceRefRepository.d.ts

@@ -0,0 +1,66 @@
+/**
+ * RecipeSourceRefRepository — recipe_source_refs 表 CRUD (Drizzle ORM)
+ *
+ * Recipe 来源引用桥接表：建立 Recipe ↔ 源码文件的映射关系。
+ * 表使用复合主键 (recipe_id, source_path)，没有独立 id 列。
+ *
+ * 主要消费者：SourceRefReconciler
+ */
+import type { DrizzleDB } from '../../infrastructure/database/drizzle/index.js';
+export interface RecipeSourceRefEntity {
+    recipeId: string;
+    sourcePath: string;
+    status: string;
+    newPath: string | null;
+    verifiedAt: number;
+}
+export interface RecipeSourceRefInsert {
+    recipeId: string;
+    sourcePath: string;
+    status?: string;
+    newPath?: string | null;
+    verifiedAt: number;
+}
+export declare class RecipeSourceRefRepositoryImpl {
+    #private;
+    constructor(drizzle: DrizzleDB);
+    /** 按 Recipe ID 查询所有关联的源引用 */
+    findByRecipeId(recipeId: string): RecipeSourceRefEntity[];
+    /** 按源文件路径查询所有关联的引用 */
+    findBySourcePath(sourcePath: string): RecipeSourceRefEntity[];
+    /** 按状态查询 */
+    findByStatus(status: string): RecipeSourceRefEntity[];
+    /** 查找指定复合键 */
+    findOne(recipeId: string, sourcePath: string): RecipeSourceRefEntity | null;
+    /** 查询所有 stale 引用 */
+    findStale(): RecipeSourceRefEntity[];
+    /** 统计条数 */
+    count(): number;
+    /** UPSERT — 插入或更新（按复合主键） */
+    upsert(data: RecipeSourceRefInsert): void;
+    /** 更新状态 */
+    updateStatus(recipeId: string, sourcePath: string, status: string, newPath?: string): boolean;
+    /** 按 Recipe ID 删除所有关联引用 */
+    deleteByRecipeId(recipeId: string): number;
+    /** 删除指定复合键 */
+    deleteOne(recipeId: string, sourcePath: string): boolean;
+    /** 检查表是否可访问（SourceRefReconciler 使用） */
+    isAccessible(): boolean;
+    /** Stale counts grouped by recipe (for SourceRefReconciler signal emission) */
+    getStaleCountsByRecipe(): Array<{
+        recipeId: string;
+        staleCount: number;
+        totalCount: number;
+    }>;
+    /** Find all entries with status='renamed' and non-null new_path */
+    findRenamed(): RecipeSourceRefEntity[];
+    /** Replace source path (updates composite key column) — used by SourceRefReconciler.applyRepairs */
+    replaceSourcePath(recipeId: string, oldSourcePath: string, newSourcePath: string, verifiedAt: number): void;
+    /** 查询多个 Recipe 的非 stale 来源引用（SearchEngine _supplementDetails 用） */
+    findActiveByRecipeIds(ids: string[]): {
+        recipeId: string;
+        sourcePath: string;
+        status: string;
+        newPath: string | null;
+    }[];
+}

package/dist/lib/repository/sourceref/RecipeSourceRefRepository.js

@@ -0,0 +1,182 @@
+/**
+ * RecipeSourceRefRepository — recipe_source_refs 表 CRUD (Drizzle ORM)
+ *
+ * Recipe 来源引用桥接表：建立 Recipe ↔ 源码文件的映射关系。
+ * 表使用复合主键 (recipe_id, source_path)，没有独立 id 列。
+ *
+ * 主要消费者：SourceRefReconciler
+ */
+import { and, eq, inArray, isNotNull, ne, sql } from 'drizzle-orm';
+import { recipeSourceRefs } from '../../infrastructure/database/drizzle/schema.js';
+/* ═══ Repository 实现 ═══ */
+export class RecipeSourceRefRepositoryImpl {
+    #drizzle;
+    constructor(drizzle) {
+        this.#drizzle = drizzle;
+    }
+    /* ─── 查询 ─── */
+    /** 按 Recipe ID 查询所有关联的源引用 */
+    findByRecipeId(recipeId) {
+        return this.#drizzle
+            .select()
+            .from(recipeSourceRefs)
+            .where(eq(recipeSourceRefs.recipeId, recipeId))
+            .all();
+    }
+    /** 按源文件路径查询所有关联的引用 */
+    findBySourcePath(sourcePath) {
+        return this.#drizzle
+            .select()
+            .from(recipeSourceRefs)
+            .where(eq(recipeSourceRefs.sourcePath, sourcePath))
+            .all();
+    }
+    /** 按状态查询 */
+    findByStatus(status) {
+        return this.#drizzle
+            .select()
+            .from(recipeSourceRefs)
+            .where(eq(recipeSourceRefs.status, status))
+            .all();
+    }
+    /** 查找指定复合键 */
+    findOne(recipeId, sourcePath) {
+        const row = this.#drizzle
+            .select()
+            .from(recipeSourceRefs)
+            .where(and(eq(recipeSourceRefs.recipeId, recipeId), eq(recipeSourceRefs.sourcePath, sourcePath)))
+            .limit(1)
+            .get();
+        return row ?? null;
+    }
+    /** 查询所有 stale 引用 */
+    findStale() {
+        return this.findByStatus('stale');
+    }
+    /** 统计条数 */
+    count() {
+        const row = this.#drizzle.select({ cnt: sql `count(*)` }).from(recipeSourceRefs).get();
+        return row?.cnt ?? 0;
+    }
+    /* ─── 写入 ─── */
+    /** UPSERT — 插入或更新（按复合主键） */
+    upsert(data) {
+        this.#drizzle
+            .insert(recipeSourceRefs)
+            .values({
+            recipeId: data.recipeId,
+            sourcePath: data.sourcePath,
+            status: data.status ?? 'active',
+            newPath: data.newPath ?? null,
+            verifiedAt: data.verifiedAt,
+        })
+            .onConflictDoUpdate({
+            target: [recipeSourceRefs.recipeId, recipeSourceRefs.sourcePath],
+            set: {
+                status: data.status ?? 'active',
+                newPath: data.newPath ?? null,
+                verifiedAt: data.verifiedAt,
+            },
+        })
+            .run();
+    }
+    /** 更新状态 */
+    updateStatus(recipeId, sourcePath, status, newPath) {
+        const set = { status };
+        if (newPath !== undefined) {
+            set.newPath = newPath;
+        }
+        const result = this.#drizzle
+            .update(recipeSourceRefs)
+            .set(set)
+            .where(and(eq(recipeSourceRefs.recipeId, recipeId), eq(recipeSourceRefs.sourcePath, sourcePath)))
+            .run();
+        return result.changes > 0;
+    }
+    /* ─── 删除 ─── */
+    /** 按 Recipe ID 删除所有关联引用 */
+    deleteByRecipeId(recipeId) {
+        const result = this.#drizzle
+            .delete(recipeSourceRefs)
+            .where(eq(recipeSourceRefs.recipeId, recipeId))
+            .run();
+        return result.changes;
+    }
+    /** 删除指定复合键 */
+    deleteOne(recipeId, sourcePath) {
+        const result = this.#drizzle
+            .delete(recipeSourceRefs)
+            .where(and(eq(recipeSourceRefs.recipeId, recipeId), eq(recipeSourceRefs.sourcePath, sourcePath)))
+            .run();
+        return result.changes > 0;
+    }
+    /** 检查表是否可访问（SourceRefReconciler 使用） */
+    isAccessible() {
+        try {
+            this.#drizzle
+                .select({ recipeId: recipeSourceRefs.recipeId })
+                .from(recipeSourceRefs)
+                .limit(1)
+                .get();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** Stale counts grouped by recipe (for SourceRefReconciler signal emission) */
+    getStaleCountsByRecipe() {
+        const rows = this.#drizzle
+            .select({
+            recipeId: recipeSourceRefs.recipeId,
+            staleCount: sql `count(*)`,
+            totalCount: sql `(SELECT count(*) FROM recipe_source_refs r2 WHERE r2.recipe_id = ${recipeSourceRefs.recipeId})`,
+        })
+            .from(recipeSourceRefs)
+            .where(eq(recipeSourceRefs.status, 'stale'))
+            .groupBy(recipeSourceRefs.recipeId)
+            .all();
+        return rows.map((r) => ({
+            recipeId: r.recipeId,
+            staleCount: Number(r.staleCount),
+            totalCount: Number(r.totalCount),
+        }));
+    }
+    /** Find all entries with status='renamed' and non-null new_path */
+    findRenamed() {
+        return this.#drizzle
+            .select()
+            .from(recipeSourceRefs)
+            .where(and(eq(recipeSourceRefs.status, 'renamed'), isNotNull(recipeSourceRefs.newPath)))
+            .all();
+    }
+    /** Replace source path (updates composite key column) — used by SourceRefReconciler.applyRepairs */
+    replaceSourcePath(recipeId, oldSourcePath, newSourcePath, verifiedAt) {
+        this.#drizzle
+            .update(recipeSourceRefs)
+            .set({
+            sourcePath: newSourcePath,
+            status: 'active',
+            newPath: null,
+            verifiedAt,
+        })
+            .where(and(eq(recipeSourceRefs.recipeId, recipeId), eq(recipeSourceRefs.sourcePath, oldSourcePath)))
+            .run();
+    }
+    /** 查询多个 Recipe 的非 stale 来源引用（SearchEngine _supplementDetails 用） */
+    findActiveByRecipeIds(ids) {
+        if (ids.length === 0) {
+            return [];
+        }
+        return this.#drizzle
+            .select({
+            recipeId: recipeSourceRefs.recipeId,
+            sourcePath: recipeSourceRefs.sourcePath,
+            status: recipeSourceRefs.status,
+            newPath: recipeSourceRefs.newPath,
+        })
+            .from(recipeSourceRefs)
+            .where(and(inArray(recipeSourceRefs.recipeId, ids), ne(recipeSourceRefs.status, 'stale')))
+            .all();
+    }
+}

package/dist/lib/repository/sync/SyncRepoAdapter.d.ts

@@ -0,0 +1,58 @@
+/**
+ * SyncRepoAdapter — KnowledgeSyncService 用的仓储适配器
+ *
+ * 将 KnowledgeSyncService 中的 raw SQL 操作封装在 lib/repository/ 层（lint 白名单目录），
+ * 使 KnowledgeSyncService 本身不再需要 escape-hatch 标记。
+ */
+type RawDb = {
+    prepare(sql: string): {
+        run(...args: unknown[]): void;
+        get(...args: unknown[]): unknown;
+        all(): Array<Record<string, unknown>>;
+    };
+};
+/** KnowledgeSyncService 所需的 DB 操作最小接口 */
+export interface SyncRepo {
+    /** 创建可复用的 UPSERT 语句 */
+    createUpsertStmt(cols: string[]): {
+        run: (...args: unknown[]) => void;
+    };
+    /** 检查 entry 是否已存在 */
+    entryExists(id: string): boolean;
+    /** 创建审计日志插入语句（可能失败返回 null） */
+    createAuditInsertStmt(): {
+        run: (...args: unknown[]) => void;
+    } | null;
+    /** 查询所有非 deprecated 且有 sourceFile 的条目 */
+    findActiveEntriesWithSourceFile(): Array<{
+        id: string;
+        sourceFile: string;
+    }>;
+    /** 标记条目为 deprecated */
+    deprecateEntry(id: string, reason: string, timestamp: number): void;
+}
+/**
+ * Raw-db 适配器：实现 SyncRepo 接口
+ * 使用 raw SQL 访问 knowledge_entries 和 audit_logs 表。
+ */
+export declare class RawDbSyncAdapter implements SyncRepo {
+    #private;
+    constructor(db: RawDb);
+    createUpsertStmt(cols: string[]): {
+        run(...args: unknown[]): void;
+        get(...args: unknown[]): unknown;
+        all(): Array<Record<string, unknown>>;
+    };
+    entryExists(id: string): boolean;
+    createAuditInsertStmt(): {
+        run(...args: unknown[]): void;
+        get(...args: unknown[]): unknown;
+        all(): Array<Record<string, unknown>>;
+    } | null;
+    findActiveEntriesWithSourceFile(): Array<{
+        id: string;
+        sourceFile: string;
+    }>;
+    deprecateEntry(id: string, reason: string, timestamp: number): void;
+}
+export {};

package/dist/lib/repository/sync/SyncRepoAdapter.js

@@ -0,0 +1,58 @@
+/**
+ * SyncRepoAdapter — KnowledgeSyncService 用的仓储适配器
+ *
+ * 将 KnowledgeSyncService 中的 raw SQL 操作封装在 lib/repository/ 层（lint 白名单目录），
+ * 使 KnowledgeSyncService 本身不再需要 escape-hatch 标记。
+ */
+/**
+ * Raw-db 适配器：实现 SyncRepo 接口
+ * 使用 raw SQL 访问 knowledge_entries 和 audit_logs 表。
+ */
+export class RawDbSyncAdapter {
+    #db;
+    constructor(db) {
+        this.#db = db;
+    }
+    createUpsertStmt(cols) {
+        const updateCols = cols.filter((c) => !['id', 'createdBy', 'createdAt'].includes(c));
+        const setClauses = updateCols.map((c) => `${c} = excluded.${c}`).join(',\n      ');
+        const sql = `
+      INSERT INTO knowledge_entries (${cols.join(', ')})
+      VALUES (${cols.map(() => '?').join(', ')})
+      ON CONFLICT(id) DO UPDATE SET
+      ${setClauses}
+    `;
+        return this.#db.prepare(sql);
+    }
+    entryExists(id) {
+        const row = this.#db.prepare('SELECT 1 FROM knowledge_entries WHERE id = ?').get(id);
+        return !!row;
+    }
+    createAuditInsertStmt() {
+        try {
+            return this.#db.prepare(`
+        INSERT INTO audit_logs (id, timestamp, actor, actor_context, action, resource, operation_data, result, error_message, duration)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+        }
+        catch {
+            return null;
+        }
+    }
+    findActiveEntriesWithSourceFile() {
+        return this.#db
+            .prepare(`SELECT id, sourceFile FROM knowledge_entries
+         WHERE lifecycle NOT IN ('deprecated')
+         AND sourceFile IS NOT NULL`)
+            .all();
+    }
+    deprecateEntry(id, reason, timestamp) {
+        this.#db
+            .prepare(`UPDATE knowledge_entries
+         SET lifecycle = 'deprecated',
+             rejectionReason = ?,
+             updatedAt = ?
+         WHERE id = ?`)
+            .run(reason, timestamp, id);
+    }
+}

package/dist/lib/service/bootstrap/UiStartupTasks.js

@@ -29,8 +29,7 @@ export async function runUiStartupTasks(ctx) {
             sourceRefReconciler: sourceRefReconciler || undefined,
         });
         const db = ctx.container.get('database');
-        const rawDb = db.getDb();
-        const syncReport = await syncService.syncAll(rawDb, { skipViolations: true });
+        const syncReport = await syncService.syncAll(db, { skipViolations: true });
         report.syncAll = {
             synced: syncReport.synced,
             created: syncReport.created,
@@ -54,7 +53,7 @@ export async function runUiStartupTasks(ctx) {
     try {
         if (ctx.container.services.stagingManager) {
             const sm = ctx.container.get('stagingManager');
-            const result = sm.checkAndPromote();
+            const result = await sm.checkAndPromote();
             report.staging = { promoted: result.promoted.length };
             if (result.promoted.length > 0) {
                 logger.info(`[UiStartupTasks] Stage 2: auto-promoted ${result.promoted.length} staging entries`);
@@ -104,7 +103,7 @@ export async function runUiStartupTasks(ctx) {
     try {
         if (ctx.container.services.proposalExecutor) {
             const executor = ctx.container.get('proposalExecutor');
-            const result = executor.checkAndExecute();
+            const result = await executor.checkAndExecute();
             report.proposalCheck = {
                 executed: result.executed.length,
                 rejected: result.rejected.length,
@@ -125,7 +124,7 @@ export async function runUiStartupTasks(ctx) {
     try {
         if (ctx.container.services.knowledgeMetabolism) {
             const metabolism = ctx.container.get('knowledgeMetabolism');
-            const result = metabolism.runFullCycle();
+            const result = await metabolism.runFullCycle();
             report.metabolismCycle = {
                 proposalCount: result.summary.proposalCount,
                 contradictions: result.summary.contradictionCount,
@@ -146,7 +145,7 @@ export async function runUiStartupTasks(ctx) {
     try {
         if (ctx.container.services.lifecycleSupervisor) {
             const supervisor = ctx.container.get('lifecycleSupervisor');
-            const result = supervisor.checkTimeouts();
+            const result = await supervisor.checkTimeouts();
             report.timeoutCheck = {
                 timedOut: result.timedOut.length,
                 checked: result.checked,