@lmzhen/dsh-evolution-activity 0.1.0-rc.5 → 0.1.0-rc.51

package/README.md

@@ -21,4 +21,5 @@ Independent of request-prefix construction. This package does not alter the asse
 ## Known Limitations and Deferred Work
 
 
-- No known durable consumer gaps at this time. Runtime contracts are covered by package and boundary tests.
+- The projection registers BOTH contract generations — `stateSchema` + `wire.viewSchema` (DSH 0.1.1+ session-projection contract) and legacy `schema` + `view` (0.1.0-rc.6 era) — because each registry ignores the fields it does not know. When the legacy fields are removed, drop the old half of the dual registration.
+- On 0.1.1+ hosts the cold-read path (`restore`) calls `stateSchema.parse` on checkpointed rows; a registration missing `stateSchema` would throw on the first cold read, so the new half is load-bearing, not cosmetic.

package/lib/index.js

@@ -1,45 +1,85 @@
 import z from "@deepseek-ai/schemastery";
-import { z as z$1 } from "zod";
+import { evolutionHome } from "@lmzhen/dsh-evolution-core";
+import { join } from "node:path";
 //#region lib/types/index.js
 /**
-* Session projection for self-evolution activity.
+* Durable activity store for self-evolution plan outcomes.
+*
+* Adjudication (rc.42, A-line P0-1): plan outcomes are process events on the
+* cordis bus (a session log carrying `evolution/*` types is refused wholesale
+* at resume), so the retired session projection is replaced by this driver:
+* it subscribes to `evolution/plan-applied` (payload v2, with sessionId) and
+* persists every outcome to `$DSH_HOME/evolution/activity.json` through the
+* evolution IO seam — the same best-effort sidecar posture as
+* `feedback.json` and the curator reports. A storage-domain table is deferred
+* until a consumer needs domain routing (the domain spec version-gates its
+* media, so adding a table is not a free schema addition).
+*
+* The sidecar is append-merge (load → fold → save under an in-process queue),
+* so records survive host restarts and are readable without a session.
 * @module @lmzhen/dsh-evolution-activity
 */
