@lmzhen/dsh-evolution-plan-validator 0.9.0 → 0.11.1

package/README.md

@@ -4,6 +4,19 @@ Deterministic validator for model-produced evolution plans: it exports the plan
 (`EvolutionPlan`, `MemoryOp`, `SkillOp`) and the single `validateEvolutionPlan(plan,
 context)` entry point.
 
+The per-op questions are the named, ordered table `PLAN_RULES` (one table per op kind, same form
+as the tool path's write gates): the first refusing rule names the reason, and every id is pinned
+by the suite, so a rename or a reorder is a visible change. Container-level rejections (a
+non-array `skillOps`, a malformed entry) stay outside the tables — they judge the container, not
+an operation.
+
+One row is **report-only**: `EVIDENCE_CLASS` records into `ValidationResult.reports` and never
+refuses. It reads `ValidationContext.substantiveEvidenceSeqs` (core `evidenceKindIndex`) and
+reports an op whose entire citation list is a turn/step boundary frame — the range rule cannot
+tell such a frame from a real exchange. It is phase 1 of the evidence-consistency rule: an
+observation window before anyone decides to refuse on it, and `undefined` (a log that cannot be
+classified) stays silent rather than reporting every op.
+
 ## Model surface
 
 - **Model-visible:** nothing of its own: no prompt, no tool schema and no service; consumers own the model-visible effects.

package/lib/index.js

@@ -3,6 +3,21 @@ import { DEFAULT_MAX_OPS_PER_PLAN, DEFAULT_MEMORY_CHAR_LIMIT, DEFAULT_SKILL_CONT
 /**
 * Deterministic validator for model-produced evolution plans.
 * The validator never calls the model and never mutates state.
+*
+* The per-op questions are a NAMED, ORDERED TABLE (design
+* `dsh-evolution-skill-history-design.md` §3D), the same form as the tool path's
+* `tool-skill-manage/src/write-gates.ts`: the rule BODIES read the shared core tables
+* (`FORBIDDEN_CONTROL_KEYS`, `SKILL_ACTION_REQUIRED_FIELDS`, the restructure-target
+* rule), and this module owns the ORDER and the wording. Order is part of the contract — the first
+* refusing rule names the reason the model reads — and container-level rejections (a non-array
+* `skillOps`, a malformed entry) stay outside the tables because they judge the container,
+* not an operation.
+*
+* One row is REPORT-ONLY: `EVIDENCE_CLASS` records a finding in
+* `ValidationResult.reports` and never refuses an op. It is phase 1 of the
+* evidence-consistency rule — the range rule cannot tell a real exchange from a `turn/start`
+* boundary, and refusing on that difference is a later decision this observation window has to
+* earn (design §3D, §5.5).
 * @module @lmzhen/dsh-evolution-plan-validator
 */
 const MEMORY_ACTIONS = new Set([
@@ -21,20 +36,262 @@ const SKILL_ACTIONS = new Set([
 	"restructure"
 ]);
 const FORBIDDEN_KEYS = FORBIDDEN_CONTROL_KEYS;
-/** v31 REV-08 (stated honestly): this gate is SEQUENCE-RANGE ONLY — every
-* evidence item must carry an integer seq within [0, sessionSeq]. There is NO
-* quoted-text/content verification: a model can satisfy it by citing any
-* in-range event (even an unrelated one). Anti-fabrication strength lives in
-* read-before-write, budgets, and the threat scan — not here. */
+/** The seq ONE evidence item cites, or -1 when it cites none.
+*
+* P3 (v3 audit): only a REAL numeric seq passes — Number(null)/Number('')/Number(false) coerce
+* to 0 and would mint fake evidence order. */
+function citedEvidenceSeq(item) {
+	if (!item || typeof item !== "object") return -1;
+	const record = item;
+	return typeof record.event_seq === "number" ? record.event_seq : typeof record.seq === "number" ? record.seq : typeof record.event_seq === "string" && /^[0-9]+$/.test(record.event_seq) ? Number(record.event_seq) : -1;
+}
+/** v31 REV-08 (stated honestly): this gate is SEQUENCE-RANGE ONLY — every evidence item must
+* carry an integer seq within [0, sessionSeq]. There is NO quoted-text/content verification: a
+* model can satisfy it by citing any in-range event (even an unrelated one). Anti-fabrication
+* strength lives in read-before-write, budgets, and the threat scan — not here. The CLASS of the
+* cited frame is a separate, report-only question (`EVIDENCE_CLASS`). */
 function hasValidEvidence(evidence, sessionSeq) {
 	if (!Array.isArray(evidence) || evidence.length === 0) return false;
 	return evidence.every((item) => {
-		if (!item || typeof item !== "object") return false;
-		const record = item;
-		const seq = typeof record.event_seq === "number" ? record.event_seq : typeof record.seq === "number" ? record.seq : typeof record.event_seq === "string" && /^\d+$/.test(record.event_seq) ? Number(record.event_seq) : -1;
+		const seq = citedEvidenceSeq(item);
 		return Number.isInteger(seq) && seq >= 0 && seq <= sessionSeq;
 	});
 }
+/** EVIDENCE_CLASS — phase 1 of the evidence-consistency question: does ANY cited frame carry
+* content? An op whose whole citation list is a turn/step boundary is reported, never refused.
+*
+* `undefined` is not an empty set: a caller that could not classify the log has nothing to
+* say, and reporting every op would be the false-positive flood this phase exists to avoid. */
+function bookkeepingEvidenceReason(input) {
+	const substantive = input.context.substantiveEvidenceSeqs;
+	if (substantive === void 0) return null;
+	const evidence = input.op.evidence;
+	if (!Array.isArray(evidence) || evidence.length === 0) return null;
+	if (evidence.some((item) => substantive.has(citedEvidenceSeq(item)))) return null;
+	return `${input.kind} op ${input.index}: every cited evidence seq is a turn/step boundary frame — no content frame backs this op`;
+}
+/** P2-1 (v15): the string-typed fields the executors dereference with
+* `.trim()`/`.length`. `target` is included for memory ops because the
+* engine compares it against literals. */
+function malformedStringField(op, fields) {
+	const record = op;
+	for (const field of fields) {
+		const value = record[field];
+		if (value !== void 0 && value !== null && typeof value !== "string") return field;
+	}
+	return null;
+}
+/** The memory op's questions, in the order the model meets them. */
+const MEMORY_PLAN_RULES = [
+	{
+		id: "FIELD_TYPE",
+		run: ({ op, index }) => {
+			const badField = malformedStringField(op, [
+				"facts",
+				"content",
+				"old_text",
+				"target"
+			]);
+			return badField === null ? null : `memory op ${index}: field ${badField} must be a string`;
+		}
+	},
+	{
+		id: "EVIDENCE_RANGE",
+		run: ({ op, index, context }) => hasValidEvidence(op.evidence, context.sessionSeq) ? null : `memory op ${index}: evidence is required and must reference a valid session seq`
+	},
+	{
+		id: "CONTROL_KEYS",
+		run: ({ op, index }) => {
+			for (const key of FORBIDDEN_KEYS) if (key in op) return `memory op ${index}: forbidden field ${key}`;
+			return null;
+		}
+	},
+	{
+		id: "TARGET",
+		run: ({ op, index }) => op.target === "memory" || op.target === "user" ? null : `memory op ${index}: target must be memory or user`
+	},
+	{
+		id: "ACTION",
+		run: ({ op, index }) => {
+			const action = op.action ?? "add";
+			return MEMORY_ACTIONS.has(action) ? null : `memory op ${index}: unknown action ${action}`;
+		}
+	},
+	{
+		id: "PAYLOAD",
+		run: ({ op, index }) => {
+			const action = op.action ?? "add";
+			const text = (op.facts ?? op.content ?? "").trim();
+			return action !== "remove" && text.length === 0 ? `memory op ${index}: ${action} requires facts/content` : null;
+		}
+	},
+	{
+		id: "ANCHOR",
+		run: ({ op, index }) => {
+			const action = op.action ?? "add";
+			return action !== "add" && !(op.old_text ?? "").trim() ? `memory op ${index}: ${action} requires old_text` : null;
+		}
+	},
+	{
+		id: "BUDGET",
+		run: ({ op, index, context }) => {
+			const text = (op.facts ?? op.content ?? "").trim();
+			const budget = op.target === "user" ? context.maxUserChars ?? DEFAULT_USER_CHAR_LIMIT : context.maxMemoryChars ?? DEFAULT_MEMORY_CHAR_LIMIT;
+			return text.length > budget ? `memory op ${index}: content exceeds ${op.target === "user" ? "user" : "memory"} budget` : null;
+		}
+	},
+	{
+		id: "EVIDENCE_CLASS",
+		reportOnly: true,
+		run: bookkeepingEvidenceReason
+	}
+];
+/** The skill op's questions, in the order the model meets them. */
+const SKILL_PLAN_RULES = [
+	{
+		id: "FIELD_TYPE",
+		run: ({ op, index }) => {
+			const badField = malformedStringField(op, [
+				"name",
+				"content",
+				"old_string",
+				"new_string",
+				"file_path",
+				"file_content",
+				"absorbed_into"
+			]);
+			return badField === null ? null : `skill op ${index}: field ${badField} must be a string`;
+		}
+	},
+	{
+		id: "REPLACE_ALL",
+		run: ({ op, index }) => op.replace_all === void 0 || typeof op.replace_all === "boolean" ? null : `skill op ${index}: field replace_all must be a boolean`
+	},
+	{
+		id: "CONTROL_KEYS",
+		run: ({ op, index }) => {
+			for (const key of FORBIDDEN_KEYS) if (key in op) return `skill op ${index}: forbidden field ${key}`;
+			return null;
+		}
+	},
+	{
+		id: "NAME",
+		run: ({ op, index }) => (op.name ?? "").trim() ? null : `skill op ${index}: name is required`
+	},
+	{
+		id: "PROTECTED",
+		run: ({ op, index, context }) => {
+			const name = (op.name ?? "").trim();
+			return context.protectedSkillNames?.has(name) ? `skill op ${index}: skill "${name}" is protected` : null;
+		}
+	},
+	{
+		id: "EVIDENCE_RANGE",
+		run: ({ op, index, context }) => hasValidEvidence(op.evidence, context.sessionSeq) ? null : `skill op ${index}: evidence is required and must reference a valid session seq`
+	},
+	{
+		id: "ACTION",
+		run: ({ op, index }) => {
+			const action = op.action ?? "patch";
+			return SKILL_ACTIONS.has(action) ? null : `skill op ${index}: unknown action ${action}`;
+		}
+	},
+	{
+		id: "REQUIRED_FIELDS",
+		run: ({ op, index }) => {
+			const action = op.action ?? "patch";
+			const requiredFields = SKILL_ACTION_REQUIRED_FIELDS[action];
+			if (requiredFields === void 0) return null;
+			const record = op;
+			for (const field of requiredFields) if (record[field] === void 0 || record[field] === null) return `skill op ${index}: ${action} requires ${field}`;
+			return null;
+		}
+	},
+	{
+		id: "WRITE_PAYLOAD",
+		run: ({ op, index }) => {
+			const action = op.action ?? "patch";
+			return (action === "create" || action === "edit" || action === "update") && !(op.content ?? "").trim() ? `skill op ${index}: ${action} requires content` : null;
+		}
+	},
+	{
+		id: "PATCH_ANCHOR",
+		run: ({ op, index }) => op.action === "patch" && !(op.old_string ?? "") ? `skill op ${index}: patch requires old_string` : null
+	},
+	{
+		id: "DELETE_TARGET",
+		run: ({ op, index }) => op.action === "delete" && !(op.absorbed_into ?? "").trim() ? `skill op ${index}: delete requires absorbed_into` : null
+	},
+	{
+		id: "SUPPORT_PAYLOAD",
+		run: ({ op, index }) => op.action === "write_file" && !(op.file_content ?? "").trim() ? `skill op ${index}: write_file requires file_content` : null
+	},
+	{
+		id: "BUDGET",
+		run: ({ op, index, context }) => {
+			return [
+				op.file_content ?? "",
+				op.content ?? "",
+				op.new_string ?? ""
+			].reduce((max, value) => Math.max(max, value.length), 0) > (context.maxSkillContentChars ?? DEFAULT_SKILL_CONTENT_CHARS) ? `skill op ${index}: content exceeds skill budget` : null;
+		}
+	},
+	{
+		id: "RESTRUCTURE",
+		run: ({ op, index }) => {
+			if (op.action !== "restructure") return null;
+			if (!Array.isArray(op.restructure) || op.restructure.length === 0) return `skill op ${index}: restructure requires a non-empty restructure list`;
+			if (op.restructure.length > MAX_RESTRUCTURE_MOVES) return `skill op ${index}: restructure exceeds ${MAX_RESTRUCTURE_MOVES} moves`;
+			for (const [moveIndex, move] of op.restructure.entries()) {
+				if (!move || typeof move.heading !== "string" || !move.heading.trim()) return `skill op ${index}: restructure[${moveIndex}] requires a non-empty heading`;
+				if (typeof move.to_file !== "string") return `skill op ${index}: restructure[${moveIndex}] to_file must be references/<topic>.md`;
+				const targetIssue = validateRestructureTarget(move.to_file);
+				if (targetIssue) return `skill op ${index}: restructure[${moveIndex}] ${targetIssue}`;
+			}
+			return null;
+		}
+	},
+	{
+		id: "EVIDENCE_CLASS",
+		reportOnly: true,
+		run: bookkeepingEvidenceReason
+	}
+];
+/**
+* The plan path's rule tables, by op kind — the named set whose ORDER this module owns.
+*
+* Exported so a rename or a reorder is a visible change (the suite pins the ids), and so the tool
+* path's gate table and this one can be compared side by side without reading either
+* implementation.
+*/
+const PLAN_RULES = {
+	memory: MEMORY_PLAN_RULES,
+	skill: SKILL_PLAN_RULES
+};
+/** Run one op's table in order: the first refusing rule names the reason, a report-only row
+* records its verdict and lets the op continue. */
+function runPlanRules(rules, op, context, index, kind, reports) {
+	for (const rule of rules) {
+		const reason = rule.run({
+			op,
+			kind,
+			index,
+			context
+		});
+		if (reason === null) continue;
+		if (rule.reportOnly === true) {
+			reports.push({
+				rule: rule.id,
+				kind,
+				index,
+				reason
+			});
+			continue;
+		}
+		return reason;
+	}
+	return null;
+}
 /** Object root guard (V4-23, symmetric with the maintain validator): null,
 * primitives and arrays are not a plan record and must be rejected with an
 * explicit message, never a raw TypeError from `.memoryOps`/`.summary`. */
@@ -42,6 +299,7 @@ function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function validateEvolutionPlan(plan, context) {
+	const reports = [];
 	if (!isRecord(plan)) return {
 		accepted: {
 			memoryOps: [],
@@ -52,6 +310,7 @@ function validateEvolutionPlan(plan, context) {
 			kind: "memory",
 			reason: "plan root: must be an object"
 		}],
+		reports,
 		ok: false
 	};
 	const maxOps = context.maxOpsPerPlan ?? DEFAULT_MAX_OPS_PER_PLAN;
@@ -85,6 +344,7 @@ function validateEvolutionPlan(plan, context) {
 		return {
 			accepted,
 			rejected,
+			reports,
 			ok: false
 		};
 	}
@@ -97,6 +357,7 @@ function validateEvolutionPlan(plan, context) {
 		return {
 			accepted,
 			rejected,
+			reports,
 			ok: false
 		};
 	}
@@ -110,7 +371,7 @@ function validateEvolutionPlan(plan, context) {
 			continue;
 		}
 		const op = rawOp;
-		const reason = validateMemoryOp(op, context, index);
+		const reason = runPlanRules(MEMORY_PLAN_RULES, op, context, index, "memory", reports);
 		if (reason) rejected.push({
 			index,
 			kind: "memory",
@@ -131,7 +392,7 @@ function validateEvolutionPlan(plan, context) {
 			continue;
 		}
 		const op = rawOp;
-		const reason = validateSkillOp(op, context, index);
+		const reason = runPlanRules(SKILL_PLAN_RULES, op, context, index, "skill", reports);
 		if (reason) rejected.push({
 			index,
 			kind: "skill",
@@ -145,85 +406,9 @@ function validateEvolutionPlan(plan, context) {
 	return {
 		accepted,
 		rejected,
+		reports,
 		ok: rejected.length === 0 && memoryOps.length + skillOps.length > 0
 	};
 }
-function validateMemoryOp(op, context, index) {
-	const badField = malformedStringField(op, [
-		"facts",
-		"content",
-		"old_text",
-		"target"
-	]);
-	if (badField) return `memory op ${index}: field ${badField} must be a string`;
-	if (!hasValidEvidence(op.evidence, context.sessionSeq)) return `memory op ${index}: evidence is required and must reference a valid session seq`;
-	for (const key of FORBIDDEN_KEYS) if (key in op) return `memory op ${index}: forbidden field ${key}`;
-	if (op.target !== "memory" && op.target !== "user") return `memory op ${index}: target must be memory or user`;
-	const action = op.action ?? "add";
-	if (!MEMORY_ACTIONS.has(action)) return `memory op ${index}: unknown action ${action}`;
-	const text = (op.facts ?? op.content ?? "").trim();
-	if (action !== "remove" && text.length === 0) return `memory op ${index}: ${action} requires facts/content`;
-	if (action !== "add" && !(op.old_text ?? "").trim()) return `memory op ${index}: ${action} requires old_text`;
-	const budget = op.target === "user" ? context.maxUserChars ?? DEFAULT_USER_CHAR_LIMIT : context.maxMemoryChars ?? DEFAULT_MEMORY_CHAR_LIMIT;
-	if (text.length > budget) return `memory op ${index}: content exceeds ${op.target === "user" ? "user" : "memory"} budget`;
-	return null;
-}
-/** P2-1 (v15): the string-typed fields the executors dereference with
-* `.trim()`/`.length`. `target` is included for memory ops because the
-* engine compares it against literals. */
-function malformedStringField(op, fields) {
-	const record = op;
-	for (const field of fields) {
-		const value = record[field];
-		if (value !== void 0 && value !== null && typeof value !== "string") return field;
-	}
-	return null;
-}
-function validateSkillOp(op, context, index) {
-	const badField = malformedStringField(op, [
-		"name",
-		"content",
-		"old_string",
-		"new_string",
-		"file_path",
-		"file_content",
-		"absorbed_into"
-	]);
-	if (badField) return `skill op ${index}: field ${badField} must be a string`;
-	if (op.replace_all !== void 0 && typeof op.replace_all !== "boolean") return `skill op ${index}: field replace_all must be a boolean`;
-	for (const key of FORBIDDEN_KEYS) if (key in op) return `skill op ${index}: forbidden field ${key}`;
-	const name = (op.name ?? "").trim();
-	if (!name) return `skill op ${index}: name is required`;
-	if (context.protectedSkillNames?.has(name)) return `skill op ${index}: skill "${name}" is protected`;
-	if (!hasValidEvidence(op.evidence, context.sessionSeq)) return `skill op ${index}: evidence is required and must reference a valid session seq`;
-	const action = op.action ?? "patch";
-	if (!SKILL_ACTIONS.has(action)) return `skill op ${index}: unknown action ${action}`;
-	const requiredFields = SKILL_ACTION_REQUIRED_FIELDS[action];
-	if (requiredFields !== void 0) {
-		const record = op;
-		for (const field of requiredFields) if (record[field] === void 0 || record[field] === null) return `skill op ${index}: ${action} requires ${field}`;
-	}
-	if ((action === "create" || action === "edit" || action === "update") && !(op.content ?? "").trim()) return `skill op ${index}: ${action} requires content`;
-	if (action === "patch" && !(op.old_string ?? "")) return `skill op ${index}: patch requires old_string`;
-	if (action === "delete" && !(op.absorbed_into ?? "").trim()) return `skill op ${index}: delete requires absorbed_into`;
-	const writeBytes = [
-		op.file_content ?? "",
-		op.content ?? "",
-		op.new_string ?? ""
-	].reduce((max, value) => Math.max(max, value.length), 0);
-	if (action === "write_file" && !(op.file_content ?? "").trim()) return `skill op ${index}: write_file requires file_content`;
-	if (writeBytes > (context.maxSkillContentChars ?? DEFAULT_SKILL_CONTENT_CHARS)) return `skill op ${index}: content exceeds skill budget`;
-	if (action === "restructure") {
-		if (!Array.isArray(op.restructure) || op.restructure.length === 0) return `skill op ${index}: restructure requires a non-empty restructure list`;
-		if (op.restructure.length > MAX_RESTRUCTURE_MOVES) return `skill op ${index}: restructure exceeds ${MAX_RESTRUCTURE_MOVES} moves`;
-		for (const [moveIndex, move] of op.restructure.entries()) {
-			if (!move || typeof move.heading !== "string" || !move.heading.trim()) return `skill op ${index}: restructure[${moveIndex}] requires a non-empty heading`;
-			if (typeof move.to_file !== "string") return `skill op ${index}: restructure[${moveIndex}] to_file must be references/<topic>.md`;
-			const targetIssue = validateRestructureTarget(move.to_file);
-			if (targetIssue) return `skill op ${index}: restructure[${moveIndex}] ${targetIssue}`;
-		}
-	}
-	return null;
-}
 //#endregion
-export { validateEvolutionPlan };
+export { PLAN_RULES, validateEvolutionPlan };

package/lib/types/index.d.ts

@@ -1,6 +1,21 @@
 /**
  * Deterministic validator for model-produced evolution plans.
  * The validator never calls the model and never mutates state.
+ *
+ * The per-op questions are a NAMED, ORDERED TABLE (design
+ * `dsh-evolution-skill-history-design.md` §3D), the same form as the tool path's
+ * `tool-skill-manage/src/write-gates.ts`: the rule BODIES read the shared core tables
+ * (`FORBIDDEN_CONTROL_KEYS`, `SKILL_ACTION_REQUIRED_FIELDS`, the restructure-target
+ * rule), and this module owns the ORDER and the wording. Order is part of the contract — the first
+ * refusing rule names the reason the model reads — and container-level rejections (a non-array
+ * `skillOps`, a malformed entry) stay outside the tables because they judge the container,
+ * not an operation.
+ *
+ * One row is REPORT-ONLY: `EVIDENCE_CLASS` records a finding in
+ * `ValidationResult.reports` and never refuses an op. It is phase 1 of the
+ * evidence-consistency rule — the range rule cannot tell a real exchange from a `turn/start`
+ * boundary, and refusing on that difference is a later decision this observation window has to
+ * earn (design §3D, §5.5).
  * @module @lmzhen/dsh-evolution-plan-validator
  */
 export interface MemoryOp {
@@ -42,6 +57,12 @@ export interface EvolutionPlan {
 export interface ValidationContext {
     /** Upper bound for the latest valid session seq. */
     sessionSeq: number;
+    /** The seqs of the frames that carry CONTENT (core `evidenceKindIndex`), or
+     * `undefined` when the caller cannot classify the log (a session whose events carry no
+     * seq). Read by the report-only `EVIDENCE_CLASS` row only: an op whose entire citation
+     * list is a bookkeeping frame (`turn/start`, `step/start`, …) becomes visible
+     * without being refused. */
+    substantiveEvidenceSeqs?: ReadonlySet<number> | undefined;
     maxOpsPerPlan?: number;
     protectedSkillNames?: ReadonlySet<string>;
     maxMemoryChars?: number;
@@ -53,10 +74,50 @@ export interface RejectedOp {
     kind: 'memory' | 'skill';
     reason: string;
 }
+/** The op kinds a plan carries, and the two keys of {@link PLAN_RULES}. */
+export type PlanOpKind = 'memory' | 'skill';
+/** One report-only finding: a rule that let the op proceed and still had something to say.
+ * `ValidationResult.ok` ignores this list — a report is never a refusal. */
+export interface PlanRuleReport {
+    /** The reporting rule's id from {@link PLAN_RULES}. */
+    rule: string;
+    kind: PlanOpKind;
+    index: number;
+    reason: string;
+}
 export interface ValidationResult {
     accepted: EvolutionPlan;
     rejected: RejectedOp[];
+    /** Findings from the report-only rows; empty when every op was either clean or refused. */
+    reports: PlanRuleReport[];
     ok: boolean;
 }
+/** What one rule reads: the op, which table it came from, and the caller's context. */
+export interface PlanRuleInput<Op> {
+    readonly op: Op;
+    readonly kind: PlanOpKind;
+    readonly index: number;
+    readonly context: ValidationContext;
+}
+/** One named question the plan path asks about ONE op. */
+export interface PlanRule<Op> {
+    /** Stable id: a report cites it, and the table's order is the refusal order. */
+    readonly id: string;
+    /** Records the verdict in `ValidationResult.reports` instead of refusing the op. */
+    readonly reportOnly?: boolean;
+    /** @returns the refusal reason, or null to let the op proceed. */
+    run(input: PlanRuleInput<Op>): string | null;
+}
+/**
+ * The plan path's rule tables, by op kind — the named set whose ORDER this module owns.
+ *
+ * Exported so a rename or a reorder is a visible change (the suite pins the ids), and so the tool
+ * path's gate table and this one can be compared side by side without reading either
+ * implementation.
+ */
+export declare const PLAN_RULES: {
+    readonly memory: readonly PlanRule<MemoryOp>[];
+    readonly skill: readonly PlanRule<SkillOp>[];
+};
 export declare function validateEvolutionPlan(plan: EvolutionPlan, context: ValidationContext): ValidationResult;
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-plan-validator",
   "description": "Deterministic validator for model-produced evolution plans (community build)",
-  "version": "0.9.0",
+  "version": "0.11.1",
   "publishConfig": {
     "access": "public"
   },
@@ -26,6 +26,6 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@lmzhen/dsh-evolution-core": "^0.9.0"
+    "@lmzhen/dsh-evolution-core": "^0.11.1"
   }
 }