dsh-daoing-memory 0.1.7 → 0.1.8

package/lib/types/core.d.ts

@@ -64,6 +64,10 @@ export interface MemoryCoreConfig {
     consolidateEveryNew: number;
     /** Consolidation: minimum HOURS elapsed since the last consolidation (interval, not a fixed clock point) (008 §1). */
     consolidateIntervalHours: number;
+    /** Deletion-feedback summarization: minimum HOURS between LLM summarization runs. */
+    deletionFeedbackIntervalHours: number;
+    /** Deletion-feedback summarization: minimum new deletions since last run to trigger. */
+    deletionFeedbackMinDeletions: number;
 }
 /** The mechanism defaults (005 mapping documented in the README). */
 export declare const DEFAULT_CORE_CONFIG: MemoryCoreConfig;
@@ -153,6 +157,33 @@ export declare class MemoryCore {
      * — consolidation never hard-deletes). Every step is ledgered.
      */
     consolidate(request: ConsolidateRequest, actor: string): ConsolidateResult;
+    /** Family id for the auto-generated extraction-feedback experience. */
+    static readonly DELETION_FEEDBACK_FAMILY = "extraction-feedback";
+    /**
+     * Check whether a deletion-feedback summarization run is due.
+     * Conditions: enough new deletions since last run AND enough time elapsed.
+     * @returns { due, lastTs, newDeletions, hoursSince }
+     */
+    deletionFeedbackDue(): {
+        due: boolean;
+        lastTs: number;
+        newDeletions: number;
+        hoursSince: number;
+    };
+    /**
+     * Apply an LLM-generated deletion-feedback summary as an extraction-feedback
+     * experience. If one already exists, it is revised in place (new revision);
+     * otherwise a new candidate experience is created.
+     * @param summary - the LLM-generated summary text (gist + reasoning).
+     * @param actor - who triggered the summarization ('system').
+     * @returns the upserted experience snapshot.
+     */
+    applyDeletionFeedback(summary: string, actor: string): ExperienceSnapshot;
+    /**
+     * Get the current extraction-feedback experience (if any) for injection into
+     * the extraction prompt.
+     */
+    getDeletionFeedback(): ExperienceSnapshot | undefined;
     /** Human pin/unpin: pinned cards keep the trust floor and escape budgets. */
     humanPin(request: HumanPinRequest, actor: MemoryActor): ExperienceSnapshot;
     /** Human delete: tombstone the family; the ledger keeps the fingerprint. */

package/lib/types/core.js

@@ -45,6 +45,8 @@ export const DEFAULT_CORE_CONFIG = {
     candidateTrialFloorScore: 0.18,
     consolidateEveryNew: 6,
     consolidateIntervalHours: 24,
+    deletionFeedbackIntervalHours: 24,
+    deletionFeedbackMinDeletions: 3,
 };
 /** Objective-evidence markers overriding a claimed experience-attributed failure. */
 const ENVIRONMENT_EVIDENCE_PATTERN = /network|timeout|timed out|EPERM|EACCES|ECONNREFUSED|ENOTFOUND|429|503|quota|rate.?limit|unauthorized|dns|proxy|网络|超时|断网|权限|配额|限流|服务不可用|服务繁忙/i;
