@snoai/memory 1.2.8 → 1.2.10

package/dist/internal/store/maintenance.js

@@ -1,22 +1,22 @@
 import { BACKUP_INTERVAL_MS, BACKUP_MIN_FREE_DISK_RATIO, FTS_MERGE_INTERVAL_MS, INTEGRITY_CHECK_INTERVAL_MS, MAINTENANCE_TICK_MS, PLANNER_STATISTICS_INTERVAL_MS, REM_TRIGGER_CHECK_INTERVAL_MS, USAGE_EVENT_RETENTION_INTERVAL_MS, USAGE_OUTBOX_INTERVAL_MS } from "../config/index.js";
 import { REM_SIDECAR_TOKEN_HEADER } from "../contract/routes.js";
 import "../engine/shared/utils.js";
-import "../../coding-skin-_Qu3INZD.js";
+import "../../coding-skin-azRXA51Z.js";
 import "../config/settings.js";
-import "../../llm-client-fVrzPcyz.js";
-import "../model/llm-mode-routing.js";
-import { n as appendAuditEntryStrict, o as getAuditPath, t as appendAuditEntry } from "../../runtime-audit-log-BCeujlEp.js";
+import { n as appendAuditEntryStrict, p as readJsonlLines, s as getAuditPath, t as appendAuditEntry } from "../../runtime-audit-log-DK6xAYxh.js";
 import { getDiscoveryPath, getSnoStationMemStateDir } from "../contract/profile.js";
 import "../engine/shared/paths.js";
+import "../../llm-client-ConEyQEs.js";
+import "../model/llm-mode-routing.js";
 import { defineRemSafetyGuard, requireRemOwnerDecisions } from "../engine/rem/index.js";
 import { n as state_vocabulary_default, r as attribute_dictionary_default } from "../../relation-dictionary-Cev1kyLe.js";
-import "../../memory-store-shared-DqpWJXZZ.js";
-import { n as loadSqliteVecExtension } from "../../unplaced-candidate-migration-CbQHzcEM.js";
+import "../../memory-store-shared-CURizQIy.js";
+import { n as loadSqliteVecExtension } from "../../unplaced-candidate-migration-BCcdQkcx.js";
 import { openSqliteDatabase } from "./sqlite-runtime.js";
-import "../../connection-C9YD5sgm.js";
-import "../../store-CUk-jEGA.js";
+import "../../connection-PQcq3TPO.js";
+import "../../store-BQxkgJTX.js";
 import "../../embedding-provider-client-40tpzKou.js";
-import "../../retriever-ZoLvPRHq.js";
+import "../../retriever-BXQmJMh0.js";
 import { t as recordMemoryTelemetryIncident } from "../../memory-telemetry-incidents-BWA9kcZx.js";
 import { z } from "zod";
 import "@snoai/chunking";
@@ -35,7 +35,7 @@ import { withLogContext as withLogContext$1 } from "@snoai/utils/log-context";
 * @boundary Memory store serialization, schema compatibility, and CLI operations.
 * @see store.ts, memory-management-cli.ts, schema.ts.
 */
-const log$4 = createLogger("sno-station-mem:backup");
+const log$5 = createLogger("sno-station-mem:backup");
 const BACKUP_PREFIX = "sno-station-mem-";
 const BACKUP_SUFFIX = ".sqlite";
 const BACKUP_FILE_REGEX = /^sno-station-mem-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}-p\d+-[a-z0-9]+\.sqlite$/;