-const activitySchema = z$1.object({ items: z$1.array(z$1.object({
-	planId: z$1.string(),
-	kind: z$1.string(),
-	memoryApplied: z$1.number().min(0),
-	skillApplied: z$1.number().min(0),
-	rejectedOps: z$1.number().min(0),
-	at: z$1.number().min(0)
-})) });
-function applyState(state, event, maxItems = 20) {
-	if (event.type !== "evolution/plan-applied") return state;
-	const data = event.data;
-	const time = event.time;
-	return { items: [...state.items, {
-		planId: data.planId,
-		kind: "plan",
-		memoryApplied: data.memoryApplied,
-		skillApplied: data.skillApplied,
-		rejectedOps: data.rejectedOps,
-		at: time
-	}].slice(-maxItems) };
+/** Version of the `activity.json` shape; writers always emit the current one. */
+const ACTIVITY_FILE_VERSION = 2;
+function activityFile(root) {
+	return join(root, "activity.json");
+}
+/** Fold one plan-applied payload into a bounded record list (pure). */
+function applyActivityEvent(items, event, maxItems, at = Date.now()) {
+	const record = {
+		sessionId: event.sessionId,
+		planId: event.planId,
+		policyFingerprint: event.policyFingerprint,
+		memoryApplied: event.memoryApplied,
+		skillApplied: event.skillApplied,
+		rejectedOps: event.rejectedOps,
+		evidenceQuotes: event.evidenceQuotes,
+		estimatedInputChars: event.estimatedInputChars,
+		at
+	};
+	const cap = Math.max(1, maxItems);
+	return [...items, record].slice(-cap);
+}
+async function loadActivity(root, io) {
+	const raw = await io.readText(activityFile(root));
+	if (raw === null) return [];
+	try {
+		const parsed = JSON.parse(raw);
+		return (typeof parsed === "object" && parsed !== null && Array.isArray(parsed.items) ? parsed.items : []).filter((item) => typeof item === "object" && item !== null && typeof item.planId === "string" && typeof item.sessionId === "string");
+	} catch {
+		return [];
+	}
+}
+async function saveActivity(root, items, io) {
+	await io.writeText(activityFile(root), JSON.stringify({
+		version: 2,
+		items
+	}, null, 2));
 }
 const name = "evolution-activity";
-const Config = z.object({ maxItems: z.number().default(20) });
+const Config = z.object({ maxItems: z.number().default(200) });
 function apply(ctx, rawConfig = {}) {
-	const maxItems = rawConfig.maxItems ?? 20;
-	ctx.inject(["sessionProjections"], (projectionCtx) => {
-		projectionCtx.sessionProjections.register({
-			key: "evolution-activity",
-			schema: activitySchema,
-			init: () => ({ items: [] }),
-			apply: (state, event) => applyState(state, event, maxItems),
-			view: (state) => ({ items: state.items }),
-			stateVersion: 1
+	const maxItems = rawConfig.maxItems ?? 200;
+	const ioRegistry = ctx.get("evolutionIo");
+	if (!ioRegistry) {
+		ctx.logger.warn("evolution-activity: no evolution IO provider mounted; plan outcomes will not be persisted");
+		return;
+	}
+	const io = {
+		readText: (path) => ioRegistry.provider().readText(path),
+		writeText: (path, content) => ioRegistry.provider().writeText(path, content)
+	};
+	const root = evolutionHome();
+	let chain = Promise.resolve();
+	ctx.on("evolution/plan-applied", (event) => {
+		const run = chain.then(async () => {
+			await saveActivity(root, applyActivityEvent(await loadActivity(root, io), event, maxItems), io);
+		});
+		chain = run.then(() => void 0, () => void 0);
+		run.catch((error) => {
+			ctx.logger.warn(error instanceof Error ? error : String(error));
 		});
 	});
 }
 //#endregion
-export { Config, apply, applyState, name };
+export { ACTIVITY_FILE_VERSION, Config, activityFile, apply, applyActivityEvent, loadActivity, name, saveActivity };

package/lib/types/index.d.ts

@@ -1,41 +1,52 @@
 /**
- * Session projection for self-evolution activity.
+ * Durable activity store for self-evolution plan outcomes.
+ *
+ * Adjudication (rc.42, A-line P0-1): plan outcomes are process events on the
+ * cordis bus (a session log carrying `evolution/*` types is refused wholesale
+ * at resume), so the retired session projection is replaced by this driver:
+ * it subscribes to `evolution/plan-applied` (payload v2, with sessionId) and
+ * persists every outcome to `$DSH_HOME/evolution/activity.json` through the
+ * evolution IO seam — the same best-effort sidecar posture as
+ * `feedback.json` and the curator reports. A storage-domain table is deferred
+ * until a consumer needs domain routing (the domain spec version-gates its
+ * media, so adding a table is not a free schema addition).
+ *
+ * The sidecar is append-merge (load → fold → save under an in-process queue),
+ * so records survive host restarts and are readable without a session.
  * @module @deepseek-ai/dsh-evolution-activity
  */
 import type { Context } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
-export interface EvolutionActivityItem {
+import type { EvolutionPlanAppliedEvent } from '@deepseek-ai/dsh-evolution-core';
+/** One persisted plan outcome (payload v2 of `evolution/plan-applied`). */
+export interface EvolutionActivityRecord {
+    sessionId: string;
     planId: string;
-    kind: string;
+    policyFingerprint?: string | undefined;
     memoryApplied: number;
     skillApplied: number;
     rejectedOps: number;
+    evidenceQuotes?: number | undefined;
+    estimatedInputChars?: number | undefined;
     at: number;
 }
-export interface EvolutionActivityProjection {
-    items: EvolutionActivityItem[];
+/** Version of the `activity.json` shape; writers always emit the current one. */
+export declare const ACTIVITY_FILE_VERSION = 2;
+export declare function activityFile(root: string): string;
+/** Minimal IO surface the driver needs (subset of `EvolutionIoLike`). */
+export interface ActivityIoLike {
+    readText(path: string): Promise<string | null>;
+    writeText(path: string, content: string): Promise<void>;
 }
-export interface State {
-    items: EvolutionActivityItem[];
-}
-type SessionEventLike = {
-    type: 'evolution/plan-applied';
-    data: {
-        planId: string;
-        memoryApplied: number;
-        skillApplied: number;
-        rejectedOps: number;
-    };
-    time: number;
-} | {
-    type: string;
-};
-export declare function applyState(state: State, event: SessionEventLike, maxItems?: number): State;
+/** Fold one plan-applied payload into a bounded record list (pure). */
+export declare function applyActivityEvent(items: EvolutionActivityRecord[], event: EvolutionPlanAppliedEvent, maxItems: number, at?: number): EvolutionActivityRecord[];
+export declare function loadActivity(root: string, io: ActivityIoLike): Promise<EvolutionActivityRecord[]>;
+export declare function saveActivity(root: string, items: EvolutionActivityRecord[], io: ActivityIoLike): Promise<void>;
 export declare const name = "evolution-activity";
 export interface Config {
+    /** Bounded sidecar: how many recent outcomes are kept. */
     maxItems?: number;
 }
 export declare const Config: z<Config>;
 export declare function apply(ctx: Context, rawConfig?: Config): void;
-export {};
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-activity",
   "description": "Session projection for self-evolution activity (community build)",
-  "version": "0.1.0-rc.5",
+  "version": "0.1.0-rc.51",
   "publishConfig": {
     "access": "public"
   },
@@ -33,15 +33,17 @@
   "license": "MIT",
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.1",
-    "zod": "^4.4.3"
+    "@lmzhen/dsh-evolution-core": "^0.1.0-rc.51"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-invariants": "^0.1.0-rc.6",
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-session-projection": "^0.1.0-rc.6"
+    "@deepseek-ai/dsh-invariants": "^0.1.0-rc.6"
   },
   "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-invariants": "^0.1.0-rc.6",
-    "@deepseek-ai/dsh-session-projection": "^0.1.0-rc.6"
+    "@lmzhen/dsh-evolution-core": "^0.1.0-rc.51",
+    "@lmzhen/dsh-evolution-io": "^0.1.0-rc.51",
+    "@lmzhen/dsh-evolution-io-node": "^0.1.0-rc.51"
   }
 }