@@ -657,6 +659,11 @@ export class MemoryCore {
     /** 上升通道: apply extracted facts over the pending diary window. */
     extract(request, actor, trigger = 'manual') {
         const result = { applied: [], conflicts: [], rejected: [], appliedConcerns: 0 };
+        // Include deletion-feedback guidance if an extraction-feedback experience exists.
+        const feedback = this.getDeletionFeedback();
+        if (feedback !== undefined) {
+            result.deletionFeedback = feedback.reasoning;
+        }
         const now = Date.now();
         const consumedDiary = new Set();
         for (const proposal of request.proposals) {
@@ -970,6 +977,92 @@ export class MemoryCore {
         }
         return result;
     }
+    // ── deletion-feedback summarization (P1-2) ────────────────────────────────
+    /** Family id for the auto-generated extraction-feedback experience. */
+    static DELETION_FEEDBACK_FAMILY = 'extraction-feedback';
+    /**
+     * Check whether a deletion-feedback summarization run is due.
+     * Conditions: enough new deletions since last run AND enough time elapsed.
+     * @returns { due, lastTs, newDeletions, hoursSince }
+     */
+    deletionFeedbackDue() {
+        const lastTs = this.store.lastDeletionFeedbackTs();
+        const hoursSince = lastTs === 0 ? Infinity : (Date.now() - lastTs) / (60 * 60 * 1000);
+        const newDeletions = this.store.countDeletionsSince(lastTs);
+        const enoughDeletions = newDeletions >= this.config.deletionFeedbackMinDeletions;
+        const intervalPassed = hoursSince >= this.config.deletionFeedbackIntervalHours;
+        return { due: enoughDeletions && intervalPassed, lastTs, newDeletions, hoursSince };
+    }
+    /**
+     * Apply an LLM-generated deletion-feedback summary as an extraction-feedback
+     * experience. If one already exists, it is revised in place (new revision);
+     * otherwise a new candidate experience is created.
+     * @param summary - the LLM-generated summary text (gist + reasoning).
+     * @param actor - who triggered the summarization ('system').
+     * @returns the upserted experience snapshot.
+     */
+    applyDeletionFeedback(summary, actor) {
+        const now = Date.now();
+        const existing = this.store.findExperienceByFamily(MemoryCore.DELETION_FEEDBACK_FAMILY);
+        if (existing !== undefined) {
+            // Revise in place: create a new revision with updated content
+            const next = {
+                ...existing,
+                revision: existing.revision + 1,
+                gist: summary.slice(0, 200),
+                reasoning: summary,
+                status: 'live',
+                updatedAt: now,
+            };
+            this.store.upsertExperience(next);
+            this.ledger('revise', 'experience', next.id, actor, {
+                revision: next.revision,
+                previousRevision: existing.revision,
+            }, 'deletion-feedback summarization');
+            return next;
+        }
+        // Create new extraction-feedback experience
+        const id = crypto.randomUUID();
+        const exp = {
+            id,
+            familyId: id,
+            revision: 1,
+            kind: 'positive',
+            source: 'system',
+            family: MemoryCore.DELETION_FEEDBACK_FAMILY,
+            gist: summary.slice(0, 200),
+            situation: ['memory_extract 提炼新记忆时，参考此经验避免重复提取已被用户否定的类型'],
+            path: [{ order: 1, action: '读取此经验的 reasoning 字段，了解哪些类型的记忆曾被用户删除及原因' }, { order: 2, action: '提炼时避开这些类型，优先提取用户认可的记忆模式' }],
+            reasoning: summary,
+            limits: ['此经验由系统自动生成，禁止人工删除（只能归档）', '内容会随删除记录增多而定期更新'],
+            status: 'live',
+            alpha: 5,
+            beta: 2,
+            pinned: false,
+            tokensSaved: 0,
+            tokensSpent: 0,
+            context: '',
+            globalFlag: true,
+            verifiedCount: 0,
+            rejectCount: 0,
+            createdAt: now,
+            updatedAt: now,
+        };
+        this.store.upsertExperience(exp);
+        this.ledger('refine', 'experience', exp.id, actor, {
+            family: exp.family,
+            status: exp.status,
+        }, 'deletion-feedback summarization (initial)');
+        this.store.setLastDeletionFeedbackTs(now);
+        return exp;
+    }
+    /**
+     * Get the current extraction-feedback experience (if any) for injection into
+     * the extraction prompt.
+     */
+    getDeletionFeedback() {
+        return this.store.findExperienceByFamily(MemoryCore.DELETION_FEEDBACK_FAMILY);
+    }
     // ── human operations (all ledgered) ───────────────────────────────────────
     /** Human pin/unpin: pinned cards keep the trust floor and escape budgets. */
     humanPin(request, actor) {

package/lib/types/index.d.ts

@@ -55,6 +55,10 @@ export interface Config {
     recallFloorScore?: number;
     /** Shadow replay agreement required to adopt a draft. */
     shadowPassRate?: number;
+    /** Minimum hours between deletion-feedback LLM summarization runs. */
+    deletionFeedbackIntervalHours?: number;
+    /** Minimum new deletions since last run to trigger summarization. */
+    deletionFeedbackMinDeletions?: number;
 }
 /** Resolve the plugin config with explicit defaults; unknown keys fail loud. */
 export declare function resolveConfig(config: Config): Required<Omit<Config, 'databasePath' | 'workspacePath'>> & {

package/lib/types/index.js

@@ -25,6 +25,7 @@ export function resolveConfig(config) {
         'challengeConsecutiveFails', 'challengeWindow', 'challengeWindowFailRate',
         'familyLiveCap', 'complexityTokenGate', 'complexityStepGate',
         'duplicateOverlapGate', 'recallFloorScore', 'shadowPassRate',
+        'deletionFeedbackIntervalHours', 'deletionFeedbackMinDeletions',
     ];
     const unknown = Object.keys(config).filter(key => !known.includes(key));
     if (unknown.length > 0) {
@@ -49,6 +50,8 @@ export function resolveConfig(config) {
         duplicateOverlapGate: config.duplicateOverlapGate ?? DEFAULT_CORE_CONFIG.duplicateOverlapGate,
         recallFloorScore: config.recallFloorScore ?? DEFAULT_CORE_CONFIG.recallFloorScore,
         shadowPassRate: config.shadowPassRate ?? DEFAULT_CORE_CONFIG.shadowPassRate,
+        deletionFeedbackIntervalHours: config.deletionFeedbackIntervalHours ?? DEFAULT_CORE_CONFIG.deletionFeedbackIntervalHours,
+        deletionFeedbackMinDeletions: config.deletionFeedbackMinDeletions ?? DEFAULT_CORE_CONFIG.deletionFeedbackMinDeletions,
     };
 }
 /**
@@ -74,6 +77,8 @@ export function apply(ctx, config = {}) {
         duplicateOverlapGate: resolved.duplicateOverlapGate,
         recallFloorScore: resolved.recallFloorScore,
         shadowPassRate: resolved.shadowPassRate,
+        deletionFeedbackIntervalHours: resolved.deletionFeedbackIntervalHours,
+        deletionFeedbackMinDeletions: resolved.deletionFeedbackMinDeletions,
     };
     mkdirSync(join(resolved.databasePath, '..'), { recursive: true });
     const db = new DatabaseSync(resolved.databasePath);

package/lib/types/service.d.ts

@@ -44,7 +44,28 @@ export declare class MemoryService extends TypertRemoteService {
     /** 记: append one diary entry; signals the extraction duty when due. */
     appendDiary(agent: Agent, request: DiaryAppendRequest): DiaryAppendResult;
     /** 上升通道: apply extracted facts over the pending diary window. */
-    extract(agent: Agent, request: ExtractFactsRequest): ExtractFactsResult;
+    extract(agent: Agent, request: ExtractFactsRequest): Promise<ExtractFactsResult>;
+    /**
+     * Check if deletion-feedback summarization is due and run it if so.
+     * Uses the agent's current model route for the LLM call.
+     */
+    private maybeRunDeletionFeedbackSummarization;
+    /**
+     * Call the LLM to summarize deletion records into extraction feedback rules.
+     * Uses ctx.llm.stream() with the agent's current model route.
+     */
+    private summarizeDeletionsWithLlm;
+    /**
+     * Remote: manually trigger deletion-feedback summarization (for testing/debugging).
+     */
+    runDeletionFeedback(agent: Agent): Promise<{
+        ran: boolean;
+        summary?: string;
+    }>;
+    /**
+     * Remote: get the current deletion-feedback experience (for debugging).
+     */
+    getDeletionFeedback(agent: Agent): ExperienceSnapshot | null;
     /** Diary timeline for the workbench (007 §2: server-side pagination, newest first). */
     listDiary(agent: Agent, limit: number, offset: number, onlyUnextracted: boolean): DiaryEntry[];
     /** Several diary entries by id (008 Path A: fact→diary provenance). */

package/lib/types/service.js

@@ -64,6 +64,8 @@ let MemoryService = (() => {
     let _family_decorators;
     let _appendDiary_decorators;
     let _extract_decorators;
+    let _runDeletionFeedback_decorators;
+    let _getDeletionFeedback_decorators;
     let _listDiary_decorators;
     let _getDiaryByIds_decorators;
     let _listFacts_decorators;
@@ -110,6 +112,8 @@ let MemoryService = (() => {
             _family_decorators = [Remote('family')];
             _appendDiary_decorators = [Remote('appendDiary')];
             _extract_decorators = [Remote('extract')];
+            _runDeletionFeedback_decorators = [Remote('runDeletionFeedback')];
+            _getDeletionFeedback_decorators = [Remote('getDeletionFeedback')];
             _listDiary_decorators = [Remote('listDiary')];
             _getDiaryByIds_decorators = [Remote('getDiaryByIds')];
             _listFacts_decorators = [Remote('listFacts')];
@@ -153,6 +157,8 @@ let MemoryService = (() => {
             __esDecorate(this, null, _family_decorators, { kind: "method", name: "family", static: false, private: false, access: { has: obj => "family" in obj, get: obj => obj.family }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _appendDiary_decorators, { kind: "method", name: "appendDiary", static: false, private: false, access: { has: obj => "appendDiary" in obj, get: obj => obj.appendDiary }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _extract_decorators, { kind: "method", name: "extract", static: false, private: false, access: { has: obj => "extract" in obj, get: obj => obj.extract }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _runDeletionFeedback_decorators, { kind: "method", name: "runDeletionFeedback", static: false, private: false, access: { has: obj => "runDeletionFeedback" in obj, get: obj => obj.runDeletionFeedback }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getDeletionFeedback_decorators, { kind: "method", name: "getDeletionFeedback", static: false, private: false, access: { has: obj => "getDeletionFeedback" in obj, get: obj => obj.getDeletionFeedback }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _listDiary_decorators, { kind: "method", name: "listDiary", static: false, private: false, access: { has: obj => "listDiary" in obj, get: obj => obj.listDiary }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getDiaryByIds_decorators, { kind: "method", name: "getDiaryByIds", static: false, private: false, access: { has: obj => "getDiaryByIds" in obj, get: obj => obj.getDiaryByIds }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _listFacts_decorators, { kind: "method", name: "listFacts", static: false, private: false, access: { has: obj => "listFacts" in obj, get: obj => obj.listFacts }, metadata: _metadata }, null, _instanceExtraInitializers);
@@ -244,9 +250,106 @@ let MemoryService = (() => {
             return this.core.appendDiary(request, actorOf(agent));
         }
         /** 上升通道: apply extracted facts over the pending diary window. */
-        extract(agent, request) {
+        async extract(agent, request) {
+            // P1-2: lazy-trigger deletion-feedback summarization before extraction.
+            // If enough deletions have accumulated and enough time has passed, run an
+            // LLM summarization to update the extraction-feedback experience. This
+            // ensures the feedback is fresh when the extraction prompt references it.
+            await this.maybeRunDeletionFeedbackSummarization(agent);
             return this.core.extract(request, actorOf(agent), 'manual');
         }
+        /**
+         * Check if deletion-feedback summarization is due and run it if so.
+         * Uses the agent's current model route for the LLM call.
+         */
+        async maybeRunDeletionFeedbackSummarization(agent) {
+            const check = this.core.deletionFeedbackDue();
+            if (!check.due)
+                return;
+            try {
+                const records = this.core['store'].getDeletionRecordsSince(check.lastTs, 50);
+                if (records.length === 0)
+                    return;
+                const summary = await this.summarizeDeletionsWithLlm(agent, records);
+                if (summary.length > 0) {
+                    this.core.applyDeletionFeedback(summary, 'system');
+                }
+            }
+            catch {
+                // Summarization failure is non-fatal — extraction proceeds without updated feedback.
+            }
+        }
+        /**
+         * Call the LLM to summarize deletion records into extraction feedback rules.
+         * Uses ctx.llm.stream() with the agent's current model route.
+         */
+        async summarizeDeletionsWithLlm(agent, records) {
+            const header = agent.session.requestHeader()?.config;
+            if (header === undefined)
+                return ''; // no model route available
+            const provider = header.provider;
+            const model = header.model;
+            if (provider === undefined || model === undefined)
+                return '';
+            const deletionList = records.map((r, i) => `${i + 1}. [${new Date(r.ts).toLocaleDateString('zh-CN')}] 删除的经验：「${r.gist.slice(0, 80)}」\n   原因：${r.reason || '（未填写）'}`).join('\n\n');
+            const systemPrompt = `你是一个记忆系统的反馈分析器。你的任务是分析用户删除记忆时填写的原因，总结出"什么类型的记忆不值得提取"的规则。
+
+输出要求：
+1. 用简洁的中文列出 3-5 条规则
+2. 每条规则说明：什么类型的记忆应该避免提取，以及为什么
+3. 规则要具体可操作，不要泛泛而谈
+4. 如果删除原因都很相似，合并为更精炼的规则`;
+            const userPrompt = `以下是近期被用户删除的记忆及其删除原因：
+
+${deletionList}
+
+请总结成提取反馈规则。`;
+            const messages = [{
+                    role: 'user',
+                    content: [{ type: 'text', text: userPrompt }],
+                }];
+            let text = '';
+            const options = {
+                provider,
+                model,
+                messages,
+                system: systemPrompt,
+                maxTokens: 1500,
+                sessionId: agent.session.id,
+            };
+            for await (const chunk of this.ctx.llm.stream(options)) {
+                if (chunk.type === 'text-delta')
+                    text += chunk.text;
+            }
+            return text.trim();
+        }
+        /**
+         * Remote: manually trigger deletion-feedback summarization (for testing/debugging).
+         */
+        async runDeletionFeedback(agent) {
+            const check = this.core.deletionFeedbackDue();
+            const records = this.core['store'].getDeletionRecordsSince(check.lastTs, 50);
+            if (records.length === 0)
+                return { ran: false };
+            try {
+                const summary = await this.summarizeDeletionsWithLlm(agent, records);
+                if (summary.length > 0) {
+                    this.core.applyDeletionFeedback(summary, 'system');
+                    return { ran: true, summary };
+                }
+                return { ran: false };
+            }
+            catch (e) {
+                return { ran: false, summary: String(e) };
+            }
+        }
+        /**
+         * Remote: get the current deletion-feedback experience (for debugging).
+         */
+        getDeletionFeedback(agent) {
+            void agent;
+            return this.core.getDeletionFeedback() ?? null;
+        }
         /** Diary timeline for the workbench (007 §2: server-side pagination, newest first). */
         listDiary(agent, limit, offset, onlyUnextracted) {
             void agent;

package/lib/types/store.d.ts

@@ -224,6 +224,22 @@ export declare class MemoryStore {
     lastConsolidationTs(): number;
     /** Non-deleted experiences created strictly after `ts` (new material since last consolidation). */
     countExperiencesSince(ts: number): number;
+    /** Last deletion-feedback summarization ts (0 = never). Stored in memory_meta. */
+    lastDeletionFeedbackTs(): number;
+    /** Record the timestamp of a deletion-feedback summarization run. */
+    setLastDeletionFeedbackTs(ts: number): void;
+    /** Count experience deletions (ledger op='delete', objectType='experience') since a given ts. */
+    countDeletionsSince(ts: number): number;
+    /** Get the deletion ledger blocks since a given ts (for LLM summarization input). */
+    getDeletionRecordsSince(ts: number, limit?: number): Array<{
+        seq: number;
+        ts: number;
+        objectId: string;
+        reason: string;
+        gist: string;
+    }>;
+    /** Find the active (non-deleted) experience by family name. Returns the latest revision. */
+    findExperienceByFamily(family: string): ExperienceSnapshot | undefined;
     /** Archive a set of experiences by family_id (leave recall; recoverable — never hard-deleted autonomously). */
     archiveExperienceIds(ids: string[], ts: number): void;
     /** Record one recall event. */

package/lib/types/store.js

@@ -724,6 +724,39 @@ export class MemoryStore {
         const row = this.db.prepare('SELECT COUNT(*) AS n FROM experiences WHERE deleted = 0 AND created_at > ?').get(ts);
         return row.n;
     }
+    // ── deletion-feedback summarization (P1-2) ────────────────────────────────
+    /** Last deletion-feedback summarization ts (0 = never). Stored in memory_meta. */
+    lastDeletionFeedbackTs() {
+        const row = this.db.prepare("SELECT value FROM memory_meta WHERE key = 'last_deletion_feedback_ts'").get();
+        return row ? Number(row.value) : 0;
+    }
+    /** Record the timestamp of a deletion-feedback summarization run. */
+    setLastDeletionFeedbackTs(ts) {
+        this.db.prepare("INSERT OR REPLACE INTO memory_meta (key, value) VALUES ('last_deletion_feedback_ts', ?)").run(String(ts));
+    }
+    /** Count experience deletions (ledger op='delete', objectType='experience') since a given ts. */
+    countDeletionsSince(ts) {
+        const row = this.db.prepare("SELECT COUNT(*) AS n FROM ledger WHERE op = 'delete' AND object_type = 'experience' AND ts > ?").get(ts);
+        return row.n;
+    }
+    /** Get the deletion ledger blocks since a given ts (for LLM summarization input). */
+    getDeletionRecordsSince(ts, limit = 50) {
+        const rows = this.db.prepare("SELECT seq, ts, object_id, reason, payload FROM ledger WHERE op = 'delete' AND object_type = 'experience' AND ts > ? ORDER BY ts DESC LIMIT ?").all(ts, limit);
+        return rows.map(r => {
+            let gist = '';
+            try {
+                const p = JSON.parse(r.payload);
+                gist = p.gist ?? '';
+            }
+            catch { /* ignore parse errors */ }
+            return { seq: r.seq, ts: r.ts, objectId: r.object_id, reason: r.reason ?? '', gist };
+        });
+    }
+    /** Find the active (non-deleted) experience by family name. Returns the latest revision. */
+    findExperienceByFamily(family) {
+        const row = this.db.prepare("SELECT * FROM experiences WHERE family = ? AND deleted = 0 ORDER BY revision DESC LIMIT 1").get(family);
+        return row ? this.rowToExperience(row) : undefined;
+    }
     /** Archive a set of experiences by family_id (leave recall; recoverable — never hard-deleted autonomously). */
     archiveExperienceIds(ids, ts) {
         const stmt = this.db.prepare(`UPDATE experiences SET status = ?, updated_at = ? WHERE family_id = ? AND deleted = 0 AND status IN ('candidate','live','challenged')`);

package/lib/types/types.d.ts

@@ -452,6 +452,8 @@ export interface ExtractFactsResult {
     }[];
     /** Concern nodes created/extended by this extraction (007 §2). */
     appliedConcerns: number;
+    /** Deletion-feedback guidance (if an extraction-feedback experience exists). The agent should reference this when forming future extraction proposals. */
+    deletionFeedback?: string;
 }
 /** Concern shape (open by design; the enum only guides the model). */
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-daoing-memory",
   "description": "Self-evolving memory for DeepSeek Harness (DSH): earned experiences, diary/fact semantic memory, concern tracking, and an append-only audit ledger.",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "type": "module",
   "license": "MIT",
   "author": "daoing",