@lmzhen/dsh-evolution-core 0.1.0-rc.70 → 0.1.0-rc.72

package/lib/index.js

@@ -294,8 +294,21 @@ async function mutateUsage(root, io, task) {
 * folds copy this set only.
 */
 function applyCuratorFields(disk, curated) {
+	applyCuratorMetaFields(disk, curated);
+	applyCuratorLifecycleFields(disk, curated);
+}
+/** Copy only the lifecycle pair (state/archived_at) — see the ownership split
+* rationale on {@link applyCuratorMetaFields}. */
+function applyCuratorLifecycleFields(disk, curated) {
 	disk.state = curated.state;
 	disk.archived_at = curated.archived_at;
+}
+/**
+* Copy the recomputed meta pair (quality_score/quality_warn + the
+* marker-mirrored pin flag) — refreshed tree-wide each run by design, so a
+* concurrent curator run's lifecycle changes are never reverted by them.
+*/
+function applyCuratorMetaFields(disk, curated) {
 	disk.quality_score = curated.quality_score;
 	disk.quality_warn = curated.quality_warn;
 	disk.pinned = curated.pinned;
@@ -305,13 +318,20 @@ function applyCuratorFields(disk, curated) {
 * each curated record is projected onto its disk peer by copying only the
 * curator-owned fields, so a concurrent tool-side bump between snapshot and
 * save survives. Records absent from the snapshot are left untouched; a
-* curated record with no disk peer is seeded from the snapshot.
+* curated record with no disk peer is seeded from the snapshot. `stateOwned`
+* (rc.72 H-1) restricts the lifecycle pair to the names this run ACTUALLY
+* transitioned — a concurrent curator run's archive/restore is never reverted
+* by a stale snapshot; without it both pairs apply everywhere.
 */
-function foldCuratorFields(disk, curated) {
+function foldCuratorFields(disk, curated, stateOwned) {
 	for (const [name, record] of curated) {
 		const diskRecord = disk.get(name);
-		if (diskRecord) applyCuratorFields(diskRecord, record);
-		else disk.set(name, { ...record });
+		if (!diskRecord) {
+			disk.set(name, { ...record });
+			continue;
+		}
+		applyCuratorMetaFields(diskRecord, record);
+		if (stateOwned === void 0 || stateOwned.has(name)) applyCuratorLifecycleFields(diskRecord, record);
 	}
 }
 async function saveUsage(root, map, io = nodeEvolutionIo()) {
@@ -728,10 +748,29 @@ function computeLifecycleTransitions(usage, config, now = /* @__PURE__ */ new Da
 * learn on target X" is answerable. The aggregate `feedback.json` is a
 * rebuildable boot cache, never the truth.
 *
-* The malformed-refusal posture matches the whole sidecar family (rc.65): an
-* append NEVER rewrites a corrupt log — the bytes stay untouched.
+* Rotation (rc.71, 007 design): when the active log reaches
+* `EVENT_LOG_ROTATE_AT` the older half is split into an archive
+* (`events-<lastArchivedSeq>.json`); the boot timeline merges active +
+* archives and dedupes by seq (active copy wins), so the rotation crash window
+* yields the identical timeline. Archival naming is STRICTLY numeric
+* (`/^events-\d+\.json$/`) — user files under the same directory are never
+* read as archives and never pruned (rc.72 G-2).
 */
 const EVENT_LOG_VERSION = 1;
+/** Active-log split point (rc.71): when the active log reaches this many events
+* the older half is rotated into an archive; the active stays bounded so a
+* single append stays O(active) instead of O(total-history). Tunable default —
+* callers may override per append (the tests use small values). */
+const EVENT_LOG_ROTATE_AT = 4e3;
+/** Number of archives retained (rc.71): older archives are pruned at rotation,
+* mirroring retainReports. The horizon covers the loop-analysis window. */
+const EVENT_LOG_RETAIN_ARCHIVES = 10;
+/** Archive file prefix: `events-<lastArchivedSeq>.json`. The active file is
+* `events.json` and never matches this glob. */
+const EVENT_ARCHIVE_PREFIX = "events-";
+/** Archive naming is strictly numeric: a user file such as `events-backup.json`
+* under the same directory is neither read into the timeline nor pruned. */
+const EVENT_ARCHIVE_RE = /^events-(\d+)\.json$/;
 function eventsFile(home) {
 	return join(home, "evolution", "events.json");
 }
@@ -759,39 +798,108 @@ function parseEvolutionEvents(raw) {
 	}
 }
 /**
+* List the numeric archives under the log's directory, sorted ascending by
+* their last-archived seq. Single glob predicate for the timeline, the
+* retention pass and the feedback migration check (rc.72 H-3).
+*/
+async function listEventArchives(io, path) {
+	const dir = dirname(path);
+	return (await io.list(dir)).filter((name) => EVENT_ARCHIVE_RE.test(name)).sort((a, b) => {
+		return Number.parseInt(a.slice(7, a.length - 5), 10) - Number.parseInt(b.slice(7, b.length - 5), 10);
+	});
+}
+/**
 * Append one event under the write lock (rc.68): `seq` = current max + 1
 * computed inside the transact, so two processes appending concurrently never
 * collide. A malformed log is refused (bytes preserved) and the append fails.
 * Returns the assigned seq.
+*
+* Rotation (rc.71, 007 design): when the active log reaches `rotateAt`, the
+* older half is copied into an archive inside the SAME transact (the archive
+* path has its own lock, so no recursion) and the active is replaced with the
+* newer half + the new event. seqs stay globally monotonic; a crash between
+* archive write and active write leaves both copies, which the timeline merge
+* dedupes by seq. An archive-write failure aborts the append (active keeps the
+* full old content — no loss) and the caller's best-effort handling applies.
+*
+* rc.72 G-1: when the ACTIVE is missing/whitespace but archives exist (a
+* deleted active, or B-2 self-heal), seq derivation consults the archive names
+* — the active restarts AFTER the highest archived seq, never at 1, so a new
+* event can never shadow an archived one in the seq-deduped timeline.
 */
-async function appendEvolutionEvent(io, path, event) {
+async function appendEvolutionEvent(io, path, event, rotateAt = EVENT_LOG_ROTATE_AT) {
 	let assigned = 0;
-	await transactIo(io, path, (current) => {
+	await transactIo(io, path, async (current) => {
 		if (current !== null && current.trim() !== "") try {
 			JSON.parse(current);
 		} catch {
-			return Promise.resolve(current);
+			return current;
 		}
-		const events = parseEvolutionEvents(current);
-		const maxSeq = events.reduce((max, entry) => Math.max(max, entry.seq), 0);
+		const nextEvents = await rotateIfDue(io, path, parseEvolutionEvents(current), rotateAt);
+		let maxSeq = nextEvents.reduce((max, entry) => Math.max(max, entry.seq), 0);
+		if (maxSeq === 0) for (const name of await listEventArchives(io, path)) maxSeq = Math.max(maxSeq, Number.parseInt(name.slice(7, name.length - 5), 10));
 		const record = {
 			...event,
 			seq: maxSeq + 1,
 			at: (/* @__PURE__ */ new Date()).toISOString()
 		};
 		assigned = record.seq;
-		return Promise.resolve(JSON.stringify({
+		return JSON.stringify({
 			version: 1,
-			events: [...events, record]
-		}, null, 2));
+			events: [...nextEvents, record]
+		}, null, 2);
 	});
 	if (assigned === 0) throw new Error(`evolution event log is malformed and was not touched: ${path}`);
 	return assigned;
 }
+/**
+* Split the active log at its midpoint when due: the older half is written to
+* `events-<lastArchivedSeq>.json` (await — a failed archive write aborts the
+* append so the active is never truncated without its copy), old archives are
+* pruned, and the newer half is returned as the next active body. No-op when
+* under the threshold; `rotateAt < 2` is a guarded no-op (rc.72 G-1: a
+* one-event rotate would archive everything and restart seqs at 1).
+*/
+async function rotateIfDue(io, path, events, rotateAt) {
+	if (rotateAt < 2 || events.length < rotateAt) return events;
+	const mid = Math.ceil(events.length / 2);
+	const head = events.slice(0, mid);
+	const tail = events.slice(mid);
+	if (tail.length === 0) return events;
+	const anchor = tail[0]?.seq ?? 0;
+	const archivePath = join(dirname(path), `${EVENT_ARCHIVE_PREFIX}${anchor - 1}.json`);
+	await io.writeText(archivePath, JSON.stringify({
+		version: 1,
+		events: head
+	}, null, 2));
+	await retainEventArchives(io, path);
+	return tail;
+}
+/**
+* Prune old event archives (rc.71): keep the newest `EVENT_LOG_RETAIN_ARCHIVES`.
+* The name's numeric part is the last archived seq, so ordering is NUMERIC —
+* lexicographic would rank `events-10` before `events-2`. Only strictly
+* numeric names participate (rc.72 G-2: user files are never deleted).
+* Best-effort per removal; exported for the retention test.
+*/
+async function retainEventArchives(io, path) {
+	const dir = dirname(path);
+	const names = await listEventArchives(io, path);
+	const excess = names.slice(0, Math.max(0, names.length - 10));
+	for (const name of excess) await io.remove(join(dir, name)).catch(() => {});
+}
 /** Read the event log; a missing/whitespace-only file reads as empty,
 * corrupt content is flagged (and refused on append). */
 async function readEvolutionEvents(io, path) {
-	const raw = await io.readText(path);
+	let raw;
+	try {
+		raw = await io.readText(path);
+	} catch {
+		return {
+			events: [],
+			malformed: true
+		};
+	}
 	if (raw === null || raw.trim() === "") return {
 		events: [],
 		malformed: false
@@ -813,6 +921,30 @@ async function readEvolutionEvents(io, path) {
 		};
 	}
 }
+/**
+* Read the full timeline (rc.71): active log + all archives, merged by seq
+* (active copy wins, duplicates only arise from the rotation crash window),
+* sorted ascending. Per-file malformed flag as in `readEvolutionEvents`; a
+* malformed (or unreadable) ARCHIVE is skipped — it never bricks the boot and
+* it is still flagged.
+*/
+async function readEvolutionTimeline(io, path) {
+	const dir = dirname(path);
+	let malformed = false;
+	const bySeq = /* @__PURE__ */ new Map();
+	for (const name of await listEventArchives(io, path)) {
+		const read = await readEvolutionEvents(io, join(dir, name));
+		if (read.malformed) malformed = true;
+		for (const event of read.events) bySeq.set(event.seq, event);
+	}
+	const active = await readEvolutionEvents(io, path);
+	if (active.malformed) malformed = true;
+	for (const event of active.events) bySeq.set(event.seq, event);
+	return {
+		events: [...bySeq.values()].sort((a, b) => a.seq - b.seq),
+		malformed
+	};
+}
 //#endregion
 //#region lib/types/prompts.js
 /**
@@ -3130,4 +3262,4 @@ function evolutionHome(env = process.env) {
 	return join(env.DSH_HOME ?? join(homedir(), ".dsh"), "evolution");
 }
 //#endregion
-export { AUTHORING_DESCRIPTION_BAR, COMBINED_REVIEW_PLAN_PROMPT, COMBINED_REVIEW_PROMPT, COMPLETION_SKILL_REVIEW_PROMPT, CURATOR_DRY_RUN_BANNER, CURATOR_PROMPT, DEFAULT_ARCHIVE_AFTER_DAYS, DEFAULT_CONSOLIDATION_FAILURES, DEFAULT_CURATOR_INTERVAL_HOURS, DEFAULT_MAX_OPS_PER_PLAN, DEFAULT_MEMORY_CHAR_LIMIT, DEFAULT_MIN_IDLE_HOURS, DEFAULT_MUTATION_CAP, DEFAULT_REVIEW_MEMORY_INTERVAL, DEFAULT_REVIEW_SKILL_INTERVAL, DEFAULT_SKILL_CONTENT_CHARS, DEFAULT_SKILL_LIMITS, DEFAULT_SKILL_REVIEW_COMPLETION_MIN_TOOL_CALLS, DEFAULT_SKILL_REVIEW_TRIGGER, DEFAULT_STALE_AFTER_DAYS, DEFAULT_SUBSTANTIVE_MIN_AGENT_CHARS, DEFAULT_SUBSTANTIVE_MIN_TOOL_CALLS, DEFAULT_SUBSTANTIVE_MIN_USER_CHARS, DEFAULT_USER_CHAR_LIMIT, DSH_AUTHORING_STANDARDS, ENTRY_DELIMITER, EVENT_LOG_VERSION, EvolutionGateSet, LOW_QUALITY_THRESHOLD, MAX_DESCRIPTION_LENGTH, MAX_SKILL_CONTENT_CHARS, MAX_SKILL_FILE_BYTES, MAX_SKILL_NAME_LENGTH, MEMORY_REVIEW_PROMPT, MUTATIONS_FILE_VERSION, MemoryStore, PROMPT_BUNDLE, PROMPT_BUNDLE_ID, PROMPT_BUNDLE_VERSION, PROTECTED_BUILTIN_SKILLS, QUALITY_WEIGHTS, SKILLS_GUIDANCE, SKILL_NAME_RE, SKILL_REVIEW_PLAN_PROMPT, SKILL_REVIEW_PROMPT, SNAPSHOT_EXTRA_NAME_RE, SUPPORT_DIRS, SUPPRESSED_FILE_VERSION, SkillLibrary, advanceReview, appendEvolutionEvent, applyCuratorFields, authoringFeedback, buildCuratorRunReport, buildLearnPrompt, bumpPatch, bumpUse, bumpView, computeDedupGroups, computeLifecycleTransitions, computePrefixClusters, computeQualityScores, computeScopeView, contentHash, createGateSet, emptyRecord, evaluateThreat, eventsFile, evolutionHome, evolutionIoAdapter, foldCuratorFields, foldTurn, getRecord, latestActivityAt, lifecycleCandidate, loadMutations, loadSuppressedNames, loadUsage, markAgentCreated, memoryRoot, mutateUsage, mutationsFile, nodeEvolutionIo, normalizeUsageRecord, observeEvent, parseCuratorNominations, parseEvolutionEvents, parseFrontmatter, readEvolutionEvents, recordMutation, relatedSkillNames, renderCuratorReportMarkdown, resolveOrigins, reviewPrompt, saveSuppressedNames, saveUsage, scanContentThreats, scanMemoryThreats, scanThreats, skillsRoot, suppressedFile, transactIo, updateSuppressedNames, usageFile, validateFrontmatter, verifyPromptBundle };
+export { AUTHORING_DESCRIPTION_BAR, COMBINED_REVIEW_PLAN_PROMPT, COMBINED_REVIEW_PROMPT, COMPLETION_SKILL_REVIEW_PROMPT, CURATOR_DRY_RUN_BANNER, CURATOR_PROMPT, DEFAULT_ARCHIVE_AFTER_DAYS, DEFAULT_CONSOLIDATION_FAILURES, DEFAULT_CURATOR_INTERVAL_HOURS, DEFAULT_MAX_OPS_PER_PLAN, DEFAULT_MEMORY_CHAR_LIMIT, DEFAULT_MIN_IDLE_HOURS, DEFAULT_MUTATION_CAP, DEFAULT_REVIEW_MEMORY_INTERVAL, DEFAULT_REVIEW_SKILL_INTERVAL, DEFAULT_SKILL_CONTENT_CHARS, DEFAULT_SKILL_LIMITS, DEFAULT_SKILL_REVIEW_COMPLETION_MIN_TOOL_CALLS, DEFAULT_SKILL_REVIEW_TRIGGER, DEFAULT_STALE_AFTER_DAYS, DEFAULT_SUBSTANTIVE_MIN_AGENT_CHARS, DEFAULT_SUBSTANTIVE_MIN_TOOL_CALLS, DEFAULT_SUBSTANTIVE_MIN_USER_CHARS, DEFAULT_USER_CHAR_LIMIT, DSH_AUTHORING_STANDARDS, ENTRY_DELIMITER, EVENT_ARCHIVE_PREFIX, EVENT_LOG_RETAIN_ARCHIVES, EVENT_LOG_ROTATE_AT, EVENT_LOG_VERSION, EvolutionGateSet, LOW_QUALITY_THRESHOLD, MAX_DESCRIPTION_LENGTH, MAX_SKILL_CONTENT_CHARS, MAX_SKILL_FILE_BYTES, MAX_SKILL_NAME_LENGTH, MEMORY_REVIEW_PROMPT, MUTATIONS_FILE_VERSION, MemoryStore, PROMPT_BUNDLE, PROMPT_BUNDLE_ID, PROMPT_BUNDLE_VERSION, PROTECTED_BUILTIN_SKILLS, QUALITY_WEIGHTS, SKILLS_GUIDANCE, SKILL_NAME_RE, SKILL_REVIEW_PLAN_PROMPT, SKILL_REVIEW_PROMPT, SNAPSHOT_EXTRA_NAME_RE, SUPPORT_DIRS, SUPPRESSED_FILE_VERSION, SkillLibrary, advanceReview, appendEvolutionEvent, applyCuratorFields, applyCuratorLifecycleFields, applyCuratorMetaFields, authoringFeedback, buildCuratorRunReport, buildLearnPrompt, bumpPatch, bumpUse, bumpView, computeDedupGroups, computeLifecycleTransitions, computePrefixClusters, computeQualityScores, computeScopeView, contentHash, createGateSet, emptyRecord, evaluateThreat, eventsFile, evolutionHome, evolutionIoAdapter, foldCuratorFields, foldTurn, getRecord, latestActivityAt, lifecycleCandidate, listEventArchives, loadMutations, loadSuppressedNames, loadUsage, markAgentCreated, memoryRoot, mutateUsage, mutationsFile, nodeEvolutionIo, normalizeUsageRecord, observeEvent, parseCuratorNominations, parseEvolutionEvents, parseFrontmatter, readEvolutionEvents, readEvolutionTimeline, recordMutation, relatedSkillNames, renderCuratorReportMarkdown, resolveOrigins, retainEventArchives, reviewPrompt, saveSuppressedNames, saveUsage, scanContentThreats, scanMemoryThreats, scanThreats, skillsRoot, suppressedFile, transactIo, updateSuppressedNames, usageFile, validateFrontmatter, verifyPromptBundle };

package/lib/types/evolution-events.d.ts

@@ -6,11 +6,27 @@
  * learn on target X" is answerable. The aggregate `feedback.json` is a
  * rebuildable boot cache, never the truth.
  *
- * The malformed-refusal posture matches the whole sidecar family (rc.65): an
- * append NEVER rewrites a corrupt log — the bytes stay untouched.
+ * Rotation (rc.71, 007 design): when the active log reaches
+ * `EVENT_LOG_ROTATE_AT` the older half is split into an archive
+ * (`events-<lastArchivedSeq>.json`); the boot timeline merges active +
+ * archives and dedupes by seq (active copy wins), so the rotation crash window
+ * yields the identical timeline. Archival naming is STRICTLY numeric
+ * (`/^events-\d+\.json$/`) — user files under the same directory are never
+ * read as archives and never pruned (rc.72 G-2).
  */
 import { type EvolutionIoLike } from './io.ts';
 export declare const EVENT_LOG_VERSION = 1;
+/** Active-log split point (rc.71): when the active log reaches this many events
+ * the older half is rotated into an archive; the active stays bounded so a
+ * single append stays O(active) instead of O(total-history). Tunable default —
+ * callers may override per append (the tests use small values). */
+export declare const EVENT_LOG_ROTATE_AT = 4000;
+/** Number of archives retained (rc.71): older archives are pruned at rotation,
+ * mirroring retainReports. The horizon covers the loop-analysis window. */
+export declare const EVENT_LOG_RETAIN_ARCHIVES = 10;
+/** Archive file prefix: `events-<lastArchivedSeq>.json`. The active file is
+ * `events.json` and never matches this glob. */
+export declare const EVENT_ARCHIVE_PREFIX = "events-";
 export interface EvolutionEvent {
     /** Global monotonic order key, assigned inside the append transact. */
     seq: number;
@@ -37,22 +53,59 @@ export declare function eventsFile(home: string): string;
  * sidecar's per-field normalization on read).
  */
 export declare function parseEvolutionEvents(raw: string | null): EvolutionEvent[];
+/**
+ * List the numeric archives under the log's directory, sorted ascending by
+ * their last-archived seq. Single glob predicate for the timeline, the
+ * retention pass and the feedback migration check (rc.72 H-3).
+ */
+export declare function listEventArchives(io: EvolutionIoLike, path: string): Promise<string[]>;
 /**
  * Append one event under the write lock (rc.68): `seq` = current max + 1
  * computed inside the transact, so two processes appending concurrently never
  * collide. A malformed log is refused (bytes preserved) and the append fails.
  * Returns the assigned seq.
+ *
+ * Rotation (rc.71, 007 design): when the active log reaches `rotateAt`, the
+ * older half is copied into an archive inside the SAME transact (the archive
+ * path has its own lock, so no recursion) and the active is replaced with the
+ * newer half + the new event. seqs stay globally monotonic; a crash between
+ * archive write and active write leaves both copies, which the timeline merge
+ * dedupes by seq. An archive-write failure aborts the append (active keeps the
+ * full old content — no loss) and the caller's best-effort handling applies.
+ *
+ * rc.72 G-1: when the ACTIVE is missing/whitespace but archives exist (a
+ * deleted active, or B-2 self-heal), seq derivation consults the archive names
+ * — the active restarts AFTER the highest archived seq, never at 1, so a new
+ * event can never shadow an archived one in the seq-deduped timeline.
  */
-export declare function appendEvolutionEvent(io: EvolutionIoLike, path: string, event: Omit<EvolutionEvent, 'seq' | 'at'>): Promise<number>;
+export declare function appendEvolutionEvent(io: EvolutionIoLike, path: string, event: Omit<EvolutionEvent, 'seq' | 'at'>, rotateAt?: number): Promise<number>;
+/**
+ * Prune old event archives (rc.71): keep the newest `EVENT_LOG_RETAIN_ARCHIVES`.
+ * The name's numeric part is the last archived seq, so ordering is NUMERIC —
+ * lexicographic would rank `events-10` before `events-2`. Only strictly
+ * numeric names participate (rc.72 G-2: user files are never deleted).
+ * Best-effort per removal; exported for the retention test.
+ */
+export declare function retainEventArchives(io: EvolutionIoLike, path: string): Promise<void>;
 export interface EventLogRead {
     events: EvolutionEvent[];
     /** True when the body is not valid JSON (syntax-level damage): refused on
      * append, bytes untouched. Well-formed JSON with a damaged `events` field
      * is REPLACEABLE garbage — reads as empty and is rewritten at the next
-     * append (rc.70 F-1: read and append agree on the same boundary). */
+     * append (rc.70 F-1: read and append agree on the same boundary). A READ
+     * error (EISDIR etc.) also flags malformed — the file is unusable either
+     * way and is never overwritten (the append read would fail identically). */
     malformed: boolean;
 }
 /** Read the event log; a missing/whitespace-only file reads as empty,
  * corrupt content is flagged (and refused on append). */
 export declare function readEvolutionEvents(io: EvolutionIoLike, path: string): Promise<EventLogRead>;
+/**
+ * Read the full timeline (rc.71): active log + all archives, merged by seq
+ * (active copy wins, duplicates only arise from the rotation crash window),
+ * sorted ascending. Per-file malformed flag as in `readEvolutionEvents`; a
+ * malformed (or unreadable) ARCHIVE is skipped — it never bricks the boot and
+ * it is still flagged.
+ */
+export declare function readEvolutionTimeline(io: EvolutionIoLike, path: string): Promise<EventLogRead>;
 //# sourceMappingURL=evolution-events.d.ts.map

package/lib/types/usage.d.ts

@@ -53,14 +53,26 @@ export declare function mutateUsage(root: string, io: EvolutionIoLike, task: (ma
  * folds copy this set only.
  */
 export declare function applyCuratorFields(disk: UsageRecord, curated: UsageRecord): void;
+/** Copy only the lifecycle pair (state/archived_at) — see the ownership split
+ * rationale on {@link applyCuratorMetaFields}. */
+export declare function applyCuratorLifecycleFields(disk: UsageRecord, curated: UsageRecord): void;
+/**
+ * Copy the recomputed meta pair (quality_score/quality_warn + the
+ * marker-mirrored pin flag) — refreshed tree-wide each run by design, so a
+ * concurrent curator run's lifecycle changes are never reverted by them.
+ */
+export declare function applyCuratorMetaFields(disk: UsageRecord, curated: UsageRecord): void;
 /**
  * Fold a curator run-start snapshot onto the current on-disk map (rc.67 K-2):
  * each curated record is projected onto its disk peer by copying only the
  * curator-owned fields, so a concurrent tool-side bump between snapshot and
  * save survives. Records absent from the snapshot are left untouched; a
- * curated record with no disk peer is seeded from the snapshot.
+ * curated record with no disk peer is seeded from the snapshot. `stateOwned`
+ * (rc.72 H-1) restricts the lifecycle pair to the names this run ACTUALLY
+ * transitioned — a concurrent curator run's archive/restore is never reverted
+ * by a stale snapshot; without it both pairs apply everywhere.
  */
-export declare function foldCuratorFields(disk: UsageMap, curated: UsageMap): void;
+export declare function foldCuratorFields(disk: UsageMap, curated: UsageMap, stateOwned?: ReadonlySet<string>): void;
 export declare function saveUsage(root: string, map: UsageMap, io?: EvolutionIoLike): Promise<void>;
 export declare function getRecord(map: UsageMap, name: string): UsageRecord;
 export declare function bumpView(map: UsageMap, name: string, when?: Date): void;

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.1.0-rc.70",
+  "version": "0.1.0-rc.72",
   "publishConfig": {
     "access": "public"
   },