@klarkxy/dsh-mood 0.1.0

package/lib/index.js

@@ -0,0 +1,1261 @@
+import { CHAT_EVENTS_SLOT, CONTRACT_SECTION, DEFAULT_QUESTION, MAX_PROJECT_ID_CHARS, MOOD_AI_PLUGIN, MOOD_ANALYZE_PURPOSE, MOOD_PLUGIN, MOOD_RPC_CHANNEL, MOOD_SOURCE_KIND, PROMPT_VERSION, SCHEMA_VERSION, cloneContract, defaultSettings, excerptOf, fail, isMoodMode, ok, parseSessionId, projectIdFromCwd, readinessLabel, sessionIdOf } from "./contracts.js";
+import { registerHostRpc } from "@klarkxy/dsh-ai-services/host-rpc";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { randomUUID } from "node:crypto";
+import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
+import { z } from "zod";
+//#region src/evidence.ts
+function textFromContent(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	const parts = [];
+	for (const block of content) {
+		if (!block || typeof block !== "object") continue;
+		const row = block;
+		if (row.type === "text" && typeof row.text === "string") parts.push(row.text);
+	}
+	return parts.join("\n");
+}
+function asRecord$1(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function messageSource(value) {
+	const row = asRecord$1(value);
+	return asRecord$1(row?.source) ?? asRecord$1(asRecord$1(row?.message)?.source);
+}
+function isHumanUserMessage(message) {
+	return message?.source?.kind === "user";
+}
+function isMoodMessage(message) {
+	if (message?.source?.kind !== "plugin:@klarkxy/dsh-mood" || message.source.plugin !== "@klarkxy/dsh-mood") return false;
+	if (message.source.form === "snapshot") return Boolean(message.source.sections?.some((section) => section.name === CONTRACT_SECTION));
+	return true;
+}
+function incomingAreAuxiliaryOnly(messages) {
+	if (messages.length === 0) return true;
+	return messages.every((message) => !isHumanUserMessage(message));
+}
+function humanTextOf(message) {
+	return textFromContent(message.content);
+}
+function messageIdOf(value) {
+	if (typeof value === "string" && value.length > 0) return value;
+}
+function collectClaimedHumans(messages) {
+	const humans = [];
+	for (const message of messages) {
+		if (!isHumanUserMessage(message)) continue;
+		const id = messageIdOf(message.id);
+		if (!id) continue;
+		const text = humanTextOf(message);
+		if (!text.trim()) continue;
+		humans.push({
+			id,
+			text
+		});
+	}
+	return humans;
+}
+function latestUserSeq(events) {
+	let seq = 0;
+	for (const event of events) if (event.type === "user/message" && messageSource(event.data)?.kind === "user") seq = event.seq;
+	return seq;
+}
+/** Immutable claimed user-message ids only. Previous turn seq is not this request. */
+function sourceVersionOf(humans) {
+	return humans.map((item) => item.id).filter(Boolean).join("|");
+}
+function evidenceForRequest(sessionId, events, claimed) {
+	const ids = new Set(claimed.map((item) => item.id));
+	if (ids.size === 0) return [];
+	const refs = [];
+	for (const event of events) {
+		if (event.type !== "user/message") continue;
+		const data = asRecord$1(event.data);
+		const id = messageIdOf(data?.id);
+		if (!id || !ids.has(id)) continue;
+		if (messageSource(event.data)?.kind !== "user") continue;
+		const excerpt = excerptOf(textFromContent(data?.content));
+		refs.push(excerpt ? {
+			sessionId,
+			seq: event.seq,
+			kind: "user",
+			excerpt
+		} : {
+			sessionId,
+			seq: event.seq,
+			kind: "user"
+		});
+	}
+	return refs;
+}
+//#endregion
+//#region src/inject.ts
+function contractMessageInput(text) {
+	return {
+		source: {
+			kind: MOOD_SOURCE_KIND,
+			plugin: MOOD_PLUGIN,
+			form: "snapshot",
+			sections: [{
+				name: CONTRACT_SECTION,
+				text
+			}]
+		},
+		content: [{
+			type: "text",
+			text
+		}]
+	};
+}
+function createMoodContextMessage(text) {
+	return createUserMessage(contractMessageInput(text));
+}
+function formatContract(contract, clarification = []) {
+	const lines = [
+		`【需求约定 · ${readinessLabel(contract.readiness)}】`,
+		contract.goal ? `目标：${contract.goal}` : "",
+		contract.deliverables.length ? `交付：${contract.deliverables.join("；")}` : "",
+		contract.inScope.length ? `范围内：${contract.inScope.join("；")}` : "",
+		contract.outOfScope.length ? `范围外：${contract.outOfScope.join("；")}` : "",
+		contract.constraints.length ? `约束：${contract.constraints.join("；")}` : "",
+		contract.acceptance.length ? `验收：${contract.acceptance.join("；")}` : "",
+		contract.assumptions.length ? `假定：${contract.assumptions.join("；")}` : ""
+	];
+	if (clarification.length) {
+		lines.push("澄清：");
+		for (const item of clarification) {
+			const answer = item.answer ? ` → ${item.answer}` : "";
+			lines.push(`- [${item.status}] ${item.question}${answer}`);
+		}
+	} else if (contract.questions.length) lines.push(`待确认：${contract.questions.join("；")}`);
+	if (contract.evidence.length) lines.push("证据：" + contract.evidence.map((item) => `#${item.seq}${item.excerpt ? `「${item.excerpt}」` : ""}`).join(" "));
+	lines.push("本约定不能代替文件修改或发布审批。未确认前不要当作已授权。");
+	return lines.filter(Boolean).join("\n");
+}
+function mergeContractMessage(messages, extra) {
+	return [...messages.filter((message) => !isMoodMessage(message)), extra];
+}
+//#endregion
+//#region src/analyze.ts
+function asString$1(value) {
+	return typeof value === "string" ? value.trim() : "";
+}
+function asList(value, max = 16) {
+	if (!Array.isArray(value)) return [];
+	const items = [];
+	for (const entry of value) {
+		const text = asString$1(entry);
+		if (!text) continue;
+		items.push(text.slice(0, 400));
+		if (items.length >= max) break;
+	}
+	return items;
+}
+function parseAnalysis(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return void 0;
+	const raw = trimmed.match(/```(?:json)?\s*([\s\S]*?)```/)?.[1]?.trim() ?? trimmed;
+	const start = raw.indexOf("{");
+	const end = raw.lastIndexOf("}");
+	if (start < 0 || end <= start) return void 0;
+	try {
+		const parsed = JSON.parse(raw.slice(start, end + 1));
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+		const row = parsed;
+		const goal = asString$1(row.goal).slice(0, 2e3);
+		const questions = asList(row.questions, 3);
+		return {
+			goal,
+			deliverables: asList(row.deliverables),
+			inScope: asList(row.inScope),
+			outOfScope: asList(row.outOfScope),
+			constraints: asList(row.constraints),
+			acceptance: asList(row.acceptance),
+			assumptions: asList(row.assumptions),
+			questions
+		};
+	} catch {
+		return;
+	}
+}
+function boundQuestions(questions, kind) {
+	const unique = [];
+	for (const question of questions) {
+		const text = question.trim();
+		if (!text) continue;
+		if (unique.includes(text)) continue;
+		unique.push(text.slice(0, 400));
+		if (unique.length === 3) return unique;
+	}
+	if (unique.length === 0 && (kind === "material" || kind === "risk")) return [DEFAULT_QUESTION];
+	return unique;
+}
+const ANALYZE_SYSTEM = [
+	"你在确认写作任务需求。只根据给定的真实用户原文归纳。",
+	"不要编造未给出的文件、人物、字数或验收条件。",
+	"不要把需求确认写成文件修改或发布授权。",
+	"返回一个 JSON 对象，不要 Markdown。",
+	"键：goal, deliverables, inScope, outOfScope, constraints, acceptance, assumptions, questions。",
+	`questions 最多 3 条，仅在存在实质含糊或风险时提出；原文已经可执行则 questions 为空数组。`
+].join("\n");
+function thinContract(input) {
+	return {
+		id: input.id,
+		sessionId: input.sessionId,
+		sourceVersion: input.sourceVersion,
+		revision: input.revision,
+		goal: input.goal.slice(0, 2e3),
+		deliverables: input.extra?.deliverables ?? [],
+		inScope: input.extra?.inScope ?? [],
+		outOfScope: input.extra?.outOfScope ?? [],
+		constraints: input.extra?.constraints ?? [],
+		acceptance: input.extra?.acceptance ?? [],
+		assumptions: input.extra?.assumptions ?? [],
+		questions: input.extra?.questions ?? [],
+		evidence: input.evidence,
+		readiness: input.readiness,
+		updatedAt: input.now
+	};
+}
+function contractFromDraft(input) {
+	const draft = input.draft;
+	return thinContract({
+		id: input.id,
+		sessionId: input.sessionId,
+		sourceVersion: input.sourceVersion,
+		revision: input.revision,
+		goal: draft?.goal || input.goalFallback,
+		evidence: input.evidence,
+		readiness: input.readiness,
+		now: input.now,
+		extra: {
+			deliverables: draft?.deliverables ?? [],
+			inScope: draft?.inScope ?? [],
+			outOfScope: draft?.outOfScope ?? [],
+			constraints: draft?.constraints ?? [],
+			acceptance: draft?.acceptance ?? [],
+			assumptions: draft?.assumptions ?? [],
+			questions: input.questions
+		}
+	});
+}
+const analyzePurpose = {
+	id: "mood.analyze",
+	label: "需求澄清",
+	defaultTarget: {
+		kind: "role",
+		role: "normal"
+	},
+	maxOutputTokens: 1024,
+	timeoutMs: 6e4
+};
+//#endregion
+//#region src/trigger.ts
+const ACK = /^(好的?|嗯+|行|ok|okay|收到|谢谢[.。!！]?|thanks[.!]?)$/i;
+const CONTINUE = /^(继续|接着(?:做|写|改)?|go on|continue)$/i;
+const VAGUE = /帮我(?:看|改|写|弄)?一下|改一下|写一下|处理一下|优化一下|弄好|随便|看情况|你决定|都行|无所谓|或者就|怎么写都行|看着办|帮我改改|改改/;
+const RISK = /删除全部|全部删除|清空(?:全书|所有|全部)?|覆盖原文|覆盖所有|重写全|全部重写|并发布|发布到|永久删除|替换所有/;
+const PATH = /\.[A-Za-z][A-Za-z0-9]{0,7}\b|第[一二三四五六七八九十百0-9]+章|[A-Za-z]:\\|\//;
+const BOUND = /不超过|不少于|至少|最多|保持|不要|仅|只|必须|字以内|<=|≥|\d+\s*(?:字|句|段|行)/;
+const NAMED = /[\u4e00-\u9fff]{2,6}(?:的)?(?:对白|对话|语气|出场)|“[^”]{2,40}”/;
+const EXPLAIN = /解释什么是|^什么是|explain\s+what/i;
+const TRANSLATE = /翻译成|译成|translate\s+.+\s+into/i;
+const LOCAL_EDIT = /把第[一二三四五六七八九十百0-9]+[行句段]|修正拼写|重命名为|把错字|typo/i;
+function classifyRequest(text, options = {}) {
+	const trimmed = text.replace(/\s+/g, " ").trim();
+	if (!trimmed) return "skip";
+	if (ACK.test(trimmed)) return "skip";
+	if (CONTINUE.test(trimmed)) return options.hasConfirmedContract ? "skip" : "material";
+	if (RISK.test(trimmed)) return "risk";
+	if (EXPLAIN.test(trimmed) || TRANSLATE.test(trimmed) || LOCAL_EDIT.test(trimmed)) return "clear";
+	if (VAGUE.test(trimmed)) return "material";
+	const specific = PATH.test(trimmed) || NAMED.test(trimmed);
+	const bounded = BOUND.test(trimmed);
+	if (specific && bounded && trimmed.length >= 16) return "clear";
+	if (specific || bounded) return "mild";
+	return "clear";
+}
+function shouldAnalyze(kind, mode, pendingManual) {
+	if (kind === "skip") return false;
+	if (pendingManual) return true;
+	if (mode === "manual") return false;
+	if (mode === "strict") return true;
+	return kind === "material" || kind === "risk";
+}
+function shouldWriteClearContract(kind, pendingManual, mode = "auto") {
+	return kind === "clear" && !pendingManual && mode === "auto";
+}
+function isBlockingKind(kind) {
+	return kind === "material" || kind === "risk";
+}
+//#endregion
+//#region src/questions.ts
+/** Native option label; selecting it without custom text is not an answer. */
+const ASK_DETAIL_OPTION = "补充说明";
+function toAskItems(items) {
+	return items.filter((item) => item.status === "pending").map((item) => ({
+		id: item.id,
+		header: "澄清",
+		question: item.question,
+		options: [{
+			label: ASK_DETAIL_OPTION,
+			description: "在自定义输入中写明范围、约束或验收标准"
+		}]
+	}));
+}
+function pendingClarifications(questions) {
+	return questions.map((question, index) => ({
+		id: `q${index + 1}`,
+		question,
+		status: "pending"
+	}));
+}
+function answerText(item) {
+	const selected = item.selected.map((entry) => entry.trim()).filter(Boolean).filter((entry) => entry !== ASK_DETAIL_OPTION);
+	const custom = item.custom?.trim() ?? "";
+	if (custom && selected.length) return `${selected.join("；")}；${custom}`;
+	if (custom) return custom;
+	return selected.join("；");
+}
+function applyAnswers(items, answer) {
+	const byId = new Map((answer?.answers ?? []).map((entry) => [entry.id, entry]));
+	return items.map((item) => {
+		if (item.status !== "pending") return item;
+		const entry = byId.get(item.id);
+		if (!entry) return {
+			...item,
+			status: "skipped"
+		};
+		const text = answerText(entry);
+		if (!text) return {
+			...item,
+			status: "skipped"
+		};
+		return {
+			...item,
+			status: "answered",
+			answer: text.slice(0, 400)
+		};
+	});
+}
+function markClarification(items, status) {
+	return items.map((item) => item.status === "pending" ? {
+		...item,
+		status
+	} : item);
+}
+function readinessAfterAnswers(items, kind = "mild") {
+	if (items.some((item) => item.status === "pending")) return "pending";
+	if (items.length === 0) return "user-confirmed";
+	if (items.every((item) => item.status === "answered")) return "user-confirmed";
+	if (isBlockingKind(kind)) return "pending";
+	return "disclosed-assumptions";
+}
+function answeredNotes(items) {
+	return items.filter((item) => item.status === "answered" && item.answer).map((item) => `${item.question}：${item.answer}`);
+}
+function isAskAborted(error) {
+	if (!error || typeof error !== "object") return false;
+	const row = error;
+	if (row.code === "ASK_ABORTED" || row.code === "ASK_CANCELLED") return true;
+	const name = String(row.name ?? "");
+	return name === "AbortError" || name === "TimeoutError";
+}
+function isAbortLike(error, signal) {
+	if (signal?.aborted) return true;
+	if (!error || typeof error !== "object") return false;
+	const row = error;
+	const name = String(row.name ?? "");
+	const code = String(row.code ?? "");
+	return name === "AbortError" || name === "TimeoutError" || code === "ABORT_ERR" || code === "ABORTED" || isAskAborted(error);
+}
+//#endregion
+//#region src/schema.ts
+function asRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function asString(value, max) {
+	if (typeof value !== "string") return void 0;
+	const text = value.trim();
+	if (text.length > max) return void 0;
+	return text;
+}
+function asStringList(value, maxItems, maxChars) {
+	if (!Array.isArray(value) || value.length > maxItems) return void 0;
+	const items = [];
+	for (const entry of value) {
+		if (typeof entry !== "string" || entry.length > maxChars) return void 0;
+		items.push(entry);
+	}
+	return items;
+}
+function parseModeUpdate(payload) {
+	const row = asRecord(payload);
+	if (!row) return void 0;
+	if (typeof row.expectedRevision !== "number" || !Number.isInteger(row.expectedRevision) || row.expectedRevision < 0) return void 0;
+	if (!isMoodMode(row.mode)) return void 0;
+	return {
+		expectedRevision: row.expectedRevision,
+		mode: row.mode
+	};
+}
+function parseManual(payload) {
+	const sessionId = parseSessionId(payload);
+	return sessionId ? { sessionId } : void 0;
+}
+const PATCH_KEYS = [
+	"goal",
+	"deliverables",
+	"inScope",
+	"outOfScope",
+	"constraints",
+	"acceptance",
+	"assumptions",
+	"questions"
+];
+function parseEdit(payload) {
+	const row = asRecord(payload);
+	if (!row) return void 0;
+	const sessionId = parseSessionId(row);
+	if (!sessionId) return void 0;
+	if (typeof row.expectedRevision !== "number" || !Number.isInteger(row.expectedRevision) || row.expectedRevision < 0) return void 0;
+	const patchRow = asRecord(row.patch);
+	if (!patchRow) return void 0;
+	const patch = {};
+	for (const key of Object.keys(patchRow)) if (!PATCH_KEYS.includes(key)) return void 0;
+	if (patchRow.goal !== void 0) {
+		const goal = asString(patchRow.goal, 2e3);
+		if (goal === void 0) return void 0;
+		patch.goal = goal;
+	}
+	for (const key of [
+		"deliverables",
+		"inScope",
+		"outOfScope",
+		"constraints",
+		"acceptance",
+		"assumptions",
+		"questions"
+	]) {
+		if (patchRow[key] === void 0) continue;
+		const list = asStringList(patchRow[key], 16, 400);
+		if (!list) return void 0;
+		patch[key] = list;
+	}
+	if (Object.keys(patch).length === 0) return void 0;
+	return {
+		sessionId,
+		expectedRevision: row.expectedRevision,
+		patch
+	};
+}
+//#endregion
+//#region src/service.ts
+var MoodService = class {
+	options;
+	settings;
+	sessions = /* @__PURE__ */ new Map();
+	storageFailed = false;
+	active = true;
+	ai;
+	unregisterPurpose;
+	pending = Promise.resolve();
+	now;
+	nextId;
+	constructor(options) {
+		this.options = options;
+		const loaded = cloneState(options.store?.load() ?? {
+			settings: defaultSettings(),
+			sessions: {}
+		});
+		this.settings = loaded.settings;
+		for (const [sessionId, row] of Object.entries(loaded.sessions)) this.sessions.set(sessionId, {
+			...row,
+			clarification: row.clarification ?? [],
+			pendingManual: Boolean(row.pendingManual),
+			generation: 0
+		});
+		this.now = options.now ?? Date.now;
+		this.nextId = options.id ?? randomUUID;
+		this.syncAi();
+	}
+	getContract(sessionId) {
+		const contract = this.sessions.get(sessionId)?.contract;
+		return contract ? cloneContract(contract) : void 0;
+	}
+	status(sessionId) {
+		const status = {
+			settings: { ...this.settings },
+			storageFailed: this.storageFailed
+		};
+		if (!sessionId) return status;
+		const row = this.ensure(sessionId);
+		status.session = this.view(sessionId, row);
+		return status;
+	}
+	isActive() {
+		return this.active;
+	}
+	async dispose() {
+		this.active = false;
+		for (const row of this.sessions.values()) {
+			row.generation += 1;
+			row.work?.abort();
+			row.work = void 0;
+		}
+		this.detachAi();
+		await this.pending;
+	}
+	async call(endpoint, payload, signal) {
+		if (!this.active) return fail("MOOD_DISABLED", "需求澄清已关闭。");
+		if (signal.aborted) return fail("MOOD_CANCELLED", "请求已取消。");
+		try {
+			if (endpoint === "status") return ok(this.status(parseSessionId(payload)));
+			if (endpoint === "contract") {
+				const sessionId = this.hostSessionId(parseSessionId(payload), false);
+				if (!sessionId) return fail("MOOD_INVALID", "缺少会话。");
+				return ok(this.getContract(sessionId) ?? null);
+			}
+			if (endpoint === "mode") {
+				const parsed = parseModeUpdate(payload);
+				if (!parsed) return fail("MOOD_INVALID", "模式格式无效。");
+				return ok(await this.updateMode(parsed.mode, parsed.expectedRevision));
+			}
+			if (endpoint === "manual") {
+				const parsed = parseManual(payload);
+				if (!parsed) return fail("MOOD_INVALID", "缺少会话。");
+				const sessionId = this.hostSessionId(parsed.sessionId, true);
+				if (!sessionId) return fail("MOOD_SESSION_NOT_FOUND", "会话不在当前 Host。");
+				return ok(await this.requestManual(sessionId));
+			}
+			if (endpoint === "retry") {
+				const parsed = parseManual(payload);
+				if (!parsed) return fail("MOOD_INVALID", "缺少会话。");
+				const sessionId = this.hostSessionId(parsed.sessionId, true);
+				if (!sessionId) return fail("MOOD_SESSION_NOT_FOUND", "会话不在当前 Host。");
+				return ok(await this.requestRetry(sessionId));
+			}
+			if (endpoint === "edit") {
+				const parsed = parseEdit(payload);
+				if (!parsed) return fail("MOOD_INVALID", "修订格式无效。");
+				const sessionId = this.hostSessionId(parsed.sessionId, true);
+				if (!sessionId) return fail("MOOD_SESSION_NOT_FOUND", "会话不在当前 Host。");
+				return ok(await this.editContract(sessionId, parsed.expectedRevision, parsed.patch));
+			}
+			return fail("MOOD_INVALID", "未知操作。");
+		} catch (error) {
+			const code = error && typeof error === "object" && "code" in error ? String(error.code) : "MOOD_FAILED";
+			return fail(code, error instanceof Error ? error.message : "需求澄清操作失败。");
+		}
+	}
+	async handlePreStep(payload, next) {
+		const inner = await next();
+		if (!this.active) return inner;
+		if (inner.kind !== "enter") return inner;
+		payload.signal.throwIfAborted();
+		const sessionId = sessionIdOf(payload.agent);
+		if (!sessionId) return inner;
+		const claimedMessages = payload.messages;
+		const state = this.ensure(sessionId);
+		state.projectId = projectIdFromCwd(payload.agent.session?.header?.cwd ?? payload.agent.session?.meta?.cwd) ?? projectIdFromCwd(this.options.liveSession?.(sessionId)?.header?.cwd ?? this.options.liveSession?.(sessionId)?.meta?.cwd) ?? state.projectId;
+		if (incomingAreAuxiliaryOnly(claimedMessages) && !state.pendingManual) {
+			if (this.isBlocked(state)) return { kind: "reject" };
+			return this.enter(inner, state.contract, state.clarification);
+		}
+		const claimed = collectClaimedHumans(claimedMessages);
+		const sourceVersion = sourceVersionOf(claimed);
+		const evidence = evidenceForRequest(sessionId, this.options.readEvents(sessionId) ?? [], claimed);
+		const text = claimed.at(-1)?.text ?? "";
+		if (claimed.length) this.supersedeIfNew(sessionId, sourceVersion);
+		const live = this.ensure(sessionId);
+		if (live.lastHandledVersion === sourceVersion && !live.pendingManual && isSettled(live.contract?.readiness)) return this.enter(inner, live.contract, live.clarification);
+		const kind = classifyRequest(text, { hasConfirmedContract: isSettled(live.contract?.readiness) });
+		if (kind === "skip" && !live.pendingManual) return this.enter(inner, live.contract, live.clarification);
+		if (shouldWriteClearContract(kind, live.pendingManual, this.settings.mode)) {
+			const generation = live.generation;
+			const contract = thinContract({
+				id: this.nextId(),
+				sessionId,
+				sourceVersion,
+				revision: nextRevision(live.contract),
+				goal: text.slice(0, 2e3),
+				evidence,
+				readiness: "clear-request",
+				now: this.now()
+			});
+			if (!await this.commitIfCurrent(sessionId, generation, {
+				contract,
+				clarification: [],
+				lastHandledVersion: sourceVersion,
+				pendingManual: false,
+				heldRequest: void 0,
+				projectId: live.projectId
+			})) return this.afterStale(inner);
+			return this.enter(inner, contract, []);
+		}
+		if (!shouldAnalyze(kind, this.settings.mode, live.pendingManual)) return inner;
+		const generation = live.generation;
+		live.inflightVersion = sourceVersion;
+		const work = this.replaceWork(sessionId);
+		const combined = combineSignals(payload.signal, work.signal, this.ai?.signal);
+		let draft = void 0;
+		try {
+			draft = await this.runAnalysis({
+				sessionId,
+				sourceVersion,
+				text,
+				evidence,
+				signal: combined,
+				generation
+			});
+		} catch (error) {
+			if (!this.generationCurrent(sessionId, generation)) return this.afterStale(inner);
+			const status = isAbortLike(error, combined) ? "cancelled" : "pending";
+			await this.blockUnresolved({
+				sessionId,
+				generation,
+				sourceVersion,
+				text,
+				evidence,
+				kind,
+				claimed: claimedMessages,
+				status,
+				inner
+			});
+			return { kind: "reject" };
+		}
+		if (!this.generationCurrent(sessionId, generation)) return this.afterStale(inner);
+		const questions = boundQuestions(draft?.questions ?? [], kind);
+		const clarification = pendingClarifications(questions);
+		let contract = contractFromDraft({
+			id: this.nextId(),
+			sessionId,
+			sourceVersion,
+			revision: nextRevision(this.ensure(sessionId).contract),
+			goalFallback: text.slice(0, 2e3),
+			evidence,
+			draft,
+			questions,
+			readiness: questions.length || isBlockingKind(kind) ? "pending" : "disclosed-assumptions",
+			now: this.now()
+		});
+		if (questions.length > 0) {
+			const asked = await this.askOnce(payload.agent, clarification, combined);
+			if (!this.generationCurrent(sessionId, generation)) return this.afterStale(inner);
+			if (asked.kind === "aborted" || asked.kind === "failed") {
+				const status = asked.kind === "aborted" ? "cancelled" : "pending";
+				await this.blockUnresolved({
+					sessionId,
+					generation,
+					sourceVersion,
+					text,
+					evidence,
+					kind,
+					claimed: claimedMessages,
+					status,
+					inner,
+					contract,
+					clarification: asked.kind === "aborted" ? markClarification(clarification, "cancelled") : clarification
+				});
+				return { kind: "reject" };
+			}
+			const answered = applyAnswers(clarification, asked.answer);
+			const readiness = readinessAfterAnswers(answered, kind);
+			if (isBlockingKind(kind) && readiness !== "user-confirmed") {
+				contract = {
+					...contract,
+					readiness: "pending",
+					assumptions: draft?.assumptions ?? contract.assumptions,
+					constraints: [...contract.constraints, ...answeredNotes(answered)],
+					questions: answered.filter((item) => item.status !== "answered").map((item) => item.question),
+					updatedAt: this.now()
+				};
+				await this.commitIfCurrent(sessionId, generation, {
+					contract,
+					clarification: answered,
+					pendingManual: false,
+					lastHandledVersion: void 0,
+					heldRequest: holdOf(sourceVersion, kind, claimedMessages),
+					projectId: this.ensure(sessionId).projectId
+				});
+				return { kind: "reject" };
+			}
+			contract = {
+				...contract,
+				readiness,
+				assumptions: [...contract.assumptions, ...isBlockingKind(kind) ? [] : answered.filter((item) => item.status === "skipped").map((item) => `未回答：${item.question}`)],
+				constraints: [...contract.constraints, ...answeredNotes(answered)],
+				questions: answered.filter((item) => item.status !== "answered").map((item) => item.question),
+				updatedAt: this.now()
+			};
+			if (!await this.commitIfCurrent(sessionId, generation, {
+				contract,
+				clarification: answered,
+				lastHandledVersion: sourceVersion,
+				pendingManual: false,
+				heldRequest: void 0,
+				projectId: this.ensure(sessionId).projectId
+			})) return this.afterStale(inner);
+			return this.enter(inner, contract, answered);
+		}
+		if (isBlockingKind(kind) && contract.readiness === "pending") {
+			await this.commitIfCurrent(sessionId, generation, {
+				contract,
+				clarification,
+				pendingManual: false,
+				lastHandledVersion: void 0,
+				heldRequest: holdOf(sourceVersion, kind, claimedMessages),
+				projectId: this.ensure(sessionId).projectId
+			});
+			return { kind: "reject" };
+		}
+		if (!await this.commitIfCurrent(sessionId, generation, {
+			contract,
+			clarification,
+			lastHandledVersion: sourceVersion,
+			pendingManual: false,
+			heldRequest: void 0,
+			projectId: this.ensure(sessionId).projectId
+		})) return this.afterStale(inner);
+		return this.enter(inner, contract, clarification);
+	}
+	async runAnalysis(input) {
+		const scope = this.ai;
+		if (!scope?.active) return void 0;
+		input.signal.throwIfAborted();
+		const result = await scope.run({
+			purpose: MOOD_ANALYZE_PURPOSE,
+			sessionId: input.sessionId,
+			sourceVersion: input.sourceVersion,
+			promptVersion: PROMPT_VERSION,
+			schemaVersion: SCHEMA_VERSION,
+			system: ANALYZE_SYSTEM,
+			input: JSON.stringify({
+				text: input.text,
+				evidence: input.evidence
+			}),
+			signal: input.signal,
+			priority: "interactive",
+			isCurrent: () => this.generationCurrent(input.sessionId, input.generation) && !input.signal.aborted
+		});
+		if (result.receipt.status !== "success") return void 0;
+		if (!this.generationCurrent(input.sessionId, input.generation)) return void 0;
+		return parseAnalysis(result.text);
+	}
+	async askOnce(agent, clarification, signal) {
+		const ask = this.options.askUser;
+		const items = toAskItems(clarification);
+		if (!items.length || !ask) return { kind: "failed" };
+		try {
+			return {
+				kind: "answered",
+				answer: await ask({
+					agent,
+					questions: items,
+					signal
+				})
+			};
+		} catch (error) {
+			if (isAbortLike(error, signal)) return { kind: "aborted" };
+			return { kind: "failed" };
+		}
+	}
+	afterStale(inner) {
+		if (!this.active) return inner;
+		return { kind: "reject" };
+	}
+	enter(decision, contract, clarification) {
+		if (!this.active || !contract) return decision;
+		if (contract.readiness === "pending" || contract.readiness === "cancelled" || contract.readiness === "stale") return decision;
+		const text = formatContract(contract, clarification);
+		const extra = this.options.createInjectMessage ? this.options.createInjectMessage(text) : createMoodContextMessage(text);
+		return {
+			...decision,
+			messages: mergeContractMessage(decision.messages ?? [], extra)
+		};
+	}
+	async blockUnresolved(input) {
+		if (!this.generationCurrent(input.sessionId, input.generation)) return;
+		const state = this.ensure(input.sessionId);
+		const questions = boundQuestions(input.contract?.questions ?? [], input.kind);
+		const clarification = input.clarification ?? markClarification(pendingClarifications(questions), input.status === "pending" ? "pending" : input.status);
+		const contract = input.contract ? {
+			...input.contract,
+			readiness: input.status,
+			questions,
+			updatedAt: this.now()
+		} : thinContract({
+			id: this.nextId(),
+			sessionId: input.sessionId,
+			sourceVersion: input.sourceVersion,
+			revision: nextRevision(state.contract),
+			goal: input.text.slice(0, 2e3),
+			evidence: input.evidence,
+			readiness: input.status,
+			now: this.now(),
+			extra: { questions }
+		});
+		const hold = isBlockingKind(input.kind) || clarification.length > 0 ? holdOf(input.sourceVersion, input.kind, input.claimed) : void 0;
+		await this.commitIfCurrent(input.sessionId, input.generation, {
+			contract,
+			clarification,
+			pendingManual: false,
+			lastHandledVersion: void 0,
+			heldRequest: hold,
+			projectId: state.projectId
+		});
+		input.inner;
+	}
+	async updateMode(mode, expectedRevision) {
+		return this.serialize(async () => {
+			this.assertLive();
+			if (expectedRevision !== this.settings.revision) coded("MOOD_STALE", "需求澄清设置已更新，请刷新后重试。");
+			const proposed = this.snapshot();
+			proposed.settings = {
+				mode,
+				revision: this.settings.revision + 1
+			};
+			await this.persistProposed(proposed);
+			this.commitState(proposed);
+			return this.status();
+		});
+	}
+	async requestManual(sessionId) {
+		const state = this.ensure(sessionId);
+		const generation = state.generation;
+		const held = state.heldRequest;
+		if (!await this.commitIfCurrent(sessionId, generation, {
+			pendingManual: true,
+			lastHandledVersion: void 0,
+			heldRequest: held,
+			clarification: state.clarification,
+			contract: state.contract,
+			projectId: state.projectId
+		})) coded("MOOD_CANCELLED", "会话已切换，未执行手动分析。");
+		if (held?.messages.length) await this.resumeExact(sessionId, held.messages);
+		return this.status(sessionId);
+	}
+	async requestRetry(sessionId) {
+		const state = this.ensure(sessionId);
+		const held = state.heldRequest;
+		if (!held?.messages.length) coded("MOOD_NOT_FOUND", "没有可按原请求重试的内容。");
+		const generation = state.generation;
+		if (!await this.commitIfCurrent(sessionId, generation, {
+			pendingManual: false,
+			lastHandledVersion: void 0,
+			heldRequest: held,
+			clarification: state.clarification.map((item) => item.status === "cancelled" || item.status === "stale" ? {
+				...item,
+				status: "pending",
+				answer: void 0
+			} : item),
+			contract: state.contract ? {
+				...state.contract,
+				readiness: "pending",
+				updatedAt: this.now()
+			} : state.contract,
+			projectId: state.projectId
+		})) coded("MOOD_CANCELLED", "会话已切换，未重试。");
+		await this.resumeExact(sessionId, held.messages);
+		return this.status(sessionId);
+	}
+	async resumeExact(sessionId, messages) {
+		const resume = this.options.resumeHeld;
+		if (!resume) coded("MOOD_NO_RESUME", "当前 Host 不能按原请求恢复。");
+		await resume(sessionId, messages);
+	}
+	async editContract(sessionId, expectedRevision, patch) {
+		const state = this.ensure(sessionId);
+		const generation = state.generation;
+		const current = state.contract;
+		if (!current) coded("MOOD_NOT_FOUND", "还没有可修订的约定。");
+		if (current.revision !== expectedRevision) coded("MOOD_STALE", "约定已更新，请刷新后重试。");
+		const evidence = [...current.evidence, {
+			sessionId,
+			seq: latestUserSeq(this.options.readEvents(sessionId) ?? []),
+			kind: "manual",
+			excerpt: excerptOf(patch.goal ?? "修订约定")
+		}];
+		const contract = {
+			...current,
+			...patch,
+			revision: current.revision + 1,
+			readiness: "user-confirmed",
+			evidence,
+			updatedAt: this.now()
+		};
+		if (!await this.commitIfCurrent(sessionId, generation, {
+			contract,
+			clarification: state.clarification.map((item) => item.status === "pending" ? {
+				...item,
+				status: "answered",
+				answer: "作者直接修订约定"
+			} : item),
+			pendingManual: false,
+			lastHandledVersion: state.lastHandledVersion,
+			heldRequest: void 0,
+			projectId: state.projectId
+		})) coded("MOOD_CANCELLED", "会话已切换，未保存修订。");
+		return this.status(sessionId);
+	}
+	hostSessionId(sessionId, required) {
+		if (!sessionId) return void 0;
+		if (!this.options.liveSession) return sessionId;
+		const live = this.options.liveSession(sessionId);
+		if (!live) return required ? void 0 : sessionId;
+		return live.id != null ? String(live.id) : sessionId;
+	}
+	ensure(sessionId) {
+		const existing = this.sessions.get(sessionId);
+		if (existing) return existing;
+		const created = {
+			clarification: [],
+			pendingManual: false,
+			generation: 0
+		};
+		this.sessions.set(sessionId, created);
+		return created;
+	}
+	view(sessionId, row) {
+		return {
+			sessionId,
+			...row.projectId ? { projectId: row.projectId } : {},
+			...row.contract ? { contract: cloneContract(row.contract) } : {},
+			clarification: row.clarification.map((item) => ({ ...item })),
+			pendingManual: row.pendingManual,
+			held: Boolean(row.heldRequest?.messages.length)
+		};
+	}
+	isBlocked(state) {
+		if (!state.heldRequest) return false;
+		const readiness = state.contract?.readiness;
+		return readiness === "pending" || readiness === "cancelled" || state.clarification.some((item) => item.status === "pending" || item.status === "cancelled");
+	}
+	async commitIfCurrent(sessionId, generation, patch) {
+		return this.serialize(async () => {
+			if (!this.generationCurrent(sessionId, generation)) return false;
+			const proposed = this.snapshot();
+			proposed.sessions[sessionId] = storedOf({
+				...this.ensure(sessionId),
+				...patch
+			});
+			await this.persistProposed(proposed);
+			if (!this.generationCurrent(sessionId, generation)) return false;
+			this.commitState(proposed);
+			return true;
+		});
+	}
+	supersedeIfNew(sessionId, sourceVersion) {
+		const state = this.ensure(sessionId);
+		const previous = state.inflightVersion ?? state.heldRequest?.sourceVersion ?? state.contract?.sourceVersion;
+		if (!previous || previous === sourceVersion) return;
+		this.supersede(sessionId);
+	}
+	supersede(sessionId) {
+		const state = this.ensure(sessionId);
+		state.generation += 1;
+		state.work?.abort();
+		state.work = void 0;
+		state.inflightVersion = void 0;
+		state.heldRequest = void 0;
+		state.lastHandledVersion = void 0;
+		if (state.contract && state.contract.readiness !== "stale" && state.contract.readiness !== "cancelled") state.contract = {
+			...state.contract,
+			readiness: "stale",
+			updatedAt: this.now()
+		};
+		state.clarification = markClarification(state.clarification, "stale");
+	}
+	replaceWork(sessionId) {
+		const state = this.ensure(sessionId);
+		state.work?.abort();
+		const work = new AbortController();
+		state.work = work;
+		return work;
+	}
+	generationCurrent(sessionId, generation) {
+		if (!this.active) return false;
+		const state = this.sessions.get(sessionId);
+		return Boolean(state && state.generation === generation);
+	}
+	snapshot() {
+		const sessions = {};
+		for (const [sessionId, row] of this.sessions) sessions[sessionId] = storedOf(row);
+		return cloneState({
+			settings: this.settings,
+			sessions
+		});
+	}
+	commitState(proposed) {
+		this.settings = proposed.settings;
+		const next = /* @__PURE__ */ new Map();
+		for (const [sessionId, row] of Object.entries(proposed.sessions)) {
+			const previous = this.sessions.get(sessionId);
+			next.set(sessionId, {
+				...row,
+				generation: previous?.generation ?? 0,
+				work: previous?.work,
+				inflightVersion: previous?.inflightVersion
+			});
+		}
+		this.sessions = next;
+	}
+	async persistProposed(proposed) {
+		this.assertLive();
+		if (!this.options.store) {
+			this.storageFailed = false;
+			return;
+		}
+		try {
+			await this.options.store.save(cloneState(proposed));
+			this.storageFailed = false;
+		} catch (error) {
+			this.storageFailed = true;
+			if (error && typeof error === "object" && "code" in error) throw error;
+			coded("MOOD_STORAGE", "需求澄清保存失败，已保留原内容。");
+		}
+	}
+	assertLive() {
+		if (!this.active) coded("MOOD_DISABLED", "需求澄清已关闭。");
+	}
+	serialize(run) {
+		const task = this.pending.then(run, run);
+		this.pending = task.then(() => {}, () => {});
+		return task;
+	}
+	syncAi() {
+		if (!this.active) {
+			this.detachAi();
+			return;
+		}
+		if (this.ai) return;
+		const scope = this.options.activateAi?.();
+		if (!scope) return;
+		this.ai = scope;
+		this.unregisterPurpose = scope.registerPurpose(analyzePurpose);
+	}
+	detachAi() {
+		this.unregisterPurpose?.();
+		this.unregisterPurpose = void 0;
+		this.ai?.dispose();
+		this.ai = void 0;
+	}
+};
+function isSettled(readiness) {
+	return readiness === "user-confirmed" || readiness === "clear-request" || readiness === "disclosed-assumptions";
+}
+function nextRevision(contract) {
+	return (contract?.revision ?? 0) + 1;
+}
+function holdOf(sourceVersion, kind, messages) {
+	return {
+		sourceVersion,
+		trigger: kind === "risk" || kind === "material" || kind === "mild" || kind === "clear" ? kind : "material",
+		messages: structuredClone(messages)
+	};
+}
+function storedOf(row) {
+	return {
+		clarification: row.clarification,
+		pendingManual: row.pendingManual,
+		...row.contract ? { contract: row.contract } : {},
+		...row.lastHandledVersion !== void 0 ? { lastHandledVersion: row.lastHandledVersion } : {},
+		...row.projectId ? { projectId: row.projectId } : {},
+		...row.heldRequest ? { heldRequest: row.heldRequest } : {}
+	};
+}
+function cloneState(state) {
+	return structuredClone(state);
+}
+function coded(code, message) {
+	throw Object.assign(new Error(message), { code });
+}
+function combineSignals(...signals) {
+	const live = signals.filter((item) => Boolean(item));
+	if (live.length === 0) return new AbortController().signal;
+	if (live.length === 1) return live[0];
+	return AbortSignal.any(live);
+}
+//#endregion
+//#region src/storage.ts
+const evidenceSchema = z.object({
+	sessionId: z.string().min(1).max(200),
+	seq: z.number().int().nonnegative(),
+	kind: z.enum([
+		"user",
+		"tool",
+		"turn",
+		"manual"
+	]),
+	excerpt: z.string().max(200).optional()
+}).strict();
+const contractSchema = z.object({
+	id: z.string().min(1).max(120),
+	sessionId: z.string().min(1).max(200),
+	sourceVersion: z.string().min(1).max(400),
+	revision: z.number().int().nonnegative(),
+	goal: z.string().max(2e3),
+	deliverables: z.array(z.string().max(400)).max(16),
+	inScope: z.array(z.string().max(400)).max(16),
+	outOfScope: z.array(z.string().max(400)).max(16),
+	constraints: z.array(z.string().max(400)).max(16),
+	acceptance: z.array(z.string().max(400)).max(16),
+	assumptions: z.array(z.string().max(400)).max(16),
+	questions: z.array(z.string().max(400)).max(8),
+	evidence: z.array(evidenceSchema).max(32),
+	readiness: z.enum([
+		"pending",
+		"clear-request",
+		"user-confirmed",
+		"disclosed-assumptions",
+		"cancelled",
+		"stale"
+	]),
+	updatedAt: z.number().int().nonnegative()
+}).strict();
+const clarificationSchema = z.object({
+	id: z.string().min(1).max(80),
+	question: z.string().max(400),
+	status: z.enum([
+		"pending",
+		"answered",
+		"skipped",
+		"cancelled",
+		"stale"
+	]),
+	answer: z.string().max(400).optional()
+}).strict();
+const heldRequestSchema = z.object({
+	sourceVersion: z.string().min(1).max(400),
+	trigger: z.enum([
+		"material",
+		"risk",
+		"mild",
+		"clear"
+	]),
+	messages: z.array(z.unknown()).max(32)
+}).strict();
+const sessionSchema = z.object({
+	contract: contractSchema.optional(),
+	clarification: z.array(clarificationSchema).max(8),
+	lastHandledVersion: z.string().max(400).optional(),
+	pendingManual: z.boolean(),
+	projectId: z.string().max(MAX_PROJECT_ID_CHARS).optional(),
+	heldRequest: heldRequestSchema.optional()
+}).strict();
+const settingsSchema = z.object({
+	revision: z.number().int().nonnegative(),
+	mode: z.enum([
+		"auto",
+		"manual",
+		"strict"
+	])
+}).strict();
+const moodStateSchema = z.object({
+	settings: settingsSchema,
+	sessions: z.record(z.string().min(1).max(200), sessionSchema)
+}).strict();
+const moodDomain = defineDomain({
+	name: "dsh_editor_mood",
+	version: 1,
+	tables: { state: domainTable(moodStateSchema) }
+});
+function emptyMoodState() {
+	return {
+		settings: defaultSettings(),
+		sessions: {}
+	};
+}
+function domainStore(domain) {
+	const table = domain.table("state");
+	return {
+		load() {
+			const row = table.get("global");
+			if (!row) return emptyMoodState();
+			return {
+				settings: {
+					...defaultSettings(),
+					...row.settings
+				},
+				sessions: { ...row.sessions ?? {} }
+			};
+		},
+		async save(state) {
+			await table.put("global", {
+				settings: { ...state.settings },
+				sessions: { ...state.sessions }
+			});
+		}
+	};
+}
+//#endregion
+//#region src/index.ts
+const name = MOOD_PLUGIN;
+const inject = [
+	"aiServices",
+	"storageDomain",
+	"sessions",
+	"userQuestions",
+	"agents",
+	"connection",
+	"webServer"
+];
+async function apply(ctx) {
+	const host = ctx;
+	if (!host.storageDomain || !host.aiServices || !host.sessions || !host.userQuestions || !host.agents) throw new Error("dsh-mood requires Host aiServices, storageDomain, sessions, userQuestions, and agents");
+	const domain = await host.storageDomain.open(moodDomain);
+	const service = new MoodService({
+		store: domainStore(domain),
+		readEvents: (sessionId) => readSessionEvents(host, sessionId),
+		liveSession: (sessionId) => readLiveSession(host, sessionId),
+		activateAi: () => host.aiServices.activate(MOOD_PLUGIN),
+		askUser: (request) => host.userQuestions.ask(request),
+		createInjectMessage: (text) => createMoodContextMessage(text),
+		resumeHeld: async (sessionId, messages) => {
+			resumeHeldOnHost(host.agents, sessionId, messages);
+		}
+	});
+	ctx.provide("aiMood", service);
+	ctx.effect(() => async () => {
+		await service.dispose();
+		await domain.close();
+	}, "dsh-mood.dispose");
+	ctx.effect(() => registerHostRpc(host, MOOD_RPC_CHANNEL, (endpoint, payload, signal) => service.call(endpoint, payload, signal)), "dsh-mood.rpc");
+	ctx.effect(() => {
+		const offStep = listen(ctx, "agent/pre-step", async (payload, next) => service.handlePreStep(payload, next));
+		return () => {
+			offStep?.();
+		};
+	}, "dsh-mood.pre-step");
+}
+function readLiveSession(host, sessionId) {
+	return host.sessions.get(sessionId) ?? host.sessions.get(String(sessionId));
+}
+function readSessionEvents(host, sessionId) {
+	return readLiveSession(host, sessionId)?.snapshotEvents?.();
+}
+/** Bound invoke: native steer/followup call this.send on the live Agents.get instance. */
+function resumeHeldOnHost(agents, sessionId, messages) {
+	const agent = agents.get(sessionId) ?? agents.get(String(sessionId));
+	if (!agent) throw Object.assign(/* @__PURE__ */ new Error("当前 Host 没有可恢复的会话。"), { code: "MOOD_SESSION_NOT_FOUND" });
+	const humans = messages.filter((message) => isHumanUserMessage(message));
+	if (!humans.length) throw Object.assign(/* @__PURE__ */ new Error("没有可重试的原请求。"), { code: "MOOD_NOT_FOUND" });
+	if (typeof agent.steer === "function") {
+		for (const human of humans) agent.steer(human);
+		return;
+	}
+	if (typeof agent.followup === "function") {
+		for (const human of humans) agent.followup(human);
+		return;
+	}
+	throw Object.assign(/* @__PURE__ */ new Error("当前会话不能按原请求重试。"), { code: "MOOD_NO_RESUME" });
+}
+function listen(ctx, name, handler) {
+	const off = ctx.on.call(ctx, name, handler);
+	return typeof off === "function" ? off : void 0;
+}
+//#endregion
+export { CHAT_EVENTS_SLOT, MOOD_AI_PLUGIN, MOOD_PLUGIN, MOOD_RPC_CHANNEL, MoodService, apply, createMoodContextMessage, defaultSettings, domainStore, inject, moodDomain, name, projectIdFromCwd, resumeHeldOnHost };
+
+//# sourceMappingURL=index.js.map