@klarkxy/dsh-self-improvement 0.1.0

package/lib/index.js

@@ -0,0 +1,1207 @@
+import { CHAT_EVENTS_SLOT, EXTRACT_PURPOSE, LESSON_INJECTION_SECTION, LESSON_SCHEMA_TAG, MAX_PROJECT_ID_CHARS, MEMORY_UNAVAILABLE_MESSAGE, SELF_IMPROVEMENT_ACTIVATE_ID, SELF_IMPROVEMENT_PLUGIN, SELF_IMPROVEMENT_RPC_CHANNEL, SELF_IMPROVEMENT_SOURCE_KIND, evidenceWatermark, fail, projectIdFromCwd, sessionCwd } from "./contracts.js";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { registerHostRpc } from "@klarkxy/dsh-ai-services/host-rpc";
+import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
+import { z } from "zod";
+//#region src/detect.ts
+const HUMAN_CORRECTION = /^(?:不对(?:[，,：:\s]|$)|不是这样|你搞错了|纠正[：:]|更正[：:]|不要再|以后不要|我说的是|应该改成|that's wrong|that is wrong|you got it wrong|correction:|don't do that again|do not do that again|never do that again|i meant\b|i said\b)/i;
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function excerptOf(text) {
+	const trimmed = text.replace(/\s+/g, " ").trim();
+	return trimmed.length <= 240 ? trimmed : `${trimmed.slice(0, 237)}...`;
+}
+function textFromContent(content) {
+	if (!Array.isArray(content)) return typeof content === "string" ? content : "";
+	const parts = [];
+	for (const block of content) {
+		const row = asRecord(block);
+		if (!row) continue;
+		if (row.type === "text" && typeof row.text === "string") parts.push(row.text);
+		else if (row.type === "tool-result" && Array.isArray(row.content)) parts.push(textFromContent(row.content));
+	}
+	return parts.join("\n");
+}
+function sourceKind(data) {
+	const source = asRecord(asRecord(data)?.source);
+	return typeof source?.kind === "string" ? source.kind : void 0;
+}
+function isHumanUserMessage(event) {
+	return event.type === "user/message" && sourceKind(event.data) === "user";
+}
+function lastHumanRequestText(events) {
+	for (let index = events.length - 1; index >= 0; index -= 1) {
+		const event = events[index];
+		if (!event || !isHumanUserMessage(event)) continue;
+		const text = textFromContent(asRecord(event.data)?.content).trim();
+		if (text) return text;
+	}
+	return "";
+}
+function requestTextFromMessages(messages) {
+	for (let index = messages.length - 1; index >= 0; index -= 1) {
+		const row = asRecord(messages[index]);
+		if (!row) continue;
+		if (asRecord(row.source)?.kind !== "user") continue;
+		const text = textFromContent(row.content).trim();
+		if (text) return text;
+	}
+	return "";
+}
+function toolCallName(events, callId) {
+	for (const event of events) {
+		if (event.type !== "tool/call") continue;
+		const row = asRecord(event.data);
+		if (row && String(row.callId) === callId && typeof row.name === "string") return row.name;
+	}
+}
+function toolResultInfo(event) {
+	if (event.type !== "tool/result") return void 0;
+	const row = asRecord(event.data);
+	const message = asRecord(row?.message);
+	const content = Array.isArray(message?.content) ? message.content : [];
+	const block = asRecord(content[0]);
+	const callId = String(block?.toolCallId ?? asRecord(message?.source)?.callId ?? "");
+	if (!callId) return void 0;
+	return {
+		callId,
+		isError: block?.isError === true || Boolean(row?.error),
+		text: textFromContent(content)
+	};
+}
+function detectLessonTriggers(events, sessionId, afterSeq = -1) {
+	const triggers = [];
+	const seen = /* @__PURE__ */ new Set();
+	const range = events.filter((event) => event.seq > afterSeq).sort((a, b) => a.seq - b.seq);
+	const priorActivity = events.some((event) => event.seq <= afterSeq && (event.type === "assistant/message" || event.type === "tool/result" || event.type === "tool/call")) || range.some((event) => event.type === "assistant/message" || event.type === "tool/call" || event.type === "tool/result");
+	for (const event of range) {
+		if (!isHumanUserMessage(event) || !priorActivity) continue;
+		const text = textFromContent(asRecord(event.data)?.content).trim();
+		if (!text || !HUMAN_CORRECTION.test(text)) continue;
+		const evidence = [{
+			sessionId,
+			seq: event.seq,
+			kind: "user",
+			excerpt: excerptOf(text)
+		}];
+		const key = evidence.map((item) => `${item.seq}:${item.kind}`).join("|");
+		if (seen.has(key)) continue;
+		seen.add(key);
+		triggers.push({
+			kind: "human-correction",
+			evidence,
+			titleHint: excerptOf(text.split(/[。.!?\n]/, 1)[0] ?? text),
+			contentHint: text
+		});
+	}
+	const results = range.flatMap((event) => {
+		const info = toolResultInfo(event);
+		return info ? [{
+			event,
+			...info,
+			name: toolCallName(events, info.callId)
+		}] : [];
+	});
+	const pendingFailure = /* @__PURE__ */ new Map();
+	for (const row of results) {
+		const name = row.name ?? row.callId;
+		if (row.isError) {
+			if (!pendingFailure.has(name)) pendingFailure.set(name, {
+				seq: row.event.seq,
+				text: row.text,
+				name
+			});
+			continue;
+		}
+		const failure = pendingFailure.get(name);
+		if (!failure) continue;
+		pendingFailure.delete(name);
+		const evidence = [{
+			sessionId,
+			seq: failure.seq,
+			kind: "tool",
+			excerpt: excerptOf(failure.text || `${name} failed`)
+		}, {
+			sessionId,
+			seq: row.event.seq,
+			kind: "tool",
+			excerpt: excerptOf(row.text || `${name} succeeded`)
+		}];
+		const key = evidence.map((item) => `${item.seq}:${item.kind}`).join("|");
+		if (seen.has(key)) continue;
+		seen.add(key);
+		triggers.push({
+			kind: "verified-tool-fix",
+			evidence,
+			toolName: name,
+			titleHint: `工具 ${name} 失败后已核实修复`,
+			contentHint: `工具 ${name} 曾失败，随后同名调用返回非错误结果。失败摘录：${evidence[0]?.excerpt ?? ""}。成功摘录：${evidence[1]?.excerpt ?? ""}。`
+		});
+	}
+	return triggers;
+}
+//#endregion
+//#region src/extract.ts
+/** Matches Memory `newMemoryRecordSchema` field caps so create does not fail as 记忆条目格式无效. */
+const TITLE_MAX = 160;
+const CONTENT_MAX = 4e3;
+const TAG_MAX = 40;
+const EXCEPTION_MAX = 200;
+const EXCERPT_MAX = 400;
+const LIST_MAX = 16;
+const SKIP = { skip: true };
+function clip(value, max) {
+	return value.trim().slice(0, max);
+}
+function schemaTags() {
+	return [LESSON_SCHEMA_TAG].filter((tag) => tag.length > 0 && tag.length <= TAG_MAX).slice(0, LIST_MAX);
+}
+function schemaEvidence(refs) {
+	return refs.slice(0, LIST_MAX).map((ref) => {
+		const excerpt = ref.excerpt ? clip(ref.excerpt, EXCERPT_MAX) : void 0;
+		return excerpt ? {
+			sessionId: ref.sessionId,
+			seq: ref.seq,
+			kind: ref.kind,
+			excerpt
+		} : {
+			sessionId: ref.sessionId,
+			seq: ref.seq,
+			kind: ref.kind
+		};
+	});
+}
+function parseExtraction(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return void 0;
+	const body = (trimmed.match(/```(?:json)?\s*([\s\S]*?)```/i)?.[1] ?? trimmed).trim();
+	const start = body.indexOf("{");
+	const end = body.lastIndexOf("}");
+	if (start < 0 || end <= start) return void 0;
+	let parsed;
+	try {
+		parsed = JSON.parse(body.slice(start, end + 1));
+	} catch {
+		return;
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+	const row = parsed;
+	if (row.skip === true) return SKIP;
+	if (typeof row.title !== "string" || typeof row.content !== "string") return void 0;
+	const title = clip(row.title, TITLE_MAX);
+	const content = clip(row.content, CONTENT_MAX);
+	if (!title || !content) return void 0;
+	return {
+		title,
+		content,
+		exceptions: Array.isArray(row.exceptions) ? row.exceptions.filter((item) => typeof item === "string").map((item) => clip(item, EXCEPTION_MAX)).filter(Boolean).slice(0, LIST_MAX) : []
+	};
+}
+function draftFromTrigger(trigger) {
+	return {
+		title: clip(trigger.titleHint, TITLE_MAX) || "教训",
+		content: clip(trigger.contentHint, CONTENT_MAX),
+		exceptions: []
+	};
+}
+const EXTRACT_SYSTEM = [
+	"Extract at most one durable lesson from the supplied original-session evidence.",
+	"Use only explicit human corrections or a tool failure later verified by a non-error result for the same tool.",
+	"Do not infer success from later silence or from the assistant claiming it learned or fixed anything.",
+	"If evidence is insufficient, reply with JSON {\"skip\":true}.",
+	"Otherwise reply with JSON {\"title\":string,\"content\":string,\"exceptions\":string[]} only."
+].join(" ");
+function candidateRecord(draft, trigger, projectId) {
+	return {
+		scope: {
+			kind: "project",
+			projectId
+		},
+		kind: "lesson",
+		status: "candidate",
+		title: clip(draft.title, TITLE_MAX) || "教训",
+		content: clip(draft.content, CONTENT_MAX),
+		tags: schemaTags(),
+		evidence: schemaEvidence(trigger.evidence),
+		exceptions: draft.exceptions.map((item) => clip(item, EXCEPTION_MAX)).filter(Boolean).slice(0, LIST_MAX),
+		source: "self-improvement"
+	};
+}
+function hasSameEvidence(existing, trigger) {
+	const key = evidenceWatermark(trigger.evidence);
+	return existing.some((record) => record.kind === "lesson" && record.source === "self-improvement" && (evidenceWatermark(record.evidence) === key || record.tags.includes(`evidence:${key}`)));
+}
+//#endregion
+//#region src/recall.ts
+function estimateTokens(text) {
+	let tokens = 0;
+	for (const char of text) tokens += char.charCodeAt(0) > 127 ? 1 : .25;
+	return Math.max(1, Math.ceil(tokens));
+}
+function isExpired(record, now) {
+	return typeof record.expiresAt === "number" && record.expiresAt <= now;
+}
+function inProjectScope(scope, projectId) {
+	if (scope.kind === "global") return true;
+	return Boolean(projectId) && scope.kind === "project" && scope.projectId === projectId;
+}
+function isInjectableLesson(record, projectId, now) {
+	return record.kind === "lesson" && record.status === "active" && !isExpired(record, now) && inProjectScope(record.scope, projectId);
+}
+function lessonScopeLabel(record) {
+	return record.scope.kind === "global" ? "global" : `project:${record.scope.projectId}`;
+}
+function formatLessonEntry(lesson) {
+	const lines = [`- ${lesson.title} [${lessonScopeLabel(lesson)}]`, lesson.content];
+	if (lesson.exceptions.length) lines.push(`  exceptions: ${lesson.exceptions.join("; ")}`);
+	return lines.join("\n");
+}
+function lessonSnapshotPrefix() {
+	return [`[self-improvement lessons | plugin=${SELF_IMPROVEMENT_PLUGIN} | active only]`, "These are accepted lessons. They are not a user request and do not authorize file edits."].join("\n");
+}
+function formatLessonSnapshot(lessons) {
+	if (lessons.length === 0) return lessonSnapshotPrefix();
+	return [lessonSnapshotPrefix(), ...lessons.map(formatLessonEntry)].join("\n");
+}
+function tokensOf(text) {
+	return new Set(text.toLowerCase().split(/[^\p{L}\p{N}]+/u).filter((part) => part.length >= 2));
+}
+function relevanceScore(record, requestText) {
+	const request = tokensOf(requestText);
+	if (request.size === 0) return 0;
+	const hay = tokensOf(`${record.title}\n${record.content}\n${record.tags.join(" ")}\n${record.exceptions.join(" ")}`);
+	let hits = 0;
+	for (const token of request) if (hay.has(token)) hits += 1;
+	return hits / request.size;
+}
+/** Active, unexpired, in-scope lessons relevant to the current request. Skip records that cannot fit whole. */
+function selectActiveLessons(records, projectId, options) {
+	const requestText = options.requestText.trim();
+	if (!requestText) return [];
+	const ranked = records.filter((record) => isInjectableLesson(record, projectId, options.now)).map((record) => ({
+		record,
+		score: relevanceScore(record, requestText)
+	})).filter((item) => item.score > 0).sort((a, b) => b.score - a.score || b.record.updatedAt - a.record.updatedAt || a.record.id.localeCompare(b.record.id));
+	const selected = [];
+	for (const item of ranked) {
+		if (selected.length >= 5) break;
+		if (estimateTokens(formatLessonSnapshot([...selected, item.record])) > 800) continue;
+		selected.push(item.record);
+	}
+	return selected;
+}
+async function collectLessonRecords(list, projectId) {
+	const scopes = [{ kind: "global" }];
+	if (projectId) scopes.push({
+		kind: "project",
+		projectId
+	});
+	const rows = await Promise.all(scopes.map((scope) => list(scope)));
+	const byId = /* @__PURE__ */ new Map();
+	for (const record of rows.flat()) byId.set(record.id, record);
+	return [...byId.values()];
+}
+//#endregion
+//#region src/inject.ts
+function isSelfImprovementLessonMessage(message) {
+	if (!message || typeof message !== "object") return false;
+	const row = message;
+	if (row.source?.kind !== "plugin:@klarkxy/dsh-self-improvement" || row.source.plugin !== "@klarkxy/dsh-self-improvement") return false;
+	return row.source.form === "snapshot" && Boolean(row.source.sections?.some((section) => section.name === "dsh-self-improvement:lessons"));
+}
+function lessonInjectPayload(lessons) {
+	const text = formatLessonSnapshot(lessons);
+	return {
+		source: {
+			kind: SELF_IMPROVEMENT_SOURCE_KIND,
+			plugin: SELF_IMPROVEMENT_PLUGIN,
+			form: "snapshot",
+			sections: [{
+				name: LESSON_INJECTION_SECTION,
+				text
+			}]
+		},
+		content: [{
+			type: "text",
+			text
+		}]
+	};
+}
+function createLessonInjectionMessage(lessons) {
+	return createUserMessage(lessonInjectPayload(lessons));
+}
+function injectLessonMessages(decision, lessons) {
+	if (decision.kind !== "enter") return decision;
+	const without = decision.messages.filter((message) => !isSelfImprovementLessonMessage(message));
+	if (lessons.length === 0) return {
+		...decision,
+		messages: without
+	};
+	return {
+		...decision,
+		messages: [createLessonInjectionMessage(lessons), ...without]
+	};
+}
+//#endregion
+//#region src/skills.ts
+function yamlScalar(value) {
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return JSON.stringify(value);
+}
+function skillDownloadName(id, title) {
+	return `self-improvement-${title.replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "skill"}-${id.replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 12) || "id"}.md`;
+}
+function skillNameFromTitle(title) {
+	return title.replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-+|-+$/g, "").slice(0, 64).toLowerCase() || "self-improvement-lesson";
+}
+function skillDescriptionFromLessons(lessons) {
+	const first = lessons[0];
+	return (first ? `${first.title}: ${first.content}` : "Accepted self-improvement lessons.").replace(/[\r\n]+/g, " ").trim().slice(0, 200) || "Accepted self-improvement lessons.";
+}
+function skillSourcesFromLessons(lessons) {
+	return lessons.map((lesson) => ({
+		id: lesson.id,
+		revision: lesson.revision,
+		status: lesson.status,
+		scope: lesson.scope,
+		expiresAt: lesson.expiresAt
+	}));
+}
+function sourcesMatchLive(sources, lessons, now) {
+	if (sources.length === 0) return false;
+	const byId = new Map(lessons.map((lesson) => [lesson.id, lesson]));
+	for (const source of sources) {
+		const live = byId.get(source.id);
+		if (!live || live.kind !== "lesson") return false;
+		if (live.revision !== source.revision) return false;
+		if (live.status !== "active" || source.status !== "active") return false;
+		if (isExpired(live, now)) return false;
+		if (live.scope.kind !== source.scope.kind) return false;
+		if (live.scope.kind === "project" && source.scope.kind === "project" && live.scope.projectId !== source.scope.projectId) return false;
+	}
+	return true;
+}
+function provenanceYaml(lessons) {
+	const lines = ["provenance:"];
+	for (const lesson of lessons) {
+		lines.push(`  - lessonId: ${yamlScalar(lesson.id)}`);
+		lines.push(`    revision: ${lesson.revision}`);
+		lines.push(`    scope: ${yamlScalar(lessonScopeLabel(lesson))}`);
+		lines.push(`    status: ${yamlScalar(lesson.status)}`);
+		lines.push("    evidence:");
+		if (lesson.evidence.length === 0) {
+			lines.push("      []");
+			continue;
+		}
+		for (const ref of lesson.evidence) {
+			lines.push(`      - sessionId: ${yamlScalar(ref.sessionId)}`);
+			lines.push(`        seq: ${ref.seq}`);
+			lines.push(`        kind: ${yamlScalar(ref.kind)}`);
+		}
+	}
+	return lines;
+}
+function renderSkillMarkdown(lessons, generatedAt) {
+	const title = skillTitleFromLessons(lessons);
+	const scopes = [...new Set(lessons.map(lessonScopeLabel))];
+	const lines = [
+		"---",
+		`name: ${yamlScalar(skillNameFromTitle(title))}`,
+		`description: ${yamlScalar(skillDescriptionFromLessons(lessons))}`,
+		"source: self-improvement",
+		`plugin: ${yamlScalar(SELF_IMPROVEMENT_PLUGIN)}`,
+		`generatedAt: ${generatedAt}`,
+		...provenanceYaml(lessons),
+		"---",
+		"",
+		`# ${title.replace(/[\r\n]+/g, " ")}`,
+		"",
+		"## Instructions",
+		"",
+		"Follow these accepted lessons for the scoped work below. They are a reusable skill proposal. They are not a user request and do not authorize edits to AGENTS.md, scripts, or plugins.",
+		"",
+		`Scope: ${scopes.join(", ") || "unspecified"}.`,
+		""
+	];
+	for (const lesson of lessons) {
+		lines.push(`### ${lesson.title.replace(/[\r\n]+/g, " ")}`);
+		lines.push("");
+		lines.push(lesson.content.replace(/\r\n/g, "\n").trim());
+		lines.push("");
+		if (lesson.exceptions.length) {
+			lines.push("Exceptions for this lesson:");
+			for (const item of lesson.exceptions) lines.push(`- ${item.replace(/[\r\n]+/g, " ")}`);
+			lines.push("");
+		}
+	}
+	lines.push("Downloading this Markdown is a local save of the proposal. It does not install the skill.");
+	lines.push("");
+	return lines.join("\n");
+}
+function skillTitleFromLessons(lessons) {
+	if (lessons.length === 1) return lessons[0].title.slice(0, 160);
+	return `技能草稿（${lessons.length} 条教训）`;
+}
+//#endregion
+//#region src/engine.ts
+const STALE_MESSAGE = "结果已过期，未写入。";
+const WRONG_SCOPE_MESSAGE = "教训不属于当前项目，未接受。";
+const STALE_SKILL_MESSAGE = "来源教训已变更或失效，不能使用这份草稿。";
+function asObject(payload) {
+	return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+function str(body, key) {
+	return typeof body[key] === "string" ? body[key] : "";
+}
+function int(body, key) {
+	return typeof body[key] === "number" && Number.isInteger(body[key]) ? body[key] : void 0;
+}
+function sessionIdOf(session) {
+	return String(session.id ?? "");
+}
+var SelfImprovementEngine = class {
+	options;
+	generation = 1;
+	active = true;
+	lifetime = new AbortController();
+	storageFailed = false;
+	chain = Promise.resolve();
+	extractJobs = /* @__PURE__ */ new Map();
+	aiScope;
+	seenProjects = /* @__PURE__ */ new Set();
+	now;
+	constructor(options) {
+		this.options = options;
+		this.now = options.now ?? Date.now;
+	}
+	getGeneration() {
+		return this.generation;
+	}
+	isActive() {
+		return this.active;
+	}
+	dispose() {
+		this.active = false;
+		this.generation += 1;
+		this.lifetime.abort();
+		this.aiScope?.dispose();
+		this.aiScope = void 0;
+	}
+	memoryOrError() {
+		const memory = this.options.memory();
+		if (!memory) return fail("MEMORY_UNAVAILABLE", MEMORY_UNAVAILABLE_MESSAGE);
+		return memory;
+	}
+	asMemory(value) {
+		return typeof value.list === "function";
+	}
+	requireActive() {
+		if (this.active) return void 0;
+		return fail("DISABLED", "自我改进已关闭，摘录和教训注入已停止。");
+	}
+	async persist(work) {
+		try {
+			const value = await work();
+			this.storageFailed = false;
+			return value;
+		} catch (error) {
+			this.storageFailed = true;
+			throw error;
+		}
+	}
+	currentSignal(signal) {
+		return signal ? AbortSignal.any([signal, this.lifetime.signal]) : this.lifetime.signal;
+	}
+	rememberProject(projectId) {
+		this.seenProjects.add(projectId);
+	}
+	knownProjectIds(extra) {
+		const ids = new Set(this.seenProjects);
+		if (extra) ids.add(extra);
+		for (const [, row] of this.options.watermarks.entries()) if (row.projectId) ids.add(row.projectId);
+		return [...ids];
+	}
+	sameMemory(expected) {
+		return this.options.memory() === expected;
+	}
+	beginWork() {
+		const disabled = this.requireActive();
+		if (disabled) return disabled;
+		const memory = this.memoryOrError();
+		if (!this.asMemory(memory)) return memory;
+		return {
+			generation: this.generation,
+			memory
+		};
+	}
+	isWork(value) {
+		return "memory" in value;
+	}
+	/** Linearize disable/replace against captured generation + Memory. Never start a new write after this fails. */
+	revalidate(generation, memory) {
+		if (this.active && this.generation === generation && this.sameMemory(memory)) return void 0;
+		if (!this.active) return this.requireActive();
+		if (!this.sameMemory(memory)) return fail("MEMORY_UNAVAILABLE", MEMORY_UNAVAILABLE_MESSAGE);
+		return fail("SUPERSEDED", STALE_MESSAGE);
+	}
+	failed(value) {
+		return typeof value === "object" && value !== null && "ok" in value && value.ok === false;
+	}
+	mutationGuards(generation, memory) {
+		return {
+			signal: this.lifetime.signal,
+			isCurrent: () => !this.revalidate(generation, memory)
+		};
+	}
+	isGuardRejection(error) {
+		if (!error || typeof error !== "object") return false;
+		const name = "name" in error ? String(error.name) : "";
+		const code = "code" in error ? String(error.code) : "";
+		return name === "AbortError" || name === "TimeoutError" || code === "ABORT_ERR" || code === "ABORTED" || code === "MEMORY_CANCELLED" || code === "MEMORY_DISABLED" || code === "CANCELLED";
+	}
+	/** Invoke a Memory/Skill write only while still current. Queued Memory work receives captured generation/identity + lifetime abort. An already-started write is not rolled back; the RPC still fails if we are no longer current after it. */
+	async mutateWhileCurrent(generation, memory, run) {
+		const before = this.revalidate(generation, memory);
+		if (before) return before;
+		try {
+			const value = await run(this.mutationGuards(generation, memory));
+			const after = this.revalidate(generation, memory);
+			if (after) return after;
+			return value;
+		} catch (error) {
+			return this.rejectionOrThrow(error, generation, memory);
+		}
+	}
+	rejectionOrThrow(error, generation, memory) {
+		const stale = this.revalidate(generation, memory);
+		if (stale) return stale;
+		if (this.isGuardRejection(error) || this.lifetime.signal.aborted) return fail("CANCELLED", "操作已取消。");
+		throw error;
+	}
+	async listAllLessons(projectId, expectedMemory) {
+		const memory = expectedMemory ?? this.options.memory();
+		if (!memory) return [];
+		const scopes = [{ kind: "global" }, ...this.knownProjectIds(projectId).map((id) => ({
+			kind: "project",
+			projectId: id
+		}))];
+		const rows = await Promise.all(scopes.map((scope) => memory.list({
+			scope,
+			kinds: ["lesson"]
+		})));
+		if (!this.sameMemory(memory)) return [];
+		const byId = /* @__PURE__ */ new Map();
+		for (const record of rows.flat()) if (record.kind === "lesson") byId.set(record.id, record);
+		return [...byId.values()];
+	}
+	currentRequestText(session, decision) {
+		if (decision?.kind === "enter") {
+			const fromDecision = requestTextFromMessages(decision.messages);
+			if (fromDecision) return fromDecision;
+		}
+		return lastHumanRequestText(session.snapshotEvents());
+	}
+	async recordsForInjection(projectId, requestText, expectedMemory) {
+		const generation = this.generation;
+		const memory = expectedMemory ?? this.options.memory();
+		if (!memory || !this.active) return [];
+		const listed = await collectLessonRecords((scope) => memory.list({
+			scope,
+			kinds: ["lesson"]
+		}), projectId);
+		if (!this.active || this.generation !== generation || !this.sameMemory(memory)) return [];
+		return selectActiveLessons(listed, projectId, {
+			now: this.now(),
+			requestText
+		});
+	}
+	async applyPreStep(session, decision, signal) {
+		signal.throwIfAborted();
+		if (!this.active || decision.kind !== "enter") return decision;
+		const generation = this.generation;
+		const memory = this.options.memory();
+		if (!memory) return injectLessonMessages(decision, []);
+		const projectId = projectIdFromCwd(sessionCwd(session));
+		const requestText = this.currentRequestText(session, decision);
+		const lessons = await this.recordsForInjection(projectId, requestText, memory);
+		if (!this.active || this.generation !== generation || !this.sameMemory(memory)) return injectLessonMessages(decision, []);
+		return injectLessonMessages(decision, lessons);
+	}
+	async writeWatermark(sessionId, seq, projectId) {
+		await this.persist(() => this.options.watermarks.put(sessionId, {
+			sessionId,
+			seq,
+			projectId,
+			updatedAt: this.now()
+		}));
+	}
+	ensureAi() {
+		if (this.aiScope?.active) return this.aiScope;
+		const ai = this.options.ai();
+		if (!ai) return void 0;
+		this.aiScope = ai.activate(SELF_IMPROVEMENT_ACTIVATE_ID);
+		this.aiScope.registerPurpose({
+			id: EXTRACT_PURPOSE,
+			label: "自我改进摘录",
+			defaultTarget: {
+				kind: "role",
+				role: "normal"
+			},
+			maxOutputTokens: 400,
+			maxInputChars: 8e3
+		});
+		return this.aiScope;
+	}
+	async draftTrigger(trigger, sessionId, sourceVersion, signal, generation) {
+		const scope = this.ensureAi();
+		if (!scope) return draftFromTrigger(trigger);
+		const result = await scope.run({
+			purpose: EXTRACT_PURPOSE,
+			sessionId,
+			sourceVersion,
+			system: EXTRACT_SYSTEM,
+			input: JSON.stringify({
+				kind: trigger.kind,
+				evidence: trigger.evidence,
+				hint: trigger.contentHint
+			}),
+			signal,
+			isCurrent: () => this.active && this.generation === generation && scope.active,
+			priority: "background"
+		});
+		if (!this.active || this.generation !== generation) return void 0;
+		if (result.receipt.status !== "success") return void 0;
+		const parsed = parseExtraction(result.text);
+		if (!parsed || "skip" in parsed) return void 0;
+		return parsed;
+	}
+	noteExtractStart(sessionId) {
+		this.extractJobs.set(sessionId, (this.extractJobs.get(sessionId) ?? 0) + 1);
+	}
+	noteExtractEnd(sessionId) {
+		const next = (this.extractJobs.get(sessionId) ?? 1) - 1;
+		if (next <= 0) this.extractJobs.delete(sessionId);
+		else this.extractJobs.set(sessionId, next);
+	}
+	isExtracting(sessionId) {
+		if (sessionId) return (this.extractJobs.get(sessionId) ?? 0) > 0;
+		for (const count of this.extractJobs.values()) if (count > 0) return true;
+		return false;
+	}
+	enqueue(run) {
+		const task = this.chain.then(run, run);
+		this.chain = task.then(() => {}, () => {});
+		return task;
+	}
+	/** Queue auto and manual extract on the existing chain. Counts rise synchronously at request entry. */
+	enqueueExtract(session, signal, mode) {
+		const sessionId = sessionIdOf(session);
+		this.noteExtractStart(sessionId);
+		return this.enqueue(async () => {
+			try {
+				return await this.runExtractFromSession(session, signal, mode);
+			} finally {
+				this.noteExtractEnd(sessionId);
+			}
+		});
+	}
+	async extractFromSession(session, signal, mode = "auto") {
+		return this.enqueueExtract(session, signal, mode);
+	}
+	considerSession(session, signal) {
+		return this.enqueueExtract(session, signal, "auto").then(() => {}, () => {});
+	}
+	async runExtractFromSession(session, signal, mode) {
+		const disabled = this.requireActive();
+		if (disabled) return disabled;
+		const memory = this.memoryOrError();
+		if (!this.asMemory(memory)) return memory;
+		const sessionId = sessionIdOf(session);
+		if (!sessionId) return fail("INVALID", "缺少会话。");
+		const projectId = projectIdFromCwd(sessionCwd(session));
+		if (!projectId) return fail("WRONG_SCOPE", "无法确定当前项目，未写入候选。");
+		const generation = this.generation;
+		try {
+			const combined = this.currentSignal(signal);
+			combined.throwIfAborted();
+			const events = session.snapshotEvents();
+			const lastSeq = events.reduce((max, event) => Math.max(max, event.seq), -1);
+			const watermark = this.options.watermarks.get(sessionId)?.seq ?? -1;
+			const triggers = detectLessonTriggers(events, sessionId, mode === "manual" ? -1 : watermark);
+			if (triggers.length === 0) {
+				if (mode === "auto") {
+					const written = await this.mutateWhileCurrent(generation, memory, () => this.writeWatermark(sessionId, lastSeq, projectId));
+					if (this.failed(written)) return written;
+				}
+				const stale = this.revalidate(generation, memory);
+				if (stale) return stale;
+				return {
+					ok: true,
+					value: {
+						created: [],
+						skipped: 0
+					}
+				};
+			}
+			const existing = await this.listAllLessons(projectId, memory);
+			const staleList = this.revalidate(generation, memory);
+			if (staleList) return staleList;
+			const created = [];
+			let skipped = 0;
+			const sourceVersion = `${sessionId}:${watermark}:${lastSeq}:${generation}`;
+			for (const trigger of triggers) {
+				combined.throwIfAborted();
+				if (hasSameEvidence(existing.concat(created), trigger)) {
+					skipped += 1;
+					continue;
+				}
+				const draft = await this.draftTrigger(trigger, sessionId, sourceVersion, combined, generation);
+				const staleDraft = this.revalidate(generation, memory);
+				if (staleDraft) return staleDraft;
+				if (!draft) {
+					skipped += 1;
+					continue;
+				}
+				const record = await this.mutateWhileCurrent(generation, memory, (guards) => memory.create(candidateRecord(draft, trigger, projectId), guards));
+				if (this.failed(record)) return record;
+				this.rememberProject(projectId);
+				const activated = await this.mutateWhileCurrent(generation, memory, (guards) => memory.update(record.id, { status: "active" }, record.revision, guards));
+				if (this.failed(activated)) {
+					skipped += 1;
+					existing.push(record);
+					continue;
+				}
+				created.push(activated);
+				existing.push(activated);
+			}
+			const watermarkWrite = await this.mutateWhileCurrent(generation, memory, () => this.writeWatermark(sessionId, lastSeq, projectId));
+			if (this.failed(watermarkWrite)) return watermarkWrite;
+			return {
+				ok: true,
+				value: {
+					created,
+					skipped
+				}
+			};
+		} catch (error) {
+			return this.rejectionOrThrow(error, generation, memory);
+		}
+	}
+	async requireLesson(id, extraProjectId, memory, generation) {
+		const rows = await this.listAllLessons(extraProjectId, memory);
+		const stale = this.revalidate(generation, memory);
+		if (stale) return stale;
+		const record = rows.find((item) => item.id === id);
+		if (!record || record.kind !== "lesson") return fail("NOT_FOUND", "找不到该教训。");
+		return record;
+	}
+	async acceptLesson(id, expectedRevision, scope, currentProjectId) {
+		const work = this.beginWork();
+		if (!this.isWork(work)) return work;
+		const { generation, memory } = work;
+		const record = await this.requireLesson(id, currentProjectId, memory, generation);
+		if (!("id" in record)) return record;
+		const stale = this.revalidate(generation, memory);
+		if (stale) return stale;
+		if (record.revision !== expectedRevision) return fail("STALE", "记录已更新，请刷新后重试。");
+		if (isExpired(record, this.now())) return fail("STALE", "教训已过期。");
+		if (record.status !== "candidate" && record.status !== "active") return fail("INVALID", "只能接受候选或已生效的教训。");
+		if (scope === "project") {
+			if (record.scope.kind === "project" && currentProjectId && record.scope.projectId !== currentProjectId) return fail("WRONG_SCOPE", WRONG_SCOPE_MESSAGE);
+			const updated = await this.mutateWhileCurrent(generation, memory, (guards) => memory.update(id, { status: "active" }, expectedRevision, guards));
+			if (this.failed(updated)) return updated;
+			return {
+				ok: true,
+				value: updated
+			};
+		}
+		if (record.scope.kind === "global") {
+			const updated = await this.mutateWhileCurrent(generation, memory, (guards) => memory.update(id, { status: "active" }, expectedRevision, guards));
+			if (this.failed(updated)) return updated;
+			return {
+				ok: true,
+				value: updated
+			};
+		}
+		const promoted = await this.mutateWhileCurrent(generation, memory, (guards) => memory.promoteToGlobal(id, expectedRevision, guards));
+		if (this.failed(promoted)) return promoted;
+		return {
+			ok: true,
+			value: promoted
+		};
+	}
+	async setLessonStatus(id, expectedRevision, status, extraProjectId) {
+		const work = this.beginWork();
+		if (!this.isWork(work)) return work;
+		const { generation, memory } = work;
+		const record = await this.requireLesson(id, extraProjectId, memory, generation);
+		if (!("id" in record)) return record;
+		const stale = this.revalidate(generation, memory);
+		if (stale) return stale;
+		if (record.revision !== expectedRevision) return fail("STALE", "记录已更新，请刷新后重试。");
+		const updated = await this.mutateWhileCurrent(generation, memory, (guards) => memory.update(id, { status }, expectedRevision, guards));
+		if (this.failed(updated)) return updated;
+		return {
+			ok: true,
+			value: updated
+		};
+	}
+	skills() {
+		return [...this.options.skills.entries()].map(([, row]) => row).sort((a, b) => b.updatedAt - a.updatedAt);
+	}
+	async liveSkillLessons(lessonIds, memory, generation) {
+		const records = await this.listAllLessons(void 0, memory);
+		const stale = this.revalidate(generation, memory);
+		if (stale) return stale;
+		const lessons = lessonIds.map((id) => records.find((item) => item.id === id));
+		if (lessons.some((item) => !item || item.kind !== "lesson")) return fail("INVALID", "找不到所选教训。");
+		return lessons;
+	}
+	async previewSkill(lessonIds) {
+		const work = this.beginWork();
+		if (!this.isWork(work)) return work;
+		const { generation, memory } = work;
+		if (lessonIds.length === 0) return fail("INVALID", "请选择已生效的教训。");
+		const lessons = await this.liveSkillLessons(lessonIds, memory, generation);
+		if (!Array.isArray(lessons)) return lessons;
+		const stale = this.revalidate(generation, memory);
+		if (stale) return stale;
+		const now = this.now();
+		if (lessons.some((item) => item.status !== "active" || isExpired(item, now))) return fail("INVALID", "只能从未过期且已生效的教训生成技能草稿。");
+		const record = {
+			id: crypto.randomUUID(),
+			revision: 0,
+			status: "preview",
+			lessonIds,
+			sources: skillSourcesFromLessons(lessons),
+			title: skillTitleFromLessons(lessons),
+			markdown: renderSkillMarkdown(lessons, now),
+			createdAt: now,
+			updatedAt: now,
+			exportState: "none",
+			audit: [{
+				at: now,
+				action: "preview"
+			}]
+		};
+		const stored = await this.mutateWhileCurrent(generation, memory, () => this.persist(() => this.options.skills.put(record.id, record)));
+		if (this.failed(stored)) return stored;
+		return {
+			ok: true,
+			value: record
+		};
+	}
+	skillOrError(id) {
+		const record = this.options.skills.get(id);
+		if (!record) return fail("NOT_FOUND", "找不到该技能草稿。");
+		return record;
+	}
+	async requireCurrentSkillSources(skill, memory, generation) {
+		const lessons = await this.liveSkillLessons(skill.lessonIds, memory, generation);
+		if (!Array.isArray(lessons)) return lessons;
+		const stale = this.revalidate(generation, memory);
+		if (stale) return stale;
+		if (!sourcesMatchLive(skill.sources, lessons, this.now())) return fail("STALE", STALE_SKILL_MESSAGE);
+	}
+	async patchSkill(id, expectedRevision, patch) {
+		const work = this.beginWork();
+		if (!this.isWork(work)) return work;
+		const { generation, memory } = work;
+		const current = this.skillOrError(id);
+		if (!("id" in current)) return current;
+		if (current.revision !== expectedRevision) return fail("STALE", "记录已更新，请刷新后重试。");
+		const next = {
+			...patch(current),
+			revision: current.revision + 1,
+			updatedAt: this.now()
+		};
+		const stored = await this.mutateWhileCurrent(generation, memory, () => this.persist(() => this.options.skills.put(id, next)));
+		if (this.failed(stored)) return stored;
+		return {
+			ok: true,
+			value: next
+		};
+	}
+	async acceptSkill(id, expectedRevision) {
+		const work = this.beginWork();
+		if (!this.isWork(work)) return work;
+		const { generation, memory } = work;
+		const current = this.skillOrError(id);
+		if (!("id" in current)) return current;
+		const stale = await this.requireCurrentSkillSources(current, memory, generation);
+		if (stale) return stale;
+		const after = this.revalidate(generation, memory);
+		if (after) return after;
+		return this.patchSkill(id, expectedRevision, (record) => ({
+			...record,
+			status: "accepted",
+			audit: [...record.audit, {
+				at: this.now(),
+				action: "accepted"
+			}]
+		}));
+	}
+	async prepareSkillExport(id, expectedRevision) {
+		const work = this.beginWork();
+		if (!this.isWork(work)) return work;
+		const { generation, memory } = work;
+		const current = this.skillOrError(id);
+		if (!("id" in current)) return current;
+		if (current.revision !== expectedRevision) return fail("STALE", "记录已更新，请刷新后重试。");
+		if (current.status !== "accepted" && current.status !== "preview") return fail("INVALID", "只能导出预览或已接受的技能草稿。");
+		const stale = await this.requireCurrentSkillSources(current, memory, generation);
+		if (stale) return stale;
+		const after = this.revalidate(generation, memory);
+		if (after) return after;
+		return {
+			ok: true,
+			value: {
+				filename: skillDownloadName(current.id, current.title),
+				markdown: current.markdown,
+				skill: current
+			}
+		};
+	}
+	async recordSkillExport(id, expectedRevision, filename) {
+		return this.patchSkill(id, expectedRevision, (record) => ({
+			...record,
+			exportState: "recorded",
+			exportedAt: this.now(),
+			exportFilename: filename,
+			audit: [...record.audit, {
+				at: this.now(),
+				action: "export",
+				detail: filename
+			}]
+		}));
+	}
+	async snapshot(sessionId) {
+		const session = sessionId ? this.options.sessionOf(sessionId) : void 0;
+		const projectId = projectIdFromCwd(sessionCwd(session));
+		const memoryAvailable = Boolean(this.options.memory());
+		return {
+			ok: true,
+			value: {
+				memoryAvailable,
+				memoryMessage: memoryAvailable ? void 0 : MEMORY_UNAVAILABLE_MESSAGE,
+				projectId,
+				generation: this.generation,
+				storageFailed: this.storageFailed,
+				lessons: memoryAvailable ? await this.listAllLessons(projectId) : [],
+				skills: this.skills(),
+				extracting: this.isExtracting(sessionId)
+			}
+		};
+	}
+	async call(endpoint, payload, signal) {
+		try {
+			signal.throwIfAborted();
+			const body = asObject(payload);
+			const sessionId = str(body, "sessionId");
+			const projectId = projectIdFromCwd(sessionCwd(this.options.sessionOf(sessionId)));
+			if (endpoint === "status") return await this.snapshot(sessionId || void 0);
+			if (endpoint === "extract") {
+				const session = this.options.sessionOf(sessionId);
+				if (!session) return fail("NOT_FOUND", "找不到会话。");
+				return await this.extractFromSession(session, signal, "manual");
+			}
+			if (endpoint === "inspect") {
+				const work = this.beginWork();
+				if (!this.isWork(work)) return work;
+				const record = await this.requireLesson(str(body, "id"), projectId, work.memory, work.generation);
+				return "id" in record ? {
+					ok: true,
+					value: record
+				} : record;
+			}
+			if (endpoint === "accept") {
+				const revision = int(body, "expectedRevision");
+				if (!str(body, "id") || revision === void 0) return fail("INVALID", "缺少记录或版本。");
+				const scope = str(body, "scope") === "global" ? "global" : "project";
+				return await this.acceptLesson(str(body, "id"), revision, scope, projectId);
+			}
+			if (endpoint === "reject" || endpoint === "revoke") {
+				const revision = int(body, "expectedRevision");
+				if (!str(body, "id") || revision === void 0) return fail("INVALID", "缺少记录或版本。");
+				return await this.setLessonStatus(str(body, "id"), revision, endpoint === "reject" ? "rejected" : "revoked", projectId);
+			}
+			if (endpoint === "skill.preview") {
+				const lessonIds = Array.isArray(body.lessonIds) ? body.lessonIds.filter((id) => typeof id === "string") : [];
+				return await this.previewSkill(lessonIds);
+			}
+			if (endpoint === "skill.accept") {
+				const revision = int(body, "expectedRevision");
+				if (!str(body, "id") || revision === void 0) return fail("INVALID", "缺少记录或版本。");
+				return await this.acceptSkill(str(body, "id"), revision);
+			}
+			if (endpoint === "skill.reject" || endpoint === "skill.revoke") {
+				const revision = int(body, "expectedRevision");
+				if (!str(body, "id") || revision === void 0) return fail("INVALID", "缺少记录或版本。");
+				const status = endpoint === "skill.reject" ? "rejected" : "revoked";
+				return await this.patchSkill(str(body, "id"), revision, (current) => ({
+					...current,
+					status,
+					audit: [...current.audit, {
+						at: this.now(),
+						action: status
+					}]
+				}));
+			}
+			if (endpoint === "skill.export") {
+				const revision = int(body, "expectedRevision");
+				if (!str(body, "id") || revision === void 0) return fail("INVALID", "缺少记录或版本。");
+				return await this.prepareSkillExport(str(body, "id"), revision);
+			}
+			if (endpoint === "skill.exported") {
+				const revision = int(body, "expectedRevision");
+				const filename = str(body, "filename");
+				if (!str(body, "id") || revision === void 0 || !filename) return fail("INVALID", "缺少记录、版本或文件名。");
+				return await this.recordSkillExport(str(body, "id"), revision, filename);
+			}
+			if (endpoint === "skill.unexport") {
+				const revision = int(body, "expectedRevision");
+				if (!str(body, "id") || revision === void 0) return fail("INVALID", "缺少记录或版本。");
+				return await this.patchSkill(str(body, "id"), revision, (current) => ({
+					...current,
+					exportState: "revoked",
+					exportRevokedAt: this.now(),
+					audit: [...current.audit, {
+						at: this.now(),
+						action: "unexport",
+						detail: "in-app record only"
+					}]
+				}));
+			}
+			return fail("INVALID", "未知操作。");
+		} catch (error) {
+			if (this.isGuardRejection(error) || this.lifetime.signal.aborted) return fail("CANCELLED", "操作已取消。");
+			if (this.storageFailed) return fail("STORAGE_FAILED", "保存失败，已保留上一次成功的状态。");
+			return fail("INTERNAL", error instanceof Error ? error.message : "操作失败。");
+		}
+	}
+};
+//#endregion
+//#region src/storage.ts
+const knowledgeScopeSchema = z.union([z.object({ kind: z.literal("global") }).strict(), z.object({
+	kind: z.literal("project"),
+	projectId: z.string().min(1).max(MAX_PROJECT_ID_CHARS)
+}).strict()]);
+const skillSourceSchema = z.object({
+	id: z.string().min(1).max(80),
+	revision: z.number().int().nonnegative(),
+	status: z.enum([
+		"candidate",
+		"active",
+		"rejected",
+		"superseded",
+		"revoked",
+		"deleted"
+	]),
+	scope: knowledgeScopeSchema,
+	expiresAt: z.number().int().nonnegative().optional()
+}).strict();
+const skillRecordSchema = z.object({
+	id: z.string().min(1).max(80),
+	revision: z.number().int().nonnegative(),
+	status: z.enum([
+		"preview",
+		"accepted",
+		"rejected",
+		"revoked"
+	]),
+	lessonIds: z.array(z.string().min(1).max(80)).min(1).max(16),
+	sources: z.array(skillSourceSchema).min(1).max(16),
+	title: z.string().min(1).max(160),
+	markdown: z.string().min(1).max(8e4),
+	createdAt: z.number().int().nonnegative(),
+	updatedAt: z.number().int().nonnegative(),
+	exportState: z.enum([
+		"none",
+		"recorded",
+		"revoked"
+	]),
+	exportedAt: z.number().int().nonnegative().optional(),
+	exportRevokedAt: z.number().int().nonnegative().optional(),
+	exportFilename: z.string().max(180).optional(),
+	audit: z.array(z.object({
+		at: z.number().int().nonnegative(),
+		action: z.string().min(1).max(64),
+		detail: z.string().max(500).optional()
+	}).strict()).max(64)
+}).strict();
+const watermarkSchema = z.object({
+	sessionId: z.string().min(1).max(200),
+	seq: z.number().int().nonnegative(),
+	projectId: z.string().min(1).max(MAX_PROJECT_ID_CHARS).optional(),
+	updatedAt: z.number().int().nonnegative()
+}).strict();
+const selfImprovementDomain = defineDomain({
+	name: "dsh_editor_self_improvement",
+	version: 1,
+	tables: {
+		skills: domainTable(skillRecordSchema),
+		watermarks: domainTable(watermarkSchema)
+	}
+});
+//#endregion
+//#region src/index.ts
+const name = "@klarkxy/dsh-self-improvement";
+const inject = [
+	"storageDomain",
+	"connection",
+	"webServer"
+];
+function readService(ctx, key) {
+	const record = ctx;
+	try {
+		const direct = record[key];
+		if (direct !== void 0) return direct;
+	} catch {}
+	try {
+		return record.get?.(key);
+	} catch {
+		return;
+	}
+}
+function sessionOf(ctx, sessionId) {
+	return readService(ctx, "sessions")?.get?.(sessionId);
+}
+function listen(ctx, name, handler) {
+	const off = ctx.on.call(ctx, name, handler);
+	return typeof off === "function" ? off : void 0;
+}
+async function apply(ctx) {
+	const host = ctx;
+	const domain = await host.storageDomain.open(selfImprovementDomain);
+	const engine = new SelfImprovementEngine({
+		memory: () => readService(ctx, "aiMemory"),
+		ai: () => readService(ctx, "aiServices"),
+		sessionOf: (id) => sessionOf(ctx, id),
+		skills: domain.table("skills"),
+		watermarks: domain.table("watermarks")
+	});
+	ctx.effect(() => async () => {
+		engine.dispose();
+		await domain.close();
+	}, "self-improvement.dispose");
+	ctx.provide("selfImprovement", engine);
+	ctx.effect(() => registerHostRpc(host, SELF_IMPROVEMENT_RPC_CHANNEL, (endpoint, payload, signal) => engine.call(endpoint, payload, signal)), "self-improvement.rpc");
+	ctx.effect(() => {
+		const offStep = listen(ctx, "agent/pre-step", (async (payload, next) => {
+			const decision = await next();
+			return engine.applyPreStep(payload.agent.session, decision, payload.signal);
+		}));
+		const offStop = listen(ctx, "agent/turn-stopping", ((payload) => {
+			engine.considerSession(payload.agent.session, payload.signal);
+		}));
+		return () => {
+			offStep?.();
+			offStop?.();
+		};
+	}, "self-improvement.hooks");
+}
+//#endregion
+export { CHAT_EVENTS_SLOT, SELF_IMPROVEMENT_RPC_CHANNEL, SelfImprovementEngine, apply, inject, listen, name };
+
+//# sourceMappingURL=index.js.map