@lmzhen/dsh-evolution-core 0.3.36 → 0.3.37

package/lib/index.js

@@ -423,6 +423,7 @@ function parseUsage(raw) {
 	if (raw === null) return map;
 	try {
 		const parsed = JSON.parse(raw);
+		if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return map;
 		for (const [name, record] of Object.entries(parsed)) map.set(name, normalizeUsageRecord(record));
 	} catch {}
 	return map;
@@ -499,6 +500,10 @@ function foldCuratorFields(disk, curated, stateOwned) {
 		if (stateOwned === void 0 || stateOwned.has(name)) applyCuratorLifecycleFields(diskRecord, record);
 	}
 }
+/** Whole-file usage write (V6-37, 0.3.37): this is the ONE path that bypasses
+* the malformed-defense and the transact lock — prefer `mutateUsage` for any
+* read-modify-write so a concurrent writer cannot lose its update and a
+* malformed sidecar stays recoverable. Kept for fixture/test seeding. */
 async function saveUsage(root, map, io = nodeEvolutionIo()) {
 	const obj = Object.fromEntries(map.entries());
 	await io.writeText(usageFile(root), JSON.stringify(obj, null, 2));
@@ -1601,6 +1606,24 @@ function buildLearnPrompt(userRequest) {
 	].join("\n");
 }
 //#endregion
