@lmzhen/dsh-evolution-core 0.19.0 → 0.19.2

package/lib/index.js

@@ -6049,6 +6049,15 @@ function newRunRegistry(options) {
 	const records = [];
 	const controllers = /* @__PURE__ */ new Map();
 	const ordered = () => [...records].sort((a, b) => b.startedAt - a.startedAt);
+	/** The ONE wording of the orphan verdict — read-time convergence says it in two places. */
+	const ORPHAN_FAILURE = "no live owner process — the run was interrupted before it settled (orphan)";
+	/** A `running` record whose owner is gone, as the index must show it. */
+	const orphanOf = (record) => ({
+		...record,
+		state: "failed",
+		endedAt: now(),
+		failure: ORPHAN_FAILURE
+	});
 	/** Keep every RUNNING record plus the newest terminal ones: memory and the
 	* index share one cap, so the two can never disagree about the history. */
 	const trim = () => {
@@ -6065,7 +6074,12 @@ function newRunRegistry(options) {
 				const onDisk = parseIndex(current);
 				const merged = /* @__PURE__ */ new Map();
 				for (const record of onDisk.records) merged.set(record.id, record);
-				for (const record of records) merged.set(record.id, record);
+				for (const record of records) {
+					const onDiskRow = merged.get(record.id);
+					const settledElsewhere = onDiskRow !== void 0 && TERMINAL.has(onDiskRow.state) && !TERMINAL.has(record.state);
+					if (!controllers.has(record.id) && settledElsewhere) continue;
+					merged.set(record.id, record);
+				}
 				const view = [...merged.values()].sort((a, b) => b.startedAt - a.startedAt);
 				const live = view.filter((record) => record.state === "running");
 				const done = view.filter((record) => TERMINAL.has(record.state)).slice(0, maxRecords);
@@ -6100,8 +6114,25 @@ function newRunRegistry(options) {
 			};
 			let converged = 0;
 			let liveElsewhere = 0;
+			let healed = 0;
 			for (const record of parsed.records) {
-				if (records.some((item) => item.id === record.id)) continue;
+				const knownIndex = records.findIndex((item) => item.id === record.id);
+				if (knownIndex >= 0) {
+					const known = records[knownIndex];
+					if (!controllers.has(record.id) && !TERMINAL.has(known.state)) {
+						if (TERMINAL.has(record.state)) {
+							delete known.endedAt;
+							delete known.resultRef;
+							delete known.failure;
+							Object.assign(known, record);
+							healed++;
+						} else if (record.pid === void 0 || !isProcessAlive(record.pid)) {
+							records[knownIndex] = orphanOf(record);
+							converged++;
+						}
+					}
+					continue;
+				}
 				if (record.state !== "running") {
 					records.push(record);
 					continue;
@@ -6112,25 +6143,21 @@ function newRunRegistry(options) {
 					continue;
 				}
 				converged++;
-				records.push({
-					...record,
-					state: "failed",
-					endedAt: now(),
-					failure: "no live owner process — the run was interrupted before it settled (orphan)"
-				});
+				records.push(orphanOf(record));
 			}
-			if (converged > 0) await persist();
+			if (converged > 0 || healed > 0) await persist();
 			const notes = [
 				parsed.note,
 				converged > 0 ? `${converged} run(s) with no live owner were recorded as failed(orphan)` : void 0,
-				liveElsewhere > 0 ? `${liveElsewhere} run(s) are in flight in another process sharing this home` : void 0
+				liveElsewhere > 0 ? `${liveElsewhere} run(s) are in flight in another process sharing this home` : void 0,
+				healed > 0 ? `${healed} run(s) settled by their owner were re-read from the index` : void 0
 			].filter((note) => note !== void 0);
 			return {
 				ok: true,
 				...notes.length > 0 ? { note: notes.join("; ") } : {}
 			};
 		},
-		begin(kind) {
+		async begin(kind) {
 			const id = randomUUID();
 			const startedAt = now();
 			const controller = new AbortController();
@@ -6142,7 +6169,7 @@ function newRunRegistry(options) {
 				startedAt,
 				pid: process.pid
 			});
-			persist();
+			await persist();
 			return {
 				id,
 				kind,

package/lib/types/run-registry.d.ts

@@ -65,13 +65,23 @@ export interface RunOutcome {
 }
 /** The registry surface the commands row drives. */
 export interface RunRegistry {
-    /** Converge the persisted index once at mount; see the module doc. */
+    /**
+     * Converge the persisted index; the commands row calls it before answering any read
+     * (0.19.1: it also re-reads a terminal state written by the run's OWNER — see the
+     * implementation note below).
+     */
     load(): Promise<{
         ok: boolean;
         note?: string;
     }>;
-    /** Register a new run, arm its cancellation, and return its handle. */
-    begin(kind: RunKind): RunHandle;
+    /**
+     * Register a new run, arm its cancellation, and return its handle.
+     *
+     * Resolves only once the row is in the shared index (0.19.1, review P2): the detached
+     * lifetime starts when the caller answers "started", so a plane that reads that answer
+     * must find the run. The cost is one local index write on the ack path (milliseconds).
+     */
+    begin(kind: RunKind): Promise<RunHandle>;
     /** Record a run's terminal state (first writer wins). */
     settle(id: string, outcome: RunOutcome): Promise<void>;
     /** The live run, when there is one (one kind today — see the implementation note). */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lmzhen/dsh-evolution-core",
   "description": "Shared stores, prompts, signals and lifecycle logic for the dsh-evolution plugin family (community build)",
-  "version": "0.19.0",
+  "version": "0.19.2",
   "publishConfig": {
     "access": "public"
   },