dsh-daoing-memory 0.1.18 → 0.1.19

package/lib/client.js

@@ -8632,61 +8632,61 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			document.head.appendChild(tag);
 		}
 		var Workbench_module_css_default = {
-			"cardDetail": "vPI34G_cardDetail",
-			"btnDanger": "vPI34G_btnDanger",
-			"warnLine": "vPI34G_warnLine",
-			"badgePinned": "vPI34G_badgePinned",
-			"workbenchTabs": "vPI34G_workbenchTabs",
-			"cardMeta": "vPI34G_cardMeta",
-			"actions": "vPI34G_actions",
-			"statusCandidate": "vPI34G_statusCandidate",
-			"title": "vPI34G_title",
+			"body": "vPI34G_body",
 			"titleBlock": "vPI34G_titleBlock",
-			"cardHead": "vPI34G_cardHead",
-			"badge": "vPI34G_badge",
-			"badgeNegative": "vPI34G_badgeNegative",
-			"detailLabel": "vPI34G_detailLabel",
-			"toolbar": "vPI34G_toolbar",
-			"cardSub": "vPI34G_cardSub",
-			"statusOther": "vPI34G_statusOther",
-			"trust": "vPI34G_trust",
-			"header": "vPI34G_header",
-			"concernBg": "vPI34G_concernBg",
-			"panel": "vPI34G_panel",
-			"workbenchTabActive": "vPI34G_workbenchTabActive",
+			"check": "vPI34G_check",
+			"tabActive": "vPI34G_tabActive",
+			"workbenchTabs": "vPI34G_workbenchTabs",
+			"badgePositive": "vPI34G_badgePositive",
 			"error": "vPI34G_error",
+			"badgeNegative": "vPI34G_badgeNegative",
+			"detailRow": "vPI34G_detailRow",
 			"okLine": "vPI34G_okLine",
-			"page": "vPI34G_page",
-			"payloadFull": "vPI34G_payloadFull",
-			"payloadToggle": "vPI34G_payloadToggle",
+			"tab": "vPI34G_tab",
 			"badgeConflict": "vPI34G_badgeConflict",
-			"btn": "vPI34G_btn",
-			"badgePositive": "vPI34G_badgePositive",
-			"statusLive": "vPI34G_statusLive",
+			"payloadToggle": "vPI34G_payloadToggle",
+			"cellActions": "vPI34G_cellActions",
+			"statusCandidate": "vPI34G_statusCandidate",
+			"page": "vPI34G_page",
 			"table": "vPI34G_table",
-			"statusChallenged": "vPI34G_statusChallenged",
-			"historyTitle": "vPI34G_historyTitle",
-			"workbenchTab": "vPI34G_workbenchTab",
-			"tab": "vPI34G_tab",
-			"field": "vPI34G_field",
+			"trust": "vPI34G_trust",
+			"warnLine": "vPI34G_warnLine",
+			"cardMeta": "vPI34G_cardMeta",
 			"valueCell": "vPI34G_valueCell",
-			"card": "vPI34G_card",
-			"tabActive": "vPI34G_tabActive",
-			"tabs": "vPI34G_tabs",
+			"badge": "vPI34G_badge",
 			"column": "vPI34G_column",
 			"sectionTitle": "vPI34G_sectionTitle",
+			"workbenchTabActive": "vPI34G_workbenchTabActive",
+			"rules": "vPI34G_rules",
+			"concernBg": "vPI34G_concernBg",
+			"field": "vPI34G_field",
+			"tabs": "vPI34G_tabs",
+			"statusLive": "vPI34G_statusLive",
+			"detailLabel": "vPI34G_detailLabel",
+			"statusOther": "vPI34G_statusOther",
+			"columns": "vPI34G_columns",
+			"badgePinned": "vPI34G_badgePinned",
+			"title": "vPI34G_title",
 			"statline": "vPI34G_statline",
-			"check": "vPI34G_check",
-			"cardTitle": "vPI34G_cardTitle",
+			"btn": "vPI34G_btn",
+			"cardDetail": "vPI34G_cardDetail",
+			"payloadFull": "vPI34G_payloadFull",
+			"statusChallenged": "vPI34G_statusChallenged",
+			"cardHead": "vPI34G_cardHead",
+			"list": "vPI34G_list",
+			"historyTitle": "vPI34G_historyTitle",
+			"toolbar": "vPI34G_toolbar",
 			"subtitle": "vPI34G_subtitle",
-			"detailRow": "vPI34G_detailRow",
+			"cardSub": "vPI34G_cardSub",
 			"form": "vPI34G_form",
-			"body": "vPI34G_body",
-			"list": "vPI34G_list",
-			"cellActions": "vPI34G_cellActions",
+			"cardTitle": "vPI34G_cardTitle",
+			"panel": "vPI34G_panel",
+			"actions": "vPI34G_actions",
+			"header": "vPI34G_header",
+			"workbenchTab": "vPI34G_workbenchTab",
 			"empty": "vPI34G_empty",
-			"columns": "vPI34G_columns",
-			"rules": "vPI34G_rules"
+			"btnDanger": "vPI34G_btnDanger",
+			"card": "vPI34G_card"
 		};
 		//#endregion
 		//#region lib/types/client/ExperiencePage.js
@@ -9328,17 +9328,17 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			document.head.appendChild(tag);
 		}
 		var ReasonDialog_module_css_default = {
-			"btnConfirm": "HH3IWW_btnConfirm",
-			"title": "HH3IWW_title",
-			"hint": "HH3IWW_hint",
+			"subtitle": "HH3IWW_subtitle",
+			"overlay": "HH3IWW_overlay",
 			"footer": "HH3IWW_footer",
-			"textarea": "HH3IWW_textarea",
 			"buttons": "HH3IWW_buttons",
-			"subtitle": "HH3IWW_subtitle",
+			"btnCancel": "HH3IWW_btnCancel",
 			"dialog": "HH3IWW_dialog",
-			"overlay": "HH3IWW_overlay",
+			"btnConfirm": "HH3IWW_btnConfirm",
+			"hint": "HH3IWW_hint",
 			"header": "HH3IWW_header",
-			"btnCancel": "HH3IWW_btnCancel"
+			"title": "HH3IWW_title",
+			"textarea": "HH3IWW_textarea"
 		};
 		//#endregion
 		//#region lib/types/client/ReasonDialog.js

