@lmzhen/dsh-evolution-state-domain 0.1.0-rc.1

package/README.md

@@ -0,0 +1,26 @@
+# @deepseek-ai/dsh-evolution-state-domain
+
+storage-domain provider for evolution state
+
+
+## Model Experience
+
+### Indirect model surface
+
+#### What the model sees
+
+`@deepseek-ai/dsh-evolution-state-domain` registers no direct prompt or tool schema itself. Model-visible effects are owned by the packages that consume this service.
+
+#### Token effect
+
+Zero direct token effect from this package; consumers add any model-visible tokens.
+
+#### KV Cache effect
+
+Independent of request-prefix construction. This package does not alter the assembled prompt or tool list.
+
+## Known Limitations and Deferred Work
+
+
+- - Requires the host-plane `storage-domain` facility. The bundle row stays dormant when it is absent.
+

package/lib/index.js

@@ -0,0 +1,158 @@
+import { z } from "zod";
+import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
+//#region lib/types/index.js
+/**
+* storage-domain provider for evolution state.
+*
+* When this provider is mounted, review/curator/pending records live in the
+* DSH storage-domain data form: schema-validated, change-emitting, durable KV
+* with whatever backend the domain facility routes (`json`, `sqlite`, remote
+* RPC, …). The provider is one of several implementations of the same seam.
+* @module @lmzhen/dsh-evolution-state-domain
+*/
+const name = "evolution-state-domain";
+const inject = ["evolutionStateStorage", "storageDomain"];
+const reviewStateSchema = z.object({
+	turnsSinceMemory: z.number().int().nonnegative(),
+	turnsSinceSkill: z.number().int().nonnegative(),
+	lastTurn: z.number().int().nonnegative()
+});
+const curatorStateSchema = z.object({
+	lastRunAt: z.number().nonnegative(),
+	runCount: z.number().int().nonnegative(),
+	lastSummary: z.string(),
+	paused: z.boolean()
+});
+const pendingSchema = z.object({
+	id: z.string(),
+	kind: z.union([
+		z.literal("memory"),
+		z.literal("skill"),
+		z.literal("skill_batch"),
+		z.literal("capability")
+	]),
+	summary: z.string(),
+	args: z.unknown(),
+	createdAt: z.string(),
+	status: z.union([
+		z.literal("pending"),
+		z.literal("approved"),
+		z.literal("rejected")
+	]),
+	resolvedAt: z.string().optional(),
+	claimedBy: z.string().optional(),
+	claimedAt: z.string().optional()
+});
+const EVOLUTION_DOMAIN = defineDomain({
+	name: "evolution",
+	version: 1,
+	tables: {
+		review_state: domainTable(reviewStateSchema),
+		curator_state: domainTable(curatorStateSchema),
+		pending: domainTable(pendingSchema)
+	}
+});
+function apply(ctx) {
+	let domain = null;
+	let opening = null;
+	async function ensure() {
+		if (domain) return domain;
+		const facility = ctx.get("storageDomain");
+		if (!facility) throw new Error("evolution-state-domain requires @deepseek-ai/dsh-storage-domain");
+		opening ??= facility.open(EVOLUTION_DOMAIN);
+		domain = await opening;
+		return domain;
+	}
+	const provider = {
+		name: "domain",
+		async loadReviewState(sessionId) {
+			return (await ensure()).table("review_state").get(sessionId) ?? null;
+		},
+		async saveReviewState(sessionId, record) {
+			await (await ensure()).table("review_state").put(sessionId, record);
+		},
+		async loadCuratorState() {
+			return (await ensure()).table("curator_state").get("primary") ?? null;
+		},
+		async saveCuratorState(record) {
+			await (await ensure()).table("curator_state").put("primary", record);
+		},
+		async listPending(status = "pending") {
+			return [...(await ensure()).table("pending").entries()].map(([, value]) => value).filter((record) => record.status === status);
+		},
+		async savePending(record) {
+			await (await ensure()).table("pending").put(record.id, record);
+		},
+		async claimPending(id, claimId) {
+			const table = (await ensure()).table("pending");
+			try {
+				const slot = { record: null };
+				const now = Date.now();
+				await table.update(id, (current) => {
+					if (current.status !== "pending") return current;
+					const claimedAt = typeof current.claimedAt === "string" ? Date.parse(current.claimedAt) : 0;
+					if (current.claimedBy !== void 0 && Number.isFinite(claimedAt) && now - claimedAt < 10 * 6e4) return current;
+					slot.record = {
+						...current,
+						claimedBy: claimId,
+						claimedAt: new Date(now).toISOString()
+					};
+					return slot.record;
+				});
+				return slot.record;
+			} catch {
+				return null;
+			}
+		},
+		async releasePendingClaim(id, claimId) {
+			await (await ensure()).table("pending").update(id, (current) => {
+				if (current.status === "pending" && current.claimedBy === claimId) {
+					const released = { ...current };
+					delete released.claimedBy;
+					delete released.claimedAt;
+					return released;
+				}
+				return current;
+			});
+		},
+		async tryResolvePending(id, status) {
+			const table = (await ensure()).table("pending");
+			try {
+				const resolved = { record: null };
+				const record = await table.update(id, (current) => {
+					if (current.status !== "pending") return current;
+					resolved.record = {
+						...current,
+						status,
+						resolvedAt: (/* @__PURE__ */ new Date()).toISOString()
+					};
+					return resolved.record;
+				});
+				if (resolved.record === null) return {
+					record: record.status === status ? record : null,
+					applied: false
+				};
+				return {
+					record: resolved.record,
+					applied: true
+				};
+			} catch {
+				return {
+					record: null,
+					applied: false
+				};
+			}
+		}
+	};
+	ctx.effect(() => {
+		const dispose = ctx.evolutionStateStorage.registerProvider(provider);
+		return async () => {
+			dispose();
+			if (domain) await domain.close();
+			domain = null;
+			opening = null;
+		};
+	}, "evolution-state-domain.provider");
+}
+//#endregion
+export { EVOLUTION_DOMAIN, apply, curatorStateSchema, inject, name, pendingSchema, reviewStateSchema };

