@lmzhen/dsh-memory 0.44.0 → 0.46.0

package/lib/files/index.js

@@ -0,0 +1,187 @@
+import z from "@deepseek-ai/schemastery";
+import { createHash } from "node:crypto";
+import { resolve } from "node:path";
+import { DEFAULT_CONSOLIDATION_FAILURES, DEFAULT_MEMORY_CHAR_LIMIT, DEFAULT_USER_CHAR_LIMIT, MemoryStore, clampOnce, evolutionIoAdapter, liveBool, makeSerialQueue, paramRowId, payloadText, unwrapLive, userSetKeys } from "@lmzhen/dsh-evolution-core";
+//#region lib/types/files/index.js
+/**
+* Local layered memory provider for `ctx.memory`.
+* @module @lmzhen/dsh-memory-files
+*/
+const name = "memory-files";
+const inject = ["memory", "evolutionIo"];
+const Config = z.object({
+	providerName: z.string().default("files"),
+	memoryChars: z.number().min(1).volatile(),
+	userChars: z.number().min(1).volatile(),
+	memoryCharLimit: z.number().min(1).default(DEFAULT_MEMORY_CHAR_LIMIT),
+	userCharLimit: z.number().min(1).default(DEFAULT_USER_CHAR_LIMIT),
+	addDatePrefix: z.boolean().default(false).volatile(),
+	root: z.string().default(""),
+	maxConsolidationFailures: z.number().min(1).default(DEFAULT_CONSOLIDATION_FAILURES).volatile(),
+	threatExemptLabels: z.array(z.string()).default([])
+});
+function apply(ctx, rawConfig = {}) {
+	ctx.inject(["settings"], (injected) => {
+		const settings = injected.settings;
+		if (typeof settings?.configure !== "function") return;
+		const disposer = settings.configure({ auto: false }, ctx.fiber);
+		if (typeof disposer === "function") ctx.effect(() => disposer, "memory-files: settings presentation");
+	});
+	const clampedKeys = /* @__PURE__ */ new Set();
+	/**
+	* Clamp one supplied numeric value, warning once per key.
+	* @param name - the config key, for the warning.
+	* @param value - the value as supplied by the deployment or the user.
+	* @param fallback - the package default a corrected value falls back to.
+	* @returns the value the store may use.
+	*/
+	const field = (name, value, fallback) => clampOnce(clampedKeys, (message) => {
+		ctx.logger.warn(message);
+	}, `memory-files: ${name}`, value, fallback, 1);
+	const floorLimit = (value) => Math.floor(value);
+	const policyBudget = () => {
+		const snapshot = ctx.get("evolutionPolicy")?.get?.();
+		return {
+			memory: snapshot?.memoryChars,
+			user: snapshot?.userChars
+		};
+	};
+	const aliasDefaults = Config["~standard"].validate({}).value;
+	const ALIAS_OF = {
+		memoryChars: "memoryCharLimit",
+		userChars: "userCharLimit"
+	};
+	const DEFAULTS = {
+		memoryChars: DEFAULT_MEMORY_CHAR_LIMIT,
+		userChars: DEFAULT_USER_CHAR_LIMIT
+	};
+	/**
+	* The live value of one canonical budget key (G1 §8.3).
+	* @param id - the canonical registry id.
+	* @returns the value the platform resolved (user layer included), or undefined.
+	*/
+	const canonicalBudget = (id) => unwrapLive(id === "memoryChars" ? rawConfig.memoryChars : rawConfig.userChars);
+	/**
+	* Whether the OPERATOR set this budget on THIS ROW (G0/S0.4 + G1).
+	*
+	* The canonical key answers through its live reference — a user-layer value
+	* arrives the same way, which is what keeps a user choice ahead of the policy —
+	* and the deprecated alias through the default comparison above. The pair is
+	* documented in the Config JSDoc and reported by /evolution doctor (budgetIssues).
+	* @param id - the canonical registry id.
+	* @returns whether the row or the user supplied a value.
+	*/
+	const explicitBudget = (id) => {
+		if (canonicalBudget(id) !== void 0) return true;
+		const alias = rawConfig[ALIAS_OF[id]];
+		return alias !== void 0 && alias !== aliasDefaults[ALIAS_OF[id]];
+	};
+	/**
+	* The budget one key resolves to (G1 §8.4-A): the row's own value — canonical or
+	* alias — over the mounted policy, over the package default.
+	* @param id - the canonical registry id.
+	* @returns the resolved, unclamped budget.
+	*/
+	const budget = (id) => {
+		const explicit = canonicalBudget(id) ?? (explicitBudget(id) ? rawConfig[ALIAS_OF[id]] : void 0);
+		if (explicit !== void 0) return explicit;
+		const policy = policyBudget();
+		return (id === "memoryChars" ? policy.memory : policy.user) ?? DEFAULTS[id];
+	};
+	const memoryChars = () => floorLimit(field("memoryCharLimit", budget("memoryChars"), DEFAULT_MEMORY_CHAR_LIMIT));
+	const userChars = () => floorLimit(field("userCharLimit", budget("userChars"), DEFAULT_USER_CHAR_LIMIT));
+	const consolidationFailures = () => field("maxConsolidationFailures", rawConfig.maxConsolidationFailures, DEFAULT_CONSOLIDATION_FAILURES);
+	const addDatePrefix = () => liveBool(rawConfig.addDatePrefix);
+	const policyAtMount = policyBudget();
+	if (explicitBudget("memoryChars") && policyAtMount.memory !== void 0 && memoryChars() !== policyAtMount.memory) ctx.logger.warn(`memory-files: the row's memoryChars=${memoryChars()} contradicts evolution-policy memoryChars=${policyAtMount.memory} — the store enforces the row value while the review plans against the policy value; align them or leave the row unset`);
+	if (explicitBudget("userChars") && policyAtMount.user !== void 0 && userChars() !== policyAtMount.user) ctx.logger.warn(`memory-files: the row's userChars=${userChars()} contradicts evolution-policy userChars=${policyAtMount.user} — same divergence as memoryChars`);
+	const io = evolutionIoAdapter(() => ctx.evolutionIo.provider());
+	const authority = ctx.get("evolutionMutationAuthority");
+	const serializedWrite = makeSerialQueue();
+	const trimmedRoot = (rawConfig.root || "").trim();
+	const resolvedRoot = trimmedRoot === "" ? "" : resolve(trimmedRoot);
+	let store;
+	let storeKey = "";
+	/**
+	* The store for the configuration as it stands right now.
+	* @returns the current store, rebuilt when a resolved limit changed.
+	*/
+	const currentStore = () => {
+		const options = {
+			memoryCharLimit: memoryChars(),
+			userCharLimit: userChars(),
+			addDatePrefix: addDatePrefix(),
+			maxConsolidationFailures: consolidationFailures()
+		};
+		const key = `${options.memoryCharLimit}|${options.userCharLimit}|${options.addDatePrefix}|${options.maxConsolidationFailures}`;
+		if (store !== void 0 && key === storeKey) return store;
+		store = new MemoryStore({
+			...options,
+			...rawConfig.threatExemptLabels !== void 0 ? { threatExemptLabels: rawConfig.threatExemptLabels } : {},
+			...resolvedRoot !== "" ? { root: resolvedRoot } : {},
+			io,
+			...authority?.homeFence === void 0 ? {} : { fence: authority.homeFence }
+		});
+		storeKey = key;
+		return store;
+	};
+	const provider = {
+		name: rawConfig.providerName ?? "files",
+		read: (target) => currentStore().read(target),
+		applyBatch: async (target, operations) => {
+			const normalized = operations.map((op) => ({
+				action: op.action,
+				facts: payloadText(op),
+				old_text: op.old_text
+			}));
+			return await serializedWrite(() => currentStore().applyBatch(target, normalized));
+		},
+		snapshot: async () => {
+			const [memory, user] = await serializedWrite(async () => {
+				const current = currentStore();
+				return [await current.read("memory"), await current.read("user")];
+			});
+			const text = JSON.stringify([memory, user]);
+			return {
+				version: 1,
+				sha256: createHash("sha256").update(text).digest("hex"),
+				memory,
+				user
+			};
+		},
+		renderContext: () => serializedWrite(() => currentStore().renderContext())
+	};
+	/**
+	* Which surface supplied one budget.
+	* @param id - the canonical registry id.
+	* @returns 'user', 'config', 'policy' or 'default'.
+	*/
+	const limitSource = (id) => {
+		if (userSetKeys(ctx, paramRowId("memory-files")).has(id)) return "user";
+		if (explicitBudget(id)) return "config";
+		return (id === "memoryChars" ? policyBudget().memory : policyBudget().user) === void 0 ? "default" : "policy";
+	};
+	ctx.provide("evolutionMemoryBudget", {
+		get memoryCharLimit() {
+			return memoryChars();
+		},
+		get userCharLimit() {
+			return userChars();
+		},
+		get memorySource() {
+			return limitSource("memoryChars");
+		},
+		get userSource() {
+			return limitSource("userChars");
+		},
+		get policyMemoryChars() {
+			return policyBudget().memory;
+		},
+		get policyUserChars() {
+			return policyBudget().user;
+		}
+	});
+	ctx.effect(() => ctx.memory.registerProvider(provider), "memory-files.provider");
+}
+//#endregion
+export { Config, apply, inject, name };