package/lib/index.js

@@ -357,6 +357,35 @@ var MemoryStore = class {
 		return scored.slice(0, topK);
 	}
 	/**
+	* Near-duplicate candidate set for the information-gain gate (007 flow-log fix).
+	* Scores on gist+situation only (the lesson's identity) so identical lessons
+	* with divergent limits/paths still match. Returns the top-K matches (rough
+	* prefilter for the LLM semantic-dedup verdict), or [] when nothing matches.
+	*/
+	findNearDuplicates(queryTokens, statuses, topK) {
+		if (queryTokens.size === 0 || topK <= 0) return [];
+		const sql = `
+      SELECT * FROM experiences
+      WHERE deleted = 0 AND status IN (${statuses.map(() => "?").join(", ")})
+    `;
+		const rows = this.db.prepare(sql).all(...statuses);
+		const scored = [];
+		for (const row of rows) {
+			const snapshot = this.rowToExperience(row);
+			const hay = new Set(tokenize([snapshot.gist, ...snapshot.situation].join(" ")));
+			if (hay.size === 0) continue;
+			let hits = 0;
+			for (const token of queryTokens) if (hay.has(token)) hits += 1;
+			const score = hits / Math.sqrt(queryTokens.size * hay.size);
+			if (score > 0) scored.push({
+				snapshot,
+				score
+			});
+		}
+		scored.sort((a, b) => b.score - a.score);
+		return scored.slice(0, topK);
+	}
+	/**
 	* Near-duplicate detection for the information-gain gate (007 flow-log fix).
 	* Unlike recallCandidates it scores on gist+situation only (the lesson's
 	* identity), so identical lessons with divergent limits/paths still match.
@@ -1045,7 +1074,7 @@ const INGEST_SOURCE_PRIOR = {
 	}
 };
 /** Cosine-ish overlap of two token sets (for intra-batch dedup, 007). */
-function tokenOverlap(a, b) {
+function tokenOverlap$1(a, b) {
 	if (a.size === 0 || b.size === 0) return 0;
 	let hits = 0;
 	for (const t of a) if (b.has(t)) hits += 1;
@@ -1074,7 +1103,7 @@ var MemoryCore = class MemoryCore {
 		});
 	}
 	/** 生: refine one completed trajectory into a candidate (dual gate). */
