@lmzhen/dsh-evolution-state-storage 0.17.1 → 0.18.1

package/README.md

@@ -20,7 +20,9 @@ import { expect } from 'vitest' // or any runner wrapped into `ConformanceAssert
 await runStateProviderConsistency(myProvider, expect)
 ```
 
-The assertion surface is INJECTED rather than imported, which is what lets this module ship: it carries no test-runner dependency, so loading the package never loads vitest. Both shipped providers run the same suite (`evolution-state-json` / `evolution-state-domain` `tests/provider-consistency.spec.ts`), and `consistency-forge.spec.ts` proves the suite fails when a single field is forged.
+Every value the vectors use is PARAMETERIZABLE (U-2): `runStateProviderConsistency(provider, assert, options)` takes `idPrefix` / `claimPrefix` / `createdAt` / `sessionId` / `attributionSessionId` / `reviewSessionPrefix`, so a medium that already holds records in the default `c-…` namespace — or whose schema insists on a parseable stamp — runs the very same vectors under its own values. Every field defaults to the in-tree literals, so a two-argument call is unchanged. Each vector carries a `since <version>` note saying which release it became binding in.
+
+The assertion surface is INJECTED rather than imported, which is what lets this module ship: it carries no test-runner dependency, so loading the package never loads vitest. Both shipped providers run the same suite (`evolution-state-json` / `evolution-state-domain` `tests/provider-consistency.spec.ts`) — the json one also runs it under a caller-supplied namespace — and `consistency-forge.spec.ts` proves the suite fails when a single field is forged.
 
 
 ## Known limitations

package/lib/index.js

@@ -82,17 +82,38 @@ const REVIEW_STATE_SESSION_CAP = 500;
 const UNKNOWN_FIELD_POLICY = "preserve";
 const isNonNegInt = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0;
 const optionalString = (value) => value === void 0 || typeof value === "string";
-const PENDING_KINDS = new Set([
+/** 0.3.17 (S3.5, D-4): 'skill_batch' is gone — nothing ever created one (a dead enum member). A
+* historic value, if it ever reached disk, is read as an unknown kind by consumers rather than
+* minted here.
+*
+* 0.3.66: 'capability' stays with NO producer — the evolution-capability adapter was removed. It is
+* a read-compatibility member: state written by an install that used that adapter (≤0.3.65) still
+* holds such records, and they must keep loading, listing in `/evolution pending`, and answering
+* approve or reject. Dropping it would strand them two ways: json quarantines the row to
+* `<file>.corrupt` and refuses the resolving write, while the domain provider validates every
+* stored record at mount, so one such row fails the whole domain with `invalid-record`.
+*
+* S2.9/1-10: this array is the ONE source of the vocabulary — the types, the write gate below and
+* the domain provider's schema all derive from it. A second literal copy is the E-10 drift class
+* this module exists to end. */
+const PENDING_KINDS = [
 	"memory",
 	"skill",
 	"capability"
-]);
-const PENDING_STATUSES = new Set([
+];
+/** 0.3.17 (S3.3, E-24): 'executing' = claimed, runner in flight — a fresh claim only takes
+* 'pending', and resolve accepts 'pending'/'executing', so a crash mid-approve can never
+* double-execute the runner. Same one-source rule as PENDING_KINDS. */
+const PENDING_STATUSES = [
 	"pending",
 	"executing",
 	"approved",
 	"rejected"
-]);
+];
+/** Membership test for the write gate (per record per write, so the Set is worth it). */
+const PENDING_KIND_SET = new Set(PENDING_KINDS);
+/** Membership test for the write gate. */
+const PENDING_STATUS_SET = new Set(PENDING_STATUSES);
 /**
 * The write gate for one record. Both providers call this before persisting,
 * so a record the other provider would refuse can never land.
@@ -118,12 +139,12 @@ function recordIssue(table, record) {
 		return null;
 	}
 	if (typeof value.id !== "string") return "id must be a string";
-	if (typeof value.kind !== "string" || !PENDING_KINDS.has(value.kind)) return "kind must be memory|skill|capability";
+	if (typeof value.kind !== "string" || !PENDING_KIND_SET.has(value.kind)) return `kind must be ${PENDING_KINDS.join("|")}`;
 	if (typeof value.summary !== "string") return "summary must be a string";
 	if (!Object.prototype.hasOwnProperty.call(value, "args")) return "args key is required (may be any cloneable value)";
 	if (value.args === void 0) return "args must be a cloneable value — `undefined` is dropped by the json medium and the record would be unreadable after a restart (pass {} instead)";
 	if (typeof value.createdAt !== "string") return "createdAt must be a string";
-	if (typeof value.status !== "string" || !PENDING_STATUSES.has(value.status)) return "status must be pending|executing|approved|rejected";
+	if (typeof value.status !== "string" || !PENDING_STATUS_SET.has(value.status)) return `status must be ${PENDING_STATUSES.join("|")}`;
 	for (const field of [
 		"resolvedAt",
 		"claimedBy",
@@ -185,8 +206,9 @@ function cloneRecord(record) {
 * the same public operations on both providers, so neither medium can keep the
 * bound to itself.
 */
-/** Build a fixture pending record, optionally carrying origin/sessionId. */
-const pendingOf = (id, kind = "memory", attribution = {}) => ({
+/** Build a fixture pending record, optionally carrying origin/sessionId. The suite's own stamp and
+* namespace come from {@link ConformanceOptions} — see `basePendingOf`'s call sites. */
+const basePendingOf = (id, kind = "memory", attribution = {}) => ({
 	id,
 	kind,
 	summary: `${kind}:${id}`,
@@ -213,13 +235,24 @@ const findRecord = (records, id) => {
 	if (found === void 0) throw new Error(`conformance: pending record "${id}" missing from the listing`);
 	return found;
 };
-async function runStateProviderConsistency(provider, assert) {
-	await provider.saveReviewState("s-consistent", {
+async function runStateProviderConsistency(provider, assert, options = {}) {
+	const idPrefix = options.idPrefix ?? "c-";
+	const claimPrefix = options.claimPrefix ?? "claim-";
+	const stamp = options.createdAt ?? "now";
+	const sessionId = options.sessionId ?? "s-consistent";
+	const attributionSessionId = options.attributionSessionId ?? "sess-attrib";
+	const reviewSessionPrefix = options.reviewSessionPrefix ?? "s-cap-";
+	/** This run's fixture record: the module helper's fields under THIS run's namespace and stamp. */
+	const pending = (id, kind = "memory", attribution = {}) => ({
+		...basePendingOf(id, kind, attribution),
+		createdAt: stamp
+	});
+	await provider.saveReviewState(sessionId, {
 		turnsSinceMemory: 1,
 		turnsSinceSkill: 2,
 		lastTurn: 3
 	});
-	assert(await provider.loadReviewState("s-consistent")).toEqual({
+	assert(await provider.loadReviewState(sessionId)).toEqual({
 		turnsSinceMemory: 1,
 		turnsSinceSkill: 2,
 		lastTurn: 3
@@ -267,92 +300,92 @@ async function runStateProviderConsistency(provider, assert) {
 		lastSummary: "updated",
 		paused: false
 	});
-	const live = pendingOf("c-live");
+	const live = pending(`${idPrefix}live`);
 	await provider.savePending(live);
-	assert((await provider.listPending("pending")).map((record) => record.id)).toContain("c-live");
-	const claimed = await provider.claimPending("c-live", "claim-a");
+	assert((await provider.listPending("pending")).map((record) => record.id)).toContain(`${idPrefix}live`);
+	const claimed = await provider.claimPending(`${idPrefix}live`, `${claimPrefix}a`);
 	assert(claimed?.status).toBe("executing");
-	assert(claimed?.claimedBy).toBe("claim-a");
+	assert(claimed?.claimedBy).toBe(`${claimPrefix}a`);
 	expectPendingCarried(assert, claimed, live);
 	assert(typeof claimed?.claimedAt).toBe("string");
-	const resolved = await provider.tryResolvePending("c-live", "approved");
+	const resolved = await provider.tryResolvePending(`${idPrefix}live`, "approved");
 	assert(resolved.applied).toBe(true);
-	assert(resolved.record?.id).toBe("c-live");
+	assert(resolved.record?.id).toBe(`${idPrefix}live`);
 	assert(resolved.record?.status).toBe("approved");
 	expectPendingCarried(assert, resolved.record, live);
-	assert(resolved.record?.claimedBy).toBe("claim-a");
+	assert(resolved.record?.claimedBy).toBe(`${claimPrefix}a`);
 	assert(typeof resolved.record?.claimedAt).toBe("string");
 	assert(typeof resolved.record?.resolvedAt).toBe("string");
-	assert((await provider.listPending("approved")).map((record) => record.id)).toContain("c-live");
-	assert((await provider.listPending("pending")).map((record) => record.id)).not.toContain("c-live");
-	const attrib = pendingOf("c-attrib", "memory", {
+	assert((await provider.listPending("approved")).map((record) => record.id)).toContain(`${idPrefix}live`);
+	assert((await provider.listPending("pending")).map((record) => record.id)).not.toContain(`${idPrefix}live`);
+	const attrib = pending(`${idPrefix}attrib`, "memory", {
 		origin: "background_review",
-		sessionId: "sess-attrib"
+		sessionId: attributionSessionId
 	});
 	await provider.savePending(attrib);
-	expectPendingCarried(assert, await provider.claimPending("c-attrib", "claim-a"), attrib);
-	const attribResolved = await provider.tryResolvePending("c-attrib", "approved");
+	expectPendingCarried(assert, await provider.claimPending(`${idPrefix}attrib`, `${claimPrefix}a`), attrib);
+	const attribResolved = await provider.tryResolvePending(`${idPrefix}attrib`, "approved");
 	expectPendingCarried(assert, attribResolved.record, attrib);
 	assert(attribResolved.record?.origin).toBe("background_review");
-	assert(attribResolved.record?.sessionId).toBe("sess-attrib");
+	assert(attribResolved.record?.sessionId).toBe(attributionSessionId);
 	assert(typeof attribResolved.record?.resolvedAt).toBe("string");
-	const rel = pendingOf("c-release", "skill");
+	const rel = pending(`${idPrefix}release`, "skill");
 	await provider.savePending(rel);
-	assert((await provider.claimPending("c-release", "claim-b"))?.status).toBe("executing");
-	await provider.releasePendingClaim("c-release", "claim-b");
-	const released = (await provider.listPending("pending")).find((record) => record.id === "c-release");
+	assert((await provider.claimPending(`${idPrefix}release`, `${claimPrefix}b`))?.status).toBe("executing");
+	await provider.releasePendingClaim(`${idPrefix}release`, `${claimPrefix}b`);
+	const released = (await provider.listPending("pending")).find((record) => record.id === `${idPrefix}release`);
 	assert(released?.status).toBe("pending");
 	expectPendingCarried(assert, released, rel);
 	assert(released?.claimedBy).toBeUndefined();
 	assert(released?.claimedAt).toBeUndefined();
-	const scoped = pendingOf("c-scoped");
+	const scoped = pending(`${idPrefix}scoped`);
 	await provider.savePending(scoped);
-	await provider.claimPending("c-scoped", "claim-owner");
-	assert((await provider.tryResolvePending("c-scoped", "approved", "claim-foreign")).applied).toBe(false);
-	assert((await provider.listPending("executing")).map((record) => record.id)).toContain("c-scoped");
-	const ownerScope = await provider.tryResolvePending("c-scoped", "approved", "claim-owner");
+	await provider.claimPending(`${idPrefix}scoped`, `${claimPrefix}owner`);
+	assert((await provider.tryResolvePending(`${idPrefix}scoped`, "approved", `${claimPrefix}foreign`)).applied).toBe(false);
+	assert((await provider.listPending("executing")).map((record) => record.id)).toContain(`${idPrefix}scoped`);
+	const ownerScope = await provider.tryResolvePending(`${idPrefix}scoped`, "approved", `${claimPrefix}owner`);
 	assert(ownerScope.applied).toBe(true);
 	assert(ownerScope.record?.status).toBe("approved");
-	const filt = pendingOf("c-filter");
+	const filt = pending(`${idPrefix}filter`);
 	await provider.savePending(filt);
-	assert((await provider.listPending("pending")).map((record) => record.id)).toContain("c-filter");
-	assert((await provider.listPending("approved")).map((record) => record.id)).not.toContain("c-filter");
-	const post = pendingOf("c-post-resolve", "memory");
+	assert((await provider.listPending("pending")).map((record) => record.id)).toContain(`${idPrefix}filter`);
+	assert((await provider.listPending("approved")).map((record) => record.id)).not.toContain(`${idPrefix}filter`);
+	const post = pending(`${idPrefix}post-resolve`, "memory");
 	await provider.savePending(post);
-	await provider.claimPending("c-post-resolve", "claim-c");
-	await provider.tryResolvePending("c-post-resolve", "rejected");
-	await provider.releasePendingClaim("c-post-resolve", "claim-c");
-	const postResolved = (await provider.listPending("rejected")).find((record) => record.id === "c-post-resolve");
+	await provider.claimPending(`${idPrefix}post-resolve`, `${claimPrefix}c`);
+	await provider.tryResolvePending(`${idPrefix}post-resolve`, "rejected");
+	await provider.releasePendingClaim(`${idPrefix}post-resolve`, `${claimPrefix}c`);
+	const postResolved = (await provider.listPending("rejected")).find((record) => record.id === `${idPrefix}post-resolve`);
 	assert(postResolved?.status).toBe("rejected");
-	assert(postResolved?.claimedBy).toBe("claim-c");
+	assert(postResolved?.claimedBy).toBe(`${claimPrefix}c`);
 	assert(typeof postResolved?.claimedAt).toBe("string");
 	assert(typeof postResolved?.resolvedAt).toBe("string");
 	await assert(provider.savePending({
-		id: "c-bad",
+		id: `${idPrefix}bad`,
 		kind: "memory",
 		summary: "bad",
-		createdAt: "now",
+		createdAt: stamp,
 		status: "pending"
 	})).rejects.toThrow();
-	const poison = pendingOf("c-poison");
+	const poison = pending(`${idPrefix}poison`);
 	poison.args = { nested: { value: 1 } };
 	await provider.savePending(poison);
-	const returned = findRecord(await provider.listPending("pending"), "c-poison");
+	const returned = findRecord(await provider.listPending("pending"), `${idPrefix}poison`);
 	returned.summary = "poisoned";
 	returned.args.nested.value = 99;
-	const reread = findRecord(await provider.listPending("pending"), "c-poison");
-	assert(reread.summary).toBe("memory:c-poison");
+	const reread = findRecord(await provider.listPending("pending"), `${idPrefix}poison`);
+	assert(reread.summary).toBe(`memory:${idPrefix}poison`);
 	assert(reread.args.nested.value).toBe(1);
 	const uncloneable = {
-		...pendingOf("c-uncloneable"),
+		...pending(`${idPrefix}uncloneable`),
 		args: { fn: () => {} }
 	};
 	await assert(provider.savePending(uncloneable)).rejects.toThrow();
-	const aliased = pendingOf("c-alias");
+	const aliased = pending(`${idPrefix}alias`);
 	aliased.args = { nested: { value: 1 } };
 	await provider.savePending(aliased);
 	aliased.args.nested.value = 99;
-	assert(findRecord(await provider.listPending("pending"), "c-alias").args.nested.value).toBe(1);
+	assert(findRecord(await provider.listPending("pending"), `${idPrefix}alias`).args.nested.value).toBe(1);
 	await assert(provider.saveCuratorState({
 		lastRunAt: 1,
 		runCount: 0,
@@ -361,37 +394,37 @@ async function runStateProviderConsistency(provider, assert) {
 		schemaVersion: -1
 	})).rejects.toThrow();
 	await provider.savePending({
-		...pendingOf("c-extra"),
+		...pending(`${idPrefix}extra`),
 		extraField: "kept"
 	});
-	assert((await provider.listPending("pending")).find((record) => record.id === "c-extra").extraField).toBe("kept");
-	const capPrefix = "c-cap-";
-	await provider.savePending(pendingOf("c-cap-live", "skill"));
+	assert((await provider.listPending("pending")).find((record) => record.id === `${idPrefix}extra`).extraField).toBe("kept");
+	const capPrefix = `${idPrefix}cap-`;
+	await provider.savePending(pending(`${idPrefix}cap-live`, "skill"));
 	for (let index = 0; index <= 201; index += 1) {
 		const id = capPrefix + String(index).padStart(3, "0");
-		await provider.savePending(pendingOf(id));
-		await provider.claimPending(id, "claim-cap");
+		await provider.savePending(pending(id));
+		await provider.claimPending(id, `${claimPrefix}cap`);
 		await provider.tryResolvePending(id, "approved");
 	}
 	const resolvedNow = (await provider.listPending("approved")).concat(await provider.listPending("rejected")).filter((record) => record.kind !== "capability");
 	assert(resolvedNow).toHaveLength(200);
 	const resolvedIds = resolvedNow.map((record) => record.id);
-	assert(resolvedIds).not.toContain("c-cap-000");
-	assert(resolvedIds).not.toContain("c-cap-001");
+	assert(resolvedIds).not.toContain(capPrefix + "000");
+	assert(resolvedIds).not.toContain(capPrefix + "001");
 	assert(resolvedIds).toContain(capPrefix + String(201).padStart(3, "0"));
-	assert((await provider.listPending("pending")).map((record) => record.id)).toContain("c-cap-live");
-	const sessionPrefix = "s-cap-";
+	assert((await provider.listPending("pending")).map((record) => record.id)).toContain(`${idPrefix}cap-live`);
+	const sessionPrefix = reviewSessionPrefix;
 	const reviewStateOf = (turns) => ({
 		turnsSinceMemory: turns,
 		turnsSinceSkill: 0,
 		lastTurn: turns
 	});
 	for (let index = 0; index <= 500; index += 1) await provider.saveReviewState(sessionPrefix + String(index), reviewStateOf(index));
-	assert(await provider.loadReviewState("s-cap-0")).toBeNull();
-	assert(await provider.loadReviewState("s-cap-1")).toEqual(reviewStateOf(1));
+	assert(await provider.loadReviewState(sessionPrefix + "0")).toBeNull();
+	assert(await provider.loadReviewState(sessionPrefix + "1")).toEqual(reviewStateOf(1));
 	assert(await provider.loadReviewState(sessionPrefix + String(500))).toEqual(reviewStateOf(500));
-	await provider.saveReviewState("s-cap-0", reviewStateOf(999));
-	assert(await provider.loadReviewState("s-cap-0")).toEqual(reviewStateOf(999));
+	await provider.saveReviewState(sessionPrefix + "0", reviewStateOf(999));
+	assert(await provider.loadReviewState(sessionPrefix + "0")).toEqual(reviewStateOf(999));
 }
 //#endregion
 //#region lib/types/index.js
@@ -520,4 +553,4 @@ var EvolutionStateStorageRegistry = class extends Service {
 	}
 };
 //#endregion
-export { CURATOR_STATE_FILE, CURATOR_STATE_KEY, CURATOR_STATE_TABLE, EvolutionStateStorageRegistry, EvolutionStateStorageRegistry as default, PENDING_ARCHIVE_BAK_FILE, PENDING_ARCHIVE_FILE, PENDING_LEGACY_FILE, PENDING_RESOLVED_CAP, PENDING_STATE_FILE, PENDING_TABLE, PROVIDER_DOMAIN, PROVIDER_JSON, REVIEW_STATE_FILE, REVIEW_STATE_SESSION_CAP, REVIEW_STATE_TABLE, UNKNOWN_FIELD_POLICY, assertCloneable, canClaimPending, canResolvePending, cloneRecord, recordIssue, releasedStatus, runStateProviderConsistency, selectPendingOverflow, selectSessionOverflow };
+export { CURATOR_STATE_FILE, CURATOR_STATE_KEY, CURATOR_STATE_TABLE, EvolutionStateStorageRegistry, EvolutionStateStorageRegistry as default, PENDING_ARCHIVE_BAK_FILE, PENDING_ARCHIVE_FILE, PENDING_KINDS, PENDING_LEGACY_FILE, PENDING_RESOLVED_CAP, PENDING_STATE_FILE, PENDING_STATUSES, PENDING_TABLE, PROVIDER_DOMAIN, PROVIDER_JSON, REVIEW_STATE_FILE, REVIEW_STATE_SESSION_CAP, REVIEW_STATE_TABLE, UNKNOWN_FIELD_POLICY, assertCloneable, canClaimPending, canResolvePending, cloneRecord, recordIssue, releasedStatus, runStateProviderConsistency, selectPendingOverflow, selectSessionOverflow };

package/lib/types/conformance.d.ts

@@ -23,5 +23,25 @@ export interface ConformanceAssert {
         };
     };
 }
-export declare function runStateProviderConsistency(provider: EvolutionStateStorage, assert: ConformanceAssert): Promise<void>;
+/**
+ * The values a PROVIDER UNDER TEST may need to vary (U-2): a third-party medium can already hold
+ * records in the `c-…` namespace, and a strict schema may insist on a parseable `createdAt`. Every
+ * field defaults to the in-tree literals, so an existing caller's two-argument call is unchanged.
+ */
+export interface ConformanceOptions {
+    /** Namespace for every pending record this run creates (default `'c-'`). */
+    idPrefix?: string;
+    /** Namespace for every claim id (default `'claim-'`). */
+    claimPrefix?: string;
+    /** The `createdAt` stamp every fixture record carries (default `'now'`). A provider whose
+     * schema requires a parseable time passes a real stamp here. */
+    createdAt?: string;
+    /** The review-state session the round-trip vector writes (default `'s-consistent'`). */
+    sessionId?: string;
+    /** The review-state session the ATTRIBUTION vector pins (default `attributionSessionId`). */
+    attributionSessionId?: string;
+    /** Namespace for the per-session cap vector's sessions (default `'s-cap-'`). */
+    reviewSessionPrefix?: string;
+}
+export declare function runStateProviderConsistency(provider: EvolutionStateStorage, assert: ConformanceAssert, options?: ConformanceOptions): Promise<void>;
 //# sourceMappingURL=conformance.d.ts.map

package/lib/types/index.d.ts

@@ -7,26 +7,10 @@
  * @module @lmzhen/dsh-evolution-state-storage
  */
 import { Context, Service } from '@deepseek-ai/cordis';
+import type { PendingKind, PendingStatus } from './record-contract.ts';
 export * from './constants.ts';
 export * from './record-contract.ts';
 export * from './conformance.ts';
-/** 0.3.17 (S3.5, D-4): 'skill_batch' removed — nothing ever created one
- * (dead enum member); the historic value, if it ever reached disk, is read as
- * an unknown kind by consumers rather than minted here.
- *
- * 0.3.66: 'capability' is retained with NO producer — the evolution-capability
- * adapter was removed. It is a read-compatibility member: state written by an
- * install that used that adapter (≤0.3.65) still holds such records, and they
- * must keep loading, listing in `/evolution pending`, and answering approve or
- * reject. Dropping it would strand them two ways: json quarantines the row to
- * `<file>.corrupt` and refuses the resolving write, while the domain provider
- * validates every stored record at mount, so one such row fails the whole domain
- * with `invalid-record`. */
-export type PendingKind = 'memory' | 'skill' | 'capability';
-/** 0.3.17 (S3.3, E-24): 'executing' = claimed, runner in flight — a fresh
- * claim only takes 'pending', and resolve accepts 'pending'/'executing', so a
- * crash mid-approve can never double-execute the runner. */
-export type PendingStatus = 'pending' | 'executing' | 'approved' | 'rejected';
 /** 0.3.17 (S3.3): the claim lifecycle as ONE transition table — BOTH
  * providers (json/domain) must use these, never a hand-written copy (a second
  * copy is exactly the E-10 drift class). */

package/lib/types/record-contract.d.ts

@@ -21,6 +21,29 @@ export type SeamRecordTable = typeof REVIEW_STATE_TABLE | typeof CURATOR_STATE_T
 /** Unknown fields survive a provider round-trip (json preserves by
  * construction; the domain schemas are `.loose()`). */
 export declare const UNKNOWN_FIELD_POLICY: "preserve";
+/** 0.3.17 (S3.5, D-4): 'skill_batch' is gone — nothing ever created one (a dead enum member). A
+ * historic value, if it ever reached disk, is read as an unknown kind by consumers rather than
+ * minted here.
+ *
+ * 0.3.66: 'capability' stays with NO producer — the evolution-capability adapter was removed. It is
+ * a read-compatibility member: state written by an install that used that adapter (≤0.3.65) still
+ * holds such records, and they must keep loading, listing in `/evolution pending`, and answering
+ * approve or reject. Dropping it would strand them two ways: json quarantines the row to
+ * `<file>.corrupt` and refuses the resolving write, while the domain provider validates every
+ * stored record at mount, so one such row fails the whole domain with `invalid-record`.
+ *
+ * S2.9/1-10: this array is the ONE source of the vocabulary — the types, the write gate below and
+ * the domain provider's schema all derive from it. A second literal copy is the E-10 drift class
+ * this module exists to end. */
+export declare const PENDING_KINDS: readonly ["memory", "skill", "capability"];
+/** 0.3.17 (S3.3, E-24): 'executing' = claimed, runner in flight — a fresh claim only takes
+ * 'pending', and resolve accepts 'pending'/'executing', so a crash mid-approve can never
+ * double-execute the runner. Same one-source rule as PENDING_KINDS. */
+export declare const PENDING_STATUSES: readonly ["pending", "executing", "approved", "rejected"];
+/** The legal kind of one pending record. */
+export type PendingKind = (typeof PENDING_KINDS)[number];
+/** The legal status of one pending record. */
+export type PendingStatus = (typeof PENDING_STATUSES)[number];
 /**
  * The write gate for one record. Both providers call this before persisting,
  * so a record the other provider would refuse can never land.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-state-storage",
   "description": "Provider registry seam for durable evolution state (community build)",
-  "version": "0.17.1",
+  "version": "0.18.1",
   "publishConfig": {
     "access": "public"
   },