@snoai/memory 0.0.0-stage → 1.0.1

package/dist/daily-log-generator-CH_KuWHs.js

@@ -0,0 +1,469 @@
+import "./internal/config/index.js";
+import { redactSecrets } from "./internal/engine/security/redact.js";
+import { i as memoryOperationSignal, n as memoryFileWrite, t as checkMemoryOperation } from "./operation-cancellation-CTKWwNHk.js";
+import { n as RESOURCES_BY_LOCALE } from "./all-resources-BQK2ugjB.js";
+import { t as resolveLocale } from "./resolver-Dy-hnjCR.js";
+import { a as sha256Hex } from "./error-signals-lMH2uAdV.js";
+import { chunk, countTokens } from "@snoai/chunking";
+import { createLogger } from "@snoai/utils/logger";
+import { basename, dirname, join } from "node:path";
+import { appendFile, link, mkdir, readFile, readdir, stat, unlink, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import "node:fs";
+import "node:readline";
+//#region src/engine/operations/session-summary-storage.ts
+const diagnosticLog$1 = createLogger("sno-station-mem:session-summary-storage");
+/** Implements sort file names by mtime desc as the local session summary storage operation. */
+async function sortFileNamesByMtimeDesc(dir, fileNames) {
+	return (await Promise.all(fileNames.map(async (name) => {
+		try {
+			return {
+				name,
+				mtimeMs: (await stat(join(dir, name))).mtimeMs
+			};
+		} catch (error) {
+			if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) diagnosticLog$1.warn("Session file metadata unavailable", { error }, {
+				event_name: "memory.session.file.stat.failed",
+				file: "packages/memory/src/engine/operations/session-summary-storage.ts",
+				function: "sortFileNamesByMtimeDesc",
+				site_id: "memory.session.file.stat.failed"
+			});
+			return null;
+		}
+	}))).filter((x) => x !== null).sort((a, b) => b.mtimeMs - a.mtimeMs || b.name.localeCompare(a.name)).map((x) => x.name);
+}
+/** Implements sanitize file token as the local session summary storage operation. */
+function sanitizeFileToken(value, fallback) {
+	return value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32) || fallback;
+}
+/** Extracts text content from raw inputs while tolerating partial data. */
+function extractTextContent(content) {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return null;
+	const parts = [];
+	for (const item of content) {
+		if (!item || typeof item !== "object") continue;
+		const record = item;
+		if (record.type === "text" && typeof record.text === "string") parts.push(record.text);
+	}
+	return parts.length > 0 ? parts.join("\n") : null;
+}
+//#endregion
+//#region src/engine/reflection/reflection-prompt-input.ts
+function prepareReflectionPromptInputs(conversation, maxInputChars) {
+	const trimmed = conversation.trim();
+	if (!trimmed) return [];
+	const maxTokens = Math.max(1, Math.floor(maxInputChars / 3));
+	if (countTokens(trimmed) <= maxTokens) return [trimmed];
+	return chunk(trimmed, {
+		contentType: "conversation",
+		targetTokens: maxTokens,
+		maxTokens
+	}).map((draft) => draft.chunkText);
+}
+//#endregion
+//#region src/engine/reflection/transient-generation-retry.ts
+const TRANSIENT_POLICIES = {
+	transportReset: [
+		/unexpected eof/i,
+		/\beconnreset\b/i,
+		/\beconnaborted\b/i,
+		/\bepipe\b/i,
+		/connection reset/i,
+		/socket hang up/i,
+		/socket (?:closed|disconnected)/i,
+		/connection (?:closed|aborted|dropped)/i,
+		/early close/i,
+		/stream (?:ended|closed) unexpectedly/i,
+		/\bund_err_(?:socket|headers_timeout|body_timeout)\b/i
+	],
+	timeout: [
+		/\betimedout\b/i,
+		/\btimed out\b/i,
+		/\btimeout\b/i
+	],
+	upstreamUnavailable: [
+		/temporar(?:y|ily).*unavailable/i,
+		/upstream.*unavailable/i,
+		/service unavailable/i,
+		/bad gateway/i,
+		/gateway timeout/i,
+		/\b(?:http|status)\s*(?:502|503|504)\b/i
+	],
+	network: [/network error/i, /fetch failed/i]
+};
+const NON_RETRY_POLICIES = {
+	auth: [
+		/\b401\b/i,
+		/\bunauthorized\b/i,
+		/invalid api key/i,
+		/invalid[_ -]?token/i,
+		/\bauth(?:entication)?_?unavailable\b/i
+	],
+	billingOrQuota: [
+		/insufficient (?:credit|credits|balance)/i,
+		/\bbilling\b/i,
+		/\bquota exceeded\b/i,
+		/payment required/i
+	],
+	modelOrContext: [
+		/model .*not found/i,
+		/no such model/i,
+		/unknown model/i,
+		/context length/i,
+		/context window/i,
+		/request too large/i,
+		/payload too large/i,
+		/too many tokens/i,
+		/token limit/i,
+		/prompt too long/i
+	],
+	sessionOrPolicy: [
+		/session expired/i,
+		/invalid session/i,
+		/refusal/i,
+		/content policy/i,
+		/safety policy/i,
+		/content filter/i,
+		/disallowed/i
+	]
+};
+/** Implements default sleep as the local reflection retry policy operation. */
+const DEFAULT_SLEEP = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const CLIP_MAX_LEN = 260;
+const BASE_DELAY_MS = 1e3;
+const JITTER_RANGE_MS = 2e3;
+/** Converts error message into the transport shape expected by reflection retry policy. */
+function toErrorMessage(error) {
+	if (error instanceof Error) return `${error.name}: ${error.message}`.trim() || "Error";
+	if (typeof error === "string") return error;
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return String(error);
+	}
+}
+/** Implements clip single line as the local reflection retry policy operation. */
+function clipSingleLine(text, maxLen = CLIP_MAX_LEN) {
+	const oneLine = text.replace(/\s+/g, " ").trim();
+	if (oneLine.length <= maxLen) return oneLine;
+	return `${oneLine.slice(0, maxLen - 3)}...`;
+}
+function readErrorFacts(error) {
+	const message = toErrorMessage(error);
+	return {
+		message,
+		normalizedError: clipSingleLine(message),
+		transientCategory: matchPolicyCategory(TRANSIENT_POLICIES, message),
+		nonRetryCategory: matchPolicyCategory(NON_RETRY_POLICIES, message)
+	};
+}
+function matchPolicyCategory(policies, message) {
+	for (const [category, patterns] of Object.entries(policies)) if (patterns.some((pattern) => pattern.test(message))) return category;
+	return null;
+}
+function isRetryScope(scope) {
+	return scope === "reflection" || scope === "distiller";
+}
+function logRetryExhausted(params, retryError) {
+	params.onLog?.("warn", `memory-${params.scope}: retry exhausted (${params.runner}). error=${clipSingleLine(toErrorMessage(retryError))}`);
+}
+function readUsefulOutputChars(params) {
+	return params.usefulOutputChars?.() ?? 0;
+}
+/** Implements classify reflection retry as the local reflection retry policy operation. */
+function classifyReflectionRetry(input) {
+	const facts = readErrorFacts(input.error);
+	const { normalizedError } = facts;
+	if (!input.inReflectionScope) return {
+		retryable: false,
+		reason: "not_reflection_scope",
+		normalizedError
+	};
+	if (input.retryCount > 0) return {
+		retryable: false,
+		reason: "retry_already_used",
+		normalizedError
+	};
+	if (input.usefulOutputChars > 0) return {
+		retryable: false,
+		reason: "useful_output_present",
+		normalizedError
+	};
+	if (facts.nonRetryCategory !== null) return {
+		retryable: false,
+		reason: "non_retry_error",
+		normalizedError
+	};
+	if (facts.transientCategory !== null) return {
+		retryable: true,
+		reason: "transient_upstream_failure",
+		normalizedError
+	};
+	return {
+		retryable: false,
+		reason: "non_transient_error",
+		normalizedError
+	};
+}
+/** Computes reflection retry delay ms as a side-effect-free reflection retry policy value. */
+function computeReflectionRetryDelayMs(random = Math.random) {
+	const raw = random();
+	return BASE_DELAY_MS + Math.floor((Number.isFinite(raw) ? Math.min(1, Math.max(0, raw)) : 0) * JITTER_RANGE_MS);
+}
+/**
+* Implements run with reflection transient retry once as the local reflection retry policy
+* operation.
+*/
+async function runWithReflectionTransientRetryOnce(params) {
+	try {
+		return await params.execute();
+	} catch (error) {
+		const decision = classifyReflectionRetry({
+			inReflectionScope: isRetryScope(params.scope),
+			retryCount: params.retryState.count,
+			usefulOutputChars: readUsefulOutputChars(params),
+			error
+		});
+		if (!decision.retryable) throw error;
+		const delayMs = computeReflectionRetryDelayMs(params.random);
+		params.retryState.count += 1;
+		params.onLog?.("warn", `memory-${params.scope}: transient upstream failure detected (${params.runner}); retrying once in ${delayMs}ms (${decision.reason}). error=${decision.normalizedError}`);
+		await (params.sleep ?? DEFAULT_SLEEP)(delayMs);
+		try {
+			const result = await params.execute();
+			params.onLog?.("info", `memory-${params.scope}: retry succeeded (${params.runner})`);
+			return result;
+		} catch (retryError) {
+			logRetryExhausted(params, retryError);
+			throw retryError;
+		}
+	}
+}
+//#endregion
+//#region src/engine/reflection/daily-log-generator.ts
+/** @file daily-log-generator.ts
+* @purpose Runs reflection analysis and writes durable improvement-oriented records.
+* @boundary LLM prompts, reflection stores, retry handling, and learning extraction.
+* @see strategy-hook-runner.ts, memory-entry-projector.ts, learning-file-maintenance.ts.
+*/
+const diagnosticLog = createLogger("sno-station-mem:daily-log-generator");
+const REFLECTION_FALLBACK_MARKER = "(fallback) Reflection generation failed; storing minimal pointer only.";
+const USER_SKIP_MARKERS = [
+	"<relevant-memories>",
+	"UNTRUSTED DATA",
+	"END UNTRUSTED DATA"
+];
+/**
+* Tests whether should skip reflection message without mutating reflection capture policy state.
+*/
+function shouldSkipReflectionMessage(role, text) {
+	const trimmed = text.trim();
+	if (!trimmed) return true;
+	if (trimmed.startsWith("/")) return true;
+	if (role === "user" && USER_SKIP_MARKERS.some((m) => trimmed.includes(m))) return true;
+	return false;
+}
+/**
+* Reads session conversation for reflection and applies reflection capture policy fallback
+* behavior for missing data.
+*/
+async function readSessionConversationForReflection(filePath, messageCount) {
+	try {
+		const lines = (await readFile(filePath, {
+			encoding: "utf8",
+			signal: memoryOperationSignal()
+		})).trim().split("\n");
+		const messages = [];
+		for (const line of lines) try {
+			const entry = JSON.parse(line);
+			const value = entry.type === "message" ? entry.message : entry.type === "response_item" ? entry.payload : entry.type === "user" || entry.type === "assistant" ? entry.message : void 0;
+			if (!value || typeof value !== "object") continue;
+			const msg = value;
+			if (entry.type === "response_item" && msg.type !== "message") continue;
+			const role = entry.type === "user" || entry.type === "assistant" ? entry.type : typeof msg.role === "string" ? msg.role : "";
+			if (role !== "user" && role !== "assistant") continue;
+			const text = extractTextContent(entry.type === "response_item" && Array.isArray(msg.content) ? msg.content.map((part) => part && typeof part === "object" && "type" in part && (part.type === "input_text" || part.type === "output_text") ? {
+				type: "text",
+				text: "text" in part ? part.text : void 0
+			} : part) : msg.content);
+			if (!text || shouldSkipReflectionMessage(role, text)) continue;
+			messages.push(`${role}: ${redactSecrets(text)}`);
+		} catch {}
+		if (messages.length === 0) return null;
+		return messages.join("\n");
+	} catch {
+		return null;
+	}
+}
+/**
+* Reads session conversation with reset fallback and applies reflection capture policy fallback
+* behavior for missing data.
+*/
+async function readSessionConversationWithResetFallback(sessionFilePath, messageCount) {
+	const primary = await readSessionConversationForReflection(sessionFilePath, messageCount);
+	if (primary) return primary;
+	try {
+		const dir = dirname(sessionFilePath);
+		const resetPrefix = `${basename(sessionFilePath)}.reset.`;
+		const latest = (await sortFileNamesByMtimeDesc(dir, (await readdir(dir)).filter((name) => name.startsWith(resetPrefix))))[0];
+		if (latest) return await readSessionConversationForReflection(join(dir, latest), messageCount);
+	} catch {}
+	return primary;
+}
+/**
+* Assembles reflection prompt from validated inputs for deterministic reflection capture policy.
+*
+* Locale-aware: resolves the conversation's locale and dispatches to the
+* matching `i18n/res/<locale>/reflection-prompts.ts` builder.
+*/
+function buildReflectionPrompt(conversation, maxInputChars, toolErrorSignals = []) {
+	const locale = resolveLocale({ text: conversation });
+	return RESOURCES_BY_LOCALE[locale].reflectionPrompts.buildReflectionPrompt(conversation, maxInputChars, toolErrorSignals);
+}
+/**
+* Assembles reflection fallback text from validated inputs for deterministic reflection capture
+* policy.
+*
+* Locale-aware: optional `conversation` text seeds locale resolution; absent
+* input defaults to the system default locale.
+*/
+function buildReflectionFallbackText(conversation = "") {
+	const locale = resolveLocale({ text: conversation });
+	return RESOURCES_BY_LOCALE[locale].reflectionPrompts.buildReflectionFallbackText();
+}
+/** Implements generate reflection text as the local reflection capture policy operation. */
+async function generateReflectionText(params) {
+	const promptInputs = prepareReflectionPromptInputs(params.conversation, params.maxInputChars);
+	if (promptInputs.length === 0) return {
+		text: buildReflectionFallbackText(params.conversation),
+		usedFallback: true,
+		promptHash: sha256Hex(""),
+		error: "empty reflection input"
+	};
+	const prompts = [];
+	const outputs = [];
+	/** Implements on retry log as the local reflection capture policy operation. */
+	const onRetryLog = (level, message) => {
+		if (level === "warn") diagnosticLog.warn("Reflection generation retry reported", { error: message }, {
+			event_name: "memory.daily_log_generator.reflection.generation.retry.reported",
+			file: "packages/memory/src/engine/reflection/daily-log-generator.ts",
+			function: "onRetryLog",
+			site_id: "reflection.daily-log-generator.onRetryLog.b52810f5af"
+		});
+		else diagnosticLog.info("Reflection generation retry reported", { error: message }, {
+			event_name: "memory.daily_log_generator.reflection.generation.retry.reported",
+			file: "packages/memory/src/engine/reflection/daily-log-generator.ts",
+			function: "onRetryLog",
+			site_id: "reflection.daily-log-generator.onRetryLog.977c99d43c"
+		});
+	};
+	for (const promptInput of promptInputs) {
+		const prompt = buildReflectionPrompt(promptInput, params.maxInputChars, params.toolErrorSignals ?? []);
+		prompts.push(prompt);
+		const promptHash = sha256Hex(prompts.join("\n\n--- chunk ---\n\n"));
+		const retryState = { count: 0 };
+		try {
+			const text = await runWithReflectionTransientRetryOnce({
+				scope: "reflection",
+				runner: "embedded",
+				retryState,
+				onLog: onRetryLog,
+				/** Executes the registered command after SDK argument validation and shared safety checks. */
+				execute: async () => params.generate(prompt, params.timeoutMs)
+			});
+			if (text && text.trim().length > 0) {
+				outputs.push(text.trim());
+				continue;
+			}
+		} catch (err) {
+			const errMsg = err instanceof Error ? `${err.name}: ${err.message}` : String(err);
+			diagnosticLog.warn("Reflection generation failed", { error: err }, {
+				event_name: "memory.daily_log_generator.reflection.generation.failed",
+				file: "packages/memory/src/engine/reflection/daily-log-generator.ts",
+				function: "generateReflectionText",
+				site_id: "reflection.daily-log-generator.generateReflectionText.c0c554e65c"
+			});
+			return {
+				text: buildReflectionFallbackText(params.conversation),
+				usedFallback: true,
+				promptHash,
+				error: errMsg
+			};
+		}
+		return {
+			text: buildReflectionFallbackText(params.conversation),
+			usedFallback: true,
+			promptHash,
+			error: "generate returned empty text"
+		};
+	}
+	return {
+		text: outputs.join("\n\n"),
+		usedFallback: false,
+		promptHash: sha256Hex(prompts.join("\n\n--- chunk ---\n\n"))
+	};
+}
+/** Validates daily log file before it enters the reflection capture policy boundary. */
+async function ensureDailyLogFile(dailyPath, dateStr) {
+	const temporaryPath = `${dailyPath}.${randomUUID()}.tmp`;
+	try {
+		await memoryFileWrite(() => writeFile(temporaryPath, `# ${dateStr}\n\n`, {
+			encoding: "utf-8",
+			flag: "wx"
+		}));
+		try {
+			await link(temporaryPath, dailyPath);
+		} catch (error) {
+			if (!(error instanceof Error && "code" in error && error.code === "EEXIST")) throw error;
+		}
+	} finally {
+		await unlink(temporaryPath).catch((error) => {
+			if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
+		});
+	}
+}
+/**
+* Persists reflection to filesystem through the single reflection capture policy write path.
+*/
+async function writeReflectionToFilesystem(params) {
+	const date = new Date(params.nowTs);
+	const dateStr = date.toISOString().split("T")[0] ?? "";
+	const timeHms = date.toISOString().split("T")[1]?.split(".")[0] ?? "";
+	const timeCompact = timeHms.replace(/:/g, "");
+	const body = `${[
+		`# Reflection: ${dateStr} ${timeHms} UTC`,
+		"",
+		`- Session Key: ${params.sessionKey}`,
+		`- Session ID: ${params.sessionId}`,
+		`- Command: ${params.command}`,
+		`- Error Signatures: ${params.toolErrorSignals.length ? params.toolErrorSignals.map((s) => s.signatureHash).join(", ") : "(none)"}`,
+		""
+	].join("\n")}${params.reflectionText.trim()}\n`;
+	const outDir = join(params.workspaceDir, "memory", "reflections", dateStr);
+	checkMemoryOperation();
+	await mkdir(outDir, { recursive: true });
+	const agentToken = sanitizeFileToken(params.agentId, "agent");
+	const sessionToken = sanitizeFileToken(params.sessionId, "session");
+	for (let attempt = 0; attempt < 10; attempt++) {
+		const fileName = `${timeCompact}-${agentToken}-${sessionToken}${attempt === 0 ? "" : `-${Math.random().toString(36).slice(2, 8)}`}.md`;
+		const relPath = join("memory", "reflections", dateStr, fileName);
+		const absPath = join(params.workspaceDir, relPath);
+		try {
+			await memoryFileWrite(() => writeFile(absPath, body, {
+				encoding: "utf-8",
+				flag: "wx"
+			}));
+			const dailyPath = join(params.workspaceDir, "memory", `${dateStr}.md`);
+			await ensureDailyLogFile(dailyPath, dateStr);
+			await memoryFileWrite(() => appendFile(dailyPath, `- [${timeHms} UTC] Reflection generated: \`${relPath}\`\n`, "utf-8"));
+			return relPath;
+		} catch (err) {
+			if (err && typeof err === "object" && "code" in err && err.code === "EEXIST") continue;
+			throw err;
+		}
+	}
+	throw new Error(`Failed to allocate unique reflection file for ${dateStr} ${timeCompact}`);
+}
+//#endregion
+export { generateReflectionText as a, shouldSkipReflectionMessage as c, ensureDailyLogFile as i, writeReflectionToFilesystem as l, buildReflectionFallbackText as n, readSessionConversationForReflection as o, buildReflectionPrompt as r, readSessionConversationWithResetFallback as s, REFLECTION_FALLBACK_MARKER as t, extractTextContent as u };