-	refine(request, actor) {
+	refine(request, actor, opts) {
 		if (!((request.evidence.traceRef ?? "").trim() !== "" || (request.evidence.sessionRef ?? "").trim() !== "" || (request.evidence.note ?? "").trim() !== "")) return {
 			accepted: false,
 			reason: "rejected-evidence: every assertion needs an episodic evidence pointer (traceRef/sessionRef/note)"
@@ -1088,25 +1117,27 @@ var MemoryCore = class MemoryCore {
 			accepted: false,
 			reason: `rejected-complexity: trajectory below both gates (tokens < ${String(this.config.complexityTokenGate)}, steps < ${String(this.config.complexityStepGate)}, no failure, not human-marked)`
 		};
-		const dedupTokens = new Set(tokenize([request.gist, ...request.situation].join(" ")));
-		const near = this.store.findNearDuplicate(dedupTokens, [
-			"candidate",
-			"live",
-			"challenged",
-			"archived",
-			"cold"
-		]);
-		if (near !== void 0 && near.score >= this.config.duplicateOverlapGate) {
-			this.ledger("corroborate", "experience", near.snapshot.id, actor, {
-				family: request.family,
-				gist: request.gist,
-				score: near.score
-			});
-			return {
-				accepted: false,
-				reason: "rejected-information-gain: near-duplicate of an existing experience; corroborated it instead",
-				corroboratedId: near.snapshot.id
-			};
+		if (opts?.dedup !== false) {
+			const dedupTokens = new Set(tokenize([request.gist, ...request.situation].join(" ")));
+			const near = this.store.findNearDuplicate(dedupTokens, [
+				"candidate",
+				"live",
+				"challenged",
+				"archived",
+				"cold"
+			]);
+			if (near !== void 0 && near.score >= this.config.duplicateOverlapGate) {
+				this.ledger("corroborate", "experience", near.snapshot.id, actor, {
+					family: request.family,
+					gist: request.gist,
+					score: near.score
+				});
+				return {
+					accepted: false,
+					reason: "rejected-information-gain: near-duplicate of an existing experience; corroborated it instead",
+					corroboratedId: near.snapshot.id
+				};
+			}
 		}
 		const now = Date.now();
 		const snapshot = {
@@ -1154,7 +1185,7 @@ var MemoryCore = class MemoryCore {
 	* candidate carrying provenance (sourceType + sourceRef), the source-authority
 	* prior, and the declared context scope. Candidates never recall until verified.
 	*/
-	ingest(request, actor) {
+	ingest(request, actor, opts) {
 		if ((request.sourceRef ?? "").trim() === "") throw new Error("memory: ingest requires a non-empty sourceRef provenance");
 		const prior = INGEST_SOURCE_PRIOR[request.sourceType] ?? INGEST_SOURCE_PRIOR.other;
 		const context = request.context ?? "";
@@ -1170,32 +1201,34 @@ var MemoryCore = class MemoryCore {
 				continue;
 			}
 			const dedupTokens = new Set(tokenize([item.gist, ...item.situation].join(" ")));
-			const cross = this.store.findNearDuplicate(dedupTokens, [
-				"candidate",
-				"live",
-				"challenged",
-				"archived",
-				"cold"
-			]);
-			if (cross !== void 0 && cross.score >= this.config.duplicateOverlapGate) {
-				this.ledger("corroborate", "experience", cross.snapshot.id, actor, {
-					family: item.family,
-					gist: item.gist,
-					score: cross.score,
-					via: "ingest"
-				});
-				rejected.push({
-					gist: item.gist,
-					reason: "rejected-information-gain: near-duplicate of an existing experience; corroborated it instead"
-				});
-				continue;
-			}
-			if (acceptedDedup.some((prev) => tokenOverlap(dedupTokens, prev) >= this.config.duplicateOverlapGate)) {
-				rejected.push({
-					gist: item.gist,
-					reason: "rejected-information-gain: near-duplicate of another item in this same ingest batch"
-				});
-				continue;
+			if (opts?.dedup !== false) {
+				const cross = this.store.findNearDuplicate(dedupTokens, [
+					"candidate",
+					"live",
+					"challenged",
+					"archived",
+					"cold"
+				]);
+				if (cross !== void 0 && cross.score >= this.config.duplicateOverlapGate) {
+					this.ledger("corroborate", "experience", cross.snapshot.id, actor, {
+						family: item.family,
+						gist: item.gist,
+						score: cross.score,
+						via: "ingest"
+					});
+					rejected.push({
+						gist: item.gist,
+						reason: "rejected-information-gain: near-duplicate of an existing experience; corroborated it instead"
+					});
+					continue;
+				}
+				if (acceptedDedup.some((prev) => tokenOverlap$1(dedupTokens, prev) >= this.config.duplicateOverlapGate)) {
+					rejected.push({
+						gist: item.gist,
+						reason: "rejected-information-gain: near-duplicate of another item in this same ingest batch"
+					});
+					continue;
+				}
 			}
 			const now = Date.now();
 			const snapshot = {
@@ -2346,6 +2379,24 @@ var MemoryCore = class MemoryCore {
 		this.ledger("release-cold", "experience", next.id, actor, { revision: next.revision }, request.reason);
 		return next;
 	}
+	/** Record a corroboration ledger event for a rejected near-duplicate.
+	*  The LLM semantic-dedup path routes a DUPLICATE verdict here so the
+	*  ledger stays consistent with the mechanical-gate path (refine/ingest). */
+	markCorroborate(nearId, actor, req, via, score) {
+		this.ledger("corroborate", "experience", nearId, actor, {
+			family: req.family,
+			gist: req.gist,
+			score,
+			via
+		});
+	}
+	/** Near-duplicate candidate set for the LLM semantic-dedup prefilter. The
+	*  service layer asks here for the mechanical word-overlap top-K before it
+	*  runs the LLM verdict; the coarse hit is only a candidate pool, not a gate. */
+	nearDuplicateCandidates(gist, situation, statuses, topK) {
+		const tokens = new Set(tokenize([gist, ...situation].join(" ")));
+		return this.store.findNearDuplicates(tokens, statuses, topK);
+	}
 	/** Human-approved self-growth: merge new evidence into a live, human-approved
 	*  experience as an incremental new revision (revision+1, parent superseded).
 	*  Only approvedBy='human' + status='live' may evolve; agent/system-approved
@@ -3630,6 +3681,23 @@ function actorOf(agent) {
 	const sessionId = agent.session?.id;
 	return sessionId === void 0 ? "agent" : `agent:${sessionId}`;
 }
+/** Top-K coarse candidate pool for the LLM semantic-dedup prefilter. */
+const DEDUP_TOP_K = 5;
+/** Statuses scanned for a near-duplicate candidate pool. */
+const DEDUP_STATUSES = [
+	"candidate",
+	"live",
+	"challenged",
+	"archived",
+	"cold"
+];
+/** Cosine-ish overlap of two token sets (for intra-batch dedup, 007). */
+function tokenOverlap(a, b) {
+	if (a.size === 0 || b.size === 0) return 0;
+	let hits = 0;
+	for (const t of a) if (b.has(t)) hits += 1;
+	return hits / Math.sqrt(a.size * b.size);
+}
 /**
 * Remote face of the memory library. All methods delegate to the core; the
 * core carries the 生·用·修·记 mechanism semantics.
@@ -4339,9 +4407,39 @@ let MemoryService = (() => {
 			this.llm = llm;
 			this.defaultModel = defaultModel;
 		}
-		/** 生: refine a completed trajectory into an experience candidate. */
-		refine(agent, request) {
-			return this.core.refine(request, actorOf(agent));
+		/** 生: refine a completed trajectory into an experience candidate.
+		*  Semantic-dedup: coarse word-overlap candidate set first; when it is
+		*  non-empty the LLM judges [merge/duplicate/different] on the FULL lesson
+		*  (gist+situation+path+reasoning+limits), replacing the mechanical gate. */
+		async refine(agent, request) {
+			const actor = actorOf(agent);
+			const cands = this.core.nearDuplicateCandidates(request.gist, request.situation, DEDUP_STATUSES, DEDUP_TOP_K);
+			if (cands.length === 0) return this.core.refine(request, actor);
+			const verdict = await this.dedupVerdictWithLlm(agent, request, cands);
+			if (verdict === "different") return this.core.refine(request, actor, { dedup: false });
+			const best = cands[0];
+			if (verdict === "merge" && best.snapshot.approvedBy === "human" && best.snapshot.status === "live") return {
+				accepted: false,
+				reason: "semantic-merge: merged into a human-approved live experience",
+				corroboratedId: this.core.evolve({
+					id: best.snapshot.id,
+					reason: "semantic-merge: " + request.gist,
+					gist: request.gist,
+					situation: request.situation,
+					path: request.path,
+					reasoning: request.reasoning,
+					limits: request.limits
+				}, actor).id
+			};
+			this.core.markCorroborate(best.snapshot.id, actor, {
+				family: request.family,
+				gist: request.gist
+			}, "refine", best.score);
+			return {
+				accepted: false,
+				reason: "rejected-information-gain: near-duplicate of an existing experience; corroborated it instead",
+				corroboratedId: best.snapshot.id
+			};
 		}
 		/** 用: recall + adjudication + injection budget + negative channel. */
 		recall(agent, request) {
@@ -4351,9 +4449,72 @@ let MemoryService = (() => {
 		report(agent, request) {
 			return this.core.report(request, actorOf(agent));
 		}
-		/** 摄取归一: source-agnostic intake; drafts become earned candidates (006 §1). */
-		ingest(agent, request) {
-			return this.core.ingest(request, actorOf(agent));
+		/** 摄取归一: source-agnostic intake; drafts become earned candidates (006 §1).
+		*  Semantic-dedup per item: coarse word-overlap candidate set; when non-empty
+		*  the LLM judges [merge/duplicate/different] on the FULL lesson. */
+		async ingest(agent, request) {
+			const actor = actorOf(agent);
+			const prior = this.core.ingest({
+				...request,
+				experiences: []
+			}, actor, { dedup: false }).sourcePrior;
+			const accepted = [];
+			const rejected = [];
+			const acceptedDedup = [];
+			for (const item of request.experiences) {
+				if (item.kind === "negative" && (item.failureReason ?? "").trim() === "") {
+					rejected.push({
+						gist: item.gist,
+						reason: "rejected-schema: negative experiences must carry the confirmed failureReason"
+					});
+					continue;
+				}
+				const cands = this.core.nearDuplicateCandidates(item.gist, item.situation, DEDUP_STATUSES, DEDUP_TOP_K);
+				if (cands.length > 0) {
+					const best = cands[0];
+					const verdict = await this.dedupVerdictWithLlm(agent, item, cands);
+					if (verdict !== "different") {
+						if (verdict === "merge" && best.snapshot.approvedBy === "human" && best.snapshot.status === "live") this.core.evolve({
+							id: best.snapshot.id,
+							reason: "semantic-merge: " + item.gist,
+							gist: item.gist,
+							situation: item.situation,
+							path: item.path,
+							reasoning: item.reasoning,
+							limits: item.limits
+						}, actor);
+						else this.core.markCorroborate(best.snapshot.id, actor, {
+							family: item.family,
+							gist: item.gist
+						}, "ingest", best.score);
+						rejected.push({
+							gist: item.gist,
+							reason: "rejected-information-gain: near-duplicate of an existing experience; corroborated it instead"
+						});
+						continue;
+					}
+				}
+				const tokens = new Set(tokenize([item.gist, ...item.situation].join(" ")));
+				if (acceptedDedup.some((prev) => tokenOverlap(tokens, prev) >= this.core.config.duplicateOverlapGate)) {
+					rejected.push({
+						gist: item.gist,
+						reason: "rejected-information-gain: near-duplicate of another item in this same ingest batch"
+					});
+					continue;
+				}
+				const itemResult = this.core.ingest({
+					...request,
+					experiences: [item]
+				}, actor, { dedup: cands.length === 0 });
+				for (const a of itemResult.accepted) accepted.push(a);
+				for (const r of itemResult.rejected) rejected.push(r);
+				acceptedDedup.push(tokens);
+			}
+			return {
+				accepted,
+				rejected,
+				sourcePrior: prior
+			};
 		}
 		/** 修: propose a revised draft for a challenged experience. */
 		revise(agent, request) {
@@ -4403,6 +4564,58 @@ let MemoryService = (() => {
 			} catch {}
 		}
 		/**
+		* LLM semantic-dedup verdict between a new lesson and a coarse candidate set.
+		* Reads the FULL lesson (gist+situation+path+reasoning+limits) on both sides
+		* and returns 'merge' | 'duplicate' | 'different'. Falls back to 'different'
+		* (accept) when the LLM is unavailable or the model route is missing, so the
+		* mechanical gate in core still governs without an LLM.
+		*/
+		async dedupVerdictWithLlm(agent, lesson, cands) {
+			const header = agent.session.requestHeader()?.config;
+			let provider = header?.provider;
+			let model = header?.model;
+			if (provider === void 0 || model === void 0) {
+				const sel = this.defaultModel?.currentSelection();
+				if (sel !== void 0) {
+					provider = sel.provider;
+					model = sel.model;
+				}
+			}
+			if (provider === void 0 || model === void 0) return "different";
+			if (this.llm === void 0) return "different";
+			const fmtLesson = (l) => "gist: " + l.gist + "\nsituation: " + l.situation.join(" | ") + "\npath:\n" + l.path.map((p) => "  " + p.order + ". " + p.action).join("\n") + "\nreasoning: " + l.reasoning + "\nlimits: " + l.limits.join(" | ");
+			const candText = cands.map((c, i) => "候选 " + (i + 1) + "（词面相似度 " + c.score.toFixed(3) + "）：\n" + fmtLesson(c.snapshot)).join("\n\n");
+			const systemPrompt = "你是记忆系统的语义去重裁判。给定一条\"新提炼的教训\"和若干\"已存在的候选经验\"，判断它们是否指同一件事。\n只输出一个词：\n- merge：语义可合并，新教训是对候选经验的增量补充\n- duplicate：语义重复，新教训无新增信息\n- different：语义不同，是不同的经验\n只输出 merge/duplicate/different 之一，不要任何其它内容。";
+			const messages = [createUserMessage({
+				content: [{
+					type: "text",
+					text: "新提炼的教训：\n" + fmtLesson(lesson) + "\n\n候选经验：\n" + candText + "\n\n判定(merge/duplicate/different)："
+				}],
+				source: {
+					kind: "plugin",
+					plugin: "dsh-daoing-memory"
+				}
+			})];
+			let text = "";
+			const options = {
+				provider,
+				model,
+				messages,
+				system: systemPrompt,
+				maxTokens: 50,
+				sessionId: agent.session.id
+			};
+			try {
+				for await (const chunk of this.llm.stream(options)) if (chunk.type === "text-delta") text += chunk.text;
+			} catch {
+				return "different";
+			}
+			const t = text.trim().toLowerCase();
+			if (t.includes("merge")) return "merge";
+			if (t.includes("duplicate")) return "duplicate";
+			return "different";
+		}
+		/**
 		* Call the LLM to summarize deletion records into extraction feedback rules.
 		* Uses ctx.llm.stream() with the agent's current model route.
 		*/

package/lib/types/core.d.ts

@@ -20,7 +20,7 @@
  *
  * @module dsh-daoing-memory/core
  */
-import type { ConcernTree, ConsolidateRequest, ConsolidateResult, DiaryAppendRequest, DiaryAppendResult, DiaryEntry, ExperienceListFilter, ExperienceSnapshot, ExtractionRecord, ExtractFactsRequest, ExtractFactsResult, FactEntry, EvolveExperienceRequest, HumanAddExperienceRequest, HumanAddFactRequest, HumanAckDiaryRequest, HumanArchiveExperienceRequest, HumanConfirmFactRequest, HumanDeleteConcernRequest, HumanDeleteExperienceRequest, HumanDeleteFactRequest, HumanEditExperienceRequest, HumanEditFactRequest, HumanPinRequest, HumanSetConcernStatusRequest, HumanReleaseColdRequest, IngestRequest, IngestResult, LedgerIntegrityResult, LedgerQueryRequest, MemoryExport, MemoryStats, RecallExperiencesRequest, RecallExperiencesResult, RefineExperienceRequest, RefineExperienceResult, ReportUseRequest, ReportUseResult, ReviseExperienceRequest, RollbackExperienceRequest, VerifyShadowRequest, VerifyShadowResult, SkillArtifact, SkillForm, SkillStatus, ReviewSkillRequest, PublishSkillRequest } from './types.ts';
+import type { ConcernTree, ConsolidateRequest, ConsolidateResult, DiaryAppendRequest, DiaryAppendResult, DiaryEntry, ExperienceListFilter, ExperienceSnapshot, ExperienceStatus, ExtractionRecord, ExtractFactsRequest, ExtractFactsResult, FactEntry, EvolveExperienceRequest, HumanAddExperienceRequest, HumanAddFactRequest, HumanAckDiaryRequest, HumanArchiveExperienceRequest, HumanConfirmFactRequest, HumanDeleteConcernRequest, HumanDeleteExperienceRequest, HumanDeleteFactRequest, HumanEditExperienceRequest, HumanEditFactRequest, HumanPinRequest, HumanSetConcernStatusRequest, HumanReleaseColdRequest, IngestRequest, IngestResult, LedgerIntegrityResult, LedgerQueryRequest, MemoryExport, MemoryStats, RecallExperiencesRequest, RecallExperiencesResult, RefineExperienceRequest, RefineExperienceResult, ReportUseRequest, ReportUseResult, ReviseExperienceRequest, RollbackExperienceRequest, VerifyShadowRequest, VerifyShadowResult, SkillArtifact, SkillForm, SkillStatus, ReviewSkillRequest, PublishSkillRequest } from './types.ts';
 import { MemoryStore } from './store.ts';
 /** Tunable mechanism parameters, all overridable from the plugin config. */
 export interface MemoryCoreConfig {
@@ -82,13 +82,17 @@ export declare class MemoryCore {
     constructor(store: MemoryStore, config: MemoryCoreConfig);
     private ledger;
     /** 生: refine one completed trajectory into a candidate (dual gate). */
-    refine(request: RefineExperienceRequest, actor: MemoryActor): RefineExperienceResult;
+    refine(request: RefineExperienceRequest, actor: MemoryActor, opts?: {
+        dedup?: boolean;
+    }): RefineExperienceResult;
     /**
      * 摄取归一: source-agnostic intake. Every extracted draft becomes an earned
      * candidate carrying provenance (sourceType + sourceRef), the source-authority
      * prior, and the declared context scope. Candidates never recall until verified.
      */
-    ingest(request: IngestRequest, actor: MemoryActor): IngestResult;
+    ingest(request: IngestRequest, actor: MemoryActor, opts?: {
+        dedup?: boolean;
+    }): IngestResult;
     /** 用: recall → scope → adjudicate → budget → inject, plus the candidate probe channel. */
     recall(request: RecallExperiencesRequest, actor: MemoryActor): RecallExperiencesResult;
     /** 用·验: one use outcome → Beta update, attribution, quarantine, gates. */
@@ -234,6 +238,20 @@ export declare class MemoryCore {
     humanPromote(id: string, reason: string, actor: MemoryActor): ExperienceSnapshot;
     /** Human re-release (006 §3.2): move a cold-palace revision back to candidate. */
     humanReleaseCold(request: HumanReleaseColdRequest, actor: MemoryActor): ExperienceSnapshot;
+    /** Record a corroboration ledger event for a rejected near-duplicate.
+     *  The LLM semantic-dedup path routes a DUPLICATE verdict here so the
+     *  ledger stays consistent with the mechanical-gate path (refine/ingest). */
+    markCorroborate(nearId: string, actor: MemoryActor, req: {
+        family: string;
+        gist: string;
+    }, via: string, score: number): void;
+    /** Near-duplicate candidate set for the LLM semantic-dedup prefilter. The
+     *  service layer asks here for the mechanical word-overlap top-K before it
+     *  runs the LLM verdict; the coarse hit is only a candidate pool, not a gate. */
+    nearDuplicateCandidates(gist: string, situation: string[], statuses: ExperienceStatus[], topK: number): {
+        snapshot: ExperienceSnapshot;
+        score: number;
+    }[];
     /** Human-approved self-growth: merge new evidence into a live, human-approved
      *  experience as an incremental new revision (revision+1, parent superseded).
      *  Only approvedBy='human' + status='live' may evolve; agent/system-approved

package/lib/types/core.js

@@ -99,7 +99,7 @@ export class MemoryCore {
     }
     // ── 生: refine ────────────────────────────────────────────────────────────
     /** 生: refine one completed trajectory into a candidate (dual gate). */
-    refine(request, actor) {
+    refine(request, actor, opts) {
         const evidenceOk = (request.evidence.traceRef ?? '').trim() !== ''
             || (request.evidence.sessionRef ?? '').trim() !== ''
             || (request.evidence.note ?? '').trim() !== '';
@@ -120,15 +120,21 @@ export class MemoryCore {
         // Information-gain gate (007 flow-log fix): match on the lesson identity
         // (gist + situation) across the whole library; a near-duplicate corroborates
         // instead of inflating the library into a running log.
-        const dedupTokens = new Set(tokenize([request.gist, ...request.situation].join(' ')));
-        const near = this.store.findNearDuplicate(dedupTokens, ['candidate', 'live', 'challenged', 'archived', 'cold']);
-        if (near !== undefined && near.score >= this.config.duplicateOverlapGate) {
-            this.ledger('corroborate', 'experience', near.snapshot.id, actor, {
-                family: request.family,
-                gist: request.gist,
-                score: near.score,
-            });
-            return { accepted: false, reason: 'rejected-information-gain: near-duplicate of an existing experience; corroborated it instead', corroboratedId: near.snapshot.id };
+        // Information-gain gate: mechanical word-overlap is the DEFAULT (no-LLM)
+        // prefilter. When the service layer already ran LLM semantic dedup and
+        // decided DIFFERENT, it passes { dedup: false } to accept without a
+        // mechanical gate that would otherwise over-reject.
+        if (opts?.dedup !== false) {
+            const dedupTokens = new Set(tokenize([request.gist, ...request.situation].join(' ')));
+            const near = this.store.findNearDuplicate(dedupTokens, ['candidate', 'live', 'challenged', 'archived', 'cold']);
+            if (near !== undefined && near.score >= this.config.duplicateOverlapGate) {
+                this.ledger('corroborate', 'experience', near.snapshot.id, actor, {
+                    family: request.family,
+                    gist: request.gist,
+                    score: near.score,
+                });
+                return { accepted: false, reason: 'rejected-information-gain: near-duplicate of an existing experience; corroborated it instead', corroboratedId: near.snapshot.id };
+            }
         }
         const now = Date.now();
         const snapshot = {
@@ -175,7 +181,7 @@ export class MemoryCore {
      * candidate carrying provenance (sourceType + sourceRef), the source-authority
      * prior, and the declared context scope. Candidates never recall until verified.
      */
-    ingest(request, actor) {
+    ingest(request, actor, opts) {
         if ((request.sourceRef ?? '').trim() === '') {
             throw new Error('memory: ingest requires a non-empty sourceRef provenance');
         }
@@ -194,17 +200,19 @@ export class MemoryCore {
             // already accepted in this same batch. A near-duplicate corroborates
             // instead of inflating the library into a running log.
             const dedupTokens = new Set(tokenize([item.gist, ...item.situation].join(' ')));
-            const cross = this.store.findNearDuplicate(dedupTokens, ['candidate', 'live', 'challenged', 'archived', 'cold']);
-            if (cross !== undefined && cross.score >= this.config.duplicateOverlapGate) {
-                this.ledger('corroborate', 'experience', cross.snapshot.id, actor, {
-                    family: item.family, gist: item.gist, score: cross.score, via: 'ingest',
-                });
-                rejected.push({ gist: item.gist, reason: 'rejected-information-gain: near-duplicate of an existing experience; corroborated it instead' });
-                continue;
-            }
-            if (acceptedDedup.some(prev => tokenOverlap(dedupTokens, prev) >= this.config.duplicateOverlapGate)) {
-                rejected.push({ gist: item.gist, reason: 'rejected-information-gain: near-duplicate of another item in this same ingest batch' });
-                continue;
+            if (opts?.dedup !== false) {
+                const cross = this.store.findNearDuplicate(dedupTokens, ['candidate', 'live', 'challenged', 'archived', 'cold']);
+                if (cross !== undefined && cross.score >= this.config.duplicateOverlapGate) {
+                    this.ledger('corroborate', 'experience', cross.snapshot.id, actor, {
+                        family: item.family, gist: item.gist, score: cross.score, via: 'ingest',
+                    });
+                    rejected.push({ gist: item.gist, reason: 'rejected-information-gain: near-duplicate of an existing experience; corroborated it instead' });
+                    continue;
+                }
+                if (acceptedDedup.some(prev => tokenOverlap(dedupTokens, prev) >= this.config.duplicateOverlapGate)) {
+                    rejected.push({ gist: item.gist, reason: 'rejected-information-gain: near-duplicate of another item in this same ingest batch' });
+                    continue;
+                }
             }
             const now = Date.now();
             const snapshot = {
@@ -1324,6 +1332,19 @@ export class MemoryCore {
         this.ledger('release-cold', 'experience', next.id, actor, { revision: next.revision }, request.reason);
         return next;
     }
+    /** Record a corroboration ledger event for a rejected near-duplicate.
+     *  The LLM semantic-dedup path routes a DUPLICATE verdict here so the
+     *  ledger stays consistent with the mechanical-gate path (refine/ingest). */
+    markCorroborate(nearId, actor, req, via, score) {
+        this.ledger('corroborate', 'experience', nearId, actor, { family: req.family, gist: req.gist, score, via });
+    }
+    /** Near-duplicate candidate set for the LLM semantic-dedup prefilter. The
+     *  service layer asks here for the mechanical word-overlap top-K before it
+     *  runs the LLM verdict; the coarse hit is only a candidate pool, not a gate. */
+    nearDuplicateCandidates(gist, situation, statuses, topK) {
+        const tokens = new Set(tokenize([gist, ...situation].join(' ')));
+        return this.store.findNearDuplicates(tokens, statuses, topK);
+    }
     /** Human-approved self-growth: merge new evidence into a live, human-approved
      *  experience as an incremental new revision (revision+1, parent superseded).
      *  Only approvedBy='human' + status='live' may evolve; agent/system-approved

package/lib/types/service.d.ts

@@ -36,14 +36,19 @@ export declare class MemoryService extends TypertRemoteService {
             model: string;
         };
     } | undefined);
-    /** 生: refine a completed trajectory into an experience candidate. */
-    refine(agent: Agent, request: RefineExperienceRequest): RefineExperienceResult;
+    /** 生: refine a completed trajectory into an experience candidate.
+     *  Semantic-dedup: coarse word-overlap candidate set first; when it is
+     *  non-empty the LLM judges [merge/duplicate/different] on the FULL lesson
+     *  (gist+situation+path+reasoning+limits), replacing the mechanical gate. */
+    refine(agent: Agent, request: RefineExperienceRequest): Promise<RefineExperienceResult>;
     /** 用: recall + adjudication + injection budget + negative channel. */
     recall(agent: Agent, request: RecallExperiencesRequest): RecallExperiencesResult;
     /** 用·验: report one use outcome with attribution (V0 verification). */
     report(agent: Agent, request: ReportUseRequest): ReportUseResult;
-    /** 摄取归一: source-agnostic intake; drafts become earned candidates (006 §1). */
-    ingest(agent: Agent, request: IngestRequest): IngestResult;
+    /** 摄取归一: source-agnostic intake; drafts become earned candidates (006 §1).
+     *  Semantic-dedup per item: coarse word-overlap candidate set; when non-empty
+     *  the LLM judges [merge/duplicate/different] on the FULL lesson. */
+    ingest(agent: Agent, request: IngestRequest): Promise<IngestResult>;
     /** 修: propose a revised draft for a challenged experience. */
     revise(agent: Agent, request: ReviseExperienceRequest): ExperienceSnapshot;
     /** V1 controlled re-enactment: shadow replay verification for a draft. */
@@ -65,6 +70,14 @@ export declare class MemoryService extends TypertRemoteService {
      * Uses the agent's current model route for the LLM call.
      */
     private maybeRunDeletionFeedbackSummarization;
+    /**
+     * LLM semantic-dedup verdict between a new lesson and a coarse candidate set.
+     * Reads the FULL lesson (gist+situation+path+reasoning+limits) on both sides
+     * and returns 'merge' | 'duplicate' | 'different'. Falls back to 'different'
+     * (accept) when the LLM is unavailable or the model route is missing, so the
+     * mechanical gate in core still governs without an LLM.
+     */
+    private dedupVerdictWithLlm;
     /**
      * Call the LLM to summarize deletion records into extraction feedback rules.
      * Uses ctx.llm.stream() with the agent's current model route.

package/lib/types/service.js

@@ -44,11 +44,26 @@ import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
+import { tokenize } from "./store.js";
 /** Derive the ledger actor label from the wire identity. */
 function actorOf(agent) {
     const sessionId = agent.session?.id;
     return sessionId === undefined ? 'agent' : `agent:${sessionId}`;
 }
+/** Top-K coarse candidate pool for the LLM semantic-dedup prefilter. */
+const DEDUP_TOP_K = 5;
+/** Statuses scanned for a near-duplicate candidate pool. */
+const DEDUP_STATUSES = ['candidate', 'live', 'challenged', 'archived', 'cold'];
+/** Cosine-ish overlap of two token sets (for intra-batch dedup, 007). */
+function tokenOverlap(a, b) {
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let hits = 0;
+    for (const t of a)
+        if (b.has(t))
+            hits += 1;
+    return hits / Math.sqrt(a.size * b.size);
+}
 /**
  * Remote face of the memory library. All methods delegate to the core; the
  * core carries the 生·用·修·记 mechanism semantics.
@@ -233,9 +248,38 @@ let MemoryService = (() => {
             this.llm = llm;
             this.defaultModel = defaultModel;
         }
-        /** 生: refine a completed trajectory into an experience candidate. */
-        refine(agent, request) {
-            return this.core.refine(request, actorOf(agent));
+        /** 生: refine a completed trajectory into an experience candidate.
+         *  Semantic-dedup: coarse word-overlap candidate set first; when it is
+         *  non-empty the LLM judges [merge/duplicate/different] on the FULL lesson
+         *  (gist+situation+path+reasoning+limits), replacing the mechanical gate. */
+        async refine(agent, request) {
+            const actor = actorOf(agent);
+            const cands = this.core.nearDuplicateCandidates(request.gist, request.situation, DEDUP_STATUSES, DEDUP_TOP_K);
+            if (cands.length === 0) {
+                // No coarse hit: accept via the mechanical gate (kept as no-LLM fallback).
+                return this.core.refine(request, actor);
+            }
+            const verdict = await this.dedupVerdictWithLlm(agent, request, cands);
+            if (verdict === 'different') {
+                // LLM judged semantically different: accept, skipping the mechanical gate
+                // that would otherwise over-reject on word overlap.
+                return this.core.refine(request, actor, { dedup: false });
+            }
+            const best = cands[0];
+            if (verdict === 'merge' && best.snapshot.approvedBy === 'human' && best.snapshot.status === 'live') {
+                const evolved = this.core.evolve({
+                    id: best.snapshot.id,
+                    reason: 'semantic-merge: ' + request.gist,
+                    gist: request.gist,
+                    situation: request.situation,
+                    path: request.path,
+                    reasoning: request.reasoning,
+                    limits: request.limits,
+                }, actor);
+                return { accepted: false, reason: 'semantic-merge: merged into a human-approved live experience', corroboratedId: evolved.id };
+            }
+            this.core.markCorroborate(best.snapshot.id, actor, { family: request.family, gist: request.gist }, 'refine', best.score);
+            return { accepted: false, reason: 'rejected-information-gain: near-duplicate of an existing experience; corroborated it instead', corroboratedId: best.snapshot.id };
         }
         /** 用: recall + adjudication + injection budget + negative channel. */
         recall(agent, request) {
@@ -245,9 +289,58 @@ let MemoryService = (() => {
         report(agent, request) {
             return this.core.report(request, actorOf(agent));
         }
-        /** 摄取归一: source-agnostic intake; drafts become earned candidates (006 §1). */
-        ingest(agent, request) {
-            return this.core.ingest(request, actorOf(agent));
+        /** 摄取归一: source-agnostic intake; drafts become earned candidates (006 §1).
+         *  Semantic-dedup per item: coarse word-overlap candidate set; when non-empty
+         *  the LLM judges [merge/duplicate/different] on the FULL lesson. */
+        async ingest(agent, request) {
+            const actor = actorOf(agent);
+            // Source-authority prior, delegated to core so it stays the single truth.
+            const prior = this.core.ingest({ ...request, experiences: [] }, actor, { dedup: false }).sourcePrior;
+            const accepted = [];
+            const rejected = [];
+            const acceptedDedup = [];
+            for (const item of request.experiences) {
+                if (item.kind === 'negative' && (item.failureReason ?? '').trim() === '') {
+                    rejected.push({ gist: item.gist, reason: 'rejected-schema: negative experiences must carry the confirmed failureReason' });
+                    continue;
+                }
+                const cands = this.core.nearDuplicateCandidates(item.gist, item.situation, DEDUP_STATUSES, DEDUP_TOP_K);
+                if (cands.length > 0) {
+                    const best = cands[0];
+                    const verdict = await this.dedupVerdictWithLlm(agent, item, cands);
+                    if (verdict !== 'different') {
+                        if (verdict === 'merge' && best.snapshot.approvedBy === 'human' && best.snapshot.status === 'live') {
+                            this.core.evolve({
+                                id: best.snapshot.id,
+                                reason: 'semantic-merge: ' + item.gist,
+                                gist: item.gist,
+                                situation: item.situation,
+                                path: item.path,
+                                reasoning: item.reasoning,
+                                limits: item.limits,
+                            }, actor);
+                        }
+                        else {
+                            this.core.markCorroborate(best.snapshot.id, actor, { family: item.family, gist: item.gist }, 'ingest', best.score);
+                        }
+                        rejected.push({ gist: item.gist, reason: 'rejected-information-gain: near-duplicate of an existing experience; corroborated it instead' });
+                        continue;
+                    }
+                }
+                // LLM judged different (or no coarse hit): accept. Within-batch dedup via tokenOverlap.
+                const tokens = new Set(tokenize([item.gist, ...item.situation].join(' ')));
+                if (acceptedDedup.some((prev) => tokenOverlap(tokens, prev) >= this.core.config.duplicateOverlapGate)) {
+                    rejected.push({ gist: item.gist, reason: 'rejected-information-gain: near-duplicate of another item in this same ingest batch' });
+                    continue;
+                }
+                const itemResult = this.core.ingest({ ...request, experiences: [item] }, actor, { dedup: cands.length === 0 });
+                for (const a of itemResult.accepted)
+                    accepted.push(a);
+                for (const r of itemResult.rejected)
+                    rejected.push(r);
+                acceptedDedup.push(tokens);
+            }
+            return { accepted, rejected, sourcePrior: prior };
         }
         /** 修: propose a revised draft for a challenged experience. */
         revise(agent, request) {
@@ -310,6 +403,62 @@ let MemoryService = (() => {
                 // Summarization failure is non-fatal — extraction proceeds without updated feedback.
             }
         }
+        /**
+         * LLM semantic-dedup verdict between a new lesson and a coarse candidate set.
+         * Reads the FULL lesson (gist+situation+path+reasoning+limits) on both sides
+         * and returns 'merge' | 'duplicate' | 'different'. Falls back to 'different'
+         * (accept) when the LLM is unavailable or the model route is missing, so the
+         * mechanical gate in core still governs without an LLM.
+         */
+        async dedupVerdictWithLlm(agent, lesson, cands) {
+            // Try session-specific model first, fall back to the default model config.
+            const header = agent.session.requestHeader()?.config;
+            let provider = header?.provider;
+            let model = header?.model;
+            if (provider === undefined || model === undefined) {
+                const sel = this.defaultModel?.currentSelection();
+                if (sel !== undefined) {
+                    provider = sel.provider;
+                    model = sel.model;
+                }
+            }
+            if (provider === undefined || model === undefined)
+                return 'different';
+            if (this.llm === undefined)
+                return 'different';
+            const fmtLesson = (l) => 'gist: ' + l.gist + '\nsituation: ' + l.situation.join(' | ') + '\npath:\n' +
+                l.path.map((p) => '  ' + p.order + '. ' + p.action).join('\n') +
+                '\nreasoning: ' + l.reasoning + '\nlimits: ' + l.limits.join(' | ');
+            const candText = cands.map((c, i) => '候选 ' + (i + 1) + '（词面相似度 ' + c.score.toFixed(3) + '）：\n' + fmtLesson(c.snapshot)).join('\n\n');
+            const systemPrompt = '你是记忆系统的语义去重裁判。给定一条"新提炼的教训"和若干"已存在的候选经验"，判断它们是否指同一件事。\n' +
+                '只输出一个词：\n- merge：语义可合并，新教训是对候选经验的增量补充\n- duplicate：语义重复，新教训无新增信息\n- different：语义不同，是不同的经验\n' +
+                '只输出 merge/duplicate/different 之一，不要任何其它内容。';
+            const userPrompt = '新提炼的教训：\n' + fmtLesson(lesson) + '\n\n候选经验：\n' + candText + '\n\n判定(merge/duplicate/different)：';
+            const messages = [createUserMessage({
+                    content: [{ type: 'text', text: userPrompt }],
+                    source: { kind: 'plugin', plugin: 'dsh-daoing-memory' },
+                })];
+            let text = '';
+            const options = {
+                provider, model, messages, system: systemPrompt,
+                maxTokens: 50, sessionId: agent.session.id,
+            };
+            try {
+                for await (const chunk of this.llm.stream(options)) {
+                    if (chunk.type === 'text-delta')
+                        text += chunk.text;
+                }
+            }
+            catch {
+                return 'different';
+            }
+            const t = text.trim().toLowerCase();
+            if (t.includes('merge'))
+                return 'merge';
+            if (t.includes('duplicate'))
+                return 'duplicate';
+            return 'different';
+        }
         /**
          * Call the LLM to summarize deletion records into extraction feedback rules.
          * Uses ctx.llm.stream() with the agent's current model route.

package/lib/types/store.d.ts

@@ -84,6 +84,16 @@ export declare class MemoryStore {
         snapshot: ExperienceSnapshot;
         score: number;
     }[];
+    /**
+     * Near-duplicate candidate set for the information-gain gate (007 flow-log fix).
+     * Scores on gist+situation only (the lesson's identity) so identical lessons
+     * with divergent limits/paths still match. Returns the top-K matches (rough
+     * prefilter for the LLM semantic-dedup verdict), or [] when nothing matches.
+     */
+    findNearDuplicates(queryTokens: Set<string>, statuses: ExperienceStatus[], topK: number): {
+        snapshot: ExperienceSnapshot;
+        score: number;
+    }[];
     /**
      * Near-duplicate detection for the information-gain gate (007 flow-log fix).
      * Unlike recallCandidates it scores on gist+situation only (the lesson's

package/lib/types/store.js

@@ -362,6 +362,37 @@ export class MemoryStore {
         scored.sort((a, b) => b.score - a.score);
         return scored.slice(0, topK);
     }
+    /**
+     * Near-duplicate candidate set for the information-gain gate (007 flow-log fix).
+     * Scores on gist+situation only (the lesson's identity) so identical lessons
+     * with divergent limits/paths still match. Returns the top-K matches (rough
+     * prefilter for the LLM semantic-dedup verdict), or [] when nothing matches.
+     */
+    findNearDuplicates(queryTokens, statuses, topK) {
+        if (queryTokens.size === 0 || topK <= 0)
+            return [];
+        const sql = `
+      SELECT * FROM experiences
+      WHERE deleted = 0 AND status IN (${statuses.map(() => '?').join(', ')})
+    `;
+        const rows = this.db.prepare(sql).all(...statuses);
+        const scored = [];
+        for (const row of rows) {
+            const snapshot = this.rowToExperience(row);
+            const hay = new Set(tokenize([snapshot.gist, ...snapshot.situation].join(' ')));
+            if (hay.size === 0)
+                continue;
+            let hits = 0;
+            for (const token of queryTokens)
+                if (hay.has(token))
+                    hits += 1;
+            const score = hits / Math.sqrt(queryTokens.size * hay.size);
+            if (score > 0)
+                scored.push({ snapshot, score });
+        }
+        scored.sort((a, b) => b.score - a.score);
+        return scored.slice(0, topK);
+    }
     /**
      * Near-duplicate detection for the information-gain gate (007 flow-log fix).
      * Unlike recallCandidates it scores on gist+situation only (the lesson's

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.18",
+  "version": "0.1.19",
   "type": "module",
   "license": "MIT",
   "author": "daoing",