autosnippet 3.3.4 → 3.3.5

package/dist/lib/service/evolution/ProposalExecutor.js

@@ -0,0 +1,360 @@
+/**
+ * ProposalExecutor — 到期自动执行引擎
+ *
+ * 核心职责：
+ *   1. 扫描所有 observing 状态的 Proposal，检查是否到期
+ *   2. 到期 → 收集观察期表现数据 → 评估执行判据
+ *   3. 通过 → 执行操作（merge/deprecate/enhance/...）
+ *   4. 不通过 → 拒绝 Proposal，Recipe 恢复原状态
+ *
+ * 触发时机：UiStartupTasks Stage 5
+ *
+ * 安全边界：
+ *   - Agent 只做分析，ProposalExecutor 做执行
+ *   - merge/enhance 执行后 Recipe → staging（走正常路径）
+ *   - contradiction/reorganize 始终等开发者确认（不自动执行）
+ *   - 到期无判据 → expired
+ */
+import Logger from '../../infrastructure/logging/Logger.js';
+/* ────────────────────── Constants ────────────────────── */
+/** 高风险类型：需开发者确认，不自动执行 */
+const HIGH_RISK_TYPES = new Set(['contradiction', 'reorganize']);
+/** 超过此天数未操作的 pending Proposal 自动过期 */
+const PENDING_EXPIRY_DAYS = 14;
+/* ────────────────────── Class ────────────────────── */
+export class ProposalExecutor {
+    #db;
+    #repo;
+    #signalBus;
+    #logger = Logger.getInstance();
+    constructor(db, repo, options = {}) {
+        this.#db = db;
+        this.#repo = repo;
+        this.#signalBus = options.signalBus ?? null;
+    }
+    /**
+     * 定期调用（UiStartupTasks Stage 5）
+     *
+     * 扫描所有到期 Proposal → 评估 → 执行/拒绝/过期
+     */
+    checkAndExecute() {
+        const result = {
+            executed: [],
+            rejected: [],
+            expired: [],
+            skipped: [],
+        };
+        // 1. 处理到期的 observing Proposal
+        const expiredObserving = this.#repo.findExpiredObserving();
+        for (const proposal of expiredObserving) {
+            if (HIGH_RISK_TYPES.has(proposal.type)) {
+                // 高风险类型跳过自动执行
+                result.skipped.push({
+                    id: proposal.id,
+                    type: proposal.type,
+                    reason: 'high-risk type requires developer confirmation',
+                });
+                continue;
+            }
+            this.#processExpiredProposal(proposal, result);
+        }
+        // 2. 清理超期未操作的 pending Proposal
+        this.#expireOldPending(result);
+        if (result.executed.length > 0 || result.rejected.length > 0 || result.expired.length > 0) {
+            this.#logger.info(`[ProposalExecutor] checkAndExecute complete: ` +
+                `executed=${result.executed.length}, rejected=${result.rejected.length}, expired=${result.expired.length}`);
+        }
+        return result;
+    }
+    /* ═══════════════════ Internal ═══════════════════ */
+    #processExpiredProposal(proposal, result) {
+        const metrics = this.#collectRecipeMetrics(proposal.targetRecipeId);
+        const snapshot = this.#extractSnapshot(proposal);
+        switch (proposal.type) {
+            case 'merge':
+            case 'enhance':
+                this.#executeMergeOrEnhance(proposal, metrics, snapshot, result);
+                break;
+            case 'supersede':
+                this.#executeSupersede(proposal, metrics, snapshot, result);
+                break;
+            case 'deprecate':
+                this.#executeDeprecate(proposal, metrics, snapshot, result);
+                break;
+            case 'correction':
+                this.#executeCorrection(proposal, metrics, result);
+                break;
+            default:
+                result.skipped.push({
+                    id: proposal.id,
+                    type: proposal.type,
+                    reason: `unhandled type: ${proposal.type}`,
+                });
+        }
+    }
+    /* ── merge / enhance ── */
+    #executeMergeOrEnhance(proposal, metrics, snapshot, result) {
+        // 执行判据：
+        //   - 目标 Recipe 在观察期内无 FP rate 异常飙升
+        //   - 目标 Recipe 在观察期内仍有使用
+        const fpOk = metrics.ruleFalsePositiveRate < 0.4;
+        const hasUsage = metrics.guardHits > 0 || metrics.searchHits > 0;
+        if (fpOk && hasUsage) {
+            // 通过 → 将 Recipe 回到 staging（重新走 ConfidenceRouter）
+            this.#transitionRecipe(proposal.targetRecipeId, 'staging');
+            this.#repo.markExecuted(proposal.id, `观察期表现合格: FP=${(metrics.ruleFalsePositiveRate * 100).toFixed(0)}%, hits=${metrics.guardHits + metrics.searchHits}`);
+            result.executed.push({
+                id: proposal.id,
+                type: proposal.type,
+                targetRecipeId: proposal.targetRecipeId,
+            });
+            this.#emitSignal(proposal, 'executed');
+        }
+        else {
+            // 不通过 → Recipe 恢复原状态
+            this.#restoreRecipe(proposal.targetRecipeId);
+            this.#repo.markRejected(proposal.id, `观察期表现不达标: FP=${(metrics.ruleFalsePositiveRate * 100).toFixed(0)}%, hasUsage=${hasUsage}`);
+            result.rejected.push({
+                id: proposal.id,
+                type: proposal.type,
+                reason: fpOk ? 'no usage during observation' : 'FP rate too high',
+            });
+            this.#emitSignal(proposal, 'rejected');
+        }
+    }
+    /* ── supersede ── */
+    #executeSupersede(proposal, metrics, snapshot, result) {
+        // 新 Recipe 必须已到达 active
+        const newRecipeId = proposal.relatedRecipeIds[0];
+        if (!newRecipeId) {
+            this.#repo.markRejected(proposal.id, 'no related new recipe specified');
+            result.rejected.push({
+                id: proposal.id,
+                type: proposal.type,
+                reason: 'no related new recipe',
+            });
+            return;
+        }
+        const newRecipe = this.#getRecipeLifecycle(newRecipeId);
+        if (newRecipe?.lifecycle !== 'active') {
+            // 新 Recipe 尚未 active → 跳过，等下次检查
+            result.skipped.push({
+                id: proposal.id,
+                type: proposal.type,
+                reason: `new recipe ${newRecipeId} not yet active (lifecycle: ${newRecipe?.lifecycle ?? 'unknown'})`,
+            });
+            return;
+        }
+        // 对比新旧 Recipe 的使用数据
+        const newMetrics = this.#collectRecipeMetrics(newRecipeId);
+        const oldUsage = metrics.guardHits + metrics.searchHits;
+        const newUsage = newMetrics.guardHits + newMetrics.searchHits;
+        if (newUsage >= oldUsage * 0.5 || oldUsage === 0) {
+            // 新 Recipe 表现足够 → 旧 Recipe → decaying，建立 deprecated_by
+            this.#transitionRecipe(proposal.targetRecipeId, 'decaying');
+            this.#createDeprecatedByEdge(newRecipeId, proposal.targetRecipeId);
+            this.#repo.markExecuted(proposal.id, `supersede executed: new usage=${newUsage}, old usage=${oldUsage}`);
+            result.executed.push({
+                id: proposal.id,
+                type: proposal.type,
+                targetRecipeId: proposal.targetRecipeId,
+            });
+            this.#emitSignal(proposal, 'executed');
+        }
+        else {
+            // 新 Recipe 表现不足 → 拒绝
+            this.#restoreRecipe(proposal.targetRecipeId);
+            this.#repo.markRejected(proposal.id, `new recipe usage (${newUsage}) < 50% of old (${oldUsage})`);
+            result.rejected.push({
+                id: proposal.id,
+                type: proposal.type,
+                reason: 'new recipe insufficient usage',
+            });
+            this.#emitSignal(proposal, 'rejected');
+        }
+    }
+    /* ── deprecate ── */
+    #executeDeprecate(proposal, metrics, snapshot, result) {
+        const currentDecay = metrics.decayScore;
+        const snapshotDecay = snapshot?.decayScore ?? currentDecay;
+        // 观察期内 decayScore 有回升 → 拒绝
+        if (currentDecay > snapshotDecay + 10) {
+            this.#restoreRecipe(proposal.targetRecipeId);
+            this.#repo.markRejected(proposal.id, `decayScore recovered: ${snapshotDecay} → ${currentDecay}`);
+            result.rejected.push({
+                id: proposal.id,
+                type: proposal.type,
+                reason: 'decay score recovered during observation',
+            });
+            this.#emitSignal(proposal, 'rejected');
+            return;
+        }
+        // 无回升 → 根据 decayScore 决定操作
+        if (currentDecay <= 19) {
+            // 死亡 → 直接 deprecated
+            this.#transitionRecipe(proposal.targetRecipeId, 'deprecated');
+            this.#repo.markExecuted(proposal.id, `deprecated (dead): decayScore=${currentDecay}`);
+        }
+        else if (currentDecay <= 40) {
+            // 严重 → decaying
+            this.#transitionRecipe(proposal.targetRecipeId, 'decaying');
+            this.#repo.markExecuted(proposal.id, `decaying (severe): decayScore=${currentDecay}`);
+        }
+        else {
+            // 衰退减缓 → 拒绝
+            this.#restoreRecipe(proposal.targetRecipeId);
+            this.#repo.markRejected(proposal.id, `decayScore above threshold (${currentDecay}), not critical enough`);
+            result.rejected.push({
+                id: proposal.id,
+                type: proposal.type,
+                reason: `decayScore (${currentDecay}) not critical`,
+            });
+            this.#emitSignal(proposal, 'rejected');
+            return;
+        }
+        result.executed.push({
+            id: proposal.id,
+            type: proposal.type,
+            targetRecipeId: proposal.targetRecipeId,
+        });
+        this.#emitSignal(proposal, 'executed');
+    }
+    /* ── correction ── */
+    #executeCorrection(proposal, metrics, result) {
+        // correction 低风险，到期直接执行（Recipe → staging 重新审核）
+        const hasUsage = metrics.guardHits > 0 || metrics.searchHits > 0;
+        if (hasUsage) {
+            this.#transitionRecipe(proposal.targetRecipeId, 'staging');
+            this.#repo.markExecuted(proposal.id, 'correction applied, recipe → staging for re-review');
+            result.executed.push({
+                id: proposal.id,
+                type: proposal.type,
+                targetRecipeId: proposal.targetRecipeId,
+            });
+            this.#emitSignal(proposal, 'executed');
+        }
+        else {
+            this.#repo.markRejected(proposal.id, 'no usage during observation, correction unnecessary');
+            result.rejected.push({
+                id: proposal.id,
+                type: proposal.type,
+                reason: 'no usage',
+            });
+            this.#emitSignal(proposal, 'rejected');
+        }
+    }
+    /* ── expired pending cleanup ── */
+    #expireOldPending(result) {
+        const cutoff = Date.now() - PENDING_EXPIRY_DAYS * 24 * 60 * 60 * 1000;
+        const oldPending = this.#repo.find({
+            status: 'pending',
+            expiredBefore: cutoff,
+        });
+        for (const proposal of oldPending) {
+            this.#repo.markExpired(proposal.id);
+            result.expired.push({
+                id: proposal.id,
+                type: proposal.type,
+            });
+        }
+    }
+    /* ═══════════════════ DB Helpers ═══════════════════ */
+    #collectRecipeMetrics(recipeId) {
+        const row = this.#db
+            .prepare(`SELECT stats, quality FROM knowledge_entries WHERE id = ?`)
+            .get(recipeId);
+        if (!row) {
+            return {
+                guardHits: 0,
+                searchHits: 0,
+                hitsLast30d: 0,
+                decayScore: 0,
+                ruleFalsePositiveRate: 0,
+                quality: 0,
+            };
+        }
+        const stats = safeJsonParse(row.stats, {});
+        const quality = safeJsonParse(row.quality, {});
+        return {
+            guardHits: stats.guardHits ?? 0,
+            searchHits: stats.searchHits ?? 0,
+            hitsLast30d: stats.hitsLast30d ?? 0,
+            decayScore: stats.decayScore ?? 50,
+            ruleFalsePositiveRate: stats.ruleFalsePositiveRate ?? 0,
+            quality: quality.overall ?? 0,
+        };
+    }
+    #extractSnapshot(proposal) {
+        for (const ev of proposal.evidence) {
+            if (ev.snapshotAt && ev.metrics) {
+                const m = ev.metrics;
+                return {
+                    guardHits: m.guardHits ?? 0,
+                    searchHits: m.searchHits ?? 0,
+                    hitsLast30d: m.hitsLast30d ?? 0,
+                    decayScore: m.decayScore ?? 50,
+                    ruleFalsePositiveRate: m.ruleFalsePositiveRate ?? 0,
+                    quality: m.quality?.overall ?? 0,
+                };
+            }
+        }
+        return null;
+    }
+    #getRecipeLifecycle(recipeId) {
+        const row = this.#db
+            .prepare(`SELECT lifecycle FROM knowledge_entries WHERE id = ?`)
+            .get(recipeId);
+        return row ?? null;
+    }
+    #transitionRecipe(recipeId, newLifecycle) {
+        this.#db
+            .prepare(`UPDATE knowledge_entries SET lifecycle = ?, updatedAt = ? WHERE id = ?`)
+            .run(newLifecycle, Date.now(), recipeId);
+    }
+    #restoreRecipe(recipeId) {
+        // 恢复到 active（evolving/decaying → active）
+        const current = this.#getRecipeLifecycle(recipeId);
+        if (current && (current.lifecycle === 'evolving' || current.lifecycle === 'decaying')) {
+            this.#transitionRecipe(recipeId, 'active');
+        }
+    }
+    #createDeprecatedByEdge(newRecipeId, oldRecipeId) {
+        const now = Date.now();
+        try {
+            this.#db
+                .prepare(`INSERT OR IGNORE INTO knowledge_edges (from_id, from_type, to_id, to_type, relation, weight, metadata_json, created_at, updated_at)
+           VALUES (?, 'recipe', ?, 'recipe', 'deprecated_by', 1.0, '{}', ?, ?)`)
+                .run(newRecipeId, oldRecipeId, now, now);
+        }
+        catch {
+            // knowledge_edges 表可能不存在（降级容忍）
+        }
+    }
+    /* ═══════════════════ Signal ═══════════════════ */
+    #emitSignal(proposal, action) {
+        if (!this.#signalBus) {
+            return;
+        }
+        this.#signalBus.send('lifecycle', 'ProposalExecutor', proposal.confidence, {
+            target: proposal.targetRecipeId,
+            metadata: {
+                proposalId: proposal.id,
+                proposalType: proposal.type,
+                action,
+                source: proposal.source,
+            },
+        });
+    }
+}
+/* ────────────────────── Util ────────────────────── */
+function safeJsonParse(json, fallback) {
+    if (!json) {
+        return fallback;
+    }
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return fallback;
+    }
+}

