@lmzhen/dsh-evolution-core 0.16.1 → 0.17.0

package/lib/index.js

@@ -3,9 +3,10 @@ import { basename, dirname, join, resolve } from "node:path";
 import { cp, lstat, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { createHash, randomBytes } from "node:crypto";
 import { homedir } from "node:os";
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { scopeOf } from "@deepseek-ai/dsh-scope";
+import { z } from "zod";
 //#region lib/types/citations.js
 /**
 * Citation resolution for skill bodies and support files (design §5.2).
@@ -3220,6 +3221,8 @@ const EVOLUTION_ERRORS = Object.freeze({
 	"e-305-this-invocation-carries-no-2": "E-305: this invocation carries no agent — `%a1%` needs a session-backed call (run it from a session in the GUI or the CLI).",
 	"e-317-skill-write-not-confirmed": "E-317: skill \"%a1%\" was not %a2% — the confirmation prompt was declined or dismissed, so nothing was written. The prompt appears on every create and bare delete; repeat the call only if the operator asks for it.",
 	"e-318-skill-write-without-a-read": "E-318: skill \"%a1%\" was not read in this session, so this write is refused. Read it with the `skill` tool first (a read that failed does not count), then repeat the write.",
+	"e-320-the-profile-home-is-not": "E-320: the profile home is not reported by this host, so the legacy settings document cannot be located. /evolution migrate reads `<profile home>/settings.yaml.imported`; run it from a profile-launched session.",
+	"e-321-no-io-provider-is": "E-321: no evolution-io provider is mounted, so the legacy settings document cannot be read. Mount the evolution-io row (evolution-host/evolution-all) and retry.",
 	"e-319-skill-write-confirm-timed-out": "E-319: skill \"%a1%\" was not %a2% — the confirmation prompt went unanswered for %a3% second(s), so the write was cancelled. Nobody was there to decide: set `skillWriteConfirm` to `auto` to write without a prompt, keep `ask` to wait until someone answers, or raise `skillWriteConfirmTimeoutSeconds`."
 });
 /**
@@ -4573,6 +4576,426 @@ function compositionRowIds(composition) {
 	}
 	return ids;
 }
+/** The platform package a DECLARATIVE preset row names (0.2.x replaced preset directories with it). */
+const AGENT_PRESET_PACKAGE = "@deepseek-ai/dsh-agent-preset";
+/**
+* Compose the DECLARATIVE preset row from the platform base composition and the family delta.
+*
+* 0.2.x removed the directory mechanism: `dsh-agent-preset` is an ordinary composition row whose
+* `config.plugins` carries the preset's complete child plugin list
+* (`packages/preset/agent-preset/src/index.ts`, `agent-preset-registry/src/definition.ts` — the
+* definition has NO base/extends field, which is why the platform base is merged in here).
+*
+* The composition itself is {@link composePresetComposition}: same row-collision contract and the
+* same `row-overrides.json` injection, applied while the composed rows are still at column 0 — the
+* override anchors are defined against a column-0 `- id:` row, so the indentation that puts them
+* under `plugins:` must come last.
+* @param baseComposition - the platform base preset patch/composition rows.
+* @param deltaComposition - the family delta rows.
+* @param identity - row id, preset id, display fields and order.
+* @returns the row text, newline-terminated, ready to merge into a profile patch.
+*/
+/**
+* Drop the blank lines that merely separate block-sequence items, keeping the ones INSIDE a block
+* literal (`key: |` / `>`): there a blank line is part of the value, and filtering it flattened a
+* platform base preset's multi-paragraph prompt into one paragraph (G6 review, P1).
+* @param text - the composition rows.
+* @returns the rows with the separating blank lines removed.
+*/
+function denseBlockSequence(text) {
+	const out = [];
+	let scalarIndent = -1;
+	for (const line of text.split("\n")) {
+		const trimmed = line.trim();
+		const indent = line.length - line.trimStart().length;
+		if (scalarIndent >= 0 && trimmed !== "" && indent <= scalarIndent) scalarIndent = -1;
+		if (scalarIndent < 0) {
+			const match = /^(\s*)[\w".-]+:\s*[|>]/.exec(line);
+			if (match !== null) scalarIndent = (match[1] ?? "").length;
+		}
+		if (trimmed === "" && scalarIndent < 0) continue;
+		out.push(line);
+	}
+	return out.join("\n");
+}
+function composePresetRow(baseComposition, deltaComposition, identity) {
+	const plugins = denseBlockSequence(composePresetComposition(baseComposition, deltaComposition)).split("\n").map((line) => line === "" ? "" : "      " + line).join("\n");
+	return [
+		"- id: " + identity.rowId,
+		"  name: '@deepseek-ai/dsh-agent-preset'",
+		"  config:",
+		"    id: " + identity.id,
+		"    name: " + JSON.stringify(identity.name),
+		"    description: " + JSON.stringify(identity.description),
+		"    order: " + String(identity.order),
+		"    plugins:",
+		plugins,
+		""
+	].join("\n");
+}
+/** The patch-entry key that ADDS a row: a plain entry overrides the row with the same id, so a
+* preset the platform does not ship has to arrive inside an `insert` entry
+* (`packages/boot/app-boot/tests/user-patches.spec.ts:47-64`). */
+const PATCH_INSERT_KEY = "insert";
+/**
+* Wrap a composed row as the patch entry a profile patch needs.
+*
+* The row {@link composePresetRow} returns starts at column 0; a patch entry's list nests it four
+* spaces deeper. Wrapping is a separate step because the same row text is also what
+* {@link mergePresetRow} matches by id, and because the composer's override anchors are defined
+* against column-0 rows.
+* @param row - the row text, as {@link composePresetRow} returns it.
+* @returns the patch entry text, newline-terminated.
+*/
+function composePresetInsert(row) {
+	return `- ${PATCH_INSERT_KEY}:\n${row.replace(/\s+$/, "").split("\n").map((line) => "    " + line).join("\n")}\n`;
+}
+/**
+* The row list a platform base preset patch carries under `config.plugins`, dedented to column 0.
+*
+* A base preset arrives as a whole patch entry — `- insert:` / `- id: preset-standard` /
+* `config:` / `plugins:` — because that is how the platform ships it
+* (`packages/bundle/web-app/presets/standard.patch.yml`). The preset's own list is the
+* SHALLOWEST `plugins:` line: a child row may carry a key by that name far deeper.
+* @param patchText - the base preset patch file's text.
+* @returns the plugin rows, dedented and newline-terminated.
+* @throws {Error} when the patch carries no `plugins:` list.
+*/
+function basePresetPlugins(patchText) {
+	const lines = patchText.split("\n");
+	let at = -1;
+	let indent = Number.POSITIVE_INFINITY;
+	for (const [index, line] of lines.entries()) {
+		const width = /^(\s*)plugins:\s*$/.exec(line)?.[1]?.length;
+		if (width === void 0) continue;
+		if (width < indent) {
+			indent = width;
+			at = index;
+		}
+	}
+	if (at < 0) throw new Error("evolution preset composition: the base preset patch carries no `plugins:` list");
+	const block = [];
+	for (const line of lines.slice(at + 1)) {
+		if (line.trim() === "") {
+			block.push(line);
+			continue;
+		}
+		if (line.length - line.trimStart().length <= indent) break;
+		block.push(line);
+	}
+	while (block.length > 0 && block[block.length - 1]?.trim() === "") block.pop();
+	const widths = block.filter((line) => line.trim() !== "").map((line) => line.length - line.trimStart().length);
+	const dedent = widths.length === 0 ? 0 : Math.min(...widths);
+	return block.map((line) => line.slice(0, dedent).trim() === "" ? line.slice(dedent) : line).join("\n") + "\n";
+}
+/** The row id a family preset occupies: the platform ships \`preset-standard\` for id `standard`
+* (`packages/bundle/web-app/presets/standard.patch.yml`), so a family preset id mirrors it. */
+function presetRowId(id) {
+	return `preset-${id}`;
+}
+/**
+* The patch entry a profile patch receives for one preset: base rows plus the family delta, wrapped
+* as \`- insert:\`.
+*
+* The two halves are also exposed on their own — {@link composePresetRow} for the row, so
+* {@link mergePresetRow} can match it by id, and {@link basePresetPlugins} to read the platform
+* base out of a shipped patch.
+* @param basePatchText - the platform base preset patch's text.
+* @param deltaComposition - the family delta rows.
+* @param identity - row id, preset id, display fields and order.
+* @returns the patch entry text, newline-terminated.
+*/
+function composePresetEntry(basePatchText, deltaComposition, identity) {
+	return composePresetInsert(composePresetRow(basePresetPlugins(basePatchText), deltaComposition, identity));
+}
+/**
+* The text of one row's own patch item, or null when the patch carries no such row.
+*
+* The comparison unit for a freshness check: this is byte-for-byte what {@link composePresetEntry}
+* writes for the same row id, whether the row sits inside an \`- insert:\` entry (installer-written)
+* or at column 0 (saved by the Web editor).
+* @param patchText - the patch text.
+* @param rowId - the row id to read.
+* @returns the item's text, newline-terminated, or null.
+*/
+function presetRowBody(block) {
+	const lines = block.split("\n");
+	if (!/^- insert:\s*$/.test(lines[0] ?? "")) return block;
+	return lines.slice(1).map((line) => line.startsWith("    ") ? line.slice(4) : line).join("\n");
+}
+/**
+* The row BODY of a patch block, whichever form it is in.
+*
+* {@link presetRowBlock} returns the enclosing item verbatim: an installer-written row sits inside
+* `- insert:` while a row the platform's Web editor saved IS that column-0 item. A comparison must
+* compare like with like — comparing the raw block against `composePresetEntry()` (which always
+* starts with `- insert:`) reported DIFFERS for every editor-saved row, forever (G6 review, P2), and
+* the remedy it printed (`re-run the installer`) was refused by the `exists; use --force` guard.
+* @param block - a block as {@link presetRowBlock} returns it.
+* @returns the row text, `- insert:` unwrapped and its four-space indent stripped.
+*/
+function presetRowBlock(patchText, rowId) {
+	const lines = patchText.split("\n");
+	const span = rowBlockSpan(lines, rowId);
+	if (span === null) return null;
+	const block = [...lines.slice(span.start, span.end)];
+	while (block.length > 0 && (block[block.length - 1] ?? "").trim() === "") block.pop();
+	return block.join("\n") + "\n";
+}
+/** The package every shipped base preset patch declares its row with
+* (`packages/bundle/web-app/presets/standard.patch.yml`). The platform's only bundle carrying
+* preset patches today; a bundle a caller mounts is probed beside it. */
+const PLATFORM_BUNDLE_PACKAGE = "@deepseek-ai/dsh-web-app";
+/**
+* What `DSH_AGENT_PRESET_ROOT` must name: a directory holding the platform base preset patches
+* under their shipped file names (`<base>.patch.yml`) — e.g. a copy of a same-version platform
+* tree's `packages/bundle/web-app/presets/`. The desktop application is the shape that needs it:
+* its platform packages live inside `resources/app.asar`, so there is no plain
+* `node_modules/@deepseek-ai/dsh-web-app/presets/` on disk for a source installer to read.
+*/
+const AGENT_PRESET_ROOT_HINT = "point DSH_AGENT_PRESET_ROOT at a directory holding <base>.patch.yml (copy it out of a same-version dsh tree: packages/bundle/web-app/presets/)";
+/**
+* Resolve the platform patch file one `--base` names.
+*
+* 0.2.x ships each base preset as a bundle patch layer
+* (`packages/bundle/web-app/presets/<base>.patch.yml`, declared in that package's
+* `dsh.bundle.patch`), so the FILE — not a preset directory — is the base a family row is composed
+* from. Candidates, in order: an explicit `DSH_AGENT_PRESET_ROOT`; a module-graph probe when the
+* caller supplies one (a desktop/Electron host resolves the bundle inside `app.asar`, where no file
+* walk can reach); the target profile's own `node_modules`; then, walking up from the caller,
+* every `presets/` directory of a checkout's bundle packages, then every
+* `@deepseek-ai/dsh-<name>/presets/` directory of an installed tree.
+*
+* A base with no patch file is REFUSED with every probed candidate listed: composing a family preset
+* from another base's rows would mount rows the user did not ask for, with nothing saying so.
+* @param base - the base name, already validated against `evolution-agent/bases.json`.
+* @param sources - the roots to probe.
+* @returns the patch file's absolute path.
+* @throws {Error} when no candidate exists.
+*/
+function resolveBasePresetPatch(base, sources) {
+	const file = `${base}.patch.yml`;
+	const explicit = sources.root?.trim();
+	if (explicit !== void 0 && explicit !== "") {
+		const path = join(explicit, file);
+		if (!existsSync(path)) throw new Error(`evolution preset composition: DSH_AGENT_PRESET_ROOT is set but ${path} does not exist — ${AGENT_PRESET_ROOT_HINT}`);
+		return path;
+	}
+	const probes = [];
+	const probe = (path) => {
+		probes.push(path);
+		return existsSync(path) ? path : void 0;
+	};
+	if (sources.resolve !== void 0) {
+		const probeSpecifier = `${PLATFORM_BUNDLE_PACKAGE}/presets/${file}`;
+		try {
+			const found = probe(sources.resolve(probeSpecifier));
+			if (found !== void 0) return found;
+		} catch {
+			probes.push(`node module graph: ${probeSpecifier}`);
+		}
+	}
+	if (sources.profileDir !== void 0 && sources.profileDir !== "") for (const name of new Set([PLATFORM_BUNDLE_PACKAGE, ...sources.bundles ?? []])) {
+		const found = probe(join(sources.profileDir, "node_modules", ...name.split("/"), "presets", file));
+		if (found !== void 0) return found;
+	}
+	for (let level = sources.fromDir; level !== dirname(level); level = dirname(level)) {
+		const bundleRoot = join(level, "packages", "bundle");
+		for (const name of listDirectories(bundleRoot)) {
+			const found = probe(join(bundleRoot, name, "presets", file));
+			if (found !== void 0) return found;
+		}
+		const scopeRoot = join(level, "node_modules", "@deepseek-ai");
+		for (const name of listDirectories(scopeRoot)) {
+			if (!name.startsWith("dsh-")) continue;
+			const found = probe(join(scopeRoot, name, "presets", file));
+			if (found !== void 0) return found;
+		}
+	}
+	for (const root of installRoots(sources.fromDir)) for (const shape of DESKTOP_RESOURCE_SHAPES) {
+		const found = probe(join(root, ...shape, "dsh", "node_modules", "@deepseek-ai", "dsh-web-app", "presets", file));
+		if (found !== void 0) return found;
+		const scanned = probeDesktopScope(join(root, ...shape), file, probes);
+		if (scanned !== void 0) return scanned;
+	}
+	throw new Error(`evolution preset composition: cannot find the runtime platform '${base}' preset patch — no candidate carries presets/${file}. A base with no runtime patch is refused rather than composed from another base: the generated preset must follow the platform it runs on. Probed (in order): ${probes.join(", ")}. On a desktop install the platform packages live inside resources/app.asar and no plain file exists — ${AGENT_PRESET_ROOT_HINT}`);
+}
+/** The Electron resource layouts a desktop installation exposes its unpacked packages under. */
+const DESKTOP_RESOURCE_SHAPES = [["resources", "app.asar.unpacked"], [
+	"resources",
+	"app",
+	"resources",
+	"app.asar.unpacked"
+]];
+/**
+* Installation directories a desktop/Electron tree may sit at, probed before the source walk.
+*
+* The default Windows desktop location plus every ancestor that carries an
+* `resources/app.asar.unpacked` directory (a script run from inside an installation).
+* @param fromDir - the caller's own directory.
+* @returns the candidate installation roots.
+*/
+function installRoots(fromDir) {
+	const roots = [];
+	const localAppData = process.env.LOCALAPPDATA;
+	if (process.platform === "win32" && localAppData !== void 0 && localAppData !== "") roots.push(join(localAppData, "Programs", "DeepSeek Harness"));
+	for (let level = fromDir; level !== dirname(level); level = dirname(level)) if (existsSync(join(level, "resources", "app.asar.unpacked"))) roots.push(level);
+	return roots;
+}
+/**
+* Probe every `@deepseek-ai/dsh-*` package under one unpacked resource root.
+* @param resourceRoot - e.g. `<install>/resources/app.asar.unpacked`.
+* @param file - the patch file name to look for.
+* @param probes - the caller's probe log, appended to for the failure report.
+* @returns the patch path when one exists.
+*/
+function probeDesktopScope(resourceRoot, file, probes) {
+	const scopeRoot = join(resourceRoot, "dsh", "node_modules", "@deepseek-ai");
+	for (const name of listDirectories(scopeRoot)) {
+		if (!name.startsWith("dsh-")) continue;
+		const path = join(scopeRoot, name, "presets", file);
+		probes.push(path);
+		if (existsSync(path)) return path;
+	}
+}
+/**
+* Subdirectories of one directory, or none when it does not exist: a missing level is an ordinary
+* miss on a candidate walk, not a failure.
+* @param dir - the directory to list.
+* @returns the directory names.
+*/
+function listDirectories(dir) {
+	try {
+		return readdirSync(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+	} catch {
+		return [];
+	}
+}
+/**
+* The block of one row id: the enclosing column-0 list item and the row's own first line.
+*
+* An installer-written row sits inside `- insert:` (four spaces deeper); a row the Web editor
+* saved is that column-0 item itself. Both must be replaced whole, so the span reaches back to the
+* enclosing item and forward to the next one.
+* @param lines - the patch text's lines.
+* @param rowId - the row id to locate.
+* @returns the span, or null when the patch carries no such row.
+*/
+function rowBlockSpan(lines, rowId) {
+	const rowRe = new RegExp("^\\s*- id:\\s*" + rowId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "\\s*$");
+	const rowStart = lines.findIndex((line) => rowRe.test(line));
+	if (rowStart < 0) return null;
+	let start = rowStart;
+	while (start > 0 && !/^- /.test(lines[start] ?? "")) start -= 1;
+	let end = lines.length;
+	for (let index = start + 1; index < lines.length; index += 1) if (/^- /.test(lines[index] ?? "")) {
+		end = index;
+		break;
+	}
+	return {
+		start,
+		end,
+		rowStart
+	};
+}
+/**
+* Remove one row from a patch, taking its `- insert:` item with it when that item holds nothing
+* else (an empty insert entry is left-over structure the platform would keep parsing).
+* @param patchText - the patch text to edit.
+* @param rowId - the row id to remove.
+* @returns the patch text, newline-terminated; byte-identical when the id is absent.
+*/
+function removePresetRow(patchText, rowId) {
+	const lines = patchText.split("\n");
+	const span = rowBlockSpan(lines, rowId);
+	if (span === null) return patchText;
+	const rowLine = lines[span.rowStart] ?? "";
+	const rowIndent = rowLine.length - rowLine.trimStart().length;
+	const nested = rowIndent > 0;
+	const siblings = lines.slice(span.start + 1, span.end).filter((line) => {
+		return line.length - line.trimStart().length === rowIndent && line.trimStart().startsWith("- ");
+	}).length;
+	const cut = nested && siblings > 1 ? {
+		start: span.rowStart,
+		end: rowSiblingEnd(lines, span.rowStart, span.end)
+	} : span;
+	const kept = [...lines.slice(0, cut.start), ...lines.slice(cut.end)];
+	while (kept.length > 1 && (kept[kept.length - 1] ?? "") === "") kept.pop();
+	const text = kept.join("\n");
+	if (text === "") return "";
+	return text.endsWith("\n") ? text : text + "\n";
+}
+/**
+* The end of one nested row's own block inside a patch entry.
+* @param lines - the patch text's lines.
+* @param rowStart - the row's `- id:` line.
+* @param itemEnd - the enclosing item's end.
+* @returns the index of the next sibling row, or the item's end.
+*/
+function rowSiblingEnd(lines, rowStart, itemEnd) {
+	const indent = (lines[rowStart] ?? "").length - (lines[rowStart] ?? "").trimStart().length;
+	for (let index = rowStart + 1; index < itemEnd; index += 1) {
+		const line = lines[index] ?? "";
+		if (line.trim() === "") continue;
+		const width = line.length - line.trimStart().length;
+		if (width === indent && line.trimStart().startsWith("- ")) return index;
+		if (width < indent) return index;
+	}
+	return itemEnd;
+}
+/**
+* Merge one generated row into a composition (a profile patch) by row id.
+*
+* Idempotent by construction: an existing row with the same `- id:` is REPLACED whole — its block
+* is the enclosing column-0 list item, so an installer-written row inside `- insert:` and a
+* Web-editor-saved row at column 0 are both matched by {@link rowBlockSpan} — and anything else in
+* the patch stays byte-identical, because the patch usually carries rows this installer knows
+* nothing about. A missing row is appended.
+*
+* The platform seeds a fresh profile patch with the empty list `[]`
+* (`packages/boot/app-boot/src/profile.ts`, `PROFILE_PATCH_FILENAME`), which is a COMPLETE YAML
+* document: a block sequence appended after it is not parsable. That seed is therefore replaced, not
+* extended.
+* @param patchText - the current patch text (`''` for a fresh one).
+* @param row - the row text, as {@link composePresetRow} returns it.
+* @param rowId - the row id to replace or append.
+* @returns the merged patch text, newline-terminated.
+*/
+function mergePresetRow(patchText, row, rowId) {
+	const lines = patchText.split("\n");
+	const block = row.replace(/\s+$/, "").split("\n");
+	const span = rowBlockSpan(lines, rowId);
+	if (span === null) {
+		const seedIndex = lines.findIndex((line) => EMPTY_PATCH_SEED_RE.test(line));
+		const kept = trimTrailingBlankLines(seedIndex >= 0 ? [...lines.slice(0, seedIndex), ...lines.slice(seedIndex + 1)] : [...lines]);
+		return (kept.length === 0 ? block : [...kept, ...block]).join("\n") + "\n";
+	}
+	return trimTrailingBlankLines([
+		...lines.slice(0, span.start),
+		...block,
+		...lines.slice(span.end)
+	]).join("\n") + "\n";
+}
+/** The empty patch list the platform seeds a profile patch with; see {@link mergePresetRow}. */
+const EMPTY_PATCH_SEED = "[]";
+/** The seed in any spelling the platform accepts (`[]`, `[ ]`, `[] # empty`). */
+const EMPTY_PATCH_SEED_RE = /^\s*\[\s*\](\s*#.*)?\s*$/;
+/** Drop trailing blank lines only: a kept line's own terminator (a CRLF file's `\r`) is never touched. */
+function trimTrailingBlankLines(lines) {
+	const out = [...lines];
+	while (out.length > 0 && (out[out.length - 1] ?? "").trim() === "") out.pop();
+	return out;
+}
+/**
+* The text to write when a patch is left with no entries.
+*
+* A zero-byte patch file is not what the platform writes or parses; its own seed is the empty list.
+* @param patchText - the text {@link removePresetRow} returned.
+* @returns the platform's empty-list seed when nothing is left, the text otherwise.
+*/
+function presetPatchText(patchText) {
+	return patchText.trim() === "" ? `[]\n` : patchText;
+}
 //#endregion
 //#region lib/types/prompts.js
 /**
@@ -5753,6 +6176,47 @@ function readDispatchRecord(event) {
 	};
 }
 /**
+* The ledger key of one dispatch: a scope-qualified call id.
+*
+* v43 audit (FLOW4-4): a normalizer shared by every session (skill-usage's live listener holds ONE
+* process-wide instance) used the bare call id, so two sessions that produced the same id — PTC
+* sub-call ids are short, and an id-less payload falls back to a type+payload key that is not
+* unique by construction — collided: the second session's read was absorbed as "already seen" and
+* never counted, and a settle in one session flipped the other's `ok`. Callers that span sessions
+* pass the session id as `scope`.
+* @param callId - the dispatch's call id (or its payload-derived fallback).
+* @param scope - the owning session id, or '' for a fold that never leaves one session.
+* @returns the key both the ledger and every projection fold dedupe on.
+*/
+function dispatchKeyOf(callId, scope = "") {
+	return scope === "" ? callId : `${scope}:${callId}`;
+}
+/**
+* The pure half of the ledger: what one event says about one dispatch.
+*
+* The DECISION (which dispatch, and whether this event is the one that opens it) lives here and
+* only here; carriers differ in what they keep — the class below keeps consumer-visible mutable
+* signals, the family's `evolutionReads`/`evolutionSignals` projection units keep plain-JSON
+* ledgers. `name` is empty on an event that only settles an already-opened dispatch (a native
+* `tool/result`), and `outcome` is present exactly when the event carried one.
+* @param event - one session event; any non-dispatch event answers `null`.
+* @param scope - the owning session id, or '' for a single-session fold.
+* @returns the step, or `null` when the event is not a dispatch.
+*/
+function dispatchStepOf(event, scope = "") {
+	const record = readDispatchRecord(event);
+	if (record === null) return null;
+	return {
+		key: dispatchKeyOf(record.callId, scope),
+		kind: record.kind,
+		callId: record.callId,
+		rootCallId: record.rootCallId,
+		name: record.name,
+		arguments: record.arguments,
+		...record.outcome === void 0 ? {} : { outcome: record.outcome }
+	};
+}
+/**
 * The family's single dispatch ledger: absorbs platform events in log order,
 * emits one \`ToolDispatchSignal\` per dispatch, and folds later events of the
 * same dispatch into the record it already emitted.
@@ -5776,18 +6240,6 @@ var ToolDispatchNormalizer = class {
 		this.maxTracked = options.maxTracked ?? Number.POSITIVE_INFINITY;
 	}
 	/**
-	* v43 audit (FLOW4-4): the ledger key. A normalizer shared by every session
-	* (skill-usage's live listener holds ONE process-wide instance) used the bare
-	* call id, so two sessions that produced the same id — PTC sub-call ids are
-	* short, and an id-less payload falls back to a type+payload key that is not
-	* unique by construction — collided: the second session's read was absorbed as
-	* "already seen" and never counted, and a settle in one session flipped the
-	* other's `ok`. Callers that span sessions pass the session id as `scope`.
-	*/
-	keyOf(callId, scope) {
-		return scope === "" ? callId : `${scope}:${callId}`;
-	}
-	/**
 	* Absorb one session event.
 	* @param event - the event to absorb; any non-dispatch event is ignored.
 	* @returns the dispatch's signal when this event FIRST reveals the dispatch,
@@ -5795,28 +6247,23 @@ var ToolDispatchNormalizer = class {
 	* non-dispatch event). A \`null\` return is never a dispatch to count again.
 	*/
 	advance(event, scope = "") {
-		const record = readDispatchRecord(event);
-		if (record === null) return null;
-		const key = this.keyOf(record.callId, scope);
-		if (record.name === "") {
-			const existing = this.records.get(key);
-			if (existing !== void 0 && record.outcome !== void 0) existing.ok = record.outcome.ok;
-			return null;
-		}
-		const existing = this.records.get(key);
+		const step = dispatchStepOf(event, scope);
+		if (step === null) return null;
+		const existing = this.records.get(step.key);
 		if (existing !== void 0) {
-			if (record.outcome !== void 0) existing.ok = record.outcome.ok;
+			if (step.outcome !== void 0) existing.ok = step.outcome.ok;
 			return null;
 		}
+		if (step.name === "") return null;
 		const signal = {
-			kind: record.kind,
-			callId: record.callId,
-			rootCallId: record.rootCallId,
-			name: record.name,
-			arguments: record.arguments,
-			ok: record.outcome?.ok
+			kind: step.kind,
+			callId: step.callId,
+			rootCallId: step.rootCallId,
+			name: step.name,
+			arguments: step.arguments,
+			ok: step.outcome?.ok
 		};
-		this.records.set(key, signal);
+		this.records.set(step.key, signal);
 		this.evict();
 		return signal;
 	}
@@ -5831,13 +6278,12 @@ var ToolDispatchNormalizer = class {
 	* @returns the dispatch this event settled, or \`null\`.
 	*/
 	settledSignalOf(event, scope = "") {
-		const record = readDispatchRecord(event);
-		if (record === null || record.outcome === void 0) return null;
-		const key = this.keyOf(record.callId, scope);
-		if (this.settledIds.has(key)) return null;
-		const signal = this.records.get(key);
+		const step = dispatchStepOf(event, scope);
+		if (step?.outcome === void 0) return null;
+		if (this.settledIds.has(step.key)) return null;
+		const signal = this.records.get(step.key);
 		if (signal === void 0) return null;
-		this.settledIds.add(key);
+		this.settledIds.add(step.key);
 		this.evict();
 		return signal;
 	}
@@ -6105,47 +6551,94 @@ function textOfBlock(block) {
 	const candidate = block;
 	return candidate.type === "text" && typeof candidate.text === "string" ? candidate.text : "";
 }
+/** The empty turn-window fold state. */
+function initialTurnFold() {
+	return {
+		substantive: false,
+		toolCalls: 0,
+		userChars: 0,
+		assistantChars: 0,
+		memorySignal: false,
+		skillSignal: false,
+		opened: []
+	};
+}
 /**
-* Per-turn dispatch ledgers, keyed by the signal object they feed.
+* Fold ONE session event into a turn-window state, purely.
 *
-* `observeEvent` folds ONE event at a time, so the dedup state has to outlive
-* the call. One WeakMap entry per `TurnSignals`, so a finished fold's ledger is
-* collectable with the fold itself and two concurrent turns never share one.
+* The one fold behind all three readers: `observeEvent` (the mutating face the live `turn/end`
+* path uses), `foldTurn` (a whole-log window fold, kept for structural test sessions) and the
+* family's `evolutionSignals` projection unit. P1-1/N4 guards stay: events arrive from disk, so
+* a persisted `data: null` / non-object or a malformed `content` skips instead of throwing.
+* @param state - the window so far.
+* @param event - the next committed session event.
+* @returns the next state; the same reference when the event carries nothing this fold reads.
 */
-const dispatchLedgers = /* @__PURE__ */ new WeakMap();
-/** The ledger folding this signal's turn, created on first use. */
-function normalizerForSignal(signal) {
-	let normalizer = dispatchLedgers.get(signal);
-	if (normalizer === void 0) {
-		normalizer = new ToolDispatchNormalizer();
-		dispatchLedgers.set(signal, normalizer);
-	}
-	return normalizer;
-}
-/** Fold one session event into the current turn observation. */
-function observeEvent(signal, event) {
+function foldTurnEvent(state, event) {
 	const data = event.data;
-	if (data === null || typeof data !== "object" || Array.isArray(data)) return;
+	if (data === null || typeof data !== "object" || Array.isArray(data)) return state;
 	if (event.type === "user/message") {
 		const content = data.content;
-		if (!Array.isArray(content)) return;
+		if (!Array.isArray(content)) return state;
 		const text = content.map(textOfBlock).join(" ");
-		signal.userChars += text.length;
-		if (CORRECTION_PATTERNS.some((pattern) => pattern.test(text))) signal.memorySignal = true;
-		if (FIX_PATTERNS.some((pattern) => pattern.test(text))) signal.skillSignal = true;
-		return;
+		return {
+			...state,
+			userChars: state.userChars + text.length,
+			memorySignal: state.memorySignal || CORRECTION_PATTERNS.some((pattern) => pattern.test(text)),
+			skillSignal: state.skillSignal || FIX_PATTERNS.some((pattern) => pattern.test(text))
+		};
 	}
 	if (event.type === "assistant/message") {
 		const message = data.message;
-		if (!message || !Array.isArray(message.content)) return;
+		if (!message || !Array.isArray(message.content)) return state;
 		const text = message.content.map(textOfBlock).join(" ");
-		signal.assistantChars += text.length;
-		return;
+		return {
+			...state,
+			assistantChars: state.assistantChars + text.length
+		};
 	}
-	const dispatch = normalizerForSignal(signal).advance(event);
-	if (dispatch === null) return;
-	if (dispatch.kind !== "program") signal.toolCalls += 1;
-	if (isSkillToolName(dispatch.name)) signal.skillSignal = true;
+	const dispatch = dispatchStepOf(event);
+	if (dispatch === null || dispatch.name === "" || state.opened.includes(dispatch.key)) return state;
+	let toolCalls = state.toolCalls;
+	if (dispatch.kind !== "program") toolCalls += 1;
+	return {
+		...state,
+		opened: [...state.opened, dispatch.key],
+		toolCalls,
+		skillSignal: state.skillSignal || isSkillToolName(dispatch.name)
+	};
+}
+/**
+* Per-turn dispatch ledgers, keyed by the signal object they feed.
+*
+* `observeEvent` folds ONE event at a time, so the ledger has to outlive the call. One WeakMap
+* entry per `TurnSignals`, so a finished fold's ledger is collectable with the fold itself and two
+* concurrent turns never share one.
+*/
+const dispatchLedgers = /* @__PURE__ */ new WeakMap();
+/** The ledger of the turn this signal is folding; empty before its first dispatch. */
+function ledgerForSignal(signal) {
+	return dispatchLedgers.get(signal) ?? [];
+}
+/**
+* Fold one session event into the current turn observation (the mutating face of
+* {@link foldTurnEvent}: every reader shares the one fold, this one copies the result back onto
+* the caller's signal object and keeps its ledger for the next event).
+* @param signal - the turn observation to advance.
+* @param event - the next committed session event.
+*/
+function observeEvent(signal, event) {
+	const next = foldTurnEvent({
+		...signal,
+		opened: [...ledgerForSignal(signal)]
+	}, event);
+	signal.substantive = next.substantive;
+	signal.toolCalls = next.toolCalls;
+	signal.userChars = next.userChars;
+	signal.assistantChars = next.assistantChars;
+	signal.memorySignal = next.memorySignal;
+	signal.skillSignal = next.skillSignal;
+	dispatchLedgers.set(signal, next.opened);
 }
 /** Compute review cadence after `turn/end`. */
 function advanceReview(state, turn, signal, config) {
@@ -6175,60 +6668,400 @@ function advanceReview(state, turn, signal, config) {
 	}
 	return null;
 }
-/** Fold all events between two sequence boundaries into one TurnSignals. */
-function foldTurn(session, fromSeq) {
-	const signal = {
-		substantive: false,
-		toolCalls: 0,
-		userChars: 0,
-		assistantChars: 0,
-		memorySignal: false,
-		skillSignal: false
-	};
-	const events = session.snapshotEvents();
-	for (let index = Math.max(0, fromSeq); index < events.length; index += 1) {
-		const event = events[index];
-		if (event) observeEvent(signal, event);
+/**
+* Fold a log slice into one turn window, purely.
+*
+* The whole-log reference for {@link foldTurnEvent}: a caller that holds events (a fixture, a
+* structural view, a replay) reads a window without touching a platform Session. Production reads
+* the same window live from the family's `evolutionSignals` projection (`sessionTurnSignals`),
+* which folds `foldTurnEvent` once per committed event.
+* @param events - the log, oldest first. Pass an array, not a live iterator, when it can grow.
+* @param fromSeq - index of the first event of the window (0 for the whole log).
+* @returns the window's signals.
+*/
+function foldTurnEvents(events, fromSeq = 0) {
+	const list = [...events];
+	let state = initialTurnFold();
+	for (let index = Math.max(0, fromSeq); index < list.length; index += 1) {
+		const event = list[index];
+		if (event) state = foldTurnEvent(state, event);
 	}
-	return signal;
+	const { substantive, toolCalls, userChars, assistantChars, memorySignal, skillSignal } = state;
+	return {
+		substantive,
+		toolCalls,
+		userChars,
+		assistantChars,
+		memorySignal,
+		skillSignal
+	};
 }
 //#endregion
-//#region lib/types/skill-reads.js
+//#region lib/types/evidence.js
 /**
-* The read-before-write RULE: which writes need a prior read, and which targets count as read.
-*
-* ONE rule for TWO enforcement points (design `dsh-evolution-write-gate-design.md` §4.2): the
-* tool path refuses an unread mutating write (E-318), and the plan path drops such an op from a
-* background review's plan. Before this module the rule lived in `evolution-review` only, so the
-* tool path could not see it at all.
-*
-* The READER is not here either: `tool-dispatch.collectReadSkillNames(events)` folds a session log
-* into the names read through a non-failed dispatch — the review's old session-shaped copy was a
-* line-for-line duplicate of it. What this module adds over it is the session-shaped ADAPTER
-* (`sessionReadSkillNames`), for the ONE caller that holds a session only STRUCTURALLY (the tool
-* path's gate, whose exec view may be a bare stub): it answers "which accessor, and what does an
-* unreadable session mean" — `undefined`, so the gate keeps its previous behavior instead of
-* refusing every write. The review path reads a real platform `Session` and calls the reader
-* directly; a fallback there would be dead code for an impossible case.
-*
-* v32 REV-06(a) is preserved by the dispatch normalizer: a skill counts as READ only when its read
-* did not fail, so a failed/timeout read cannot pass the gate and let a writer blind-overwrite
-* content the model never saw. Matching `tool/call` directly (the pre-v37 form) meant every PTC
-* session (`tool/ptc-dispatch*`) collected an EMPTY set, so every mutating op the model HAD read
-* was dropped — and nothing reported the loss.
+* Which session frames are EVIDENCE, and which are bookkeeping.
+*
+* A plan op must cite `evidence` seqs, and the validator's range rule
+* (`evolution-plan-validator`, rule `EVIDENCE_RANGE`) answers only "is this an integer inside
+* the window the plan was authored against". A boundary frame satisfies that while carrying
+* nothing a claim can rest on: the `turn/start` seq is the frame a claim about that turn was
+* most likely read out of, and citing it is indistinguishable from citing a real exchange. This
+* module owns the ONE classification of a session frame by what it CARRIES, so the plan path can
+* report an op whose whole citation list is bookkeeping (design
+* `dsh-evolution-skill-history-design.md` §3D, phase 1: report only — no op is refused here).
+*
+* The classification is a DENY list of the pure bookends, not an allow list of content frames.
+* The platform's own vocabulary (`KNOWN_SESSION_EVENT_TYPES`, 57 members at 0.1.5-rc.2) mixes
+* content frames with state-change frames, and out-of-repo plugins append types the family cannot
+* enumerate; an unknown frame is therefore treated as carrying content, because a report that
+* fires on an unclassifiable frame is a false positive and phase 1 exists to measure how many TRUE
+* ones there are. Tightening — a narrower definition, or an allow list built from the platform's
+* vocabulary — changes this table and nothing else (`evidenceKindIndex` is the only reader).
+* @module @lmzhen/dsh-evolution-core
+*/
+/** The frame types that record a boundary and carry no content: the turn and step bookends. */
+const BOOKKEEPING_FRAME_TYPES = new Set([
+	"turn/start",
+	"turn/end",
+	"step/start",
+	"step/end"
+]);
+/**
+* Whether one frame type records a boundary and carries no content.
+*
+* The classification table's SECOND reader: the live projection unit
+* (`session-projection.ts`) folds the same answer per event, so the rule stays one table.
+* @param type - a platform session-event type.
+* @returns true for the turn/step bookends.
+*/
+function isBookkeepingFrame(type) {
+	return BOOKKEEPING_FRAME_TYPES.has(type);
+}
+/**
+* The seqs of the frames that carry content.
+*
+* @param events - the session's frames, oldest first (any iterable; nothing is retained).
+* @returns the substantive seqs, or `undefined` when NO frame carried a usable seq. The two
+*   answers are different facts: an empty SET says "every sequenced frame is a boundary", while
+*   `undefined` says "this log cannot tell a boundary from a message" (a stub session in a test,
+*   a composition whose events carry no seq). A caller that cannot classify must stay silent
+*   rather than report every op — the same three-state posture as `sessionReadSkillNames`.
+*/
+function evidenceKindIndex(events) {
+	const substantive = /* @__PURE__ */ new Set();
+	let sequenced = 0;
+	for (const event of events) {
+		const seq = event.seq;
+		if (typeof seq !== "number" || !Number.isInteger(seq)) continue;
+		sequenced += 1;
+		if (typeof event.type === "string" && BOOKKEEPING_FRAME_TYPES.has(event.type)) continue;
+		substantive.add(seq);
+	}
+	return sequenced === 0 ? void 0 : substantive;
+}
+//#endregion
+//#region lib/types/session-projection.js
+/**
+* The family's session projections: the per-session facts the family used to re-read the log for.
+*
+* 0.2.x deprecates the synchronous log reads (`Session.snapshotEvents` — "existing logic may
+* remain unmigrated for now, but new calls are prohibited",
+* `core/session/src/index.ts:639-658`) and drives DOMAIN-OWNED units instead: a registered unit
+* folds every committed event once, the registry owns the subscription and the per-session
+* watermark, and a reader asks for the current state
+* (`session/session-projection/src/index.ts` — `register`/`stateOf`). Each unit here carries
+* exactly what one pure family reader derives from a log, so that reader keeps its pure form and
+* gains a projection-backed one beside it.
+*
+* State stays bounded. The evidence unit keeps the SPARSE boundary seqs and answers the dense
+* question by complement: a content-seq set grows with every session event, while a turn/step
+* boundary set grows four entries per turn.
+*
+* The registry is part of the platform's BASE bundle (`packages/bundle/base/cordis.patch.yml:158`),
+* so a real host always has it; a composition without it keeps loading (`ctx.inject` probe) and
+* its readers report "cannot classify" instead of guessing — the same posture the pure readers
+* document for a log with no seq.
 * @module @lmzhen/dsh-evolution-core
 */
+const MAX_TIMESTAMP_MS = 864e13;
+const activityStateSchema = z.object({ lastEventTime: z.number().nonnegative().max(MAX_TIMESTAMP_MS) }).strict();
+const evidenceStateSchema = z.object({
+	sequenced: z.number().int().nonnegative(),
+	through: z.number().int().min(-1).max(Number.MAX_SAFE_INTEGER),
+	bookkeeping: z.array(z.number().int().nonnegative())
+}).strict();
+/** The `evolutionActivity` unit (host-only: no client view is registered for it). */
+const evolutionActivityProjection = {
+	key: "evolutionActivity",
+	stateVersion: 1,
+	stateSchema: activityStateSchema,
+	init: () => ({ lastEventTime: 0 }),
+	apply: (state, event) => {
+		const time = typeof event.time === "number" ? event.time : state.lastEventTime;
+		return time === state.lastEventTime ? state : { lastEventTime: time };
+	}
+};
+/** The `evolutionEvidence` unit (host-only: no client view is registered for it). */
+const evolutionEvidenceProjection = {
+	key: "evolutionEvidence",
+	stateVersion: 1,
+	stateSchema: evidenceStateSchema,
+	init: () => ({
+		sequenced: 0,
+		through: -1,
+		bookkeeping: []
+	}),
+	apply: (state, event) => {
+		const seq = event.seq;
+		if (typeof seq !== "number" || !Number.isInteger(seq)) return state;
+		const sequenced = state.sequenced + 1;
+		const through = seq > state.through ? seq : state.through;
+		if (typeof event.type !== "string" || !isBookkeepingFrame(event.type)) return {
+			sequenced,
+			through,
+			bookkeeping: state.bookkeeping
+		};
+		return {
+			sequenced,
+			through,
+			bookkeeping: [...state.bookkeeping, seq]
+		};
+	}
+};
+/**
+* Whether one session object can be projected at all.
+*
+* The family's readers also take STRUCTURAL session views — `skill-reads.ts` documents the tool
+* path's bare stub — while the registry folds a session's own log (`snapshotEvents(from, to)`,
+* `eventAt(seq)`, `seq`, `inheritedEventCount`) whenever it has to build or advance a cell. A
+* view without those members has no projection state to read, and asking for one would fold a
+* log the unit cannot index.
+* @param session - the value a caller holds as its session.
+* @returns true when the registry can fold this object.
+*/
+function isProjectableSession(session) {
+	if (session === null || typeof session !== "object") return false;
+	const candidate = session;
+	const folds = typeof candidate.eventAt === "function";
+	const logs = typeof candidate.snapshotEvents === "function";
+	return folds && logs && typeof candidate.seq === "number";
+}
+const readsStateSchema = z.object({ reads: z.array(z.object({
+	key: z.string(),
+	skill: z.string().nullable(),
+	failed: z.boolean()
+}).strict()) }).strict();
+const signalsStateSchema = z.object({
+	through: z.number().int().min(-1).max(Number.MAX_SAFE_INTEGER),
+	lastEventTime: z.number().nonnegative().max(MAX_TIMESTAMP_MS),
+	turnStartSeq: z.number().int().min(-1).max(Number.MAX_SAFE_INTEGER),
+	turn: z.object({
+		substantive: z.boolean(),
+		toolCalls: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+		userChars: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+		assistantChars: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+		memorySignal: z.boolean(),
+		skillSignal: z.boolean(),
+		opened: z.array(z.string())
+	}).strict()
+}).strict();
+/** The `evolutionReads` unit (host-only: no client view is registered for it). */
+const evolutionReadsProjection = {
+	key: "evolutionReads",
+	stateVersion: 1,
+	stateSchema: readsStateSchema,
+	init: () => ({ reads: [] }),
+	apply: (state, event) => {
+		const step = dispatchStepOf(event);
+		if (step === null) return state;
+		const at = state.reads.findIndex((entry) => entry.key === step.key);
+		const settled = () => {
+			const entry = at < 0 ? void 0 : state.reads[at];
+			if (entry === void 0 || step.outcome === void 0) return state;
+			const failed = !step.outcome.ok;
+			if (entry.failed === failed) return state;
+			const reads = [...state.reads];
+			reads[at] = {
+				key: entry.key,
+				skill: entry.skill,
+				failed
+			};
+			return { reads };
+		};
+		if (step.name === "") return settled();
+		if (at >= 0) return settled();
+		if (!isSkillReadToolName(step.name)) return state;
+		const skill = skillReadNameOf({
+			kind: step.kind,
+			callId: step.callId,
+			rootCallId: step.rootCallId,
+			name: step.name,
+			arguments: step.arguments,
+			ok: step.outcome?.ok
+		}) ?? null;
+		return { reads: [...state.reads, {
+			key: step.key,
+			skill,
+			failed: step.outcome?.ok === false
+		}] };
+	}
+};
+/** The `evolutionSignals` unit (host-only: no client view is registered for it). */
+const evolutionSignalsProjection = {
+	key: "evolutionSignals",
+	stateVersion: 1,
+	stateSchema: signalsStateSchema,
+	init: () => ({
+		through: -1,
+		lastEventTime: 0,
+		turnStartSeq: -1,
+		turn: initialTurnFold()
+	}),
+	apply: (state, event) => {
+		const start = event.type === "turn/start";
+		const turn = foldTurnEvent(start ? initialTurnFold() : state.turn, event);
+		const seq = typeof event.seq === "number" && Number.isInteger(event.seq) ? event.seq : state.through;
+		const time = typeof event.time === "number" ? event.time : state.lastEventTime;
+		const turnStartSeq = start ? seq : state.turnStartSeq;
+		if (turn === state.turn && seq === state.through && time === state.lastEventTime && turnStartSeq === state.turnStartSeq) return state;
+		return {
+			through: seq,
+			lastEventTime: time,
+			turnStartSeq,
+			turn
+		};
+	}
+};
+/**
+* Register the family's units on the calling context's fiber.
+*
+* Called by the READERS (not by a plugin's mount) and idempotent by the registry's own reference
+* count: the first read of a foldable session installs the definitions, later reads count as
+* co-owners, and the keys survive until the last registrant unloads
+* (`session-projection/src/index.ts:273-292`). Registering at the read is what keeps a session
+* view the registry cannot fold (`isProjectableSession`) from ever reaching its drive — the
+* registry folds the in-memory log on first touch, so a unit that appears mid-session is still
+* correct (`:602-630`).
+*
+* Idempotent by design, so a plugin mounting later does not need its own call.
+* @param ctx - the mounting plugin's context.
+*/
+function installEvolutionProjections(ctx) {
+	const register = (registry) => {
+		registry.register(evolutionActivityProjection);
+		registry.register(evolutionEvidenceProjection);
+		registry.register(evolutionReadsProjection);
+		registry.register(evolutionSignalsProjection);
+	};
+	const mounted = ctx.get("sessionProjections");
+	if (mounted !== void 0) {
+		register(mounted);
+		return;
+	}
+	ctx.inject(["sessionProjections"], (injected) => {
+		register(injected.sessionProjections);
+	});
+}
+/**
+* Time of one session's newest event, or `undefined` when the unit is not installed.
+*
+* The curator's idleness gate reads this instead of folding the session log; `undefined` is a
+* measurement that did not happen, which the gate answers with the deployment's fail-open policy.
+* @param ctx - a context of the runtime (the service is read from the global store).
+* @param session - the session to ask about.
+* @returns the newest event's milliseconds, or undefined with no unit or no event.
+*/
+function sessionLastEventTime(ctx, session) {
+	if (!isProjectableSession(session)) return void 0;
+	installEvolutionProjections(ctx);
+	const state = ctx.get("sessionProjections")?.stateOf(session, "evolutionActivity");
+	if (state === void 0 || state.lastEventTime === 0) return void 0;
+	return state.lastEventTime;
+}
+/**
+* The skill names one session read through a non-failed dispatch, or `undefined` when the session
+* cannot be projected (a structural view, or a host without the registry).
+*
+* `undefined` is NOT an empty set: the tool path's read-before-write gate keeps its previous
+* behavior rather than refusing every write in a composition whose session object is a bare stub
+* (`skill-reads.ts` documents that three-state posture).
+* @param ctx - a context of the runtime.
+* @param session - the session whose reads are wanted.
+* @returns the names read, or undefined when the log cannot be folded.
+*/
+function sessionReadNames(ctx, session) {
+	if (!isProjectableSession(session)) return void 0;
+	installEvolutionProjections(ctx);
+	const state = ctx.get("sessionProjections")?.stateOf(session, "evolutionReads");
+	if (state === void 0) return void 0;
+	const names = /* @__PURE__ */ new Set();
+	for (const entry of state.reads) if (!entry.failed && entry.skill !== null) names.add(entry.skill);
+	return names;
+}
+/**
+* The open turn's window signals, or `undefined` when the session cannot be projected.
+*
+* The window is the events since the newest `turn/start`, folded by the same `foldTurnEvent`
+* `observeEvent` uses; `undefined` means the caller has no measurement (a structural view), not
+* that the turn was empty.
+* @param ctx - a context of the runtime.
+* @param session - the session whose open turn is being judged.
+* @returns the window signals, or undefined when the log cannot be folded.
+*/
+function sessionTurnSignals(ctx, session) {
+	if (!isProjectableSession(session)) return void 0;
+	installEvolutionProjections(ctx);
+	const state = ctx.get("sessionProjections")?.stateOf(session, "evolutionSignals");
+	if (state === void 0) return void 0;
+	const { substantive, toolCalls, userChars, assistantChars, memorySignal, skillSignal } = state.turn;
+	return {
+		substantive,
+		toolCalls,
+		userChars,
+		assistantChars,
+		memorySignal,
+		skillSignal
+	};
+}
+/**
+* The evidence index of one session, or `undefined` when the log cannot be classified.
+*
+* `undefined` covers both the missing unit and a log whose frames carry no seq: the plan path's
+* `EVIDENCE_CLASS` row is report-only and must stay silent rather than report every op.
+* @param ctx - a context of the runtime.
+* @param session - the session the review plan is authored against.
+* @returns an index answering "does this seq carry content?".
+*/
+function sessionEvidenceIndex(ctx, session) {
+	if (!isProjectableSession(session)) return void 0;
+	installEvolutionProjections(ctx);
+	const state = ctx.get("sessionProjections")?.stateOf(session, "evolutionEvidence");
+	if (state === void 0 || state.sequenced === 0) return void 0;
+	const { through, bookkeeping } = state;
+	return { has: (seq) => Number.isInteger(seq) && seq >= 0 && seq <= through && !bookkeeping.includes(seq) };
+}
+//#endregion
+//#region lib/types/skill-reads.js
 /**
 * The skill names ONE session read, or `undefined` when its log is not readable.
 *
+* Two readers, in this order: the family's `evolutionReads` projection for a platform `Session`
+* (0.2.x's live read — the deprecated synchronous log read is gone from production), then the
+* STRUCTURAL accessor for a view that is not a `Session` at all. The tool path's exec view may be a
+* bare stub, which is what this module exists for; a real Session always takes the first path.
+*
 * `undefined` is NOT an empty set: a caller that must decide (the tool path's read-before-write
 * gate) can then keep its previous behavior instead of refusing every write in a composition whose
 * session objects expose no log at all.
+* @param ctx - a context of the runtime.
 * @param session - the session whose reads are wanted; `undefined` when the call carries none.
 * @returns the names read through a non-failed `skill` dispatch, or `undefined` when unreadable.
 */
-function sessionReadSkillNames(session) {
-	const events = session?.snapshotEvents?.();
+function sessionReadSkillNames(ctx, session) {
+	if (session === void 0) return void 0;
+	const projected = sessionReadNames(ctx, session);
+	if (projected !== void 0) return projected;
+	const events = session.snapshotEvents?.();
 	return events === void 0 ? void 0 : collectReadSkillNames(events);
 }
 /** Actions whose target must have been read first (create is authorship, so it is exempt). */
@@ -6481,58 +7314,6 @@ function readingStats(full, shown) {
 	};
 }
 //#endregion
-//#region lib/types/evidence.js
-/**
-* Which session frames are EVIDENCE, and which are bookkeeping.
-*
-* A plan op must cite `evidence` seqs, and the validator's range rule
-* (`evolution-plan-validator`, rule `EVIDENCE_RANGE`) answers only "is this an integer inside
-* the window the plan was authored against". A boundary frame satisfies that while carrying
-* nothing a claim can rest on: the `turn/start` seq is the frame a claim about that turn was
-* most likely read out of, and citing it is indistinguishable from citing a real exchange. This
-* module owns the ONE classification of a session frame by what it CARRIES, so the plan path can
-* report an op whose whole citation list is bookkeeping (design
-* `dsh-evolution-skill-history-design.md` §3D, phase 1: report only — no op is refused here).
-*
-* The classification is a DENY list of the pure bookends, not an allow list of content frames.
-* The platform's own vocabulary (`KNOWN_SESSION_EVENT_TYPES`, 57 members at 0.1.5-rc.2) mixes
-* content frames with state-change frames, and out-of-repo plugins append types the family cannot
-* enumerate; an unknown frame is therefore treated as carrying content, because a report that
-* fires on an unclassifiable frame is a false positive and phase 1 exists to measure how many TRUE
-* ones there are. Tightening — a narrower definition, or an allow list built from the platform's
-* vocabulary — changes this table and nothing else (`evidenceKindIndex` is the only reader).
-* @module @lmzhen/dsh-evolution-core
-*/
-/** The frame types that record a boundary and carry no content: the turn and step bookends. */
-const BOOKKEEPING_FRAME_TYPES = new Set([
-	"turn/start",
-	"turn/end",
-	"step/start",
-	"step/end"
-]);
-/**
-* The seqs of the frames that carry content.
-*
-* @param events - the session's frames, oldest first (any iterable; nothing is retained).
-* @returns the substantive seqs, or `undefined` when NO frame carried a usable seq. The two
-*   answers are different facts: an empty SET says "every sequenced frame is a boundary", while
-*   `undefined` says "this log cannot tell a boundary from a message" (a stub session in a test,
-*   a composition whose events carry no seq). A caller that cannot classify must stay silent
-*   rather than report every op — the same three-state posture as `sessionReadSkillNames`.
-*/
-function evidenceKindIndex(events) {
-	const substantive = /* @__PURE__ */ new Set();
-	let sequenced = 0;
-	for (const event of events) {
-		const seq = event.seq;
-		if (typeof seq !== "number" || !Number.isInteger(seq)) continue;
-		sequenced += 1;
-		if (typeof event.type === "string" && BOOKKEEPING_FRAME_TYPES.has(event.type)) continue;
-		substantive.add(seq);
-	}
-	return sequenced === 0 ? void 0 : substantive;
-}
-//#endregion
 //#region lib/types/drift-signals.js
 /**
 * Library-level drift signals for the maintenance subagent (design 011).
@@ -11327,12 +12108,27 @@ const PARAM_NAMESPACES = Object.freeze({
 	"tool-skill-manage": "evolution-skills"
 });
 /**
-* The settings namespace one owner package registers. The registry's map is the only
-* place a namespace is spelled: a package without an entry has no user layer, so a
-* missing entry must fail loud here instead of letting a package fall back to a
-* private constant that the registry never sees.
+* The rows whose settings namespace CHANGED with the platform-line move (G3): the
+* platform keys a settings section by the Loader entry id now, while 0.1.x let each
+* plugin register a free-form namespace — this table is the difference, DERIVED from
+* {@link PARAM_NAMESPACES} so freezing a row id renames it in one place.
+*
+* It is the migration's TARGET (`rowId`) and its SOURCE (`namespace`, the section a
+* stored value sits in). Rows whose two names already agree are absent: there is
+* nothing to move for them.
+*/
+const NAMESPACE_MIGRATIONS = Object.freeze(Object.entries(PARAM_NAMESPACES).filter(([owner, namespace]) => namespace !== owner).map(([owner, namespace]) => Object.freeze({
+	namespace,
+	rowId: owner
+})));
+/**
+* The LEGACY settings namespace one owner package used to register through the family's
+* own seam (0.1.x). It is no longer what the platform calls the section: the platform
+* derives a settings namespace from the Loader entry id, and this registry's `owner` field
+* IS that row id, so a live lookup uses {@link paramRowId}. What remains here is the
+* migration SOURCE (G3 moves a user layer out of this string and into the row id).
 * @param owner - owner package directory name (the map's key).
-* @returns the namespace that owner registers.
+* @returns the legacy namespace that owner registered.
 * @throws when the owner has no entry in {@link PARAM_NAMESPACES}.
 */
 function paramNamespace(owner) {
@@ -11341,94 +12137,31 @@ function paramNamespace(owner) {
 	return namespace;
 }
 /**
-* G3: expose one parameter section to the user layer.
-*
-* Precedence stays 'user > deployment > default': the caller keeps reading its
-* deployment carriers (policy snapshot, then the plugin row) and consults
-* {@link ParamOverrides.get} FIRST — an unset key returns undefined, so the
-* deployment value keeps winning and the family's shadowing rules survive.
-*
-* Failure posture: a provider without `describe` (or one whose describe throws)
-* leaves the user layer UNAVAILABLE and warns once — deployment values then
-* apply. Treating an unreadable user layer as 'no overrides' would silently
-* ignore a setting the user did write, so the warning names it.
-* @typeParam T - the section's value type.
-* @param provider - the platform settings provider, or undefined when absent.
-* @param namespace - namespace to register.
-* @param schema - schemastery schema the platform validates against.
-* @param base - composition base layer (the plugin row's values).
-* @param options - warning sink and the change hook.
-* @returns a reader bound to the namespace.
-*/
-function paramSectionOverrides(provider, namespace, schema, base, options = {}) {
-	if (provider === void 0) return unavailableOverrides(namespace, base);
-	const scope = options.validate === void 0 ? provider.register(namespace, schema, {
-		base,
-		applies: "live"
-	}) : provider.register(namespace, schema, {
-		base,
-		applies: "live",
-		validate: options.validate
-	});
-	const warn = options.warn ?? (() => {});
-	let user = readUserLayer(provider, namespace);
-	if (user === void 0) warn("settings provider for " + namespace + " exposes no readable user layer; deployment values apply");
-	scope.watch(() => {
-		const next = readUserLayer(provider, namespace);
-		if (next === void 0) {
-			warn("settings provider for " + namespace + " stopped exposing its user layer; deployment values apply");
-			user = void 0;
-			options.onChange?.();
-			return;
-		}
-		user = next;
-		options.onChange?.();
-	});
-	return {
-		namespace,
-		get: (key) => user === void 0 ? void 0 : user[key],
-		resolved: () => scope.get() ?? base
-	};
-}
-/** The pre-provider reader: no user layer, deployment values only. */
-function unavailableOverrides(namespace, base) {
-	return {
-		namespace,
-		get: () => void 0,
-		resolved: () => base
-	};
-}
-/** Read the raw user section, or undefined when the provider cannot report it. */
-function readUserLayer(provider, namespace) {
-	if (provider.describe === void 0) return void 0;
-	try {
-		return provider.describe({ redactSecrets: false }).find((entry) => entry.ns === namespace)?.user ?? {};
-	} catch {
-		return;
-	}
+* The settings id one row's user layer lives under, or undefined when the owner publishes
+* no user layer at all (a deployment-only row: its knobs are E2 and never reach a settings
+* section). The platform derives a settings namespace from the Loader entry id and reports
+* it in `settings.describe()` / `configForms.get(entryId)`, and an owner package's row id is
+* its own name — spelled the same in every bundle patch.
+*
+* This is the id to LOOK UP with; {@link paramNamespace} keeps the legacy string the 0.1.x
+* seam registered, which is the G3 migration source and never a live lookup key.
+* @param owner - owner package directory name (the row id).
+* @returns the entry id the platform reports for that row, or undefined for a row without
+*   a user layer.
+*/
+function paramSettingsId(owner) {
+	return PARAM_NAMESPACES[owner] === void 0 ? void 0 : owner;
 }
 /**
-* Attach a parameter section through the optional settings service.
-* @typeParam T - the section's value type.
-* @param host - the plugin context (structurally typed).
-* @param namespace - namespace to register.
-* @param schema - schemastery schema the platform validates against.
-* @param base - composition base layer (the plugin row's values).
-* @param options - warning sink and the change hook.
-* @returns a reader that follows the provider when it appears.
+* The settings id of a row that MUST have a user layer (an owner reading its own section).
+* @param owner - owner package directory name (the row id).
+* @returns the entry id the platform reports for that row.
+* @throws when the owner publishes no user layer.
 */
-function installParamSection(host, namespace, schema, base, options = {}) {
-	let current = unavailableOverrides(namespace, base);
-	host.inject(["settings"], (injected) => {
-		const settings = injected.settings;
-		current = paramSectionOverrides(settings, namespace, schema, base, options);
-		options.onChange?.();
-	});
-	return {
-		namespace,
-		get: (key) => current.get(key),
-		resolved: () => current.resolved()
-	};
+function paramRowId(owner) {
+	const id = paramSettingsId(owner);
+	if (id === void 0) throw new Error("no settings namespace registered for owner `" + owner + "` (add it to PARAM_NAMESPACES)");
+	return id;
 }
 /**
 * Number-typed read over {@link readParam}: the family's tunables are numbers,
@@ -11443,6 +12176,196 @@ function readNumberParam(carrier, id) {
 	return typeof value === "number" ? value : void 0;
 }
 //#endregion
+//#region lib/types/namespace-migration.js
+/**
+* G3: the one-time move of the family's LEGACY settings sections into the row ids the
+* platform keys settings by now.
+*
+* On 0.1.x each plugin registered a free-form namespace (`evolution-memory`, …) through the
+* family's own seam. The platform derives a settings namespace from the Loader entry id
+* today, so those old strings address nothing: the platform's own legacy import finds no
+* such entry, warns, and leaves the values in the renamed document. This module reads that
+* document, maps each legacy section (and each deprecated key spelling) onto its row, and
+* merges the values into that row's user layer.
+*
+* Two halves, both testable without a host: {@link planNamespaceMigration} is pure (text in,
+* plan out) and {@link applyNamespaceMigration} takes the few things it needs as
+* dependencies, so the side-effecting half runs against a fake settings seat.
+* @module @lmzhen/dsh-evolution-core
+*/
+/**
+* Whether a parsed value is a plain mapping (a settings section).
+* @param value - the parsed value.
+* @returns true for a non-null, non-array object.
+*/
+function isSection(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* The key names one row may be written with: its own E3 rows, plus the deprecated
+* spellings that still resolve to them. An unknown key is refused instead of written —
+* the platform validates a write against the row's schema, so writing it would fail the
+* whole row's migration.
+* @param rowId - the row's entry id.
+* @returns every key name a legacy section may carry for that row.
+*/
+function writableKeys(rowId) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const entry of PARAM_EXPOSURE) if (entry.owner === rowId && entry.tier === "E3") keys.add(entry.id);
+	for (const [alias, canonical] of Object.entries(PARAM_ALIASES)) if (keys.has(canonical)) keys.add(alias);
+	return keys;
+}
+/**
+* Read one legacy settings document into a migration plan.
+*
+* Pure: the caller reads the file (the platform's renamed `settings.yaml.imported` first,
+* then a `settings.yaml` the platform has not imported yet) and hands the text over.
+* @param documentText - the YAML document text.
+* @returns what to write, what the family knows but need not touch, and what it refused.
+* @throws {Error} when the document is not a mapping, or a family section is not one.
+*/
+function planNamespaceMigration(documentText) {
+	const parsed = parse(documentText);
+	if (parsed === void 0 || parsed === null) return {
+		entries: [],
+		empty: [],
+		foreign: [],
+		skipped: []
+	};
+	if (!isSection(parsed)) throw new Error("the settings document is not a mapping; refusing to migrate it");
+	const legacy = new Map(NAMESPACE_MIGRATIONS.map((entry) => [entry.namespace, entry.rowId]));
+	const entries = [];
+	const empty = [];
+	const skipped = [];
+	for (const [namespace, section] of Object.entries(parsed)) {
+		const rowId = legacy.get(namespace);
+		if (rowId === void 0) continue;
+		if (!isSection(section)) throw new Error("settings section `" + namespace + "` is not a mapping; refusing to migrate it");
+		const allowed = writableKeys(rowId);
+		const values = [];
+		for (const [key, value] of Object.entries(section)) {
+			const canonical = resolveParamId(key);
+			if (!allowed.has(canonical)) {
+				skipped.push({
+					namespace,
+					key,
+					reason: "row `" + rowId + "` has no such parameter"
+				});
+				continue;
+			}
+			values.push({
+				source: key,
+				key: canonical,
+				value
+			});
+		}
+		if (values.length === 0) empty.push(namespace);
+		else entries.push({
+			namespace,
+			rowId,
+			values
+		});
+	}
+	return {
+		entries,
+		empty,
+		foreign: Object.keys(parsed).filter((name) => !legacy.has(name)).sort(),
+		skipped
+	};
+}
+/**
+* Whether two JSON-shaped config values are the same value.
+* @param left - one value.
+* @param right - the other.
+* @returns true when both serialize identically.
+*/
+function sameValue(left, right) {
+	return JSON.stringify(left) === JSON.stringify(right);
+}
+/**
+* Decide what a plan would do: the rows it would write, the keys already equal, the stored
+* values that win, and the refusals. The write half and the read-only doctor read the SAME
+* decision here — one rule, two consumers, so a report can never disagree with a run.
+* @param plan - the plan from {@link planNamespaceMigration}.
+* @param read - the row's current user layer (see {@link NamespaceMigrationDeps.read}).
+* @returns the decision; nothing is written.
+*/
+function classifyNamespaceMigration(plan, read) {
+	const write = [];
+	const conflicts = [];
+	const unchanged = [];
+	const skipped = [...plan.skipped];
+	for (const entry of plan.entries) {
+		const view = read(entry.rowId);
+		if (view === void 0) {
+			for (const value of entry.values) skipped.push({
+				namespace: entry.namespace,
+				key: value.source,
+				reason: "row `" + entry.rowId + "` is not served in this composition"
+			});
+			continue;
+		}
+		const user = view.user ?? {};
+		const patch = {};
+		for (const value of entry.values) {
+			if (!Object.hasOwn(user, value.key)) {
+				patch[value.key] = value.value;
+				continue;
+			}
+			if (sameValue(user[value.key], value.value)) {
+				unchanged.push({
+					rowId: entry.rowId,
+					key: value.key
+				});
+				continue;
+			}
+			conflicts.push({
+				rowId: entry.rowId,
+				key: value.key,
+				current: user[value.key],
+				legacy: value.value
+			});
+		}
+		if (Object.keys(patch).length > 0) write.push({
+			rowId: entry.rowId,
+			patch
+		});
+	}
+	return {
+		write,
+		conflicts,
+		unchanged,
+		skipped
+	};
+}
+/**
+* Report one kept value: the stored value is the newer decision, so it wins and the legacy
+* one is named rather than dropped.
+* @param conflict - the conflict the classification found.
+* @returns the warning text.
+*/
+function conflictWarning(conflict) {
+	return "evolution-migration: row `" + conflict.rowId + "` already sets `" + conflict.key + "`; the stored value was kept and the legacy " + JSON.stringify(conflict.legacy) + " was not applied";
+}
+async function applyNamespaceMigration(plan, deps) {
+	const decided = classifyNamespaceMigration(plan, (rowId) => deps.read(rowId));
+	for (const conflict of decided.conflicts) deps.warn(conflictWarning(conflict));
+	const written = [];
+	for (const row of decided.write) {
+		await deps.update(row.rowId, row.patch);
+		written.push({
+			rowId: row.rowId,
+			keys: Object.keys(row.patch)
+		});
+	}
+	return {
+		written,
+		conflicts: decided.conflicts,
+		unchanged: decided.unchanged,
+		skipped: decided.skipped
+	};
+}
+//#endregion
 //#region lib/types/opt-in.js
 /**
 * Tool names only a session that mounted the family's MODEL rows can see.
@@ -11539,4 +12462,4 @@ function sessionAudited(ctx, sessionId, sessionScoped) {
 	return false;
 }
 //#endregion
-export { ALIVE_LOCK_TAKEOVER_MS, AUTHORING_DESCRIPTION_BAR, AUTHORING_SPLIT_LINE_CHARS, BASELINE_ACTION, CITATION_SUPPORT_DIRS, COMBINED_REVIEW_PLAN_PROMPT, COMBINED_REVIEW_PROMPT, COMPLETION_SKILL_REVIEW_PROMPT, CONTENT_SPLIT_HINT, COST_ASCII_TOKEN_HIGH, COST_ASCII_TOKEN_LOW, COST_CJK_TOKEN_HIGH, COST_CJK_TOKEN_LOW, CURATOR_DRY_RUN_BANNER, CURATOR_PROMPT, DEAD_LOCK_TAKEOVER_MS, DEDUP_MAX_PAIR_COMPARISONS, DEDUP_SIMILARITY_THRESHOLD, DEFAULT_ARCHIVE_AFTER_DAYS, DEFAULT_ARCHIVE_RETENTION_POLICY, DEFAULT_CITATION_POLICY, DEFAULT_CITATION_REF_BUDGET, DEFAULT_CONSOLIDATION_FAILURES, DEFAULT_CURATOR_BOOT_GRACE_SECONDS, DEFAULT_CURATOR_INTERVAL_HOURS, DEFAULT_CURATOR_MODEL, DEFAULT_CURATOR_REVIEW_MAX_TOKENS, DEFAULT_HEALTH_THRESHOLDS, DEFAULT_MAX_OPS_PER_PLAN, DEFAULT_MEMORY_CHAR_LIMIT, DEFAULT_MEMORY_REVIEW_MODEL, DEFAULT_MIN_IDLE_HOURS, DEFAULT_MUTATION_CAP, DEFAULT_REFERENCE_REWRITE_POLICY, DEFAULT_REVIEW_CONTEXT_MESSAGES, DEFAULT_REVIEW_MEMORY_INTERVAL, DEFAULT_REVIEW_MESSAGE_CHARS, DEFAULT_REVIEW_SKILL_INTERVAL, DEFAULT_REVIEW_TIMEOUT_MS, DEFAULT_SKILL_CONTENT_CHARS, DEFAULT_SKILL_LIMITS, DEFAULT_SKILL_REVIEW_COMPLETION_MIN_TOOL_CALLS, DEFAULT_SKILL_REVIEW_MODEL, DEFAULT_SKILL_REVIEW_TRIGGER, DEFAULT_SKILL_VERSION_KEEP, DEFAULT_STALE_AFTER_DAYS, DEFAULT_SUBSTANTIVE_MIN_AGENT_CHARS, DEFAULT_SUBSTANTIVE_MIN_TOOL_CALLS, DEFAULT_SUBSTANTIVE_MIN_USER_CHARS, DEFAULT_SUPPORT_FILE_CHAR_POLICY, DEFAULT_SUPPORT_READ_TOOL_NAMES, DEFAULT_THREAT_MAX_SCAN_CHARS, DEFAULT_USER_CHAR_LIMIT, DISPATCH_EVENT_TYPES, DRIFT_MAX_LINE_CHARS, DRIFT_SIGNALS_VERSION, DRIFT_SIGNAL_NOUNS, DSH_AUTHORING_STANDARDS, EMPTY_LOCK_TAKEOVER_MS, ENTRY_DELIMITER, EVENT_ARCHIVE_PREFIX, EVENT_LOG_RETAIN_ARCHIVES, EVENT_LOG_ROTATE_AT, EVENT_LOG_VERSION, EVOLUTION_ERRORS, EVOLUTION_WRITE_TOOLS, EvolutionGateSet, FAMILY_SESSION_TOOL_NAMES, FORBIDDEN_CONTROL_KEYS, FUZZY_MAX_PATTERN_CHARS, FUZZY_MAX_WORK, HEALTH_STAMP_RE, HISTORY_DIR, HISTORY_INDEX_VERSION, HOOK_LINE_RE, INSTANCE_KEYS, KEEP_LINE_RE, LOCK_BODY_RE, LOCK_SUFFIX, LOCK_TEAR_TAKEOVER_MS, LOW_QUALITY_THRESHOLD, LostWriteLock, MAINTAIN_OUTPUT_INSTRUCTION, MAINTAIN_PROMPT, MAX_DESCRIPTION_LENGTH, MAX_REQUEST_BODY_BYTES, MAX_RESTRUCTURE_MOVES, MAX_SKILL_CONTENT_CHARS, MAX_SKILL_FILE_BYTES, MAX_SKILL_NAME_LENGTH, MAX_SUPPORT_READ_PATHS, MAX_TIMER_DELAY_MS, MEMORY_GUIDANCE_SECTION_ORDER, MEMORY_REVIEW_PROMPT, MIN_STAMP_BODY_CHARS, MUTATIONS_FILE_VERSION, MemoryStore, NATIVE_CALL_EVENT, NATIVE_RESULT_EVENT, PARAM_ALIASES, PARAM_EXPOSURE, PARAM_GROUP_LABELS, PARAM_NAMESPACES, PATTERN_OVERLAP, PLATFORM_CATALOG_DESCRIPTION_DEFAULT, PLATFORM_ESTIMATE_CHARS_PER_TOKEN, POLICY_STAGE_DEFAULTS, PROMPT_BUNDLE, PROMPT_BUNDLE_ID, PROMPT_BUNDLE_VERSION, PROTECTED_BUILTIN_SKILLS, PTC_DISPATCH_EVENT, PTC_DISPATCH_START_EVENT, QUALITY_WEIGHTS, READ_REQUIRED_ACTIONS, RESTRUCTURE_TARGET_RE, RETENTION_FEEDBACK_KEEP_RATIO, RETENTION_FEEDBACK_MIN_CHARS, SKILLS_GUIDANCE, SKILLS_GUIDANCE_SECTION_ORDER, SKILL_ACTION_REQUIRED_FIELDS, SKILL_NAME_RE, SKILL_REVIEW_PLAN_PROMPT, SKILL_REVIEW_PROMPT, SNAPSHOT_EXTRA_NAME_RE, SUMMARY_DUPLICATE_HINT_THRESHOLD, SUPPORT_DIRS, SUPPRESSED_FILE_VERSION, SkillLibrary, TEXT_DIFF_MAX_CHARS, TEXT_DIFF_MAX_LINES, THREAT_EXEMPTION_HINT, TOKEN_ASCII_WEIGHT, TOKEN_CJK_WEIGHT, ToolDispatchNormalizer, ToolDispatchPayloadError, UPSTREAM_LIMIT_CHARS_PER_TOKEN, VERSION_SUMMARY_MAX_CHARS, advanceReview, affinity, ageCopyKey, allowRowCollisions, anchorVerdict, appendEvolutionEvent, applyCuratorLifecycleFields, applyCuratorMetaFields, applyReferenceRewrite, assertDispatchPayload, assertSkillsRootAliasRetired, assessStructureHealth, authoringFeedback, blobPath, bodyCost, buildCuratorRunReport, buildLearnPrompt, bumpPatch, bumpSupportRead, bumpUse, bumpView, callingScope, canonicalWriteId, claimInstance, clampedNumber, clearReviewChannel, collectReadSkillNames, composePresetComposition, computeDedupGroups, computeDriftSignals, computeLifecycleTransitions, computePrefixClusters, computeQualityScores, computeScopeView, contentHash, contentRetentionFeedback, countDispatches, createGateSet, daysSinceIso, decideTakeover, describeReferenceRewrite, displayBodyOf, duplicateHeadings, elapsedSince, emptyRecord, entryTarget, errorText, evaluateThreat, eventsFile, evidenceKindIndex, evolutionEventPayloadIssue, evolutionHome, evolutionIoAdapter, evolutionRoot, filterUnreadSkillOps, findDriftSignal, foldCuratorFields, foldToolDispatches, foldTurn, frontmatterBlock, frontmatterCatalogInvalid, fuzzyPatch, getRecord, historyIndexFile, historyRoot, identity, idleDays, installParamSection, instanceClaimKey, instanceClaimedWriteSites, instanceHolder, isAbsent, isCommittedWarning, isDeprecatedParamId, isFileShapedPath, isLoopbackRequest, isMissingPath, isPresent, isProcessAlive, isProgramToolName, isReviewChannelSession, isSkillReadToolName, isSkillToolName, isUnknown, isUnreadWrite, latestActivityAt, latestVersionAt, lifecycleCandidate, listEventArchives, loadMutations, loadRowOverrides, loadSuppressedNames, loadUsage, loadVersionContent, loadVersions, makeSerialQueue, mapProbe, markAgentCreated, markReviewChannel, markerEntryName, memoryRoot, missingSupportPointers, mutateUsage, mutationsFile, narrowNameMatches, nearDuplicateSummaries, neutralizePromptVariables, newSkillLibrary, nextHistoryIndex, nodeEvolutionIo, normalizeFrontmatter, normalizeUsageRecord, normalizeVersionSummary, observeEvent, orderVersions, overlongLines, paramNamespace, paramSectionOverrides, parseCuratorNominations, parseEvolutionEvents, parseFrontmatter, parseHistoryIndex, parseLockBody, partitionVersions, pendingSelfCleanup, persistedWriteSite, persistedWriteSites, planReferenceRewrite, planRehoming, policyStageLimits, probeAbsent, probeList, probeMtime, probePresent, probeReason, probeUnknown, projectionText, readDispatchSignal, readEvolutionEvents, readEvolutionTimeline, readHistoryIndex, readJsonBody, readJsonObject, readNumberParam, readParam, readingStats, recordMutation, recordVersions, redactSecrets, relatedSkillNames, releaseInstance, renameWithRetry, renderCuratorReportMarkdown, resolveCitations, resolveExecOrigins, resolveOrigins, resolveParamId, resolveRootConfig, resolveSkillsRoot, retainEventArchives, retirementReport, reviewPrompt, saveSuppressedNames, saveUsage, scanBodyHooks, scanContentThreats, scanMemoryThreats, scanThreats, scopedProbeReport, sessionAudited, sessionReadSkillNames, sessionSeesFamilyTools, skillReadNameOf, skillRowCells, skillStateKey, skillsRoot, supportFileReadOf, suppressedFile, sweepReviewChannelSessions, textDiffFacts, tokenLineFor, transactIo, transactTaskGuard, trimPatternBoundaries, unhookedSupportPointers, updateSuppressedNames, usageFile, usageObserved, validateFrontmatter, validateRestructureTarget, valueOr, verifyPromptBundle, versionActionKind, versionRowCells, versionSummaryPrompt, versionTarget, vocabulary, writeDurableTmp, writeJson, yamlPlainScalarNeedsQuotes };
+export { AGENT_PRESET_PACKAGE, AGENT_PRESET_ROOT_HINT, ALIVE_LOCK_TAKEOVER_MS, AUTHORING_DESCRIPTION_BAR, AUTHORING_SPLIT_LINE_CHARS, BASELINE_ACTION, CITATION_SUPPORT_DIRS, COMBINED_REVIEW_PLAN_PROMPT, COMBINED_REVIEW_PROMPT, COMPLETION_SKILL_REVIEW_PROMPT, CONTENT_SPLIT_HINT, COST_ASCII_TOKEN_HIGH, COST_ASCII_TOKEN_LOW, COST_CJK_TOKEN_HIGH, COST_CJK_TOKEN_LOW, CURATOR_DRY_RUN_BANNER, CURATOR_PROMPT, DEAD_LOCK_TAKEOVER_MS, DEDUP_MAX_PAIR_COMPARISONS, DEDUP_SIMILARITY_THRESHOLD, DEFAULT_ARCHIVE_AFTER_DAYS, DEFAULT_ARCHIVE_RETENTION_POLICY, DEFAULT_CITATION_POLICY, DEFAULT_CITATION_REF_BUDGET, DEFAULT_CONSOLIDATION_FAILURES, DEFAULT_CURATOR_BOOT_GRACE_SECONDS, DEFAULT_CURATOR_INTERVAL_HOURS, DEFAULT_CURATOR_MODEL, DEFAULT_CURATOR_REVIEW_MAX_TOKENS, DEFAULT_HEALTH_THRESHOLDS, DEFAULT_MAX_OPS_PER_PLAN, DEFAULT_MEMORY_CHAR_LIMIT, DEFAULT_MEMORY_REVIEW_MODEL, DEFAULT_MIN_IDLE_HOURS, DEFAULT_MUTATION_CAP, DEFAULT_REFERENCE_REWRITE_POLICY, DEFAULT_REVIEW_CONTEXT_MESSAGES, DEFAULT_REVIEW_MEMORY_INTERVAL, DEFAULT_REVIEW_MESSAGE_CHARS, DEFAULT_REVIEW_SKILL_INTERVAL, DEFAULT_REVIEW_TIMEOUT_MS, DEFAULT_SKILL_CONTENT_CHARS, DEFAULT_SKILL_LIMITS, DEFAULT_SKILL_REVIEW_COMPLETION_MIN_TOOL_CALLS, DEFAULT_SKILL_REVIEW_MODEL, DEFAULT_SKILL_REVIEW_TRIGGER, DEFAULT_SKILL_VERSION_KEEP, DEFAULT_STALE_AFTER_DAYS, DEFAULT_SUBSTANTIVE_MIN_AGENT_CHARS, DEFAULT_SUBSTANTIVE_MIN_TOOL_CALLS, DEFAULT_SUBSTANTIVE_MIN_USER_CHARS, DEFAULT_SUPPORT_FILE_CHAR_POLICY, DEFAULT_SUPPORT_READ_TOOL_NAMES, DEFAULT_THREAT_MAX_SCAN_CHARS, DEFAULT_USER_CHAR_LIMIT, DISPATCH_EVENT_TYPES, DRIFT_MAX_LINE_CHARS, DRIFT_SIGNALS_VERSION, DRIFT_SIGNAL_NOUNS, DSH_AUTHORING_STANDARDS, EMPTY_LOCK_TAKEOVER_MS, EMPTY_PATCH_SEED, ENTRY_DELIMITER, EVENT_ARCHIVE_PREFIX, EVENT_LOG_RETAIN_ARCHIVES, EVENT_LOG_ROTATE_AT, EVENT_LOG_VERSION, EVOLUTION_ERRORS, EVOLUTION_WRITE_TOOLS, EvolutionGateSet, FAMILY_SESSION_TOOL_NAMES, FORBIDDEN_CONTROL_KEYS, FUZZY_MAX_PATTERN_CHARS, FUZZY_MAX_WORK, HEALTH_STAMP_RE, HISTORY_DIR, HISTORY_INDEX_VERSION, HOOK_LINE_RE, INSTANCE_KEYS, KEEP_LINE_RE, LOCK_BODY_RE, LOCK_SUFFIX, LOCK_TEAR_TAKEOVER_MS, LOW_QUALITY_THRESHOLD, LostWriteLock, MAINTAIN_OUTPUT_INSTRUCTION, MAINTAIN_PROMPT, MAX_DESCRIPTION_LENGTH, MAX_REQUEST_BODY_BYTES, MAX_RESTRUCTURE_MOVES, MAX_SKILL_CONTENT_CHARS, MAX_SKILL_FILE_BYTES, MAX_SKILL_NAME_LENGTH, MAX_SUPPORT_READ_PATHS, MAX_TIMER_DELAY_MS, MEMORY_GUIDANCE_SECTION_ORDER, MEMORY_REVIEW_PROMPT, MIN_STAMP_BODY_CHARS, MUTATIONS_FILE_VERSION, MemoryStore, NAMESPACE_MIGRATIONS, NATIVE_CALL_EVENT, NATIVE_RESULT_EVENT, PARAM_ALIASES, PARAM_EXPOSURE, PARAM_GROUP_LABELS, PARAM_NAMESPACES, PATTERN_OVERLAP, PLATFORM_CATALOG_DESCRIPTION_DEFAULT, PLATFORM_ESTIMATE_CHARS_PER_TOKEN, POLICY_STAGE_DEFAULTS, PROMPT_BUNDLE, PROMPT_BUNDLE_ID, PROMPT_BUNDLE_VERSION, PROTECTED_BUILTIN_SKILLS, PTC_DISPATCH_EVENT, PTC_DISPATCH_START_EVENT, QUALITY_WEIGHTS, READ_REQUIRED_ACTIONS, RESTRUCTURE_TARGET_RE, RETENTION_FEEDBACK_KEEP_RATIO, RETENTION_FEEDBACK_MIN_CHARS, SKILLS_GUIDANCE, SKILLS_GUIDANCE_SECTION_ORDER, SKILL_ACTION_REQUIRED_FIELDS, SKILL_NAME_RE, SKILL_REVIEW_PLAN_PROMPT, SKILL_REVIEW_PROMPT, SNAPSHOT_EXTRA_NAME_RE, SUMMARY_DUPLICATE_HINT_THRESHOLD, SUPPORT_DIRS, SUPPRESSED_FILE_VERSION, SkillLibrary, TEXT_DIFF_MAX_CHARS, TEXT_DIFF_MAX_LINES, THREAT_EXEMPTION_HINT, TOKEN_ASCII_WEIGHT, TOKEN_CJK_WEIGHT, ToolDispatchNormalizer, ToolDispatchPayloadError, UPSTREAM_LIMIT_CHARS_PER_TOKEN, VERSION_SUMMARY_MAX_CHARS, advanceReview, affinity, ageCopyKey, allowRowCollisions, anchorVerdict, appendEvolutionEvent, applyCuratorLifecycleFields, applyCuratorMetaFields, applyNamespaceMigration, applyReferenceRewrite, assertDispatchPayload, assertSkillsRootAliasRetired, assessStructureHealth, authoringFeedback, basePresetPlugins, blobPath, bodyCost, buildCuratorRunReport, buildLearnPrompt, bumpPatch, bumpSupportRead, bumpUse, bumpView, callingScope, canonicalWriteId, claimInstance, clampedNumber, classifyNamespaceMigration, clearReviewChannel, collectReadSkillNames, composePresetComposition, composePresetEntry, composePresetInsert, composePresetRow, computeDedupGroups, computeDriftSignals, computeLifecycleTransitions, computePrefixClusters, computeQualityScores, computeScopeView, contentHash, contentRetentionFeedback, countDispatches, createGateSet, daysSinceIso, decideTakeover, describeReferenceRewrite, dispatchKeyOf, dispatchStepOf, displayBodyOf, duplicateHeadings, elapsedSince, emptyRecord, entryTarget, errorText, evaluateThreat, eventsFile, evidenceKindIndex, evolutionActivityProjection, evolutionEventPayloadIssue, evolutionEvidenceProjection, evolutionHome, evolutionIoAdapter, evolutionReadsProjection, evolutionRoot, evolutionSignalsProjection, filterUnreadSkillOps, findDriftSignal, foldCuratorFields, foldToolDispatches, foldTurnEvent, foldTurnEvents, frontmatterBlock, frontmatterCatalogInvalid, fuzzyPatch, getRecord, historyIndexFile, historyRoot, identity, idleDays, initialTurnFold, installEvolutionProjections, instanceClaimKey, instanceClaimedWriteSites, instanceHolder, isAbsent, isBookkeepingFrame, isCommittedWarning, isDeprecatedParamId, isFileShapedPath, isLoopbackRequest, isMissingPath, isPresent, isProcessAlive, isProgramToolName, isReviewChannelSession, isSkillReadToolName, isSkillToolName, isUnknown, isUnreadWrite, latestActivityAt, latestVersionAt, lifecycleCandidate, listEventArchives, loadMutations, loadRowOverrides, loadSuppressedNames, loadUsage, loadVersionContent, loadVersions, makeSerialQueue, mapProbe, markAgentCreated, markReviewChannel, markerEntryName, memoryRoot, mergePresetRow, missingSupportPointers, mutateUsage, mutationsFile, narrowNameMatches, nearDuplicateSummaries, neutralizePromptVariables, newSkillLibrary, nextHistoryIndex, nodeEvolutionIo, normalizeFrontmatter, normalizeUsageRecord, normalizeVersionSummary, observeEvent, orderVersions, overlongLines, paramNamespace, paramRowId, paramSettingsId, parseCuratorNominations, parseEvolutionEvents, parseFrontmatter, parseHistoryIndex, parseLockBody, partitionVersions, pendingSelfCleanup, persistedWriteSite, persistedWriteSites, planNamespaceMigration, planReferenceRewrite, planRehoming, policyStageLimits, presetPatchText, presetRowBlock, presetRowBody, presetRowId, probeAbsent, probeList, probeMtime, probePresent, probeReason, probeUnknown, projectionText, readDispatchSignal, readEvolutionEvents, readEvolutionTimeline, readHistoryIndex, readJsonBody, readJsonObject, readNumberParam, readParam, readingStats, recordMutation, recordVersions, redactSecrets, relatedSkillNames, releaseInstance, removePresetRow, renameWithRetry, renderCuratorReportMarkdown, resolveBasePresetPatch, resolveCitations, resolveExecOrigins, resolveOrigins, resolveParamId, resolveRootConfig, resolveSkillsRoot, retainEventArchives, retirementReport, reviewPrompt, saveSuppressedNames, saveUsage, scanBodyHooks, scanContentThreats, scanMemoryThreats, scanThreats, scopedProbeReport, sessionAudited, sessionEvidenceIndex, sessionLastEventTime, sessionReadNames, sessionReadSkillNames, sessionSeesFamilyTools, sessionTurnSignals, skillReadNameOf, skillRowCells, skillStateKey, skillsRoot, supportFileReadOf, suppressedFile, sweepReviewChannelSessions, textDiffFacts, tokenLineFor, transactIo, transactTaskGuard, trimPatternBoundaries, unhookedSupportPointers, updateSuppressedNames, usageFile, usageObserved, validateFrontmatter, validateRestructureTarget, valueOr, verifyPromptBundle, versionActionKind, versionRowCells, versionSummaryPrompt, versionTarget, vocabulary, writeDurableTmp, writeJson, yamlPlainScalarNeedsQuotes };