+//#region lib/types/serial.js
+/**
+* A process-local serial task queue: each task starts only after the previous
+* one settles (success or failure), so read-modify-write sequences that share
+* one file never interleave inside this process. The durable cross-process
+* serialization layer is the IO backend's transact lock; this chain is the
+* second layer (0.3.17 S2.8, T-1: the shape was duplicated in state-json and
+* memory-files — one factory now).
+*/
+function makeSerialQueue() {
+	let chain = Promise.resolve();
+	return (task) => {
+		const run = chain.then(task, task);
+		chain = run.then(() => void 0, () => void 0);
+		return run;
+	};
+}
+//#endregion
 //#region lib/types/numeric.js
 /**
 * Numeric config clamping for the dsh-evolution plugin family.
@@ -1962,6 +1985,12 @@ var MemoryStore = class {
 	root;
 	maxFailures;
 	io;
+	/** V6-16 (0.3.37): same-process RMW serialization (the SkillLibrary queue) —
+	* on a backend WITHOUT a transact lock two concurrent callers compute on the
+	* same old content and the last rename wins, silently dropping one op's
+	* update. The node backend's cross-process lock already serializes; this
+	* chain covers the no-transact custom backends. */
+	serial = makeSerialQueue();
 	failureCount = 0;
 	lastFailureAt = 0;
 	constructor(options = {}) {
@@ -2068,6 +2097,9 @@ var MemoryStore = class {
 		};
 	}
 	async add(target, facts) {
+		return await this.serial(() => this.addChained(target, facts));
+	}
+	async addChained(target, facts) {
 		if (!facts.trim()) return {
 			ok: false,
 			message: "Content cannot be empty.",
@@ -2173,6 +2205,9 @@ var MemoryStore = class {
 		return render(entries) !== raw;
 	}
 	async applyBatch(target, operations) {
+		return await this.serial(() => this.applyBatchChained(target, operations));
+	}
+	async applyBatchChained(target, operations) {
 		if (operations.length === 0) return {
 			ok: false,
 			message: "operations list is empty.",
@@ -2246,6 +2281,17 @@ var MemoryStore = class {
 				if (!working.some((entry) => stripDatePrefix(entry) === body)) working.push(this.addDatePrefix ? `## ${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}\n${body}` : body);
 				continue;
 			}
+			const rawAction = op.action;
+			if (rawAction !== "remove" && rawAction !== "replace") return {
+				result: {
+					ok: false,
+					message: `Operation ${position}: unknown action "${String(rawAction)}" (expected add/remove/replace). No operations were applied.${previewEntries(entries)}`,
+					entries,
+					chars: entries.join(ENTRY_DELIMITER).length,
+					limit: this.limitFor(target)
+				},
+				write: null
+			};
 			const needle = (op.old_text ?? "").trim();
 			if (!needle) return {
 				result: {
@@ -2665,24 +2711,6 @@ function redactSecrets(text) {
 	return out;
 }
 //#endregion
-//#region lib/types/serial.js
-/**
-* A process-local serial task queue: each task starts only after the previous
-* one settles (success or failure), so read-modify-write sequences that share
-* one file never interleave inside this process. The durable cross-process
-* serialization layer is the IO backend's transact lock; this chain is the
-* second layer (0.3.17 S2.8, T-1: the shape was duplicated in state-json and
-* memory-files — one factory now).
-*/
-function makeSerialQueue() {
-	let chain = Promise.resolve();
-	return (task) => {
-		const run = chain.then(task, task);
-		chain = run.then(() => void 0, () => void 0);
-		return run;
-	};
-}
-//#endregion
 //#region lib/types/skill-health.js
 /**
 * Skill structure-health domain (rc.73 A1, 008 design): a SECOND assessment
@@ -2772,6 +2800,7 @@ function observeEvent(signal, event) {
 		return;
 	}
 	if (event.type === "assistant/message") {
+		if (!Array.isArray(event.data.message.content)) return;
 		const text = event.data.message.content.map((block) => block.type === "text" ? block.text : "").join(" ");
 		signal.assistantChars += text.length;
 		return;
@@ -3339,6 +3368,12 @@ function fuzzyIndexOf(content, pattern, from = 0) {
 	}
 	return null;
 }
+/** V6-17 (0.3.37): the fuzzy-patch scan is O(n·m) with no input bound; a
+* non-exact anchor past these budgets would block the event loop (measured
+* ~6s at 20k×20k). Exact matches go through the fast `includes` path and stay
+* allowed regardless of size. */
+const FUZZY_MAX_PATTERN_CHARS = 4096;
+const FUZZY_MAX_WORK = 8e6;
 /** Trim leading whitespace of the first line and trailing whitespace of the last line. */
 function trimPatternBoundaries(pattern) {
 	const from = pattern.search(/\S/);
@@ -3483,6 +3518,10 @@ var SkillLibrary = class {
 			if (next !== null && next !== current) await this.io.writeText(path, next);
 		}
 		const o = outcome;
+		if (o === void 0 || typeof o !== "object" || !Object.prototype.hasOwnProperty.call(o, "write")) return {
+			ok: false,
+			message: "internal error: the write transaction did not invoke the task; no write was performed"
+		};
 		if (o.write !== null && o.audit) await this.audit(o.audit.skillName, o.audit.action, o.audit.before, o.audit.after, o.audit.summary);
 		if (o.write !== null && o.event) this.notifyMutation(o.event);
 		return o.result;
@@ -3875,6 +3914,13 @@ var SkillLibrary = class {
 				},
 				write: null
 			};
+			if (!md.includes(oldString) && (oldString.length > FUZZY_MAX_PATTERN_CHARS || md.length * oldString.length > FUZZY_MAX_WORK)) return {
+				result: {
+					ok: false,
+					message: `old_string too large for fuzzy match (${oldString.length} chars in ${patchLabel}); use update for a full rewrite or a narrower anchor.`
+				},
+				write: null
+			};
 			const patched = fuzzyPatch(md, oldString, newString, replaceAll);
 			if (patched === null) return {
 				result: {

package/lib/types/memory-store.d.ts

@@ -34,6 +34,12 @@ export declare class MemoryStore {
     readonly root: string;
     private readonly maxFailures;
     private readonly io;
+    /** V6-16 (0.3.37): same-process RMW serialization (the SkillLibrary queue) —
+     * on a backend WITHOUT a transact lock two concurrent callers compute on the
+     * same old content and the last rename wins, silently dropping one op's
+     * update. The node backend's cross-process lock already serializes; this
+     * chain covers the no-transact custom backends. */
+    private readonly serial;
     private failureCount;
     private lastFailureAt;
     constructor(options?: MemoryStoreOptions);
@@ -71,6 +77,7 @@ export declare class MemoryStore {
      */
     private oversizedRefusal;
     add(target: MemoryTarget, facts: string): Promise<MemoryApplyResult>;
+    private addChained;
     /**
      * Single-entry add inside the transaction: shared checks (oversized,
      * drift, threat) and the content computation. `raw` is the locked view
@@ -80,6 +87,7 @@ export declare class MemoryStore {
     /** Canonical-form drift check derived from the locked view (same formula as `detectDrift`, no second read). */
     private driftFromRaw;
     applyBatch(target: MemoryTarget, operations: MemoryOperation[]): Promise<MemoryApplyResult>;
+    private applyBatchChained;
     /** Batch RMW inside the transaction. `write: null` = failure/no-op, disk untouched. */
     private applyBatchCore;
     renderContext(): Promise<string>;

package/lib/types/skill-health.d.ts

@@ -10,8 +10,10 @@
  * `computeQualityScores` (different dimension, different consumers).
  */
 export interface SkillHealthThresholds {
-    /** Soft body limit: body chars at/below stay 'healthy' by size; above ->
-     * 'warn'; >= 2x -> 'needs-restructure'. */
+    /** Soft body limit: a body of `softBodyChars` or MORE -> 'warn'; >= 2x ->
+     * 'needs-restructure'. V6-34 (0.3.37): the doc comment used to claim
+     * "at/below stay healthy" while the engine warns at `>=` — fixed to the
+     * implementation edge (the reason copy said "above"). */
     softBodyChars: number;
     /** Stamp-density ceiling per KB of body text: rc.NN / commit shas / ISO
      * dates per KB at/above this -> 'warn' (log-like content living in the

package/lib/types/usage.d.ts

@@ -73,6 +73,10 @@ export declare function applyCuratorMetaFields(disk: UsageRecord, curated: Usage
  * by a stale snapshot; without it both pairs apply everywhere.
  */
 export declare function foldCuratorFields(disk: UsageMap, curated: UsageMap, stateOwned?: ReadonlySet<string>): void;
+/** Whole-file usage write (V6-37, 0.3.37): this is the ONE path that bypasses
+ * the malformed-defense and the transact lock — prefer `mutateUsage` for any
+ * read-modify-write so a concurrent writer cannot lose its update and a
+ * malformed sidecar stays recoverable. Kept for fixture/test seeding. */
 export declare function saveUsage(root: string, map: UsageMap, io?: EvolutionIoLike): Promise<void>;
 export declare function getRecord(map: UsageMap, name: string): UsageRecord;
 export declare function bumpView(map: UsageMap, name: string, when?: Date): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-core",
   "description": "Shared stores, prompts, signals and lifecycle logic for the dsh-evolution plugin family (community build)",
-  "version": "0.3.36",
+  "version": "0.3.37",
   "publishConfig": {
     "access": "public"
   },