@@ -84,7 +84,7 @@ function listBackups(stateDir) {
 }
 function removeBackups(stateDir, names, reason) {
 	for (const name of names) rmSync(path.join(stateDir, name), { force: true });
-	if (names.length > 0) log$4.debug("pruned old backups", {
+	if (names.length > 0) log$5.debug("pruned old backups", {
 		removed: names.length,
 		reason
 	}, {
@@ -157,7 +157,7 @@ function runBackup(dbPath, stateDir, options = {}) {
 	const backups = listBackups(resolvedStateDir);
 	removeBackups(resolvedStateDir, backups.slice(0, Math.max(0, backups.length - 6)), "retention");
 	freeSpaceForBackup(resolvedStateDir, 0, readDiskSpace);
-	log$4.info("backup created", { backupPath: safeBackupPath }, {
+	log$5.info("backup created", { backupPath: safeBackupPath }, {
 		event_name: "sno_station_mem.backup.backup.created",
 		file: "packages/memory/src/store/backup.ts",
 		function: "runBackup",
@@ -166,6 +166,377 @@ function runBackup(dbPath, stateDir, options = {}) {
 	return safeBackupPath;
 }
 //#endregion
+//#region src/sidecar/rem-job-store.ts
+/** @file rem-job-store.ts
+* @purpose Persists append-only REM job state transitions.
+* @boundary Durable local JSONL journal used by the standalone REM sidecar.
+*/
+const log$4 = createLogger("sno-station-mem:rem-jobs");
+const remJobStateSchema = z.enum([
+	"queued",
+	"running",
+	"done",
+	"failed",
+	"skipped"
+]);
+const remJobMeasurementsSchema = z.object({
+	rows_considered: z.number().int().nonnegative(),
+	pairs_built: z.number().int().nonnegative().optional(),
+	pair_cap_binding: z.boolean().optional(),
+	model_calls: z.number().int().nonnegative(),
+	model_tokens: z.number().int().nonnegative(),
+	wall_ms: z.number().int().nonnegative()
+}).strict();
+const remJobStatsSchema = z.object({
+	operations: z.number().int().nonnegative(),
+	applied_count: z.number().int().nonnegative().optional(),
+	actionable_candidate_count: z.number().int().nonnegative().optional(),
+	applied_fraction: z.number().min(0).max(1).nullable().optional(),
+	scan: z.object({
+		scope: z.string().min(1),
+		candidate_count: z.number().int().nonnegative(),
+		stamped_skipped_count: z.number().int().nonnegative().optional(),
+		actionable_candidate_count: z.number().int().nonnegative().optional()
+	}).strict().optional(),
+	parse_failure_count: z.number().int().nonnegative().optional(),
+	top_refusal_reasons: z.array(z.string().min(1)).max(2).optional(),
+	measured: remJobMeasurementsSchema.optional(),
+	by_operation: z.array(z.object({
+		operation: z.string().min(1),
+		applied_count: z.number().int().nonnegative(),
+		actionable_candidate_count: z.number().int().nonnegative(),
+		candidate_count: z.number().int().nonnegative(),
+		parse_failure_count: z.number().int().nonnegative(),
+		top_refusal_reasons: z.array(z.string().min(1)).max(2),
+		measured: remJobMeasurementsSchema
+	}).strict()).min(1).optional()
+}).strict();
+const remWaveJobSchema = z.object({
+	payloadVersion: z.literal(1),
+	waveId: z.string().min(1),
+	correlationId: z.string().min(1),
+	scope: z.string().min(1),
+	requestedOperations: z.array(z.string().min(1)).min(1),
+	state: remJobStateSchema,
+	startedAt: z.string().datetime().nullable(),
+	finishedAt: z.string().datetime().nullable(),
+	stats: remJobStatsSchema,
+	error: z.string().min(1).optional()
+}).strict();
+const legacyJobSchema = z.object({
+	job_id: z.string().min(1),
+	state: remJobStateSchema,
+	type: z.string().min(1),
+	scope: z.string().min(1),
+	started_at: z.string().datetime().nullable(),
+	finished_at: z.string().datetime().nullable(),
+	stats: remJobStatsSchema,
+	error: z.string().min(1).optional(),
+	correlation_id: z.string().min(1)
+}).strict();
+const OPERATION_ORDER = [
+	"rem-replace",
+	"rem-update",
+	"rem-distill",
+	"rem-retire"
+];
+var RemJobStore = class RemJobStore {
+	journalPath;
+	onDurableTransition;
+	jobs = /* @__PURE__ */ new Map();
+	persistedJobs = /* @__PURE__ */ new Set();
+	mergeKeys = /* @__PURE__ */ new Map();
+	operationQueue = Promise.resolve();
+	journalRecords = 0;
+	constructor(journalPath, onDurableTransition) {
+		this.journalPath = journalPath;
+		this.onDurableTransition = onDurableTransition;
+	}
+	static async open(journalPath, onDurableTransition = () => void 0) {
+		const store = new RemJobStore(journalPath, onDurableTransition);
+		await store.migrateLegacyJournal().catch((error) => store.reportFailure(error));
+		await store.load();
+		return store;
+	}
+	isPersisted(jobId) {
+		return this.persistedJobs.has(jobId);
+	}
+	get(jobId) {
+		const job = this.jobs.get(jobId);
+		return job === void 0 ? void 0 : toRemJob(job);
+	}
+	static async readCompletedJobs(journalPath) {
+		const completed = /* @__PURE__ */ new Map();
+		for await (const line of readJsonlLines(journalPath)) try {
+			const parsed = remWaveJobSchema.parse(JSON.parse(line));
+			if (parsed.state === "done") completed.set(parsed.waveId, toRemJob(parsed));
+			else completed.delete(parsed.waveId);
+		} catch (error) {
+			log$4.error("rem.journal.failed", {
+				error,
+				path: journalPath
+			}, {
+				event_name: "rem.journal.failed",
+				file: "packages/memory/src/sidecar/rem-job-store.ts",
+				function: "readCompletedJobs",
+				site_id: "rem-job-store.readCompletedJobs.invalid-line"
+			});
+		}
+		return [...completed.values()];
+	}
+	nonTerminalJobs() {
+		return Array.from(this.jobs.values()).filter((job) => job.state === "queued" || job.state === "running").map(toRemJob);
+	}
+	async createQueued(type, scope, correlationId) {
+		return this.enqueue(async () => {
+			const requestedOperations = canonicalOperations(typeof type === "string" ? [type] : type);
+			if (requestedOperations.length === 0) throw new Error("REM wave requires at least one supported operation");
+			const mergeKey = `${correlationId}\0${scope}`;
+			const existingId = this.mergeKeys.get(mergeKey);
+			const existing = existingId === void 0 ? void 0 : this.jobs.get(existingId);
+			if (existing !== void 0 && existing.state === "queued") {
+				const mergedOperations = canonicalOperations([...existing.requestedOperations, ...requestedOperations]);
+				if (mergedOperations.length === existing.requestedOperations.length) return {
+					created: false,
+					job: toRemJob(existing)
+				};
+				const updated = remWaveJobSchema.parse({
+					...existing,
+					requestedOperations: mergedOperations
+				});
+				const durable = await this.persist(updated);
+				this.jobs.set(updated.waveId, updated);
+				if (durable) this.onDurableTransition(toRemJob(updated));
+				return {
+					created: false,
+					job: toRemJob(updated)
+				};
+			}
+			if (existing !== void 0 && existing.state !== "skipped" && existing.state !== "failed" && requestedOperations.every((operation) => existing.requestedOperations.includes(operation))) return {
+				created: false,
+				job: toRemJob(existing)
+			};
+			const job = remWaveJobSchema.parse({
+				payloadVersion: 1,
+				waveId: `rem-wave-${randomUUID()}`,
+				correlationId,
+				scope,
+				requestedOperations,
+				state: "queued",
+				startedAt: null,
+				finishedAt: null,
+				stats: { operations: 0 }
+			});
+			const durable = await this.persist(job);
+			this.jobs.set(job.waveId, job);
+			this.mergeKeys.set(mergeKey, job.waveId);
+			const outward = toRemJob(job);
+			if (durable) this.onDurableTransition(outward);
+			return {
+				created: true,
+				job: outward
+			};
+		});
+	}
+	async transition(jobId, transition) {
+		return this.enqueue(async () => {
+			const current = this.jobs.get(jobId);
+			if (!current) throw new Error(`REM job not found: ${jobId}`);
+			const next = remWaveJobSchema.parse({
+				...current,
+				state: transition.state,
+				...transition.started_at === void 0 ? {} : { startedAt: transition.started_at },
+				...transition.finished_at === void 0 ? {} : { finishedAt: transition.finished_at },
+				...transition.stats === void 0 ? {} : { stats: transition.stats },
+				...transition.error === void 0 ? {} : { error: transition.error }
+			});
+			if (next.state === "done") this.jobs.set(jobId, next);
+			const durable = await this.persist(next);
+			this.jobs.set(jobId, next);
+			const outward = toRemJob(next);
+			if (durable) this.onDurableTransition(outward);
+			return outward;
+		});
+	}
+	async load() {
+		if (!existsSync(this.journalPath)) return;
+		await this.removeTornTail();
+		let index = 0;
+		for await (const line of readJsonlLines(this.journalPath)) {
+			index++;
+			this.journalRecords++;
+			try {
+				const job = remWaveJobSchema.parse(JSON.parse(line));
+				this.jobs.set(job.waveId, job);
+				this.mergeKeys.set(`${job.correlationId}\0${job.scope}`, job.waveId);
+			} catch (error) {
+				log$4.error("rem.journal.failed", {
+					path: this.journalPath,
+					line: index,
+					error
+				}, {
+					event_name: "rem.journal.failed",
+					file: "packages/memory/src/sidecar/rem-job-store.ts",
+					function: "load",
+					site_id: "rem-job-store.load.invalid-line"
+				});
+			}
+		}
+		if (this.journalRecords >= 256) await this.compact().catch((error) => this.reportFailure(error));
+	}
+	async removeTornTail() {
+		const handle = await open(this.journalPath, "r");
+		let committed = (await handle.stat()).size;
+		const buffer = Buffer.alloc(65536);
+		try {
+			while (committed > 0) {
+				const start = Math.max(0, committed - buffer.length);
+				const { bytesRead } = await handle.read(buffer, 0, committed - start, start);
+				const newline = buffer.subarray(0, bytesRead).lastIndexOf(10);
+				if (newline >= 0) {
+					committed = start + newline + 1;
+					break;
+				}
+				committed = start;
+			}
+			if (committed < (await handle.stat()).size) await this.truncateJournal(committed);
+		} finally {
+			await handle.close();
+		}
+	}
+	async compact() {
+		const cutoff = (/* @__PURE__ */ new Date(Date.now() - 1728e5)).toISOString();
+		const retained = [...this.jobs.values()].filter((job) => job.state === "queued" || job.state === "running" || (job.finishedAt ?? job.startedAt ?? "") >= cutoff);
+		const temporary = `${this.journalPath}.${randomUUID()}.tmp`;
+		const handle = await open(temporary, "wx", 384);
+		try {
+			try {
+				for (const job of retained) await handle.writeFile(`${JSON.stringify(job)}\n`, "utf8");
+				await handle.sync();
+			} finally {
+				await handle.close();
+			}
+			await rename(temporary, this.journalPath);
+			await syncDirectory$1(path.dirname(this.journalPath));
+			const retainedIds = new Set(retained.map((job) => job.waveId));
+			for (const id of this.jobs.keys()) if (!retainedIds.has(id)) {
+				this.jobs.delete(id);
+				this.persistedJobs.delete(id);
+			}
+			for (const [key, id] of this.mergeKeys) if (!retainedIds.has(id)) this.mergeKeys.delete(key);
+			this.journalRecords = 0;
+		} finally {
+			await rm(temporary, { force: true });
+		}
+	}
+	async migrateLegacyJournal() {
+		const legacyPath = path.join(path.dirname(this.journalPath), "rem-jobs.jsonl");
+		if (!existsSync(legacyPath)) return;
+		const latest = /* @__PURE__ */ new Map();
+		for await (const line of readJsonlLines(legacyPath)) try {
+			const parsed = JSON.parse(line);
+			const job = legacyJobSchema.parse(parsed);
+			latest.set(job.job_id, job);
+		} catch (error) {
+			const reason = error instanceof Error ? error.message : String(error);
+			this.reportFailure(reason);
+		}
+		const interrupted = [...latest.values()].filter((job) => job.state === "queued" || job.state === "running");
+		if (interrupted.length > 0) {
+			const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+			const handle = await open(legacyPath, "a");
+			try {
+				for (const job of interrupted) await handle.writeFile(`${JSON.stringify({
+					...job,
+					state: "failed",
+					finished_at: finishedAt,
+					error: "sidecar_upgrade_interrupted"
+				})}\n`, "utf8");
+				await handle.sync();
+			} finally {
+				await handle.close();
+			}
+		}
+		await rename(legacyPath, path.join(path.dirname(legacyPath), "rem-jobs.v0.jsonl"));
+	}
+	reportFailure(error) {
+		log$4.error("rem.journal.failed", {
+			error,
+			path: this.journalPath
+		}, {
+			event_name: "rem.journal.failed",
+			file: "packages/memory/src/sidecar/rem-job-store.ts",
+			function: "reportFailure",
+			site_id: "rem.journal.failed"
+		});
+	}
+	async persist(job) {
+		this.persistedJobs.delete(job.waveId);
+		await this.append(job);
+		this.persistedJobs.add(job.waveId);
+		this.journalRecords++;
+		if (this.journalRecords >= 256) {
+			this.jobs.set(job.waveId, job);
+			await this.compact().catch((error) => this.reportFailure(error));
+		}
+		return true;
+	}
+	async truncateJournal(length) {
+		const handle = await open(this.journalPath, "r+");
+		try {
+			await handle.truncate(length);
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+	}
+	async append(job) {
+		const parent = path.dirname(this.journalPath);
+		await mkdir(parent, { recursive: true });
+		const journalAlreadyExisted = existsSync(this.journalPath);
+		const handle = await open(this.journalPath, "a");
+		try {
+			await handle.writeFile(`${JSON.stringify(job)}\n`, "utf8");
+			await handle.sync();
+		} finally {
+			await handle.close();
+		}
+		if (!journalAlreadyExisted) await syncDirectory$1(parent);
+	}
+	enqueue(operation) {
+		const result = this.operationQueue.then(operation);
+		this.operationQueue = result.then(() => void 0, () => void 0);
+		return result;
+	}
+};
+function canonicalOperations(operations) {
+	const unique = new Set(operations);
+	return OPERATION_ORDER.filter((operation) => unique.has(operation));
+}
+function toRemJob(job) {
+	return {
+		job_id: job.waveId,
+		state: job.state,
+		type: job.requestedOperations[0] ?? "rem-replace",
+		scope: job.scope,
+		started_at: job.startedAt,
+		finished_at: job.finishedAt,
+		stats: job.stats,
+		...job.error === void 0 ? {} : { error: job.error },
+		correlation_id: job.correlationId,
+		requested_operations: [...job.requestedOperations]
+	};
+}
+async function syncDirectory$1(directory) {
+	if (process.platform === "win32") return;
+	const handle = await open(directory, "r");
+	try {
+		await handle.sync();
+	} finally {
+		await handle.close();
+	}
+}
+//#endregion
 //#region src/sidecar/config.ts
 const REM_SIDECAR_HOST = "127.0.0.1";
 const REM_CORRELATION_ID_HEADER = "x-rem-correlation-id";
@@ -654,6 +1025,28 @@ async function evaluateScope(input, auditStateDir, state, scope, candidateCount,
 	}
 	const correlationId = remAutomaticCorrelationId(trigger, scope, trigger === "daily" ? nextDue.toISOString() : localDate);
 	const priorAttempts = scopeState.attempts.identity === correlationId ? scopeState.attempts.count : 0;
+	if (priorAttempts >= 3) {
+		await recordDecision(auditStateDir, scope, "skipped", {
+			row: "attempt-limit",
+			trigger,
+			local_date: localDate,
+			correlation_id: correlationId,
+			attempts: priorAttempts
+		});
+		const nextState = replaceScopeState(state, scope, {
+			...scopeState,
+			last_volume_pass_date: localDate,
+			attempts: {
+				identity: null,
+				count: 0
+			}
+		});
+		await writeRemTriggerStateAtomic(input.stateDir, nextState);
+		return {
+			state: nextState,
+			dispatched: false
+		};
+	}
 	await recordDecision(auditStateDir, scope, "ok", {
 		row: "dispatch",
 		trigger,
@@ -748,6 +1141,40 @@ async function dispatchRemWave(input, scope, correlationId) {
 	});
 }
 async function applyCompletedBaselines(auditStateDir, triggerStateDir, state) {
+	const durableCorrelations = /* @__PURE__ */ new Set();
+	try {
+		const completedJobs = await RemJobStore.readCompletedJobs(path.join(triggerStateDir, "rem-wave-jobs.jsonl"));
+		for (const job of completedJobs) {
+			durableCorrelations.add(job.correlation_id);
+			const current = state.scopes[job.scope];
+			if (!current || !job.correlation_id.startsWith("rem-auto-") || !job.started_at) continue;
+			const localDate = localDateAt(new Date(job.started_at), current.schedule_zone);
+			const measured = job.stats.measured;
+			const completedScope = {
+				...current,
+				last_pass_at: job.started_at > current.last_pass_at ? job.started_at : current.last_pass_at,
+				last_volume_pass_date: localDate > (current.last_volume_pass_date ?? "") ? localDate : current.last_volume_pass_date,
+				...current.attempts.identity === job.correlation_id ? { attempts: {
+					identity: null,
+					count: 0
+				} } : {},
+				...measured?.pair_cap_binding === false ? { last_covered_count: measured.rows_considered } : {}
+			};
+			if (JSON.stringify(current) === JSON.stringify(completedScope)) continue;
+			state = replaceScopeState(state, job.scope, completedScope);
+			await writeRemTriggerStateAtomic(triggerStateDir, state);
+		}
+	} catch (error) {
+		log$1.warn("REM completion jobs could not be read", {
+			error,
+			outcome: "partial"
+		}, {
+			event_name: "sidecar.trigger.completion_jobs.read.failed",
+			file: "packages/memory/src/sidecar/rem-trigger.ts",
+			function: "applyCompletedBaselines",
+			site_id: "sidecar.trigger.completion_jobs.read.failed"
+		});
+	}
 	let content;
 	try {
 		content = await readAuditTail(getAuditPath(auditStateDir));
@@ -766,7 +1193,6 @@ async function applyCompletedBaselines(auditStateDir, triggerStateDir, state) {
 		return state;
 	}
 	const dispatched = /* @__PURE__ */ new Map();
-	const triesByCorrelation = /* @__PURE__ */ new Map();
 	let nextState = state;
 	let malformedCount = 0;
 	for (const line of content.split("\n")) {
@@ -788,28 +1214,6 @@ async function applyCompletedBaselines(auditStateDir, triggerStateDir, state) {
 				});
 				continue;
 			}
-			if (entry["event"] === "rem_skipped" && typeof correlationId === "string") {
-				const skipped = dispatched.get(correlationId);
-				const tries = (triesByCorrelation.get(correlationId) ?? 0) + (typeof details?.["destination"] === "string" ? 1 : 0);
-				triesByCorrelation.set(correlationId, tries);
-				const skippedScopeState = skipped ? nextState.scopes[skipped.scope] : void 0;
-				if (skipped && skippedScopeState && tries >= 3 && isLocalDate(skipped.localDate) && (skippedScopeState.last_volume_pass_date ?? "") < skipped.localDate) nextState = replaceScopeState(nextState, skipped.scope, {
-					...skippedScopeState,
-					last_volume_pass_date: skipped.localDate,
-					attempts: {
-						identity: null,
-						count: 0
-					}
-				});
-				else if (skipped && skippedScopeState?.attempts.identity === correlationId) nextState = replaceScopeState(nextState, skipped.scope, {
-					...skippedScopeState,
-					attempts: {
-						identity: null,
-						count: 0
-					}
-				});
-				continue;
-			}
 			if (entry["event"] === "rem_failed" && details?.["source"] === "sidecar" && typeof correlationId === "string") {
 				const failed = dispatched.get(correlationId);
 				const failedScopeState = failed ? nextState.scopes[failed.scope] : void 0;
@@ -823,15 +1227,15 @@ async function applyCompletedBaselines(auditStateDir, triggerStateDir, state) {
 				});
 				continue;
 			}
-			if (entry["event"] !== "rem_completed" || typeof correlationId !== "string") continue;
+			if (entry["event"] !== "rem_completed" || typeof correlationId !== "string" || durableCorrelations.has(correlationId)) continue;
 			const dispatch = dispatched.get(correlationId);
 			if (dispatch === void 0 || state.scopes[dispatch.scope] === void 0 || entry["scope"] !== dispatch.scope) continue;
 			const currentScopeState = requiredScopeState(nextState, dispatch.scope);
 			let completedScopeState = {
 				...currentScopeState,
-				...dispatch.trigger === "daily" && isValidInstant(dispatch.passAt) ? { last_pass_at: dispatch.passAt } : {},
-				...dispatch.trigger === "daily" && isLocalDate(dispatch.localDate) ? { last_volume_pass_date: dispatch.localDate } : {},
-				...dispatch.trigger === "volume" && isLocalDate(dispatch.localDate) ? { last_volume_pass_date: dispatch.localDate } : {},
+				...dispatch.trigger === "daily" && isValidInstant(dispatch.passAt) && dispatch.passAt > currentScopeState.last_pass_at ? { last_pass_at: dispatch.passAt } : {},
+				...dispatch.trigger === "daily" && isLocalDate(dispatch.localDate) && dispatch.localDate > (currentScopeState.last_volume_pass_date ?? "") ? { last_volume_pass_date: dispatch.localDate } : {},
+				...dispatch.trigger === "volume" && isLocalDate(dispatch.localDate) && dispatch.localDate > (currentScopeState.last_volume_pass_date ?? "") ? { last_volume_pass_date: dispatch.localDate } : {},
 				...currentScopeState.attempts.identity === correlationId ? { attempts: {
 					identity: null,
 					count: 0
@@ -839,7 +1243,7 @@ async function applyCompletedBaselines(auditStateDir, triggerStateDir, state) {
 			};
 			const measured = asRecord(asRecord(details?.["stats"])?.["measured"]);
 			const rowsConsidered = measured?.["rows_considered"];
-			if (measured?.["pair_cap_binding"] === false && Number.isInteger(rowsConsidered) && Number(rowsConsidered) >= 0) completedScopeState = {
+			if ((!isValidInstant(dispatch.passAt) || dispatch.passAt >= currentScopeState.last_pass_at) && measured?.["pair_cap_binding"] === false && Number.isInteger(rowsConsidered) && Number(rowsConsidered) >= 0) completedScopeState = {
 				...completedScopeState,
 				last_covered_count: Number(rowsConsidered)
 			};

package/dist/internal/store/memory-kinds-cutover-migrator.js

@@ -3,7 +3,7 @@ import { MEMORY_CATEGORIES } from "../engine/shared/types.js";
 import { StorageError } from "../engine/shared/errors.js";
 import { a as buildInsightMetadata, c as stringifyInsightMetadata, s as parseInsightMetadata } from "../../memory-metadata-codec-DL1sbJiN.js";
 import { stableHash } from "../engine/shared/utils.js";
-import { u as runWithMemoryAuditSync } from "../../runtime-audit-log-BCeujlEp.js";
+import { d as runWithMemoryAuditSync } from "../../runtime-audit-log-DK6xAYxh.js";
 import { getSnoStationMemStateDir } from "../contract/profile.js";
 import { openSqliteDatabase } from "./sqlite-runtime.js";
 import { resolve } from "node:path";

package/dist/internal/store/migrations.js

@@ -1,6 +1,6 @@
 import { readSettings } from "../contract/profile.js";
 import { installRemSchema } from "../engine/rem/index.js";
-import { a as schema_exports, i as migrateLegacyDatabaseNamespace, n as loadSqliteVecExtension, o as applyEntityNameKeyMigration, r as resolveSimpleTokenizerPath, t as migrateUnplacedCandidates } from "../../unplaced-candidate-migration-CbQHzcEM.js";
+import { a as schema_exports, i as migrateLegacyDatabaseNamespace, n as loadSqliteVecExtension, o as applyEntityNameKeyMigration, r as resolveSimpleTokenizerPath, t as migrateUnplacedCandidates } from "../../unplaced-candidate-migration-BCcdQkcx.js";
 import { initSqliteRuntime, openSqliteDatabase } from "./sqlite-runtime.js";
 import { dirname, join } from "node:path";
 import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";

package/dist/internal/store/store.d.ts

@@ -1,3 +1,3 @@
-import { $ as TodoListResult, A as StaleSupersedeTargetError, B as TaskLifecycleMigrationManifest, C as MemoryStore, D as ProfileRecoveryEntry, E as MemorySuppressionResult, F as TaskLifecycleBatchWriteResult, G as TaskLifecycleTimestampCollisionError, H as TaskLifecycleMigrationSourceRow, I as TaskLifecycleCommandCollisionError, J as TaskLifecycleTimestampSource, K as TaskLifecycleTimestampInput, L as TaskLifecycleCommandReplayInput, M as SupersedeClose, N as SupersedePreserveExisting, O as ProfileRecoveryWrite, P as TaskLifecycleBatchWriteInput, Q as TodoListInput, R as TaskLifecycleMigrationApplyResult, S as MemoryRelationWalkInput, T as MemorySuppressionInput, U as TaskLifecycleStaleResolutionError, V as TaskLifecycleMigrationManifestRow, W as TaskLifecycleStateCollisionError, X as TaskLifecycleWriteOutcome, Y as TaskLifecycleWriteInput, Z as TaskLifecycleWriteResult, _ as CorrectMemoryInput, _t as UnplacedCandidate, a as AtomicExtractionRepairStrategy, at as ListOptions, b as MemoryRelation, c as AtomicExtractionRunParameters, ct as QuarantineDispositionReason, d as AtomicExtractionWriteRelation, dt as RecordUnplacedCandidateResult, et as TodoRecord, f as AtomicExtractionWriteResult, ft as SearchOptions, g as BeginAtomicExtractionChunkResult, gt as StoreResult, h as BeginAtomicExtractionChunkInput, ht as StoreInput, i as AtomicExtractionLedgerState, it as ChunkSearchRow, j as SupersedeActiveFactGuard, k as ReopenAtomicExtractionChunkResult, l as AtomicExtractionWriteCard, lt as QuarantinedStoreInput, m as AtomicMemoryEntityResolution, mt as StoreConfig, n as AtomicExtractionLedgerEntry, nt as BulkDeleteResult, o as AtomicExtractionReprocessBounds, ot as MemoryRow, p as AtomicMemoryEntityRegistration, pt as StatsResult, q as TaskLifecycleTimestampResolution, r as AtomicExtractionLedgerKey, rt as ChunkSearchResult, s as AtomicExtractionReprocessReason, st as PreparedChunkRow, t as ActiveTaskProjectionGuard, tt as TodoStatus, u as AtomicExtractionWriteInput, ut as RecordUnplacedCandidateInput, v as CorrectMemoryResult, vt as UnplacedCandidateQuery, w as MemoryStoreInternals, x as MemoryRelationPredicate, y as ExtractionTimestampResolution, yt as UpdateChanges, z as TaskLifecycleMigrationCensusRow } from "../../memory-store-base-z593oJ4h.js";
-import { a as repairAtomicExtractionParameters, i as AtomicExtractionCompletedElsewhere, n as ATOMIC_FACT_SURFACE_LANE, o as normalizeMemoryRelationPredicate, r as hashMemorySuppressionContent, t as buildTaskLifecycleMigrationManifest } from "../../store-DKndKig1.js";
+import { $ as TodoListResult, A as StaleSupersedeTargetError, B as TaskLifecycleMigrationManifest, C as MemoryStore, D as ProfileRecoveryEntry, E as MemorySuppressionResult, F as TaskLifecycleBatchWriteResult, G as TaskLifecycleTimestampCollisionError, H as TaskLifecycleMigrationSourceRow, I as TaskLifecycleCommandCollisionError, J as TaskLifecycleTimestampSource, K as TaskLifecycleTimestampInput, L as TaskLifecycleCommandReplayInput, M as SupersedeClose, N as SupersedePreserveExisting, O as ProfileRecoveryWrite, P as TaskLifecycleBatchWriteInput, Q as TodoListInput, R as TaskLifecycleMigrationApplyResult, S as MemoryRelationWalkInput, T as MemorySuppressionInput, U as TaskLifecycleStaleResolutionError, V as TaskLifecycleMigrationManifestRow, W as TaskLifecycleStateCollisionError, X as TaskLifecycleWriteOutcome, Y as TaskLifecycleWriteInput, Z as TaskLifecycleWriteResult, _ as CorrectMemoryInput, _t as UnplacedCandidate, a as AtomicExtractionRepairStrategy, at as ListOptions, b as MemoryRelation, c as AtomicExtractionRunParameters, ct as QuarantineDispositionReason, d as AtomicExtractionWriteRelation, dt as RecordUnplacedCandidateResult, et as TodoRecord, f as AtomicExtractionWriteResult, ft as SearchOptions, g as BeginAtomicExtractionChunkResult, gt as StoreResult, h as BeginAtomicExtractionChunkInput, ht as StoreInput, i as AtomicExtractionLedgerState, it as ChunkSearchRow, j as SupersedeActiveFactGuard, k as ReopenAtomicExtractionChunkResult, l as AtomicExtractionWriteCard, lt as QuarantinedStoreInput, m as AtomicMemoryEntityResolution, mt as StoreConfig, n as AtomicExtractionLedgerEntry, nt as BulkDeleteResult, o as AtomicExtractionReprocessBounds, ot as MemoryRow, p as AtomicMemoryEntityRegistration, pt as StatsResult, q as TaskLifecycleTimestampResolution, r as AtomicExtractionLedgerKey, rt as ChunkSearchResult, s as AtomicExtractionReprocessReason, st as PreparedChunkRow, t as ActiveTaskProjectionGuard, tt as TodoStatus, u as AtomicExtractionWriteInput, ut as RecordUnplacedCandidateInput, v as CorrectMemoryResult, vt as UnplacedCandidateQuery, w as MemoryStoreInternals, x as MemoryRelationPredicate, y as ExtractionTimestampResolution, yt as UpdateChanges, z as TaskLifecycleMigrationCensusRow } from "../../memory-store-base-Bk2dOKED.js";
+import { a as repairAtomicExtractionParameters, i as AtomicExtractionCompletedElsewhere, n as ATOMIC_FACT_SURFACE_LANE, o as normalizeMemoryRelationPredicate, r as hashMemorySuppressionContent, t as buildTaskLifecycleMigrationManifest } from "../../store-BDIAl2cc.js";
 export { ATOMIC_FACT_SURFACE_LANE, ActiveTaskProjectionGuard, AtomicExtractionCompletedElsewhere, AtomicExtractionLedgerEntry, AtomicExtractionLedgerKey, AtomicExtractionLedgerState, AtomicExtractionRepairStrategy, AtomicExtractionReprocessBounds, AtomicExtractionReprocessReason, AtomicExtractionRunParameters, AtomicExtractionWriteCard, AtomicExtractionWriteInput, AtomicExtractionWriteRelation, AtomicExtractionWriteResult, AtomicMemoryEntityRegistration, AtomicMemoryEntityResolution, BeginAtomicExtractionChunkInput, BeginAtomicExtractionChunkResult, type BulkDeleteResult, type ChunkSearchResult, type ChunkSearchRow, CorrectMemoryInput, CorrectMemoryResult, ExtractionTimestampResolution, type ListOptions, MemoryRelation, MemoryRelationPredicate, MemoryRelationWalkInput, type MemoryRow, MemoryStore, MemoryStoreInternals, MemorySuppressionInput, MemorySuppressionResult, type PreparedChunkRow, ProfileRecoveryEntry, ProfileRecoveryWrite, type QuarantineDispositionReason, type QuarantinedStoreInput, type RecordUnplacedCandidateInput, type RecordUnplacedCandidateResult, ReopenAtomicExtractionChunkResult, type SearchOptions, StaleSupersedeTargetError, type StatsResult, type StoreConfig, type StoreInput, type StoreResult, SupersedeActiveFactGuard, SupersedeClose, SupersedePreserveExisting, TaskLifecycleBatchWriteInput, TaskLifecycleBatchWriteResult, TaskLifecycleCommandCollisionError, TaskLifecycleCommandReplayInput, TaskLifecycleMigrationApplyResult, TaskLifecycleMigrationCensusRow, TaskLifecycleMigrationManifest, TaskLifecycleMigrationManifestRow, TaskLifecycleMigrationSourceRow, TaskLifecycleStaleResolutionError, TaskLifecycleStateCollisionError, TaskLifecycleTimestampCollisionError, TaskLifecycleTimestampInput, TaskLifecycleTimestampResolution, TaskLifecycleTimestampSource, TaskLifecycleWriteInput, TaskLifecycleWriteOutcome, TaskLifecycleWriteResult, TodoListInput, TodoListResult, TodoRecord, TodoStatus, type UnplacedCandidate, type UnplacedCandidateQuery, type UpdateChanges, buildTaskLifecycleMigrationManifest, hashMemorySuppressionContent, normalizeMemoryRelationPredicate, repairAtomicExtractionParameters };

package/dist/internal/store/store.js

@@ -1,2 +1,2 @@
-import { C as TaskLifecycleCommandCollisionError, E as TaskLifecycleTimestampCollisionError, S as StaleSupersedeTargetError, T as TaskLifecycleStateCollisionError, _ as hashMemorySuppressionContent, b as normalizeMemoryRelationPredicate, p as ATOMIC_FACT_SURFACE_LANE, t as buildTaskLifecycleMigrationManifest, v as AtomicExtractionCompletedElsewhere, w as TaskLifecycleStaleResolutionError, x as MemoryStore, y as repairAtomicExtractionParameters } from "../../store-CUk-jEGA.js";
+import { C as TaskLifecycleCommandCollisionError, E as TaskLifecycleTimestampCollisionError, S as StaleSupersedeTargetError, T as TaskLifecycleStateCollisionError, _ as hashMemorySuppressionContent, b as normalizeMemoryRelationPredicate, p as ATOMIC_FACT_SURFACE_LANE, t as buildTaskLifecycleMigrationManifest, v as AtomicExtractionCompletedElsewhere, w as TaskLifecycleStaleResolutionError, x as MemoryStore, y as repairAtomicExtractionParameters } from "../../store-BQxkgJTX.js";
 export { ATOMIC_FACT_SURFACE_LANE, AtomicExtractionCompletedElsewhere, MemoryStore, StaleSupersedeTargetError, TaskLifecycleCommandCollisionError, TaskLifecycleStaleResolutionError, TaskLifecycleStateCollisionError, TaskLifecycleTimestampCollisionError, buildTaskLifecycleMigrationManifest, hashMemorySuppressionContent, normalizeMemoryRelationPredicate, repairAtomicExtractionParameters };

package/dist/{llm-client-RqmOEQkg.d.ts → llm-client-BTaUVmDe.d.ts}

@@ -1,4 +1,4 @@
-import { i as LlmClientConfig, l as ModelCallId, r as LlmClient } from "./plugin-config-schema-VBSPGEG3.js";
+import { i as LlmClientConfig, l as ModelCallId, r as LlmClient } from "./plugin-config-schema-BrhMvnXJ.js";
 //#region src/model/llm-json-utils.d.ts
 /** @file llm-json-utils.ts
  * @purpose Extracts and repairs JSON returned by LLM providers.