package/dist/daily-log-generator-CsQPHl4A.d.ts

@@ -0,0 +1,73 @@
+import { t as ReflectionErrorSignal } from "./error-signals-D8_3vYu4.js";
+//#region src/engine/operations/session-summary-storage.d.ts
+/** Extracts text content from raw inputs while tolerating partial data. */
+declare function extractTextContent(content: unknown): string | null;
+//#endregion
+//#region src/engine/reflection/daily-log-generator.d.ts
+declare const REFLECTION_FALLBACK_MARKER = "(fallback) Reflection generation failed; storing minimal pointer only.";
+/**
+ * Tests whether should skip reflection message without mutating reflection capture policy state.
+ */
+declare function shouldSkipReflectionMessage(role: string, text: string): boolean;
+/**
+ * Reads session conversation for reflection and applies reflection capture policy fallback
+ * behavior for missing data.
+ */
+declare function readSessionConversationForReflection(filePath: string, messageCount: number): Promise<string | null>;
+/**
+ * Reads session conversation with reset fallback and applies reflection capture policy fallback
+ * behavior for missing data.
+ */
+declare function readSessionConversationWithResetFallback(sessionFilePath: string, messageCount: number): Promise<string | null>;
+/**
+ * Assembles reflection prompt from validated inputs for deterministic reflection capture policy.
+ *
+ * Locale-aware: resolves the conversation's locale and dispatches to the
+ * matching `i18n/res/<locale>/reflection-prompts.ts` builder.
+ */
+declare function buildReflectionPrompt(conversation: string, maxInputChars: number, toolErrorSignals?: ReflectionErrorSignal[]): string;
+/**
+ * Assembles reflection fallback text from validated inputs for deterministic reflection capture
+ * policy.
+ *
+ * Locale-aware: optional `conversation` text seeds locale resolution; absent
+ * input defaults to the system default locale.
+ */
+declare function buildReflectionFallbackText(conversation?: string): string;
+type ReflectionGenerator = (prompt: string, timeoutMs: number) => Promise<string | null>;
+type ReflectionResult = {
+  text: string;
+  usedFallback: boolean;
+  promptHash: string;
+  error?: string;
+};
+/** Implements generate reflection text as the local reflection capture policy operation. */
+declare function generateReflectionText(params: {
+  conversation: string;
+  maxInputChars: number;
+  timeoutMs: number;
+  toolErrorSignals?: ReflectionErrorSignal[];
+  generate: ReflectionGenerator;
+  logger?: {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+  };
+}): Promise<ReflectionResult>;
+/** Validates daily log file before it enters the reflection capture policy boundary. */
+declare function ensureDailyLogFile(dailyPath: string, dateStr: string): Promise<void>;
+type WriteReflectionFsParams = {
+  workspaceDir: string;
+  reflectionText: string;
+  sessionKey: string;
+  sessionId: string;
+  agentId: string;
+  command: string;
+  toolErrorSignals: ReflectionErrorSignal[];
+  nowTs: number;
+};
+/**
+ * Persists reflection to filesystem through the single reflection capture policy write path.
+ */
+declare function writeReflectionToFilesystem(params: WriteReflectionFsParams): Promise<string>;
+//#endregion
+export { buildReflectionFallbackText as a, generateReflectionText as c, shouldSkipReflectionMessage as d, writeReflectionToFilesystem as f, WriteReflectionFsParams as i, readSessionConversationForReflection as l, ReflectionGenerator as n, buildReflectionPrompt as o, extractTextContent as p, ReflectionResult as r, ensureDailyLogFile as s, REFLECTION_FALLBACK_MARKER as t, readSessionConversationWithResetFallback as u };

