@tea-agent/loop-agent 0.44.0-next.12 → 0.44.0-next.14

package/dist/worker/console/chat/browser-storage.js

@@ -0,0 +1,89 @@
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { mkdir, open, realpath, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+const stateSchema = z.object({
+    cookies: z.array(z.object({
+        name: z.string().min(1), value: z.string(), domain: z.string().min(1),
+        path: z.string().startsWith("/"), expires: z.number().finite(),
+        httpOnly: z.boolean(), secure: z.boolean(), sameSite: z.enum(["Strict", "Lax", "None"]),
+        partitionKey: z.string().optional(),
+    }).strict()).max(3000),
+    origins: z.array(z.object({
+        origin: z.string().refine((value) => {
+            try {
+                const url = new URL(value);
+                return ["http:", "https:"].includes(url.protocol) && url.origin === value;
+            }
+            catch {
+                return false;
+            }
+        }),
+        localStorage: z.array(z.object({ name: z.string(), value: z.string() }).strict()).max(10000),
+    }).strict()).max(100),
+}).strict();
+export async function exportBrowserStorage(context, directory) {
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const state = await context.storageState();
+    const target = path.join(directory, `${randomUUID()}.json`);
+    const temporary = `${target}.tmp`;
+    try {
+        await writeFile(temporary, JSON.stringify(state), { mode: 0o600, flag: "wx" });
+        await rename(temporary, target);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+    return { path: target, cookieCount: state.cookies.length, origins: state.origins.map((entry) => entry.origin), scope: "cookies+localStorage", excluded: ["sessionStorage", "IndexedDB", "OPFS", "credentials"] };
+}
+/** Parse and validate fully before obtaining or mutating a browser context. */
+export async function readBrowserStorage(filename, directory) {
+    const root = await realpath(directory);
+    const parent = await realpath(path.dirname(path.resolve(filename)));
+    const target = path.join(parent, path.basename(filename));
+    if (parent !== root || path.extname(target) !== ".json")
+        throw new Error("storage import requires a JSON file directly in the browser storage directory");
+    const handle = await open(target, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const stat = await handle.stat();
+        if (!stat.isFile() || stat.size > 5 * 1024 * 1024)
+            throw new Error("storage file must be regular and at most 5 MiB");
+        const raw = await handle.readFile("utf8");
+        try {
+            return stateSchema.parse(JSON.parse(raw));
+        }
+        catch {
+            throw new Error("invalid storage state: only cookies and http(s) origin localStorage are supported");
+        }
+    }
+    finally {
+        await handle.close();
+    }
+}
+export async function mergeBrowserStorage(context, state) {
+    // A temporary routed document writes only listed keys, without running the site's application.
+    const page = await context.newPage();
+    let cdp;
+    try {
+        cdp = await context.newCDPSession(page);
+        // page.route alone does not intercept a response supplied by an installed service worker.
+        await cdp.send("Network.enable");
+        await cdp.send("Network.setBypassServiceWorker", { bypass: true });
+        await page.route("**/*", (route) => route.fulfill({ status: 200, contentType: "text/html", body: "<!doctype html><title>Import login state</title>" }));
+        await context.addCookies(state.cookies);
+        for (const entry of state.origins) {
+            await page.goto(entry.origin, { waitUntil: "domcontentloaded", timeout: 10_000 });
+            await page.evaluate((items) => { for (const item of items)
+                localStorage.setItem(item.name, item.value); }, entry.localStorage);
+        }
+    }
+    catch (cause) {
+        throw new Error("storage merge failed; some entries may have been applied, inspect state before retrying", { cause });
+    }
+    finally {
+        await cdp?.detach().catch(() => undefined);
+        await page.close();
+    }
+    return { mode: "merge", cookieCount: state.cookies.length, origins: state.origins.map((entry) => entry.origin), reloadRequired: true };
+}

package/dist/worker/console/chat/chat-event-store.js

@@ -502,8 +502,8 @@ const DEFAULT_PERSIST_DEBOUNCE_MS = 250;
  *  interim flush is forced, so a fast stream never widens the loss window
  *  unboundedly even if the `at` clock stalls. */
 const DEFAULT_PERSIST_MAX_PENDING_UPDATES = 250;
-/** Conservative per-event scale for the byte pre-check gate (UTF-8 multibyte ≤ 4 bytes/char × pretty-print expansion). */
-const BYTE_GATE_SCALE = 12;
+/** Conservative per-event scale for the byte pre-check gate (UTF-8 multibyte ≤ 4 bytes/char). Persist is compact JSON, so this is no longer multiplied by pretty-print expansion. */
+const BYTE_GATE_SCALE = 4;
 /** Fixed envelope slack (schema keys, turnCount, nextSeq, minSeq, turns) for the byte pre-check gate. */
 const BYTE_GATE_SLACK = 8192;
 /** Legacy epoch for event files written before M5.1 (no epoch field). */
@@ -704,7 +704,8 @@ export function createChatEventStore(options) {
     const maxBytes = options?.maxBytesPerSession ?? DEFAULT_MAX_BYTES;
     const coalesceWindowMs = options?.coalesceWindowMs ?? DEFAULT_COALESCE_WINDOW_MS;
     const eventEpoch = options?.epoch?.trim() || LEGACY_EPOCH;
-    const persistWriter = options?.persistWriter ?? writeSecureJsonSync;
+    const persistWriter = options?.persistWriter ??
+        ((file, payload) => writeSecureJsonSync(file, payload, { pretty: false }));
     const persistDebounceMs = options?.persistDebounceMs ?? DEFAULT_PERSIST_DEBOUNCE_MS;
     const persistMaxPendingUpdates = options?.persistMaxPendingUpdates ?? DEFAULT_PERSIST_MAX_PENDING_UPDATES;
     const persistenceDir = options?.appData?.chatEvents
@@ -807,10 +808,10 @@ export function createChatEventStore(options) {
             epoch: ring.epoch,
         };
     }
-    /** Serialized exactly as `writeSecureJsonSync` writes it, so byte accounting
-     *  (D4) and the on-disk bytes use the same formatting. */
+    /** Serialized exactly as compact `writeSecureJsonSync` writes it, so byte
+     *  accounting (D4) and the on-disk bytes use the same formatting. */
     function serializeRingForPersist(sessionId, ring) {
-        return `${JSON.stringify(ringPayload(sessionId, ring), null, 2)}\n`;
+        return `${JSON.stringify(ringPayload(sessionId, ring))}\n`;
     }
     function bytesOfRing(sessionId, ring) {
         return Buffer.byteLength(serializeRingForPersist(sessionId, ring), "utf8");

package/dist/worker/console/chat/context-insights.js

@@ -261,6 +261,52 @@ export function deriveContextInsights(events, options = {}) {
     const browserMessages = [];
     const browserInjected = [];
     const browserToolResults = [];
+    const liveNodes = [];
+    /** Nodes removed by a prune/compaction, newest last, for the prune card. */
+    const archivedNodes = [];
+    /** Remove the ledger nodes whose seq the removal claims; deduct slices and browser rows. */
+    function claimNodes(claimed, removedAtSeq) {
+        if (claimed.size === 0)
+            return [];
+        const removedIds = [];
+        const kept = [];
+        for (const node of liveNodes) {
+            if (claimed.has(node.seq)) {
+                const slice = sliceOf(composition, node.category);
+                slice.tokens = Math.max(0, slice.tokens - node.tokens);
+                slice.items = Math.max(0, slice.items - 1);
+                archivedNodes.push({ ...node, removedAt: removedAtSeq });
+                removedIds.push(node.element.id);
+            }
+            else {
+                kept.push(node);
+            }
+        }
+        if (removedIds.length > 0) {
+            liveNodes.length = 0;
+            liveNodes.push(...kept);
+            const drop = (list) => {
+                for (let i = list.length - 1; i >= 0; i -= 1) {
+                    const row = list[i];
+                    if (row && claimed.has(row.seq))
+                        list.splice(i, 1);
+                }
+            };
+            drop(browserMessages);
+            drop(browserToolResults);
+            drop(browserInjected);
+        }
+        return removedIds;
+    }
+    /** Parse "<sessionId>:<seq>" entry ids into a keep-from seq anchor. */
+    function entrySeqOf(entryId) {
+        if (typeof entryId !== "string" || !entryId)
+            return undefined;
+        const idx = entryId.lastIndexOf(":");
+        const tail = idx >= 0 ? entryId.slice(idx + 1) : entryId;
+        const seq = Number.parseInt(tail, 10);
+        return Number.isInteger(seq) && seq >= 0 ? seq : undefined;
+    }
     if (options.systemPromptPreview) {
         addSlice(composition, "system", estimateTokensFromText(options.systemPromptPreview));
     }
@@ -306,14 +352,16 @@ export function deriveContextInsights(events, options = {}) {
                 if (text) {
                     const tokens = estimateTokensFromText(text);
                     addSlice(composition, "user", tokens);
-                    browserMessages.push({
+                    const element = {
                         id: `user:${event.seq}`,
                         label: "用户",
                         tokens,
                         preview: text,
                         seq: event.seq,
                         at: event.at,
-                    });
+                    };
+                    browserMessages.push(element);
+                    liveNodes.push({ seq: event.seq, tokens, category: "user", element });
                     if (!turnUserBrief.has(event.turnId)) {
                         turnUserBrief.set(event.turnId, text.slice(0, 200));
                     }
@@ -338,14 +386,16 @@ export function deriveContextInsights(events, options = {}) {
                     if (text) {
                         const tokens = estimateTokensFromText(text);
                         addSlice(composition, "assistant", tokens);
-                        browserMessages.push({
+                        const element = {
                             id: `assistant:${event.seq}`,
                             label: thinking ? "助手（含思考）" : "助手",
                             tokens,
                             preview: text,
                             seq: event.seq,
                             at: event.at,
-                        });
+                        };
+                        browserMessages.push(element);
+                        liveNodes.push({ seq: event.seq, tokens, category: "assistant", element });
                     }
                     const toolsCalled = stepToolsCalled.get(event.turnId) ?? [];
                     const recorded = asRecord(data.timing);
@@ -474,7 +524,7 @@ export function deriveContextInsights(events, options = {}) {
                 if (resultPreview) {
                     const tokens = estimateTokensFromText(resultPreview);
                     addSlice(composition, "toolResults", tokens);
-                    browserToolResults.push({
+                    const element = {
                         id: `result:${event.seq}`,
                         label: typeof data.toolName === "string" && data.toolName
                             ? data.toolName
@@ -484,7 +534,9 @@ export function deriveContextInsights(events, options = {}) {
                         status: data.isError === true ? "error" : "ok",
                         seq: event.seq,
                         at: event.at,
-                    });
+                    };
+                    browserToolResults.push(element);
+                    liveNodes.push({ seq: event.seq, tokens, category: "toolResults", element });
                 }
                 break;
             }
@@ -531,6 +583,30 @@ export function deriveContextInsights(events, options = {}) {
                 const after = num(data.estimatedTokensAfter);
                 const reclaimed = before !== undefined && after !== undefined ? before - after : null;
                 const pruned = data.pruned === true || data.kind === "prune";
+                // --- Exact removal (dsh-context parity) ---
+                // A prune/compaction claims live nodes either by explicit seq list
+                // (shadowedSeqs) or by a keep-from anchor (firstKeptEntryId = the
+                // first ring entry that survives). Claim exactly those nodes from
+                // the ledger: deduct slices, drop browser rows, archive the nodes.
+                const explicitSeqs = Array.isArray(data.shadowedSeqs)
+                    ? data.shadowedSeqs.filter((value) => typeof value === "number" && Number.isInteger(value) && value >= 0)
+                    : undefined;
+                const keepFromSeq = entrySeqOf(data.firstKeptEntryId);
+                let removedIds = [];
+                let removalBasis;
+                if (explicitSeqs && explicitSeqs.length > 0) {
+                    removedIds = claimNodes(new Set(explicitSeqs), event.seq);
+                    removalBasis = "seqs";
+                }
+                else if (keepFromSeq !== undefined && liveNodes.length > 0) {
+                    const rangeSeqs = new Set();
+                    for (const node of liveNodes) {
+                        if (node.seq < keepFromSeq)
+                            rangeSeqs.add(node.seq);
+                    }
+                    removedIds = claimNodes(rangeSeqs, event.seq);
+                    removalBasis = "range";
+                }
                 contextEvents.push({
                     seq: event.seq,
                     at: event.at,
@@ -548,25 +624,14 @@ export function deriveContextInsights(events, options = {}) {
                     ...(Array.isArray(data.shadowedSeqs) ? { shadowedItems: data.shadowedSeqs.length } : {}),
                     ...(typeof data.reason === "string" ? { reason: data.reason } : {}),
                     ...(pruned ? { pruned: true } : {}),
+                    ...(removedIds.length > 0 ? { removedIds } : {}),
+                    ...(removalBasis !== undefined ? { removalBasis } : {}),
                     detail: boundedText(asRecord(data.details)?.text, 300),
                 });
                 const lastStep = trend.at(-1);
                 if (lastStep && event.kind !== "compaction_start") {
                     lastStep.eventMark = pruned ? "prune" : "compact";
                 }
-                if (reclaimed !== null && reclaimed > 0) {
-                    const userSlice = sliceOf(composition, "user");
-                    const assistantSlice = sliceOf(composition, "assistant");
-                    const toolSlice = sliceOf(composition, "toolResults");
-                    let remaining = reclaimed;
-                    for (const slice of [userSlice, assistantSlice, toolSlice]) {
-                        const take = Math.min(slice.tokens, remaining);
-                        slice.tokens -= take;
-                        remaining -= take;
-                        if (remaining <= 0)
-                            break;
-                    }
-                }
                 break;
             }
             default:

package/dist/worker/console/chat/pet/pet-affinity.js

@@ -0,0 +1,169 @@
+/**
+ * Pet affinity + treat economy — ported from @linxin666/dsh-pet
+ * affinity.ts + treats.ts. Pure, clock-injected; persistence lives in the
+ * service. Ranks use plain ASCII glyphs (repo bans emoji characters).
+ * @module loop-agent/console/chat/pet/pet-affinity
+ */
+import { BUILTIN_PET_REMARKS, builtinPetRemark, } from "./pet-remarks.js";
+export const PET_AFFINITY_MAX = 999_999_999;
+export const PET_AFFINITY_RANKS = [
+    { min: 0, name: "一粒火星", glyph: "*" },
+    { min: 25, name: "小火苗", glyph: "**" },
+    { min: 50, name: "炉边伙伴", glyph: "***" },
+    { min: 80, name: "炽热搭档", glyph: "****" },
+    { min: 200, name: "烈焰挚友", glyph: "*****" },
+    { min: 500, name: "篝火达人", glyph: "******" },
+    { min: 2_000, name: "火焰大师", glyph: "*******" },
+    { min: 10_000, name: "燎原之势", glyph: "********" },
+    { min: 100_000, name: "恒星之火", glyph: "*********" },
+];
+export const defaultPetAffinityConfig = {
+    turnReward: 1,
+    petReward: 1,
+    petCooldownMs: 10_000,
+    feedReward: 5,
+    feedCooldownMs: 30_000,
+};
+export function emptyPetAffinity() {
+    return {
+        points: 0,
+        lastPetAt: 0,
+        lastFeedAt: 0,
+        pets: 0,
+        feeds: 0,
+        petRejects: 0,
+        feedRejects: 0,
+        turns: 0,
+    };
+}
+export function petRankOf(points) {
+    let rank = PET_AFFINITY_RANKS[0];
+    for (const candidate of PET_AFFINITY_RANKS) {
+        if (points >= candidate.min)
+            rank = candidate;
+    }
+    return rank;
+}
+export function petAffinityViewOf(state, nowMs, config = defaultPetAffinityConfig) {
+    const rank = petRankOf(state.points);
+    return {
+        points: state.points,
+        rank: rank.name,
+        rankGlyph: rank.glyph,
+        pets: state.pets,
+        feeds: state.feeds,
+        turns: state.turns,
+        petCooldown: nowMs - state.lastPetAt < config.petCooldownMs,
+        feedCooldown: nowMs - state.lastFeedAt < config.feedCooldownMs,
+    };
+}
+function clampPoints(points) {
+    return Math.min(PET_AFFINITY_MAX, Math.max(0, points));
+}
+/** Deterministic round-robin reaction from a persisted counter. */
+function countedRemark(kind, count) {
+    const pool = BUILTIN_PET_REMARKS[kind];
+    return pool[Math.max(0, Math.floor(count)) % pool.length] ?? builtinPetRemark(kind);
+}
+/**
+ * Apply one interaction to a copy of the state. Cooldowns only apply once
+ * the pet has been interacted with at least once (last*At === 0 = never).
+ */
+export function applyPetInteraction(state, kind, nowMs, config = defaultPetAffinityConfig) {
+    const next = { ...state };
+    if (kind === "pet") {
+        if (state.lastPetAt !== 0 &&
+            nowMs - state.lastPetAt < config.petCooldownMs) {
+            next.petRejects += 1;
+            return {
+                affinity: next,
+                delta: 0,
+                reaction: countedRemark("petCooldown", state.petRejects),
+                accepted: false,
+            };
+        }
+        next.lastPetAt = nowMs;
+        next.pets += 1;
+        next.points = clampPoints(state.points + config.petReward);
+        return {
+            affinity: next,
+            delta: config.petReward,
+            reaction: countedRemark("pet", state.pets),
+            accepted: true,
+        };
+    }
+    if (kind === "feed") {
+        if (state.lastFeedAt !== 0 &&
+            nowMs - state.lastFeedAt < config.feedCooldownMs) {
+            next.feedRejects += 1;
+            return {
+                affinity: next,
+                delta: 0,
+                reaction: countedRemark("feedCooldown", state.feedRejects),
+                accepted: false,
+            };
+        }
+        next.lastFeedAt = nowMs;
+        next.feeds += 1;
+        next.points = clampPoints(state.points + config.feedReward);
+        return {
+            affinity: next,
+            delta: config.feedReward,
+            reaction: countedRemark("feed", state.feeds),
+            accepted: true,
+        };
+    }
+    return { affinity: state, delta: 0, reaction: "", accepted: false };
+}
+/** Reward one completed turn (host calls this on phase done). */
+export function applyPetTurnReward(state, config = defaultPetAffinityConfig) {
+    const next = { ...state };
+    next.turns += 1;
+    next.points = clampPoints(state.points + config.turnReward);
+    return next;
+}
+export const defaultPetTreatConfig = {
+    turnsPerTreat: 30,
+    timeTreatMs: 300 * 60_000,
+    maxTreats: 20,
+};
+export function emptyPetTreatLedger() {
+    return { treats: 0, lastTreatGrantAt: 0, turnsAtLastTreatGrant: 0 };
+}
+function capTreats(treats, max) {
+    return Math.min(max, Math.max(0, treats));
+}
+/**
+ * Settle treat grants from both sources (work output + wall-clock time).
+ * Lazy settlement from persisted anchors — no timer, no drift. A zero-gain
+ * first settlement still writes the time anchor so the clock can start.
+ */
+export function settlePetTreatGrants(ledger, turns, nowMs, config = defaultPetTreatConfig) {
+    const turnDelta = Math.max(0, turns - ledger.turnsAtLastTreatGrant);
+    const workGrants = Math.floor(turnDelta / config.turnsPerTreat);
+    const timeAnchor = ledger.lastTreatGrantAt === 0 ? nowMs : ledger.lastTreatGrantAt;
+    const timeGrants = Math.floor(Math.max(0, nowMs - timeAnchor) / config.timeTreatMs);
+    const gained = workGrants + timeGrants;
+    if (gained <= 0) {
+        if (ledger.lastTreatGrantAt === 0) {
+            return { ledger: { ...ledger, lastTreatGrantAt: nowMs }, gained: 0 };
+        }
+        return { ledger, gained: 0 };
+    }
+    return {
+        ledger: {
+            treats: capTreats(ledger.treats + gained, config.maxTreats),
+            lastTreatGrantAt: timeGrants > 0 ? timeAnchor + timeGrants * config.timeTreatMs : timeAnchor,
+            turnsAtLastTreatGrant: workGrants > 0
+                ? turns - (turnDelta % config.turnsPerTreat)
+                : ledger.turnsAtLastTreatGrant,
+        },
+        gained,
+    };
+}
+/** Consume one treat for a feed; refuses when the stock is empty. */
+export function consumePetTreat(ledger) {
+    if (ledger.treats <= 0)
+        return { ok: false };
+    return { ok: true, ledger: { ...ledger, treats: ledger.treats - 1 } };
+}

package/dist/worker/console/chat/pet/pet-persist.js

@@ -0,0 +1,109 @@
+/**
+ * Pet persistence — ported from @linxin666/dsh-pet persist.ts, retargeted
+ * from $DSH_HOME to the console data directory. One JSON file, atomic
+ * rename write, tolerant read (corrupt file falls back to defaults).
+ * @module loop-agent/console/chat/pet/pet-persist
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { PET_AFFINITY_MAX, emptyPetAffinity, } from "./pet-affinity.js";
+import { defaultPetTreatConfig, emptyPetTreatLedger, } from "./pet-affinity.js";
+export const DEFAULT_PET_ID = "ember";
+export const DEFAULT_PET_NAME = "小橘灵";
+export const defaultPetDisplayConfig = {
+    visible: false,
+    size: 160,
+    right: 24,
+    bottom: 120,
+};
+export const PET_DISPLAY_SIZE_MIN = 32;
+export const PET_DISPLAY_SIZE_MAX = 1024;
+export const PET_DISPLAY_INSET_MAX = 10_000;
+export const PET_NAME_MAX_LENGTH = 20;
+export function emptyPetPersist() {
+    return {
+        petPersistVersion: 2,
+        petId: DEFAULT_PET_ID,
+        names: {},
+        affinity: emptyPetAffinity(),
+        treats: emptyPetTreatLedger(),
+        display: { ...defaultPetDisplayConfig },
+    };
+}
+function finiteNum(value, fallback) {
+    return typeof value === "number" && Number.isFinite(value)
+        ? value
+        : fallback;
+}
+function clamp(value, max) {
+    return Math.min(max, Math.max(0, value));
+}
+function loadPetNames(parsed) {
+    const names = {};
+    if (typeof parsed.names !== "object" || parsed.names === null)
+        return names;
+    for (const [id, value] of Object.entries(parsed.names)) {
+        if (id === "" || typeof value !== "string")
+            continue;
+        const name = value.trim();
+        if (name === "")
+            continue;
+        names[id] = name.slice(0, PET_NAME_MAX_LENGTH);
+    }
+    return names;
+}
+/** Load persisted state; missing or corrupt files fall back to defaults. */
+export function loadPetPersist(dir) {
+    try {
+        const raw = readFileSync(join(dir, "pet.json"), "utf8");
+        const parsed = JSON.parse(raw);
+        const base = emptyPetPersist();
+        const rawAffinity = (parsed.affinity ?? {});
+        const affinity = {
+            points: clamp(finiteNum(rawAffinity.points, 0), PET_AFFINITY_MAX),
+            lastPetAt: clamp(finiteNum(rawAffinity.lastPetAt, 0), Number.MAX_SAFE_INTEGER),
+            lastFeedAt: clamp(finiteNum(rawAffinity.lastFeedAt, 0), Number.MAX_SAFE_INTEGER),
+            pets: clamp(finiteNum(rawAffinity.pets, 0), Number.MAX_SAFE_INTEGER),
+            feeds: clamp(finiteNum(rawAffinity.feeds, 0), Number.MAX_SAFE_INTEGER),
+            petRejects: clamp(finiteNum(rawAffinity.petRejects, 0), Number.MAX_SAFE_INTEGER),
+            feedRejects: clamp(finiteNum(rawAffinity.feedRejects, 0), Number.MAX_SAFE_INTEGER),
+            turns: clamp(finiteNum(rawAffinity.turns, 0), Number.MAX_SAFE_INTEGER),
+        };
+        const rawTreats = (parsed.treats ?? {});
+        const treats = {
+            treats: clamp(finiteNum(rawTreats.treats, 0), defaultPetTreatConfig.maxTreats),
+            lastTreatGrantAt: clamp(finiteNum(rawTreats.lastTreatGrantAt, 0), Number.MAX_SAFE_INTEGER),
+            turnsAtLastTreatGrant: clamp(finiteNum(rawTreats.turnsAtLastTreatGrant, 0), Number.MAX_SAFE_INTEGER),
+        };
+        const rawDisplay = (parsed.display ?? {});
+        const display = {
+            visible: parsed.petPersistVersion === 2 && typeof rawDisplay.visible === "boolean"
+                ? rawDisplay.visible
+                : base.display.visible,
+            size: Math.round(Math.min(PET_DISPLAY_SIZE_MAX, Math.max(PET_DISPLAY_SIZE_MIN, finiteNum(rawDisplay.size, base.display.size)))),
+            right: Math.round(clamp(finiteNum(rawDisplay.right, base.display.right), PET_DISPLAY_INSET_MAX)),
+            bottom: Math.round(clamp(finiteNum(rawDisplay.bottom, base.display.bottom), PET_DISPLAY_INSET_MAX)),
+        };
+        const petId = typeof parsed.petId === "string" && parsed.petId.trim() !== ""
+            ? parsed.petId.trim()
+            : base.petId;
+        const names = loadPetNames(parsed);
+        if (typeof parsed.name === "string" &&
+            parsed.name.trim() !== "" &&
+            names[petId] === undefined) {
+            names[petId] = parsed.name.trim().slice(0, PET_NAME_MAX_LENGTH);
+        }
+        return { petPersistVersion: 2, petId, names, affinity, treats, display };
+    }
+    catch {
+        return emptyPetPersist();
+    }
+}
+/** Atomically persist state (write temp + rename). */
+export function savePetPersist(data, dir) {
+    mkdirSync(dir, { recursive: true });
+    const target = join(dir, "pet.json");
+    const tmp = `${target}.tmp`;
+    writeFileSync(tmp, JSON.stringify(data, null, 2), "utf8");
+    renameSync(tmp, target);
+}