package/lib/invariant.js

@@ -0,0 +1,8 @@
+//#region lib/types/invariant.js
+const PACKAGE_NAME = "@deepseek-ai/dsh-evolution-state-domain";
+const name = "evolution-state-domain-invariant";
+const inject = ["invariants"];
+const install = () => {};
+const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+//#endregion
+export { apply, inject, name };

package/lib/types/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * storage-domain provider for evolution state.
+ *
+ * When this provider is mounted, review/curator/pending records live in the
+ * DSH storage-domain data form: schema-validated, change-emitting, durable KV
+ * with whatever backend the domain facility routes (`json`, `sqlite`, remote
+ * RPC, …). The provider is one of several implementations of the same seam.
+ * @module @deepseek-ai/dsh-evolution-state-domain
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { z } from 'zod';
+import type { CuratorStateRecord, PendingRecord, ReviewStateRecord } from '@deepseek-ai/dsh-evolution-state-storage';
+export declare const name = "evolution-state-domain";
+export declare const inject: string[];
+export declare const reviewStateSchema: z.ZodObject<{
+    turnsSinceMemory: z.ZodNumber;
+    turnsSinceSkill: z.ZodNumber;
+    lastTurn: z.ZodNumber;
+}, z.core.$strip>;
+export declare const curatorStateSchema: z.ZodObject<{
+    lastRunAt: z.ZodNumber;
+    runCount: z.ZodNumber;
+    lastSummary: z.ZodString;
+    paused: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const pendingSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodUnion<readonly [z.ZodLiteral<"memory">, z.ZodLiteral<"skill">, z.ZodLiteral<"skill_batch">, z.ZodLiteral<"capability">]>;
+    summary: z.ZodString;
+    args: z.ZodUnknown;
+    createdAt: z.ZodString;
+    status: z.ZodUnion<readonly [z.ZodLiteral<"pending">, z.ZodLiteral<"approved">, z.ZodLiteral<"rejected">]>;
+    resolvedAt: z.ZodOptional<z.ZodString>;
+    claimedBy: z.ZodOptional<z.ZodString>;
+    claimedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const EVOLUTION_DOMAIN: {
+    name: string;
+    version: number;
+    tables: {
+        review_state: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, ReviewStateRecord>;
+        curator_state: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, CuratorStateRecord>;
+        pending: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, PendingRecord>;
+    };
+};
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/invariant.d.ts

@@ -0,0 +1,5 @@
+import type { Context } from '@deepseek-ai/cordis';
+export declare const name = "evolution-state-domain-invariant";
+export declare const inject: string[];
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@lmzhen/dsh-evolution-state-domain",
+  "description": "storage-domain provider for evolution state (community build)",
+  "version": "0.1.0-rc.1",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lmzhen/dsh-evolution.git",
+    "directory": "packages/dsh-evolution-state-domain"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./invariant": {
+      "types": "./lib/types/invariant.d.ts",
+      "default": "./lib/invariant.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/invariant.js",
+    "lib/types/**/*.d.ts",
+    "lib/types/invariant.d.ts"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "zod": "^3.0.0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-invariants": "^0.1.0-rc.6",
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-storage-domain": "^0.1.0-rc.6",
+    "@lmzhen/dsh-evolution-state-storage": "^0.1.0-rc.1"
+  },
+  "devDependencies": {
+    "@deepseek-ai/dsh-invariants": "^0.1.0-rc.6",
+    "@deepseek-ai/dsh-storage-domain": "^0.1.0-rc.6",
+    "@lmzhen/dsh-evolution-state-storage": "^0.1.0-rc.1"
+  }
+}