package/dist/daily-spend-estimator-DiwzBlo1.d.ts

@@ -0,0 +1,8 @@
+//#region src/engine/operations/daily-spend-estimator.d.ts
+/**
+ * Reads estimated spend today and applies daily spend accounting fallback behavior for missing
+ * data.
+ */
+declare function readEstimatedSpendToday(stateDir: string): Promise<number>;
+//#endregion
+export { readEstimatedSpendToday as t };

package/dist/data-bootstrap-Bl3lthzE.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+//#region src/store/install-manifest.d.ts
+/** Manifest shape, named so the schema can be annotated without restating it. */
+interface InstallManifestShape {
+  schemaVersion: 1;
+  dataFormatVersion: 1;
+  installationId: string;
+  createdAt: string;
+  dbPath: string;
+}
+/** Schema. No `lastSeenVersion` / `lastSeenAt`. */
+declare const InstallManifestSchema: z.ZodType<InstallManifestShape, unknown>;
+type InstallManifest = z.infer<typeof InstallManifestSchema>;
+//#endregion
+//#region src/store/data-bootstrap.d.ts
+interface BootstrapResult {
+  dbPath: string;
+  manifest: InstallManifest;
+  manifestPath: string;
+  dataDir: string;
+}
+/**
+ * Branches:
+ *   1. manifest exists → read + validate.
+ *   2. manifest missing AND data dir contains user data → refuse.
+ *   3. manifest missing, dir empty → fresh install.
+ */
+declare function bootstrapDataLayout(storePath: string): BootstrapResult;
+//#endregion
+export { bootstrapDataLayout as n, BootstrapResult as t };