dsh-daoing-memory 0.1.9 → 0.1.10

package/lib/index.js

@@ -1,7 +1,9 @@
-import { mkdirSync } from "node:fs";
+import { createRequire } from "node:module";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { createHash, randomUUID } from "node:crypto";
+import "@deepseek-ai/cordis";
 import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 //#region lib/types/store.js
 /**
@@ -12,7 +14,7 @@ import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 * @module dsh-daoing-memory/store
 */
 /** Monotone store schema version. v1→v2 is an additive ALTER migration (see open()). */
-const MEMORY_SCHEMA_VERSION = 5;
+const MEMORY_SCHEMA_VERSION = 6;
 /** Half-life (ms) of the recency weighting applied to verification samples. */
 const TRUST_HALF_LIFE_MS = 4320 * 60 * 60 * 1e3;
 /** Hash one ledger block's content, chained to the previous hash. */
@@ -182,7 +184,7 @@ var MemoryStore = class {
       );
     `);
 		const row = db.prepare("SELECT value FROM memory_meta WHERE key = ?").get("schema_version");
-		if (row === void 0) db.prepare("INSERT INTO memory_meta (key, value) VALUES (?, ?)").run("schema_version", String(5));
+		if (row === void 0) db.prepare("INSERT INTO memory_meta (key, value) VALUES (?, ?)").run("schema_version", String(6));
 		else {
 			let v = Number(row.value);
 			if (v === 1) {
@@ -201,8 +203,30 @@ var MemoryStore = class {
 				db.exec(`ALTER TABLE concerns ADD COLUMN background TEXT NOT NULL DEFAULT '';`);
 				v = 5;
 			}
-			if (v !== 5) throw new Error(`memory store schema version ${row.value} does not match 5; refusing to open`);
-			db.prepare("UPDATE memory_meta SET value = ? WHERE key = ?").run(String(5), "schema_version");
+			if (v === 5 && true) {
+				db.exec(`
+          CREATE TABLE IF NOT EXISTS skill_artifacts (
+            id TEXT PRIMARY KEY,
+            parent_experience_id TEXT NOT NULL,
+            form TEXT NOT NULL,
+            status TEXT NOT NULL,
+            draft_path TEXT,
+            published_path TEXT,
+            version INTEGER NOT NULL DEFAULT 1,
+            use_count INTEGER NOT NULL DEFAULT 0,
+            optimize_count INTEGER NOT NULL DEFAULT 0,
+            last_feedback TEXT,
+            content_hash TEXT,
+            created_at INTEGER NOT NULL,
+            updated_at INTEGER NOT NULL
+          );
+          CREATE INDEX IF NOT EXISTS idx_skill_parent ON skill_artifacts (parent_experience_id);
+          CREATE INDEX IF NOT EXISTS idx_skill_status ON skill_artifacts (status);
+        `);
+				v = 6;
+			}
+			if (v !== 6) throw new Error(`memory store schema version ${row.value} does not match 6; refusing to open`);
+			db.prepare("UPDATE memory_meta SET value = ? WHERE key = ?").run(String(6), "schema_version");
 		}
 		db.exec("CREATE INDEX IF NOT EXISTS idx_exp_context ON experiences (context);");
 		db.exec("CREATE INDEX IF NOT EXISTS idx_concern_parent ON concerns (parent_id);");
@@ -857,6 +881,60 @@ var MemoryStore = class {
 		if (row.superseded_by !== null) fact.supersededBy = row.superseded_by;
 		return fact;
 	}
+	/** Insert or update a skill artifact. */
+	upsertSkillArtifact(artifact) {
+		this.db.prepare(`
+      INSERT INTO skill_artifacts (id, parent_experience_id, form, status, draft_path, published_path,
+        version, use_count, optimize_count, last_feedback, content_hash, created_at, updated_at)
+      VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)
+      ON CONFLICT(id) DO UPDATE SET
+        status=excluded.status, draft_path=excluded.draft_path, published_path=excluded.published_path,
+        version=excluded.version, use_count=excluded.use_count, optimize_count=excluded.optimize_count,
+        last_feedback=excluded.last_feedback, content_hash=excluded.content_hash, updated_at=excluded.updated_at
+    `).run(artifact.id, artifact.parentExperienceId, artifact.form, artifact.status, artifact.draftPath ?? null, artifact.publishedPath ?? null, artifact.version, artifact.useCount, artifact.optimizeCount, artifact.lastFeedback ?? null, artifact.contentHash ?? null, artifact.createdAt, artifact.updatedAt);
+	}
+	/** Get a skill artifact by id. */
+	getSkillArtifact(id) {
+		const row = this.db.prepare("SELECT * FROM skill_artifacts WHERE id = ?").get(id);
+		return row ? this.rowToSkillArtifact(row) : void 0;
+	}
+	/** List skill artifacts, optionally filtered by parent experience or status. */
+	listSkillArtifacts(filter) {
+		const clauses = ["1 = 1"];
+		const params = [];
+		if (filter?.parentExperienceId !== void 0) {
+			clauses.push("parent_experience_id = ?");
+			params.push(filter.parentExperienceId);
+		}
+		if (filter?.status !== void 0) {
+			clauses.push("status = ?");
+			params.push(filter.status);
+		}
+		return this.db.prepare(`SELECT * FROM skill_artifacts WHERE ${clauses.join(" AND ")} ORDER BY created_at DESC`).all(...params).map((r) => this.rowToSkillArtifact(r));
+	}
+	/** Count skill artifacts by status. */
+	countSkillArtifacts(status) {
+		if (status === void 0) return this.db.prepare("SELECT COUNT(*) AS n FROM skill_artifacts").get().n;
+		return this.db.prepare("SELECT COUNT(*) AS n FROM skill_artifacts WHERE status = ?").get(status).n;
+	}
+	rowToSkillArtifact(row) {
+		const artifact = {
+			id: row.id,
+			parentExperienceId: row.parent_experience_id,
+			form: row.form,
+			status: row.status,
+			version: row.version,
+			useCount: row.use_count,
+			optimizeCount: row.optimize_count,
+			createdAt: row.created_at,
+			updatedAt: row.updated_at
+		};
+		if (row.draft_path !== null) artifact.draftPath = row.draft_path;
+		if (row.published_path !== null) artifact.publishedPath = row.published_path;
+		if (row.last_feedback !== null) artifact.lastFeedback = row.last_feedback;
+		if (row.content_hash !== null) artifact.contentHash = row.content_hash;
+		return artifact;
+	}
 };
 //#endregion
 //#region lib/types/types.js
@@ -1967,10 +2045,8 @@ var MemoryCore = class MemoryCore {
 			}, "deletion-feedback summarization");
 			return next;
 		}
-		const id = crypto.randomUUID();
 		const exp = {
-			id,
-			familyId: id,
+			id: crypto.randomUUID(),
 			revision: 1,
 			kind: "positive",
 			source: "system",
@@ -1989,6 +2065,9 @@ var MemoryCore = class MemoryCore {
 			status: "live",
 			alpha: 5,
 			beta: 2,
+			samples: 7,
+			trust: 6 / 9,
+			weightedTrust: 6 / 9,
 			pinned: false,
 			tokensSaved: 0,
 			tokensSpent: 0,
@@ -2014,6 +2093,110 @@ var MemoryCore = class MemoryCore {
 	getDeletionFeedback() {
 		return this.store.findExperienceByFamily(MemoryCore.DELETION_FEEDBACK_FAMILY);
 	}
+	/**
+	* Create a skill artifact draft from LLM-generated content.
+	* @param experienceId - parent experience family_id.
+	* @param form - output form (skill_md or script_mjs).
+	* @param content - the LLM-generated skill/script content.
+	* @param draftPath - file path where the draft is saved.
+	* @param actor - who triggered the generation.
+	* @returns the created skill artifact.
+	*/
+	createSkillDraft(experienceId, form, content, draftPath, actor) {
+		const experience = this.store.getActiveRevision(experienceId);
+		if (experience === void 0) throw new Error(`memory: experience not found: ${experienceId}`);
+		const now = Date.now();
+		const id = crypto.randomUUID();
+		const artifact = {
+			id,
+			parentExperienceId: experienceId,
+			form,
+			status: "draft",
+			draftPath,
+			version: 1,
+			useCount: 0,
+			optimizeCount: 0,
+			contentHash: createHash("sha256").update(content).digest("hex"),
+			createdAt: now,
+			updatedAt: now
+		};
+		this.store.upsertSkillArtifact(artifact);
+		this.ledger("skill-draft", "experience", experienceId, actor, {
+			skillId: id,
+			form,
+			gist: experience.gist.slice(0, 80)
+		}, `skill draft generated from experience`);
+		return artifact;
+	}
+	/**
+	* Review a skill artifact: approve or reject.
+	*/
+	reviewSkill(request, actor) {
+		const artifact = this.store.getSkillArtifact(request.id);
+		if (artifact === void 0) throw new Error(`memory: skill artifact not found: ${request.id}`);
+		if (artifact.status !== "draft" && artifact.status !== "pending_review" && artifact.status !== "revising") throw new Error(`memory: skill artifact ${request.id} is in status "${artifact.status}", cannot review`);
+		const now = Date.now();
+		const updated = {
+			...artifact,
+			status: request.decision === "approve" ? "approved" : "rejected",
+			lastFeedback: JSON.stringify({
+				decision: request.decision,
+				reason: request.reason,
+				ts: now
+			}),
+			updatedAt: now
+		};
+		this.store.upsertSkillArtifact(updated);
+		this.ledger(request.decision === "approve" ? "skill-approve" : "skill-reject", "experience", artifact.parentExperienceId, actor, {
+			skillId: request.id,
+			form: artifact.form,
+			version: artifact.version
+		}, request.reason);
+		return updated;
+	}
+	/**
+	* Publish a skill artifact: copy draft to $DSH_HOME/skills/ and mark as published.
+	* The actual file copy is done by the service layer; this method updates the DB record.
+	*/
+	publishSkill(request, publishedPath, actor) {
+		const artifact = this.store.getSkillArtifact(request.id);
+		if (artifact === void 0) throw new Error(`memory: skill artifact not found: ${request.id}`);
+		if (artifact.status !== "approved") throw new Error(`memory: skill artifact ${request.id} must be approved before publishing (current: ${artifact.status})`);
+		const now = Date.now();
+		const updated = {
+			...artifact,
+			status: "published",
+			publishedPath,
+			updatedAt: now
+		};
+		this.store.upsertSkillArtifact(updated);
+		this.ledger("skill-publish", "experience", artifact.parentExperienceId, actor, {
+			skillId: request.id,
+			form: artifact.form,
+			publishedPath
+		}, request.reason);
+		return updated;
+	}
+	/** List skill artifacts, optionally filtered. */
+	listSkillArtifacts(filter) {
+		return this.store.listSkillArtifacts(filter);
+	}
+	/** Get a single skill artifact. */
+	getSkillArtifact(id) {
+		return this.store.getSkillArtifact(id);
+	}
+	/**
+	* Check if an experience is a candidate for skill conversion.
+	* Criteria: live status, enough recall events, complex path (≥3 steps).
+	*/
+	isSkillCandidate(experienceId) {
+		const exp = this.store.getActiveRevision(experienceId);
+		if (exp === void 0 || exp.status !== "live") return false;
+		if (exp.path.length < 3) return false;
+		if (exp.verifiedCount < 2) return false;
+		if (this.store.listSkillArtifacts({ parentExperienceId: experienceId }).some((a) => a.status === "published" || a.status === "approved" || a.status === "pending_review")) return false;
+		return true;
+	}
 	/** Human pin/unpin: pinned cards keep the trust floor and escape budgets. */
 	humanPin(request, actor) {
 		const current = this.store.getActiveRevision(request.id);
@@ -2403,6 +2586,955 @@ var MemoryCore = class MemoryCore {
 	}
 };
 //#endregion
+//#region ../../llm/llm/src/brand.ts
+/**
+* Brand a message identifier.
+* @param id - the opaque message identifier.
+* @returns the same string, branded; no validation is performed.
+*/
+function MessageId(id) {
+	return id;
+}
+//#endregion
+//#region ../../llm/llm/src/call-config.ts
+/**
+* Deep-freeze a value in place with an iterative traversal, guarding cycles,
+* so later mutation throws without imposing a JavaScript call-stack depth cap.
+* {@link AbortSignal} objects are deliberately skipped because they are the
+* request's live cancellation channel and freezing them breaks abort.
+* @param value - the value to freeze in place.
+* @returns the same value, frozen.
+*/
+function deepFreeze(value) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	const pending = [{
+		kind: "visit",
+		node: value
+	}];
+	while (pending.length > 0) {
+		const task = pending.pop();
+		/* v8 ignore next -- the loop condition guarantees one pending task. */
+		if (task === void 0) continue;
+		if (task.kind === "property") {
+			pending.push({
+				kind: "visit",
+				node: task.source[task.key]
+			});
+			continue;
+		}
+		const node = task.node;
+		if (node === null || typeof node !== "object") continue;
+		if (node instanceof AbortSignal) continue;
+		if (seen.has(node)) continue;
+		seen.add(node);
+		Object.freeze(node);
+		const keys = Object.keys(node);
+		for (let index = keys.length - 1; index >= 0; index--) {
+			const key = keys[index];
+			/* v8 ignore next -- the loop is bounded by the captured key count. */
+			if (key === void 0) continue;
+			pending.push({
+				kind: "property",
+				source: node,
+				key
+			});
+		}
+	}
+	return value;
+}
+//#endregion
+//#region ../../llm/llm/src/message.ts
+/** Message value types, identity, and immutable construction helpers. */
+/**
+* Detach and deep-freeze a message whose identity already exists.
+* @param message - complete message, including its stable identity.
+* @returns an immutable snapshot that preserves the identity.
+*/
+function freezeMessage(message) {
+	return deepFreeze(structuredClone(message));
+}
+/**
+* Create one identified message and freeze it before publication.
+* @param input - complete role, content, and source for a new message.
+* @returns an immutable message with a fresh stable identity.
+*/
+function createMessage(input) {
+	return freezeMessage({
+		...input,
+		id: MessageId(crypto.randomUUID())
+	});
+}
+/**
+* Create one identified user-role message and freeze it before publication.
+* @param input - complete content and source for a new user message.
+* @returns an immutable user message with a fresh stable identity.
+*/
+function createUserMessage(input) {
+	return createMessage({
+		...input,
+		role: "user"
+	});
+}
+//#endregion
+//#region ../../../vendor/cosmokit/src/misc.ts
+/** Return true when a value is `null` or `undefined`. */
+function isNullable(value) {
+	return value === null || value === void 0;
+}
+/** Return true for non-array object values. */
+function isPlainObject(data) {
+	return data && typeof data === "object" && !Array.isArray(data);
+}
+/** Filter object entries and return a new object. */
+function filterKeys(object, filter) {
+	return Object.fromEntries(Object.entries(object).filter(([key, value]) => filter(key, value)));
+}
+/** Map object values while preserving the original key set. */
+function mapValues(object, transform) {
+	return Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transform(value, key)]));
+}
+/** Pick selected keys from an object, optionally including `undefined` values. */
+function pick(source, keys, forced) {
+	if (!keys) return { ...source };
+	const result = {};
+	for (const key of keys) if (forced || source[key] !== void 0) result[key] = source[key];
+	return result;
+}
+//#endregion
+//#region ../../../vendor/cosmokit/src/types.ts
+/** Test values using `instanceof` with a `toStringTag` fallback. */
+function is(type, value) {
+	if (arguments.length === 1) return (value) => is(type, value);
+	return type in globalThis && value instanceof globalThis[type] || Object.prototype.toString.call(value).slice(8, -1) === type;
+}
+function isArrayBufferLike(value) {
+	return is("ArrayBuffer", value) || is("SharedArrayBuffer", value);
+}
+function isArrayBufferSource(value) {
+	return isArrayBufferLike(value) || ArrayBuffer.isView(value);
+}
+let Binary;
+(function(_Binary) {
+	_Binary.is = isArrayBufferLike;
+	_Binary.isSource = isArrayBufferSource;
+	function fromSource(source) {
+		if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+		else return source;
+	}
+	_Binary.fromSource = fromSource;
+	function toBase64(source) {
+		source = fromSource(source);
+		if (typeof Buffer !== "undefined") return Buffer.from(source).toString("base64");
+		let binary = "";
+		const bytes = new Uint8Array(source);
+		for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
+		return btoa(binary);
+	}
+	_Binary.toBase64 = toBase64;
+	function fromBase64(source) {
+		if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "base64"));
+		return Uint8Array.from(atob(source), (c) => c.charCodeAt(0));
+	}
+	_Binary.fromBase64 = fromBase64;
+	function toHex(source) {
+		source = fromSource(source);
+		if (typeof Buffer !== "undefined") return Buffer.from(source).toString("hex");
+		return Array.from(new Uint8Array(source), (byte) => byte.toString(16).padStart(2, "0")).join("");
+	}
+	_Binary.toHex = toHex;
+	function fromHex(source) {
+		if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "hex"));
+		const hex = source.length % 2 === 0 ? source : source.slice(0, source.length - 1);
+		const buffer = [];
+		for (let i = 0; i < hex.length; i += 2) buffer.push(parseInt(`${hex[i]}${hex[i + 1]}`, 16));
+		return Uint8Array.from(buffer).buffer;
+	}
+	_Binary.fromHex = fromHex;
+})(Binary || (Binary = {}));
+Binary.fromBase64;
+Binary.toBase64;
+Binary.fromHex;
+Binary.toHex;
+/** Deep-clone common JavaScript values while preserving prototypes and cycles. */
+function clone(source, refs = /* @__PURE__ */ new Map()) {
+	if (!source || typeof source !== "object") return source;
+	if (is("Date", source)) return new Date(source.valueOf());
+	if (is("RegExp", source)) return new RegExp(source.source, source.flags);
+	if (isArrayBufferLike(source)) return source.slice(0);
+	if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+	const cached = refs.get(source);
+	if (cached) return cached;
+	if (Array.isArray(source)) {
+		const result = [];
+		refs.set(source, result);
+		source.forEach((value, index) => {
+			result[index] = Reflect.apply(clone, null, [value, refs]);
+		});
+		return result;
+	}
+	const result = Object.create(Object.getPrototypeOf(source));
+	refs.set(source, result);
+	for (const key of Reflect.ownKeys(source)) {
+		const descriptor = { ...Reflect.getOwnPropertyDescriptor(source, key) };
+		if ("value" in descriptor) descriptor.value = Reflect.apply(clone, null, [descriptor.value, refs]);
+		Reflect.defineProperty(result, key, descriptor);
+	}
+	return result;
+}
+/** Deeply compare arrays, dates, regexps, buffers, and plain object fields. */
+function deepEqual(a, b, strict) {
+	if (a === b) return true;
+	if (!strict && isNullable(a) && isNullable(b)) return true;
+	if (typeof a !== typeof b) return false;
+	if (typeof a !== "object") return false;
+	if (!a || !b) return false;
+	function check(test, then) {
+		return test(a) ? test(b) ? then(a, b) : false : test(b) ? false : void 0;
+	}
+	return check(Array.isArray, (a, b) => a.length === b.length && a.every((item, index) => deepEqual(item, b[index]))) ?? check(is("Date"), (a, b) => a.valueOf() === b.valueOf()) ?? check(is("RegExp"), (a, b) => a.source === b.source && a.flags === b.flags) ?? check(isArrayBufferLike, (a, b) => {
+		if (a.byteLength !== b.byteLength) return false;
+		const viewA = new Uint8Array(a);
+		const viewB = new Uint8Array(b);
+		for (let i = 0; i < viewA.length; i++) if (viewA[i] !== viewB[i]) return false;
+		return true;
+	}) ?? Object.keys({
+		...a,
+		...b
+	}).every((key) => deepEqual(a[key], b[key], strict));
+}
+//#endregion
+//#region ../../../vendor/cosmokit/src/time.ts
+let Time;
+(function(_Time) {
+	_Time.millisecond = 1;
+	const second = _Time.second = 1e3;
+	const minute = _Time.minute = second * 60;
+	const hour = _Time.hour = minute * 60;
+	const day = _Time.day = hour * 24;
+	const week = _Time.week = day * 7;
+	let timezoneOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+	function setTimezoneOffset(offset) {
+		timezoneOffset = offset;
+	}
+	_Time.setTimezoneOffset = setTimezoneOffset;
+	function getTimezoneOffset() {
+		return timezoneOffset;
+	}
+	_Time.getTimezoneOffset = getTimezoneOffset;
+	function getDateNumber(date = /* @__PURE__ */ new Date(), offset) {
+		if (typeof date === "number") date = new Date(date);
+		if (offset === void 0) offset = timezoneOffset;
+		return Math.floor((date.valueOf() / minute - offset) / 1440);
+	}
+	_Time.getDateNumber = getDateNumber;
+	function fromDateNumber(value, offset) {
+		const date = new Date(value * day);
+		if (offset === void 0) offset = timezoneOffset;
+		return new Date(+date + offset * minute);
+	}
+	_Time.fromDateNumber = fromDateNumber;
+	const numeric = /\d+(?:\.\d+)?/.source;
+	const timeRegExp = new RegExp(`^${[
+		"w(?:eek(?:s)?)?",
+		"d(?:ay(?:s)?)?",
+		"h(?:our(?:s)?)?",
+		"m(?:in(?:ute)?(?:s)?)?",
+		"s(?:ec(?:ond)?(?:s)?)?"
+	].map((unit) => `(${numeric}${unit})?`).join("")}$`);
+	function parseTime(source) {
+		const capture = timeRegExp.exec(source);
+		if (!capture) return 0;
+		return (parseFloat(capture[1]) * week || 0) + (parseFloat(capture[2]) * day || 0) + (parseFloat(capture[3]) * hour || 0) + (parseFloat(capture[4]) * minute || 0) + (parseFloat(capture[5]) * second || 0);
+	}
+	_Time.parseTime = parseTime;
+	function parseDate(date) {
+		const parsed = parseTime(date);
+		if (parsed) date = Date.now() + parsed;
+		else if (/^\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).toLocaleDateString()}-${date}`;
+		else if (/^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).getFullYear()}-${date}`;
+		return date ? new Date(date) : /* @__PURE__ */ new Date();
+	}
+	_Time.parseDate = parseDate;
+	function format(ms) {
+		const abs = Math.abs(ms);
+		if (abs >= day - hour / 2) return Math.round(ms / day) + "d";
+		else if (abs >= hour - minute / 2) return Math.round(ms / hour) + "h";
+		else if (abs >= minute - second / 2) return Math.round(ms / minute) + "m";
+		else if (abs >= second) return Math.round(ms / second) + "s";
+		return ms + "ms";
+	}
+	_Time.format = format;
+	function toDigits(source, length = 2) {
+		return source.toString().padStart(length, "0");
+	}
+	_Time.toDigits = toDigits;
+	function template(template, time = /* @__PURE__ */ new Date()) {
+		return template.replace("yyyy", time.getFullYear().toString()).replace("yy", time.getFullYear().toString().slice(2)).replace("MM", toDigits(time.getMonth() + 1)).replace("dd", toDigits(time.getDate())).replace("hh", toDigits(time.getHours())).replace("mm", toDigits(time.getMinutes())).replace("ss", toDigits(time.getSeconds())).replace("SSS", toDigits(time.getMilliseconds(), 3));
+	}
+	_Time.template = template;
+})(Time || (Time = {}));
+//#endregion
+//#region ../../../vendor/schemastery/src/index.ts
+const kSchema = Symbol.for("schemastery");
+const kValidationError = Symbol.for("ValidationError");
+globalThis.__schemastery_index__ ??= 0;
+globalThis.__schemastery_refs__ = void 0;
+var ValidationError = class extends TypeError {
+	options;
+	name = "ValidationError";
+	constructor(message, options) {
+		let prefix = "$";
+		for (const segment of options.path || []) if (typeof segment === "string") prefix += "." + segment;
+		else if (typeof segment === "number") prefix += "[" + segment + "]";
+		else if (typeof segment === "symbol") prefix += `[Symbol(${segment.toString()})]`;
+		if (prefix.startsWith(".")) prefix = prefix.slice(1);
+		super((prefix === "$" ? "" : `${prefix} `) + message);
+		this.options = options;
+	}
+	static is(error) {
+		return !!error?.[kValidationError];
+	}
+};
+Object.defineProperty(ValidationError.prototype, kValidationError, { value: true });
+const Schema = function(options) {
+	const schema = function(data, options = {}) {
+		return Schema.resolve(data, schema, options)[0];
+	};
+	if (options.refs) {
+		const refs = mapValues(options.refs, (options) => new Schema(options));
+		const getRef = (uid) => refs[uid];
+		for (const key in refs) {
+			const options = refs[key];
+			options.sKey = getRef(options.sKey);
+			options.inner = getRef(options.inner);
+			options.list = options.list && options.list.map(getRef);
+			options.dict = options.dict && mapValues(options.dict, getRef);
+		}
+		return refs[options.uid];
+	}
+	Object.assign(schema, options);
+	if (typeof schema.callback === "string") try {
+		schema.callback = new Function("return " + schema.callback)();
+	} catch {}
+	Object.defineProperty(schema, "uid", { value: globalThis.__schemastery_index__++ });
+	Object.setPrototypeOf(schema, Schema.prototype);
+	schema.meta ||= {};
+	schema.toString = schema.toString.bind(schema);
+	return schema;
+};
+Schema.prototype = Object.create(Function.prototype);
+Schema.prototype[kSchema] = true;
+Object.defineProperty(Schema.prototype, "~standard", { get() {
+	return {
+		version: 1,
+		vendor: "schemastery",
+		validate: (value) => {
+			try {
+				return { value: Schema.resolve(value, this, {})[0] };
+			} catch (error) {
+				if (ValidationError.is(error)) return { issues: [{
+					message: error.message,
+					path: error.options.path
+				}] };
+				throw error;
+			}
+		}
+	};
+} });
+Schema.ValidationError = ValidationError;
+Schema.prototype.toJSON = function toJSON() {
+	if (globalThis.__schemastery_refs__) {
+		globalThis.__schemastery_refs__[this.uid] ??= JSON.parse(JSON.stringify({ ...this }));
+		return this.uid;
+	}
+	globalThis.__schemastery_refs__ = { [this.uid]: { ...this } };
+	globalThis.__schemastery_refs__[this.uid] = JSON.parse(JSON.stringify({ ...this }));
+	const result = {
+		uid: this.uid,
+		refs: globalThis.__schemastery_refs__
+	};
+	globalThis.__schemastery_refs__ = void 0;
+	return result;
+};
+Schema.prototype.set = function set(key, value) {
+	this.dict[key] = value;
+	return this;
+};
+Schema.prototype.push = function push(value) {
+	this.list.push(value);
+	return this;
+};
+function mergeDesc(original, messages) {
+	const result = typeof original === "string" ? { "": original } : { ...original };
+	for (const locale in messages) {
+		const value = messages[locale];
+		if (value?.$description || value?.$desc) result[locale] = value.$description || value.$desc;
+		else if (typeof value === "string") result[locale] = value;
+	}
+	return result;
+}
+function getInner(value) {
+	return value?.$value ?? value?.$inner;
+}
+function extractKeys(data) {
+	return filterKeys(data ?? {}, (key) => !key.startsWith("$"));
+}
+Schema.prototype.i18n = function i18n(messages) {
+	const schema = Schema(this);
+	const desc = mergeDesc(schema.meta.description, messages);
+	if (Object.keys(desc).length) schema.meta.description = desc;
+	if (schema.dict) schema.dict = mapValues(schema.dict, (inner, key) => {
+		return inner.i18n(mapValues(messages, (data) => getInner(data)?.[key] ?? data?.[key]));
+	});
+	if (schema.list) schema.list = schema.list.map((inner, index) => {
+		return inner.i18n(mapValues(messages, (data = {}) => {
+			if (Array.isArray(getInner(data))) return getInner(data)[index];
+			if (Array.isArray(data)) return data[index];
+			return extractKeys(data);
+		}));
+	});
+	if (schema.inner) schema.inner = schema.inner.i18n(mapValues(messages, (data) => {
+		if (getInner(data)) return getInner(data);
+		return extractKeys(data);
+	}));
+	if (schema.sKey) schema.sKey = schema.sKey.i18n(mapValues(messages, (data) => data?.$key));
+	return schema;
+};
+Schema.prototype.extra = function extra(key, value) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+};
+for (const key of [
+	"required",
+	"disabled",
+	"collapse",
+	"hidden",
+	"loose"
+]) Object.assign(Schema.prototype, { [key](value = true) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+} });
+Schema.prototype.deprecated = function deprecated() {
+	const schema = Schema(this);
+	schema.meta.badges ||= [];
+	schema.meta.badges.push({
+		text: "deprecated",
+		type: "danger"
+	});
+	return schema;
+};
+Schema.prototype.experimental = function experimental() {
+	const schema = Schema(this);
+	schema.meta.badges ||= [];
+	schema.meta.badges.push({
+		text: "experimental",
+		type: "warning"
+	});
+	return schema;
+};
+Schema.prototype.pattern = function pattern(regexp) {
+	const schema = Schema(this);
+	const pattern = pick(regexp, ["source", "flags"]);
+	schema.meta = {
+		...schema.meta,
+		pattern
+	};
+	return schema;
+};
+Schema.prototype.simplify = function simplify(value) {
+	if (deepEqual(value, this.meta.default, this.type === "dict")) return null;
+	if (isNullable(value)) return value;
+	if (this.type === "object" || this.type === "dict") {
+		const result = {};
+		for (const key in value) {
+			const item = (this.type === "object" ? this.dict[key] : this.inner)?.simplify(value[key]);
+			if (this.type === "dict" || !isNullable(item)) result[key] = item;
+		}
+		if (deepEqual(result, this.meta.default, this.type === "dict")) return null;
+		return result;
+	} else if (this.type === "array" || this.type === "tuple") {
+		const result = [];
+		value.forEach((value, index) => {
+			const schema = this.type === "array" ? this.inner : this.list[index];
+			const item = schema ? schema.simplify(value) : value;
+			result.push(item);
+		});
+		return result;
+	} else if (this.type === "intersect") {
+		const result = {};
+		for (const item of this.list) Object.assign(result, item.simplify(value));
+		return result;
+	} else if (this.type === "union") for (const schema of this.list) try {
+		Schema.resolve(value, schema, {});
+		return schema.simplify(value);
+	} catch {}
+	return value;
+};
+Schema.prototype.toString = function toString(inline) {
+	return formatters[this.type]?.(this, inline) ?? `Schema<${this.type}>`;
+};
+Schema.prototype.role = function role(role, extra) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		role,
+		extra
+	};
+	return schema;
+};
+for (const key of [
+	"default",
+	"link",
+	"comment",
+	"description",
+	"max",
+	"min",
+	"step"
+]) Object.assign(Schema.prototype, { [key](value) {
+	const schema = Schema(this);
+	schema.meta = {
+		...schema.meta,
+		[key]: value
+	};
+	return schema;
+} });
+const resolvers = {};
+Schema.extend = function extend(type, resolve) {
+	resolvers[type] = resolve;
+};
+Schema.resolve = function resolve(data, schema, options = {}, strict = false) {
+	if (!schema) return [data];
+	if (options.ignore?.(data, schema)) return [data];
+	if (isNullable(data) && schema.type !== "lazy") {
+		if (schema.meta.required) throw new ValidationError(`missing required value`, options);
+		let current = schema;
+		let fallback = schema.meta.default;
+		while (current?.type === "intersect" && isNullable(fallback)) {
+			current = current.list[0];
+			fallback = current?.meta.default;
+		}
+		if (isNullable(fallback)) return [data];
+		data = clone(fallback);
+	}
+	const callback = resolvers[schema.type];
+	if (!callback) throw new ValidationError(`unsupported type "${schema.type}"`, options);
+	try {
+		return callback(data, schema, options, strict);
+	} catch (error) {
+		if (!schema.meta.loose) throw error;
+		return [schema.meta.default];
+	}
+};
+Schema.from = function from(source) {
+	if (isNullable(source)) return Schema.any();
+	else if ([
+		"string",
+		"number",
+		"boolean"
+	].includes(typeof source)) return Schema.const(source).required();
+	else if (source[kSchema]) return source;
+	else if (typeof source === "function") switch (source) {
+		case String: return Schema.string().required();
+		case Number: return Schema.number().required();
+		case Boolean: return Schema.boolean().required();
+		case Function: return Schema.function().required();
+		default: return Schema.is(source).required();
+	}
+	else throw new TypeError(`cannot infer schema from ${source}`);
+};
+Schema.lazy = function lazy(builder) {
+	const toJSON = () => {
+		if (!schema.inner[kSchema]) {
+			schema.inner = schema.builder();
+			schema.inner.meta = {
+				...schema.meta,
+				...schema.inner.meta
+			};
+		}
+		return schema.inner.toJSON();
+	};
+	const schema = new Schema({
+		type: "lazy",
+		builder,
+		inner: { toJSON }
+	});
+	return schema;
+};
+Schema.natural = function natural() {
+	return Schema.number().step(1).min(0);
+};
+Schema.percent = function percent() {
+	return Schema.number().step(.01).min(0).max(1).role("slider");
+};
+Schema.date = function date() {
+	return Schema.union([Schema.is(Date), Schema.transform(Schema.string().role("datetime"), (value, options) => {
+		const date = new Date(value);
+		if (isNaN(+date)) throw new ValidationError(`invalid date "${value}"`, options);
+		return date;
+	}, true)]);
+};
+Schema.regExp = function regExp(flag = "") {
+	return Schema.union([Schema.is(RegExp), Schema.transform(Schema.string().role("regexp", { flag }), (value, options) => {
+		try {
+			return new RegExp(value, flag);
+		} catch (e) {
+			throw new ValidationError(e.message, options);
+		}
+	}, true)]);
+};
+Schema.arrayBuffer = function arrayBuffer(encoding) {
+	return Schema.union([
+		Schema.is(ArrayBuffer),
+		Schema.is(SharedArrayBuffer),
+		Schema.transform(Schema.any(), (value, options) => {
+			if (Binary.isSource(value)) return Binary.fromSource(value);
+			throw new ValidationError(`expected ArrayBufferSource but got ${value}`, options);
+		}, true),
+		...encoding ? [Schema.transform(Schema.string(), (value, options) => {
+			try {
+				return encoding === "base64" ? Binary.fromBase64(value) : Binary.fromHex(value);
+			} catch (e) {
+				throw new ValidationError(e.message, options);
+			}
+		}, true)] : []
+	]);
+};
+Schema.extend("lazy", (data, schema, options, strict) => {
+	if (!schema.inner[kSchema]) {
+		schema.inner = schema.builder();
+		schema.inner.meta = {
+			...schema.meta,
+			...schema.inner.meta
+		};
+	}
+	return Schema.resolve(data, schema.inner, options, strict);
+});
+Schema.extend("any", (data) => {
+	return [data];
+});
+Schema.extend("never", (data, _, options) => {
+	throw new ValidationError(`expected nullable but got ${data}`, options);
+});
+Schema.extend("const", (data, { value }, options) => {
+	if (deepEqual(data, value)) return [value];
+	throw new ValidationError(`expected ${value} but got ${data}`, options);
+});
+function checkWithinRange(data, meta, description, options, skipMin = false) {
+	const { max = Infinity, min = -Infinity } = meta;
+	if (data > max) throw new ValidationError(`expected ${description} <= ${max} but got ${data}`, options);
+	if (data < min && !skipMin) throw new ValidationError(`expected ${description} >= ${min} but got ${data}`, options);
+}
+Schema.extend("string", (data, { meta }, options) => {
+	if (typeof data !== "string") throw new ValidationError(`expected string but got ${data}`, options);
+	if (meta.pattern) {
+		const regexp = new RegExp(meta.pattern.source, meta.pattern.flags);
+		if (!regexp.test(data)) throw new ValidationError(`expect string to match regexp ${regexp}`, options);
+	}
+	checkWithinRange(data.length, meta, "string length", options);
+	return [data];
+});
+function decimalShift(data, digits) {
+	const str = data.toString();
+	if (str.includes("e")) return data * Math.pow(10, digits);
+	const index = str.indexOf(".");
+	if (index === -1) return data * Math.pow(10, digits);
+	const frac = str.slice(index + 1);
+	const integer = str.slice(0, index);
+	if (frac.length <= digits) return +(integer + frac.padEnd(digits, "0"));
+	return +(integer + frac.slice(0, digits) + "." + frac.slice(digits));
+}
+function isMultipleOf(data, min, step) {
+	step = Math.abs(step);
+	if (!/^\d+\.\d+$/.test(step.toString())) return (data - min) % step === 0;
+	const index = step.toString().indexOf(".");
+	const digits = step.toString().slice(index + 1).length;
+	return Math.abs(decimalShift(data, digits) - decimalShift(min, digits)) % decimalShift(step, digits) === 0;
+}
+Schema.extend("number", (data, { meta }, options) => {
+	if (typeof data !== "number") throw new ValidationError(`expected number but got ${data}`, options);
+	checkWithinRange(data, meta, "number", options);
+	const { step } = meta;
+	if (step && !isMultipleOf(data, meta.min ?? 0, step)) throw new ValidationError(`expected number multiple of ${step} but got ${data}`, options);
+	return [data];
+});
+Schema.extend("boolean", (data, _, options) => {
+	if (typeof data === "boolean") return [data];
+	throw new ValidationError(`expected boolean but got ${data}`, options);
+});
+Schema.extend("bitset", (data, { bits, meta }, options) => {
+	let value = 0, keys = [];
+	if (typeof data === "number") {
+		value = data;
+		for (const key in bits) if (data & bits[key]) keys.push(key);
+	} else if (Array.isArray(data)) {
+		keys = data;
+		for (const key of keys) {
+			if (typeof key !== "string") throw new ValidationError(`expected string but got ${key}`, options);
+			if (key in bits) value |= bits[key];
+		}
+	} else throw new ValidationError(`expected number or array but got ${data}`, options);
+	if (value === meta.default) return [value];
+	return [value, keys];
+});
+Schema.extend("function", (data, _, options) => {
+	if (typeof data === "function") return [data];
+	throw new ValidationError(`expected function but got ${data}`, options);
+});
+Schema.extend("is", (data, { constructor }, options) => {
+	if (typeof constructor === "function") {
+		if (data instanceof constructor) return [data];
+		throw new ValidationError(`expected ${constructor.name} but got ${data}`, options);
+	} else {
+		if (isNullable(data)) throw new ValidationError(`expected ${constructor} but got ${data}`, options);
+		let prototype = Object.getPrototypeOf(data);
+		while (prototype) {
+			if (prototype.constructor?.name === constructor) return [data];
+			prototype = Object.getPrototypeOf(prototype);
+		}
+		throw new ValidationError(`expected ${constructor} but got ${data}`, options);
+	}
+});
+function property(data, key, schema, options) {
+	try {
+		const [value, adapted] = Schema.resolve(data[key], schema, {
+			...options,
+			path: [...options.path || [], key]
+		});
+		if (adapted !== void 0) data[key] = adapted;
+		return value;
+	} catch (e) {
+		if (!options?.autofix) throw e;
+		delete data[key];
+		return schema.meta.default;
+	}
+}
+Schema.extend("array", (data, { inner, meta }, options) => {
+	if (!Array.isArray(data)) throw new ValidationError(`expected array but got ${data}`, options);
+	checkWithinRange(data.length, meta, "array length", options, !isNullable(inner.meta.default));
+	return [data.map((_, index) => property(data, index, inner, options))];
+});
+Schema.extend("dict", (data, { inner, sKey }, options, strict) => {
+	if (!isPlainObject(data)) throw new ValidationError(`expected object but got ${data}`, options);
+	const result = {};
+	for (const key in data) {
+		let rKey;
+		try {
+			rKey = Schema.resolve(key, sKey, options)[0];
+		} catch (error) {
+			if (strict) continue;
+			throw error;
+		}
+		result[rKey] = property(data, key, inner, options);
+		data[rKey] = data[key];
+		if (key !== rKey) delete data[key];
+	}
+	return [result];
+});
+Schema.extend("tuple", (data, { list }, options, strict) => {
+	if (!Array.isArray(data)) throw new ValidationError(`expected array but got ${data}`, options);
+	const result = list.map((inner, index) => property(data, index, inner, options));
+	if (strict) return [result];
+	result.push(...data.slice(list.length));
+	return [result];
+});
+function merge(result, data) {
+	for (const key in data) {
+		if (key in result) continue;
+		result[key] = data[key];
+	}
+}
+Schema.extend("object", (data, { dict }, options, strict) => {
+	if (!isPlainObject(data)) throw new ValidationError(`expected object but got ${data}`, options);
+	const result = {};
+	for (const key in dict) {
+		const value = property(data, key, dict[key], options);
+		if (!isNullable(value) || key in data) result[key] = value;
+	}
+	if (!strict) merge(result, data);
+	return [result];
+});
+Schema.extend("union", (data, { list, toString }, options, strict) => {
+	const messages = [];
+	for (const inner of list) try {
+		return Schema.resolve(data, inner, options, strict);
+	} catch (error) {
+		messages.push(error);
+	}
+	throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+});
+Schema.extend("intersect", (data, { list, toString }, options, strict) => {
+	if (!list.length) return [data];
+	let result;
+	for (const inner of list) {
+		const value = Schema.resolve(data, inner, options, true)[0];
+		if (isNullable(value)) continue;
+		if (isNullable(result)) result = value;
+		else if (typeof result !== typeof value) throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+		else if (typeof value === "object") merge(result ??= {}, value);
+		else if (result !== value) throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+	}
+	if (!strict && isPlainObject(data)) merge(result, data);
+	return [result];
+});
+Schema.extend("transform", (data, { inner, callback, preserve }, options) => {
+	const [result, adapted = data] = Schema.resolve(data, inner, options, true);
+	if (preserve) return [callback(result)];
+	else return [callback(result), callback(adapted)];
+});
+const formatters = {};
+function defineMethod(name, keys, format) {
+	formatters[name] = format;
+	Object.assign(Schema, { [name](...args) {
+		const schema = new Schema({ type: name });
+		keys.forEach((key, index) => {
+			switch (key) {
+				case "sKey":
+					schema.sKey = args[index] ?? Schema.string();
+					break;
+				case "inner":
+					schema.inner = Schema.from(args[index]);
+					break;
+				case "list":
+					schema.list = args[index].map(Schema.from);
+					break;
+				case "dict":
+					schema.dict = mapValues(args[index], Schema.from);
+					break;
+				case "bits":
+					schema.bits = {};
+					for (const key in args[index]) {
+						if (typeof args[index][key] !== "number") continue;
+						schema.bits[key] = args[index][key];
+					}
+					break;
+				case "callback": {
+					const callback = schema.callback = args[index];
+					callback["toJSON"] ||= () => callback.toString();
+					break;
+				}
+				case "constructor": {
+					const constructor = schema.constructor = args[index];
+					if (typeof constructor === "function") constructor["toJSON"] ||= () => constructor["name"];
+					break;
+				}
+				default: schema[key] = args[index];
+			}
+		});
+		if (name === "object" || name === "dict") schema.meta.default = {};
+		else if (name === "array" || name === "tuple") schema.meta.default = [];
+		else if (name === "bitset") schema.meta.default = 0;
+		return schema;
+	} });
+}
+defineMethod("is", ["constructor"], ({ constructor }) => {
+	if (typeof constructor === "function") return constructor.name;
+	else return constructor;
+});
+defineMethod("any", [], () => "any");
+defineMethod("never", [], () => "never");
+defineMethod("const", ["value"], ({ value }) => typeof value === "string" ? JSON.stringify(value) : value);
+defineMethod("string", [], () => "string");
+defineMethod("number", [], () => "number");
+defineMethod("boolean", [], () => "boolean");
+defineMethod("bitset", ["bits"], () => "bitset");
+defineMethod("function", [], () => "function");
+defineMethod("array", ["inner"], ({ inner }) => `${inner.toString(true)}[]`);
+defineMethod("dict", ["inner", "sKey"], ({ inner, sKey }) => `{ [key: ${sKey.toString()}]: ${inner.toString()} }`);
+defineMethod("tuple", ["list"], ({ list }) => `[${list.map((inner) => inner.toString()).join(", ")}]`);
+defineMethod("object", ["dict"], ({ dict }) => {
+	if (Object.keys(dict).length === 0) return "{}";
+	return `{ ${Object.entries(dict).map(([key, inner]) => {
+		return `${key}${inner.meta.required ? "" : "?"}: ${inner.toString()}`;
+	}).join(", ")} }`;
+});
+defineMethod("union", ["list"], ({ list }, inline) => {
+	const result = list.map(({ toString: format }) => format()).join(" | ");
+	return inline ? `(${result})` : result;
+});
+defineMethod("intersect", ["list"], ({ list }) => {
+	return `${list.map((inner) => inner.toString(true)).join(" & ")}`;
+});
+defineMethod("transform", [
+	"inner",
+	"callback",
+	"preserve"
+], ({ inner }, isInner) => inner.toString(isInner));
+//#endregion
+//#region ../../util/timeout/src/index.ts
+/** Largest delay Node schedules without clamping it to one millisecond. */
+const MAX_TIMER_DELAY_MS = 2147483647;
+//#endregion
+//#region ../../llm/llm/src/error.ts
+/**
+* Canonical provider-neutral code for a response that completed normally but
+* carried no content blocks at all. Providers occasionally emit a degenerate
+* completion (a terminal stop with zero output); adapters classify it as this
+* failure instead of yielding an empty assistant message, because an empty
+* message silently ends the turn with nothing for the user or the loop to act
+* on. The attempt produced nothing durable, so retry policy treats it as safe
+* to repeat.
+*/
+const EMPTY_RESPONSE_CODE = "EMPTY_RESPONSE";
+new RegExp(String.raw`(?:^|[^a-z0-9])context[\s_-](?:length|window)[\s_-]` + String.raw`(?:exceed(?:ed|s)?|overflow(?:ed)?|limit[\s_-]exceeded)(?:$|[^a-z0-9])`, "i");
+new RegExp(String.raw`\b(?:request|prompt|input|messages?)\s+(?:is\s+|are\s+)?` + String.raw`too\s+(?:large|long)\s+for\s+(?:(?:this|the)\s+)?` + String.raw`(?:model(?:'s)?\s+)?context(?:\s+window)?\b`, "i");
+new RegExp(String.raw`\b(?:input|prompt|request|messages?)\b.{0,40}` + String.raw`\b(?:exceed(?:s|ed)?|overflows?|is\s+larger\s+than)\b.{0,40}` + String.raw`\b(?:the\s+)?(?:model(?:'s)?\s+)?context(?:\s+(?:length|window))?\b`, "i");
+//#endregion
+//#region ../../llm/llm/src/retry-policy.ts
+/**
+* Provider-owned request-retry policy configuration and resolution.
+*
+* Adapters expose one resolved policy per registered provider route; the
+* optional dsh-llm-retry plugin executes it on the agent's failed-step extension point.
+*
+* @module @deepseek-ai/dsh-llm/retry-policy
+*/
+const DEFAULT_MAX_RETRIES = 2;
+const DEFAULT_INITIAL_DELAY_MS = 500;
+const DEFAULT_MAX_DELAY_MS = 1e4;
+const DEFAULT_JITTER_RATIO = .1;
+const DEFAULT_RETRYABLE_CODES = Object.freeze([
+	EMPTY_RESPONSE_CODE,
+	"RATE_LIMIT",
+	"SERVER",
+	"TIMEOUT",
+	"TRANSPORT"
+]);
+const backoffSchema = Schema.object({
+	initialDelayMs: Schema.number().max(MAX_TIMER_DELAY_MS).default(DEFAULT_INITIAL_DELAY_MS),
+	maxDelayMs: Schema.number().max(MAX_TIMER_DELAY_MS).default(DEFAULT_MAX_DELAY_MS),
+	jitterRatio: Schema.number().min(0).max(1).default(DEFAULT_JITTER_RATIO)
+});
+const normalPolicySchema = Schema.object({
+	mode: Schema.const("normal").required(),
+	maxRetries: Schema.number().step(1).min(0).max(Number.MAX_SAFE_INTEGER).default(DEFAULT_MAX_RETRIES),
+	retryableCodes: Schema.array(Schema.string()).default([...DEFAULT_RETRYABLE_CODES]),
+	backoff: backoffSchema
+});
+const alwaysPolicySchema = Schema.object({
+	mode: Schema.const("always").required(),
+	backoff: backoffSchema
+});
+Schema.union([normalPolicySchema, alwaysPolicySchema]);
+//#endregion
+//#region ../../llm/llm/src/attribution.ts
+/**
+* Centralize the non-secret product identity every provider request sends as `User-Agent`, keeping
+* adapters from drifting. See
+* `.agents/notes/implemented/architecture/2026-06-21-mandatory-app-attribution-headers.md`.
+*
+* App-attribution vocabulary for provider requests.
+* @module @deepseek-ai/dsh-llm/attribution
+*/
+const { version } = createRequire(import.meta.url)("../package.json");
+//#endregion
 //#region lib/types/service.js
 /**
 * Memory library Typert Remote service: the wire face over MemoryCore.
@@ -2506,6 +3638,12 @@ let MemoryService = (() => {
 	let _humanAckDiary_decorators;
 	let _humanSetConcernStatus_decorators;
 	let _humanDeleteConcern_decorators;
+	let _generateSkillDraft_decorators;
+	let _reviewSkill_decorators;
+	let _publishSkill_decorators;
+	let _listSkillArtifacts_decorators;
+	let _getSkillArtifact_decorators;
+	let _isSkillCandidate_decorators;
 	return class MemoryService extends _classSuper {
 		static {
 			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
@@ -2554,6 +3692,12 @@ let MemoryService = (() => {
 			_humanAckDiary_decorators = [Remote("humanAckDiary")];
 			_humanSetConcernStatus_decorators = [Remote("humanSetConcernStatus")];
 			_humanDeleteConcern_decorators = [Remote("humanDeleteConcern")];
+			_generateSkillDraft_decorators = [Remote("generateSkillDraft")];
+			_reviewSkill_decorators = [Remote("reviewSkill")];
+			_publishSkill_decorators = [Remote("publishSkill")];
+			_listSkillArtifacts_decorators = [Remote("listSkillArtifacts")];
+			_getSkillArtifact_decorators = [Remote("getSkillArtifact")];
+			_isSkillCandidate_decorators = [Remote("isSkillCandidate")];
 			__esDecorate(this, null, _refine_decorators, {
 				kind: "method",
 				name: "refine",
@@ -3049,6 +4193,72 @@ let MemoryService = (() => {
 				},
 				metadata: _metadata
 			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _generateSkillDraft_decorators, {
+				kind: "method",
+				name: "generateSkillDraft",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "generateSkillDraft" in obj,
+					get: (obj) => obj.generateSkillDraft
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _reviewSkill_decorators, {
+				kind: "method",
+				name: "reviewSkill",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "reviewSkill" in obj,
+					get: (obj) => obj.reviewSkill
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _publishSkill_decorators, {
+				kind: "method",
+				name: "publishSkill",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "publishSkill" in obj,
+					get: (obj) => obj.publishSkill
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _listSkillArtifacts_decorators, {
+				kind: "method",
+				name: "listSkillArtifacts",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "listSkillArtifacts" in obj,
+					get: (obj) => obj.listSkillArtifacts
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _getSkillArtifact_decorators, {
+				kind: "method",
+				name: "getSkillArtifact",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "getSkillArtifact" in obj,
+					get: (obj) => obj.getSkillArtifact
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _isSkillCandidate_decorators, {
+				kind: "method",
+				name: "isSkillCandidate",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "isSkillCandidate" in obj,
+					get: (obj) => obj.isSkillCandidate
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
 			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
 				enumerable: true,
 				configurable: true,
@@ -3147,8 +4357,7 @@ let MemoryService = (() => {
 2. 每条规则说明：什么类型的记忆应该避免提取，以及为什么
 3. 规则要具体可操作，不要泛泛而谈
 4. 如果删除原因都很相似，合并为更精炼的规则`;
-			const messages = [{
-				role: "user",
+			const messages = [createUserMessage({
 				content: [{
 					type: "text",
 					text: `以下是近期被用户删除的记忆及其删除原因：
@@ -3156,8 +4365,12 @@ let MemoryService = (() => {
 ${deletionList}
 
 请总结成提取反馈规则。`
-				}]
-			}];
+				}],
+				source: {
+					kind: "plugin",
+					plugin: "dsh-daoing-memory"
+				}
+			})];
 			let text = "";
 			const options = {
 				provider,
@@ -3341,6 +4554,105 @@ ${deletionList}
 			this.core.humanDeleteConcern(request, "human");
 			return { deleted: true };
 		}
+		/** Generate a skill draft from an experience using LLM. */
+		async generateSkillDraft(agent, request) {
+			const experience = this.core["store"].getActiveRevision(request.experienceId);
+			if (experience === void 0) throw new Error(`memory: experience not found: ${request.experienceId}`);
+			const content = await this.generateSkillContentWithLlm(agent, experience, request.form);
+			if (content.length === 0) throw new Error("memory: LLM generated empty skill content");
+			const draftDir = join(process.env.DSH_HOME ?? join(process.cwd(), ".dsh"), "dsh-daoing-memory", "skills");
+			mkdirSync(draftDir, { recursive: true });
+			const ext = request.form === "skill_md" ? ".md" : ".mjs";
+			const draftPath = join(draftDir, `${randomUUID()}${ext}`);
+			writeFileSync(draftPath, content, "utf8");
+			return this.core.createSkillDraft(request.experienceId, request.form, content, draftPath, actorOf(agent));
+		}
+		/** Review (approve/reject) a skill artifact. */
+		reviewSkill(agent, request) {
+			return this.core.reviewSkill(request, actorOf(agent));
+		}
+		/** Publish an approved skill (copy to $DSH_HOME/skills/). */
+		publishSkill(agent, request) {
+			const artifact = this.core.getSkillArtifact(request.id);
+			if (artifact === void 0) throw new Error(`memory: skill artifact not found: ${request.id}`);
+			if (artifact.draftPath === void 0) throw new Error("memory: skill artifact has no draft path");
+			const publishDir = join(process.env.DSH_HOME ?? join(process.cwd(), ".dsh"), "skills");
+			mkdirSync(publishDir, { recursive: true });
+			const ext = artifact.form === "skill_md" ? ".md" : ".mjs";
+			const publishedPath = join(publishDir, `${artifact.id}${ext}`);
+			writeFileSync(publishedPath, readFileSync(artifact.draftPath, "utf8"), "utf8");
+			return this.core.publishSkill(request, publishedPath, actorOf(agent));
+		}
+		/** List skill artifacts. */
+		listSkillArtifacts(agent, parentExperienceId, status) {
+			const filter = {};
+			if (parentExperienceId !== "") filter.parentExperienceId = parentExperienceId;
+			if (status !== "") filter.status = status;
+			return this.core.listSkillArtifacts(filter);
+		}
+		/** Get a single skill artifact. */
+		getSkillArtifact(agent, id) {
+			return this.core.getSkillArtifact(id) ?? null;
+		}
+		/** Check if an experience is a skill conversion candidate. */
+		isSkillCandidate(agent, experienceId) {
+			return this.core.isSkillCandidate(experienceId);
+		}
+		/**
+		* Generate skill content from an experience using LLM.
+		*/
+		async generateSkillContentWithLlm(agent, experience, form) {
+			const header = agent.session.requestHeader()?.config;
+			if (header === void 0) return "";
+			const provider = header.provider;
+			const model = header.model;
+			if (provider === void 0 || model === void 0) return "";
+			const isScript = form === "script_mjs";
+			const systemPrompt = isScript ? `你是一个技能脚本生成器。根据给定的经验（gist、路径步骤、判断背景、限制条件），生成一个可直接执行的 Node.js (.mjs) 脚本。
+
+要求：
+1. 脚本必须自包含，不依赖外部包（只用 Node.js 内置模块）
+2. 脚本顶部用注释说明用途和使用方法
+3. 脚本要有错误处理
+4. 脚本要跨平台兼容（Windows/macOS/Linux）
+5. 只输出脚本代码，不要其他解释` : `你是一个 DSH skill 文档生成器。根据给定的经验（gist、路径步骤、判断背景、限制条件），生成一个 DSH skill 格式的 Markdown 文档。
+
+要求：
+1. 使用 DSH skill 标准格式（标题、描述、触发条件、步骤）
+2. 步骤要具体可操作
+3. 包含适用场景和不适用场景
+4. 只输出 Markdown 内容，不要其他解释`;
+			const messages = [createUserMessage({
+				content: [{
+					type: "text",
+					text: `经验摘要：${experience.gist}
+
+路径步骤：
+${experience.path.map((s, i) => `${i + 1}. ${s.action}`).join("\n")}
+
+判断背景：${experience.reasoning}
+
+限制条件：
+${experience.limits.map((l) => `- ${l}`).join("\n")}
+
+请生成${isScript ? "可执行脚本" : "skill 文档"}。`
+				}],
+				source: {
+					kind: "plugin",
+					plugin: "dsh-daoing-memory"
+				}
+			})];
+			let text = "";
+			for await (const chunk of this.ctx.llm.stream({
+				provider,
+				model,
+				messages,
+				system: systemPrompt,
+				maxTokens: 4e3,
+				sessionId: agent.session.id
+			})) if (chunk.type === "text-delta") text += chunk.text;
+			return text.trim();
+		}
 	};
 })();
 //#endregion