package/lib/tools/index.js

@@ -0,0 +1,341 @@
+import z from "@deepseek-ai/schemastery";
+import { MEMORY_GUIDANCE_SECTION_ORDER, clampedNumber, payloadText, unwrapLive } from "@lmzhen/dsh-evolution-core";
+import { effectiveSessionPolicy } from "@lmzhen/dsh-evolution-approval";
+import { defineTool, registerEvolutionTool } from "@lmzhen/dsh-evolution-core/platform";
+import { resolveExecOrigins } from "@lmzhen/dsh-evolution-core/skills";
+//#region lib/types/tools/index.js
+/**
+* Model-facing memory tool and runtime-context memory snapshot.
+* @module @deepseek-ai/dsh-tool-memory
+*/
+const name = "tool-memory";
+/** Max characters of each echoed memory entry (single source for the Config default and the runtime slice). */
+const DEFAULT_ENTRY_PREVIEW_CHARS = 200;
+const inject = ["tools", "memory"];
+/**
+* System-prompt memory guidance, aligned with Hermes `MEMORY_GUIDANCE`.
+* Reached by the model every turn, so it is the place to steer behavior: what
+* to save durably, what not to save, and how to phrase an entry. The tool
+* schema description (`MEMORY_TOOL_DESCRIPTION`) carries the complementary
+* operation-level guidance (add/replace/remove, batch, targets, when).
+*/
+const MEMORY_GUIDANCE = "You have durable memory across sessions. Save stable user preferences, environment facts, conventions, and tool quirks with the `memory` tool. The most valuable memory is one that stops the user correcting or reminding you again, so user preferences and recurring corrections outrank procedural task details.\nWrite entries as declarative facts, not instructions to yourself: \"User prefers concise responses\" (good); \"Always respond concisely\" (bad). Imperative phrasing is re-read as a directive in later sessions and can override the user’s current request.\nDo NOT save task progress, session outcomes, completed-work logs, PR/issue numbers, commit SHAs, or anything stale within a week — use the session query tool to recall past sessions instead. Reusable procedures belong in a skill, not memory.";
+/**
+* Tool-schema description for `memory`, aligned with Hermes `MEMORY_SCHEMA`.
+* Carries the operation-level guidance: how to batch, when to save, the
+* priority order, the target semantics, and what to skip. Reached only when
+* the model is choosing/using the tool, so it complements the always-on
+* `MEMORY_GUIDANCE` system prompt.
+*/
+const MEMORY_TOOL_DESCRIPTION = "Save durable facts to persistent memory that survive across sessions. Memory is injected into future turns, so keep entries compact and high-signal.\n\nHOW: make all changes in ONE call via an `operations` array (each item {action, facts?|content?, old_text?}). The batch applies atomically and the char limit is checked on the final result — so one call can remove/replace stale entries to free room AND add new ones. Use bare action/content/old_text only for a single lone change.\n\nWHEN: save proactively when the user states a preference, correction, or personal detail, or you learn a stable fact about their environment, conventions, or workflow. Priority: user preferences & corrections > environment facts > procedures. The best memory stops the user repeating themselves.\n\nTARGETS: \"user\" = who the user is (name, role, preferences, style). \"memory\" = your notes (environment, conventions, tool quirks, lessons).\n\nSKIP: trivial/obvious info, easily re-discovered facts, task progress, completed-work logs, temporary TODO state. To recall a past session use the session query tool, not memory. Reusable procedures belong in a skill, not memory.";
+const Config = z.object({
+	memoryEnabled: z.boolean().default(true),
+	entryPreviewChars: z.number().min(1).default(DEFAULT_ENTRY_PREVIEW_CHARS).volatile()
+});
+async function apply(ctx, rawConfig = {}) {
+	ctx.inject(["settings"], (injected) => {
+		const settings = injected.settings;
+		if (typeof settings?.configure !== "function") return;
+		const disposer = settings.configure({ auto: false }, ctx.fiber);
+		if (typeof disposer === "function") ctx.effect(() => disposer, "tool-memory: settings presentation");
+	});
+	const memoryDisabled = rawConfig.memoryEnabled === false;
+	let previewClampWarned = false;
+	const previewChars = () => {
+		const value = unwrapLive(rawConfig.entryPreviewChars);
+		const clamped = clampedNumber(value, DEFAULT_ENTRY_PREVIEW_CHARS, { min: 1 });
+		if (!previewClampWarned && value !== void 0 && clamped !== value) {
+			previewClampWarned = true;
+			ctx.logger.warn(`tool-memory: entryPreviewChars=${String(value)} is invalid; falling back to the default ${DEFAULT_ENTRY_PREVIEW_CHARS}`);
+		}
+		return clamped;
+	};
+	const systemPrompt = ctx.get("systemPrompt");
+	let snapshotText = "";
+	if (!memoryDisabled) try {
+		snapshotText = await ctx.memory.renderContext();
+	} catch (error) {
+		ctx.logger.warn(`tool-memory: memory provider not ready at mount; snapshot starts empty until the first write: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (systemPrompt && !memoryDisabled) {
+		ctx.effect(() => systemPrompt.section({
+			name: "evolution:memory-guidance",
+			order: MEMORY_GUIDANCE_SECTION_ORDER,
+			text: MEMORY_GUIDANCE,
+			interpolate: false
+		}), "tool-memory.memory-guidance");
+		ctx.effect(() => systemPrompt.context({
+			name: "evolution:memory-snapshot",
+			order: 150,
+			text: () => snapshotText,
+			interpolate: false
+		}), "tool-memory.memory-snapshot");
+		const refreshSnapshot = async () => {
+			try {
+				snapshotText = await ctx.memory.renderContext();
+			} catch {}
+		};
+		ctx.effect(() => ctx.on("evolution/memory-applied", () => {
+			refreshSnapshot();
+		}), "tool-memory.snapshot-refresh");
+		ctx.effect(() => ctx.on("evolution/memory-provider-registered", () => {
+			refreshSnapshot();
+		}), "tool-memory.snapshot-ready");
+	} else if (!memoryDisabled) ctx.logger.warn("tool-memory: systemPrompt service not mounted; memory guidance and snapshot are not injected (the write tool still works)");
+	async function executeCore(normalized) {
+		if (normalized.operations?.some((op) => {
+			const raw = op;
+			return raw === null || typeof raw !== "object";
+		})) return {
+			ok: false,
+			message: "operations 的每一项都必须是对象。",
+			entries: [],
+			chars: 0,
+			limit: 0
+		};
+		const target = normalized.target;
+		if (target !== "memory" && target !== "user") return {
+			ok: false,
+			message: `memory："target" 必须是 "memory" 或 "user"（收到 ${String(target)}）；拒绝写入。`,
+			entries: [],
+			chars: 0,
+			limit: 0
+		};
+		for (const field of [
+			"facts",
+			"old_text",
+			"content"
+		]) {
+			const value = normalized[field];
+			if (value !== void 0 && value !== null && typeof value !== "string") return {
+				ok: false,
+				message: `memory："${field}" 必须是字符串（收到 ${typeof value}）；拒绝写入。`,
+				entries: [],
+				chars: 0,
+				limit: 0
+			};
+		}
+		for (const [index, operation] of (normalized.operations ?? []).entries()) for (const field of [
+			"facts",
+			"content",
+			"old_text"
+		]) {
+			const value = operation[field];
+			if (value === void 0 || value === null || typeof value === "string") continue;
+			return {
+				ok: false,
+				message: `memory：operations[${index}].${field} 必须是字符串（收到 ${typeof value}）；拒绝写入 —— 重新批准无法修复载荷缺陷，请驳回该记录。`,
+				entries: [],
+				chars: 0,
+				limit: 0
+			};
+		}
+		const result = normalized.operations ? await ctx.memory.applyBatch(normalized.target, normalized.operations) : await ctx.memory.applyBatch(normalized.target, [{
+			action: normalized.action ?? "add",
+			facts: normalized.facts,
+			old_text: normalized.old_text
+		}]);
+		return {
+			ok: result.ok,
+			message: result.message,
+			entries: result.entries.map((entry) => entry.slice(0, previewChars())),
+			chars: result.chars,
+			limit: result.limit
+		};
+	}
+	const requiredFieldRejection = (op, position) => {
+		const body = payloadText(op);
+		if (op.action === "add") return body ? null : `第 ${position} 个操作（add）：必须提供 facts。未应用任何操作。`;
+		if (op.action !== "remove" && op.action !== "replace") return `第 ${position} 个操作：未知动作「${String(op.action)}」（应为 add/remove/replace）。未应用任何操作。`;
+		if (!(op.old_text ?? "").trim()) return `第 ${position} 个操作（${op.action}）：必须提供 old_text。未应用任何操作。`;
+		if (op.action === "replace" && !body) return `第 ${position} 个操作（replace）：必须提供 facts。`;
+		return null;
+	};
+	if (!memoryDisabled) registerEvolutionTool(ctx, defineTool({
+		name: "memory",
+		description: MEMORY_TOOL_DESCRIPTION,
+		parameters: {
+			target: {
+				type: "string",
+				enum: ["memory", "user"],
+				required: true
+			},
+			action: {
+				type: "string",
+				enum: [
+					"add",
+					"replace",
+					"remove"
+				]
+			},
+			facts: { type: "string" },
+			content: { type: "string" },
+			old_text: { type: "string" },
+			operations: {
+				type: "array",
+				items: {
+					type: "object",
+					additionalProperties: false,
+					properties: {
+						action: {
+							type: "string",
+							enum: [
+								"add",
+								"replace",
+								"remove"
+							],
+							required: true
+						},
+						facts: { type: "string" },
+						content: { type: "string" },
+						old_text: { type: "string" }
+					}
+				}
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					ok: {
+						type: "boolean",
+						required: true
+					},
+					message: {
+						type: "string",
+						required: true
+					},
+					entries: {
+						type: "array",
+						required: true,
+						items: { type: "string" }
+					},
+					chars: {
+						type: "integer",
+						required: true
+					},
+					limit: {
+						type: "integer",
+						required: true
+					},
+					pending_id: { type: "string" }
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `${value.ok ? "OK" : "Error"}: ${value.message} (${value.chars}/${value.limit} chars)`
+			}]
+		},
+		isConcurrencySafe: () => false,
+		async execute(args, exec) {
+			const conflict = (a) => {
+				const facts = payloadText({ facts: a.facts });
+				const content = payloadText({ content: a.content });
+				return facts !== "" && content !== "" && facts !== content;
+			};
+			if (Array.isArray(args.operations)) for (const op of args.operations) {
+				const raw = op;
+				if (raw === null || typeof raw !== "object") return {
+					ok: false,
+					message: "operations 的每一项都必须是对象。",
+					entries: [],
+					chars: 0,
+					limit: 0
+				};
+				if (conflict(op)) return {
+					ok: false,
+					message: "每个操作只能提供 facts 或 content 之一（同一字段）：两者给了不同的值。",
+					entries: [],
+					chars: 0,
+					limit: 0
+				};
+			}
+			else if (conflict(args)) return {
+				ok: false,
+				message: "只能提供 facts 或 content 之一（同一字段）：两者给了不同的值。",
+				entries: [],
+				chars: 0,
+				limit: 0
+			};
+			if (Array.isArray(args.operations) && args.operations.length === 0) return {
+				ok: false,
+				message: "没有提供任何操作（operations 数组为空）。",
+				entries: [],
+				chars: 0,
+				limit: 0
+			};
+			if (args.operations !== void 0 && !Array.isArray(args.operations)) return {
+				ok: false,
+				message: "形状不合法：operations 必须是 {action, content?, old_text?} 对象的数组（单个操作时可省略 operations）。",
+				entries: [],
+				chars: 0,
+				limit: 0
+			};
+			const target = args.target === "user" ? "user" : "memory";
+			const normalized = Array.isArray(args.operations) ? {
+				target,
+				operations: args.operations
+			} : {
+				target,
+				action: args.action ?? "add",
+				facts: payloadText(args),
+				old_text: args.old_text
+			};
+			if (normalized.operations) for (const [index, op] of normalized.operations.entries()) {
+				const rejection = requiredFieldRejection(op, index + 1);
+				if (rejection) return {
+					ok: false,
+					message: rejection,
+					entries: [],
+					chars: 0,
+					limit: 0
+				};
+			}
+			else {
+				const rejection = requiredFieldRejection(normalized, 1);
+				if (rejection) return {
+					ok: false,
+					message: rejection,
+					entries: [],
+					chars: 0,
+					limit: 0
+				};
+			}
+			const targetLabel = target === "memory" ? "" : `${target} `;
+			const origin = resolveExecOrigins(exec).approval;
+			const sessionPolicy = effectiveSessionPolicy(ctx, exec.agent?.session);
+			const approval = ctx.get("evolutionApproval");
+			if (approval) {
+				const decision = await approval.request({
+					kind: "memory",
+					summary: `memory ${targetLabel}${Array.isArray(args.operations) ? `${args.operations.length} ops` : args.action ?? "add"}`,
+					args: normalized,
+					origin,
+					...exec.agent?.session?.id ? { sessionId: exec.agent.session.id } : {},
+					...exec.agent?.session ? { session: exec.agent.session } : {},
+					...sessionPolicy !== void 0 ? { sessionPolicy } : {}
+				});
+				if (decision.action === "staged") return {
+					ok: true,
+					message: decision.message,
+					entries: [],
+					chars: 0,
+					limit: 0,
+					...decision.pendingId !== void 0 ? { pending_id: decision.pendingId } : {}
+				};
+			}
+			return await executeCore(normalized);
+		}
+	}));
+	ctx.inject(["evolutionApproval"], (approvalCtx) => {
+		const approval = approvalCtx.evolutionApproval;
+		const dispose = memoryDisabled ? approval.registerRunner("memory", () => Promise.resolve({
+			ok: false,
+			message: "拒绝：记忆工具已禁用（tool-memory memoryEnabled:false）—— 它的回放运行器无法执行这条暂存写入。请驳回该记录；若仍需要该写入，请在重新启用该工具后再暂存。"
+		})) : approval.registerRunner("memory", (args) => executeCore(args));
+		approvalCtx.effect(() => dispose, memoryDisabled ? "tool-memory.approval-runner-disabled" : "tool-memory.approval-runner");
+	});
+}
+//#endregion
+export { Config, MEMORY_GUIDANCE, MEMORY_TOOL_DESCRIPTION, apply, inject, name };

package/lib/types/files/index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Local layered memory provider for `ctx.memory`.
+ * @module @lmzhen/dsh-memory-files
+ */
+import type { Context, Volatile } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+export declare const name = "memory-files";
+export declare const inject: string[];
+export interface Config {
+    providerName?: string;
+    /** Store-enforced character budget for MEMORY.md — the CANONICAL registry id
+     * (G1) and a LIVE row field (registry tier E3). The policy row's `memoryChars`
+     * is the same semantic on the review-planner side; the two are NOT
+     * auto-synchronised — `/evolution doctor` reports the divergence (budgetIssues).
+     * A row may spell either this name or the deprecated alias below. No schema
+     * default: the alias carries it, and a default on the canonical key would fill
+     * it and leave the alias unreachable (the store resolves
+     * DEFAULT_MEMORY_CHAR_LIMIT after the alias fallback). */
+    memoryChars?: Volatile<number | undefined>;
+    /** Store-enforced character budget for USER.md — the CANONICAL registry id (G1),
+     * a live row field on the same terms as `memoryChars`. */
+    userChars?: Volatile<number | undefined>;
+    /** Deprecated alias of `memoryChars` (G0/S0.3): still readable, refused by
+     * writes; removal was planned for 0.7.0 and is deferred (the alias still ships — see the package README). */
+    memoryCharLimit?: number;
+    /** Deprecated alias of `userChars` (G0/S0.3): still readable, refused by
+     * writes; removal was planned for 0.7.0 and is deferred (the alias still ships — see the package README). */
+    userCharLimit?: number;
+    addDatePrefix?: Volatile<boolean>;
+    root?: string;
+    /** How many consolidation failures one turn tolerates before the tool tells the model to stop retrying. */
+    maxConsolidationFailures?: Volatile<number>;
+    /** F-2 (v18): deployment-declared benign threat labels for the MEMORY store.
+     * The skill/guard channels already read this option; without it the
+     * README's "MemoryStore store option" exemption was unreachable. */
+    threatExemptLabels?: string[];
+}
+export declare const Config: z<Schemastery.ObjectS<NoInfer<{
+    providerName: z<string, string, "defined">;
+    memoryChars: z<number, number, "volatile">;
+    userChars: z<number, number, "volatile">;
+    memoryCharLimit: z<number, number, "defined">;
+    userCharLimit: z<number, number, "defined">;
+    addDatePrefix: z<boolean, boolean, "volatile-defined">;
+    root: z<string, string, "defined">;
+    maxConsolidationFailures: z<number, number, "volatile-defined">;
+    threatExemptLabels: z<string[], string[], "defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    providerName: z<string, string, "defined">;
+    memoryChars: z<number, number, "volatile">;
+    userChars: z<number, number, "volatile">;
+    memoryCharLimit: z<number, number, "defined">;
+    userCharLimit: z<number, number, "defined">;
+    addDatePrefix: z<boolean, boolean, "volatile-defined">;
+    root: z<string, string, "defined">;
+    maxConsolidationFailures: z<number, number, "volatile-defined">;
+    threatExemptLabels: z<string[], string[], "defined">;
+}>>, "plain">;
+export declare function apply(ctx: Context, rawConfig?: Config): void;
+//# sourceMappingURL=index.d.ts.map