package/dist/lib/service/evolution/StagingManager.js

@@ -12,6 +12,7 @@
  *   0.85-0.89 → 72h
  */
 import Logger from '../../infrastructure/logging/Logger.js';
+import { unixNow } from '../../shared/utils/common.js';
 /* ────────────────────── Class ────────────────────── */
 export class StagingManager {
     #db;
@@ -54,7 +55,7 @@ export class StagingManager {
         stats.stagingEnteredAt = now;
         this.#db
             .prepare(`UPDATE knowledge_entries SET lifecycle = 'staging', stats = ?, updatedAt = ? WHERE id = ?`)
-            .run(JSON.stringify(stats), now, entryId);
+            .run(JSON.stringify(stats), unixNow(), entryId);
         // 发射信号
         if (this.#signalBus) {
             this.#signalBus.send('lifecycle', 'StagingManager.enter', confidence, {
@@ -140,7 +141,7 @@ export class StagingManager {
         stats.lastRollbackAt = now;
         this.#db
             .prepare(`UPDATE knowledge_entries SET lifecycle = 'pending', stats = ?, updatedAt = ? WHERE id = ?`)
-            .run(JSON.stringify(stats), now, entryId);
+            .run(JSON.stringify(stats), unixNow(), entryId);
         if (this.#signalBus) {
             this.#signalBus.send('lifecycle', 'StagingManager.rollback', 0.8, {
                 target: entryId,
@@ -184,9 +185,10 @@ export class StagingManager {
         delete stats.stagingConfidence;
         delete stats.stagingEnteredAt;
         stats.autoPublishedAt = now;
+        const nowS = unixNow();
         this.#db
             .prepare(`UPDATE knowledge_entries SET lifecycle = 'active', publishedAt = ?, stats = ?, updatedAt = ? WHERE id = ?`)
-            .run(now, JSON.stringify(stats), now, entry.id);
+            .run(nowS, JSON.stringify(stats), nowS, entry.id);
         if (this.#signalBus) {
             this.#signalBus.send('lifecycle', 'StagingManager.promote', 1.0, {
                 target: entry.id,

package/dist/lib/service/guard/GuardCrossFileChecks.js

@@ -42,6 +42,8 @@ export function runCrossFileChecks(files, options = {}) {
     const violations = [];
     const disabledSet = new Set(options.disabledRules || []);
     const isDisabled = (ruleId) => disabledSet.has(ruleId);
+    // 过滤掉 content 为空的条目，防止下游 split 崩溃
+    files = files.filter((f) => typeof f.content === 'string');
     // ── ObjC Category 跨文件重名检查 ──
     if (!isDisabled('objc-cross-file-duplicate-category')) {
         const categoryMap = new Map();

package/dist/lib/service/guard/ReverseGuard.d.ts

@@ -18,7 +18,7 @@ interface DatabaseLike {
         get(...params: unknown[]): Record<string, unknown> | undefined;
     };
 }
-export type DriftType = 'symbol_missing' | 'match_rate_drop' | 'api_deprecated' | 'zero_match';
+export type DriftType = 'symbol_missing' | 'match_rate_drop' | 'api_deprecated' | 'zero_match' | 'source_ref_stale';
 export type DriftSeverity = 'high' | 'medium' | 'low';
 export interface PatternDriftSignal {
     type: DriftType;

package/dist/lib/service/guard/ReverseGuard.js

@@ -59,9 +59,11 @@ export class ReverseGuard {
         if (recipe.guard_pattern) {
             signals.push(...this.#checkPatternMatchRate(recipe.id, recipe.guard_pattern, projectFiles));
         }
-        // 3. 综合判定
+        // 3. 检查 sourceRef 路径是否失效（与 SourceRefReconciler 数据交叉验证）
+        signals.push(...this.#checkSourceRefStaleness(recipe.id));
+        // 4. 综合判定
         const recommendation = this.#computeRecommendation(signals);
-        // 4. 发射信号
+        // 5. 发射信号
         if (this.#signalBus && signals.length > 0) {
             const severity = recommendation === 'decay' ? 1 : recommendation === 'investigate' ? 0.5 : 0;
             this.#signalBus.send('quality', 'ReverseGuard', severity, {
@@ -205,6 +207,34 @@ export class ReverseGuard {
         }
         return signals;
     }
+    /**
+     * 检查 recipe_source_refs 中是否有 stale 条目（与 SourceRefReconciler 数据交叉验证）
+     */
+    #checkSourceRefStaleness(recipeId) {
+        try {
+            const rows = this.#db
+                .prepare(`SELECT source_path FROM recipe_source_refs WHERE recipe_id = ? AND status = 'stale'`)
+                .all(recipeId);
+            if (rows.length === 0) {
+                return [];
+            }
+            return [
+                {
+                    type: 'source_ref_stale',
+                    detail: `${rows.length} source file(s) no longer exist: ${rows
+                        .slice(0, 3)
+                        .map((r) => r.source_path)
+                        .join(', ')}${rows.length > 3 ? ` (+${rows.length - 3} more)` : ''}`,
+                    severity: rows.length >= 3 ? 'high' : 'medium',
+                    evidence: {},
+                },
+            ];
+        }
+        catch {
+            // recipe_source_refs 表可能不存在
+            return [];
+        }
+    }
     #extractSymbols(coreCode) {
         const symbols = new Set();
         for (const pattern of SYMBOL_PATTERNS) {

package/dist/lib/service/knowledge/SourceRefReconciler.d.ts

@@ -9,6 +9,7 @@
  *   renamed — 文件已移动到 new_path，等待修复
  *   stale   — 路径失效，无法自动修复
  */
+import type { SignalBus } from '../../infrastructure/signal/SignalBus.js';
 interface DatabaseLike {
     prepare(sql: string): {
         all(...params: unknown[]): Record<string, unknown>[];
@@ -46,6 +47,7 @@ export declare class SourceRefReconciler {
     #private;
     constructor(projectRoot: string, db: DatabaseLike, options?: {
         ttlMs?: number;
+        signalBus?: SignalBus;
     });
     /**
      * 从 knowledge_entries.reasoning 填充 recipe_source_refs 表。

package/dist/lib/service/knowledge/SourceRefReconciler.js

@@ -21,11 +21,13 @@ const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
 export class SourceRefReconciler {
     #projectRoot;
     #db;
+    #signalBus;
     #logger = Logger.getInstance();
     #ttlMs;
     constructor(projectRoot, db, options) {
         this.#projectRoot = projectRoot;
         this.#db = db;
+        this.#signalBus = options?.signalBus ?? null;
         this.#ttlMs = options?.ttlMs ?? DEFAULT_TTL_MS;
     }
     /**
@@ -122,8 +124,44 @@ export class SourceRefReconciler {
             skipped: report.skipped,
             recipesProcessed: report.recipesProcessed,
         });
+        // 通过 SignalBus 发射信号 — 让 Governance 子系统感知 sourceRef 健康状况
+        if (this.#signalBus && report.stale > 0) {
+            this.#emitStaleSignals();
+        }
         return report;
     }
+    /**
+     * 为每个有 stale sourceRef 的 Recipe 发射 quality 信号。
+     * KnowledgeMetabolism 订阅 quality → 触发完整治理周期。
+     */
+    #emitStaleSignals() {
+        if (!this.#signalBus) {
+            return;
+        }
+        try {
+            const staleRecipes = this.#db
+                .prepare(`SELECT recipe_id, COUNT(*) AS stale_count,
+                  (SELECT COUNT(*) FROM recipe_source_refs r2 WHERE r2.recipe_id = r.recipe_id) AS total_count
+           FROM recipe_source_refs r
+           WHERE status = 'stale'
+           GROUP BY recipe_id`)
+                .all();
+            for (const row of staleRecipes) {
+                const staleRatio = row.stale_count / row.total_count;
+                this.#signalBus.send('quality', 'SourceRefReconciler', staleRatio, {
+                    target: row.recipe_id,
+                    metadata: {
+                        reason: 'source_ref_stale',
+                        staleCount: row.stale_count,
+                        totalRefs: row.total_count,
+                    },
+                });
+            }
+        }
+        catch {
+            // 信号发射失败不影响主流程
+        }
+    }
     /**
      * 对 stale 条目尝试 git rename 修复。
      * 使用 execFile() 安全执行 git log（防止命令注入）。
@@ -160,6 +198,16 @@ export class SourceRefReconciler {
                 renamed: report.renamed,
                 stillStale: report.stillStale,
             });
+            // 修复成功 → 发射正向 quality 信号（value≈0 表示健康方向）
+            if (this.#signalBus) {
+                this.#signalBus.send('quality', 'SourceRefReconciler', 0.1, {
+                    metadata: {
+                        reason: 'source_ref_repaired',
+                        renamed: report.renamed,
+                        stillStale: report.stillStale,
+                    },
+                });
+            }
         }
         return report;
     }

package/dist/lib/shared/schemas/mcp-tools.d.ts

@@ -183,6 +183,7 @@ export declare const SubmitKnowledgeInput: z.ZodObject<{
     skipDuplicateCheck: z.ZodDefault<z.ZodBoolean>;
     client_id: z.ZodOptional<z.ZodString>;
     dimensionId: z.ZodOptional<z.ZodString>;
+    supersedes: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type SubmitKnowledgeInput = z.infer<typeof SubmitKnowledgeInput>;
 export declare const SkillInput: z.ZodObject<{

package/dist/lib/shared/schemas/mcp-tools.js

@@ -173,6 +173,10 @@ export const SubmitKnowledgeInput = z.object({
     skipDuplicateCheck: z.boolean().default(false),
     client_id: z.string().optional(),
     dimensionId: z.string().optional().describe('冷启动关联维度 ID'),
+    supersedes: z
+        .string()
+        .optional()
+        .describe('声明新 Recipe 替代旧 Recipe 的 ID。提交后系统将创建 supersede 提案，观察窗口内对比新旧表现后自动执行。'),
 });
 // ══════════════════════════════════════════════════════
 //  10. autosnippet_skill

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autosnippet",
-  "version": "3.3.4",
+  "version": "3.3.5",
   "description": "Extract code patterns into a knowledge base for AI coding assistants",
   "type": "module",
   "main": "dist/lib/bootstrap.js",