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

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);
+}

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

@@ -0,0 +1,142 @@
+/**
+ * Pet registry — manifest v2 loading, ported from @linxin666/dsh-pet
+ * registry.ts (trimmed to the sprite2d path this port ships). Pets live as
+ * <petsRoot>/<petId>/{pet.json,spritesheet.webp}; the manifest declares the
+ * 9-track animation contract and sequence playlists.
+ * @module loop-agent/console/chat/pet/pet-registry
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+/** Animation tracks every manifest must provide (Codex 9-row contract). */
+export const PET_TRACK_ORDER = [
+    "idle",
+    "running-right",
+    "running-left",
+    "waving",
+    "jumping",
+    "failed",
+    "waiting",
+    "running",
+    "review",
+];
+function readPositiveInt(value, fallback) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0
+        ? value
+        : fallback;
+}
+function isPetTrackName(name) {
+    return PET_TRACK_ORDER.includes(name);
+}
+/**
+ * Parse + validate one manifest document. Invalid manifests throw with a
+ * descriptive message; the loader skips them (best-effort registry).
+ */
+export function parsePetManifest(raw) {
+    if (typeof raw !== "object" || raw === null) {
+        throw new Error("manifest must be an object");
+    }
+    const doc = raw;
+    if (doc.petManifestVersion !== 2) {
+        throw new Error("petManifestVersion must be 2");
+    }
+    if (typeof doc.id !== "string" || doc.id.trim() === "") {
+        throw new Error("manifest id must be a non-empty string");
+    }
+    if (doc.renderer !== "sprite2d") {
+        throw new Error(`unsupported renderer: ${String(doc.renderer)}`);
+    }
+    const sprite = doc.sprite2d;
+    if (typeof sprite !== "object" || sprite === null) {
+        throw new Error("sprite2d block missing");
+    }
+    const s = sprite;
+    if (typeof s.spritesheetPath !== "string" ||
+        s.spritesheetPath === "" ||
+        !Array.isArray(s.frames) ||
+        s.frames.length !== PET_TRACK_ORDER.length ||
+        !s.frames.every((f) => typeof f === "number" && Number.isInteger(f) && f > 0) ||
+        typeof s.tracks !== "object" ||
+        s.tracks === null) {
+        throw new Error("sprite2d atlas contract violated (frames/tracks)");
+    }
+    const tracks = {};
+    for (const [name, value] of Object.entries(s.tracks)) {
+        if (!isPetTrackName(name))
+            continue;
+        if (typeof value !== "object" || value === null)
+            continue;
+        const durations = value.durations;
+        if (!Array.isArray(durations) ||
+            !durations.every((d) => typeof d === "number" && d > 0)) {
+            continue;
+        }
+        tracks[name] = { durations };
+    }
+    for (const [index, track] of PET_TRACK_ORDER.entries()) {
+        if (tracks[track] === undefined) {
+            throw new Error(`track missing: ${track}`);
+        }
+        if (tracks[track].durations.length !== s.frames[index]) {
+            throw new Error(`track duration count mismatch: ${track}`);
+        }
+    }
+    return {
+        petManifestVersion: 2,
+        id: doc.id,
+        displayName: typeof doc.displayName === "string" && doc.displayName !== ""
+            ? doc.displayName
+            : doc.id,
+        renderer: "sprite2d",
+        ...(typeof doc.description === "string" ? { description: doc.description } : {}),
+        ...(typeof doc.license === "string" ? { license: doc.license } : {}),
+        sprite2d: {
+            spritesheetPath: s.spritesheetPath,
+            cell: {
+                width: readPositiveInt(s.cell?.width, 192),
+                height: readPositiveInt(s.cell?.height, 208),
+            },
+            columns: readPositiveInt(s.columns, 8),
+            atlasRows: readPositiveInt(s.atlasRows, PET_TRACK_ORDER.length),
+            frames: s.frames,
+            tracks,
+        },
+        ...(typeof doc.sequences === "object" && doc.sequences !== null
+            ? { sequences: doc.sequences }
+            : {}),
+    };
+}
+/**
+ * Load the registry from a pets root: every subdirectory carrying a valid
+ * pet.json becomes an entry. Invalid manifests are skipped (best effort).
+ */
+export function loadPetRegistry(petsRoot) {
+    const registry = new Map();
+    let dirents;
+    try {
+        dirents = readDir(petsRoot);
+    }
+    catch {
+        return registry;
+    }
+    for (const dirent of dirents) {
+        if (!dirent.isDirectory())
+            continue;
+        const dir = join(petsRoot, dirent.name);
+        try {
+            const raw = JSON.parse(readFileSync(join(dir, "pet.json"), "utf8"));
+            const manifest = parsePetManifest(raw);
+            if (manifest.id !== dirent.name)
+                continue;
+            registry.set(manifest.id, { manifest, dir });
+        }
+        catch {
+            // Skip invalid pet directories silently (best-effort registry).
+        }
+    }
+    return registry;
+}
+// Node fsdirent read kept behind a tiny seam for testability.
+import { readdirSync } from "node:fs";
+function readDir(path) {
+    return readdirSync(path, { withFileTypes: true });
+}

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

@@ -0,0 +1,48 @@
+/**
+ * Pet remark (reaction copy) library — ported from @linxin666/dsh-pet
+ * remarks.ts. Round-robin pools per event kind; deterministic, no clock.
+ * @module loop-agent/console/chat/pet/pet-remarks
+ */
+export const PET_REMARK_KINDS = [
+    "pet",
+    "petCooldown",
+    "feed",
+    "feedCooldown",
+    "noTreats",
+];
+export const PET_REMARK_LINE_MAX = 120;
+export const PET_REMARK_LINES_MAX = 64;
+export const BUILTIN_PET_REMARKS = {
+    pet: ["尾巴的火苗跳得更欢了！", "小橘灵舒服地眯起眼睛。", "叶子呆毛轻轻晃了晃。", "它用圆圆的脑袋蹭了蹭你。", "小短手开心地拍了拍。", "火苗噼啪一响，精神满满！", "它原地转了个圈。", "伙伴之间就要互相打气！", "小橘灵发出软软的叫声。", "今天也一起加油吧！"],
+    petCooldown: ["刚摸过啦，让它缓一缓。", "火苗还在兴奋地摇晃。", "小橘灵害羞地偏了偏头。", "稍等，它正在整理呆毛。", "十秒后再来摸摸吧。", "它抱住脑袋，表示有点晕。", "先让尾巴的火苗稳定下来。", "小橘灵眨了眨眼。", "不要急，它一直在这里。", "休息一下再继续互动吧。"],
+    feed: ["火苗果真好吃！", "小橘灵满足地拍了拍肚子。", "尾巴的火苗一下子旺了！", "它把火苗果吃得干干净净。", "吃饱以后更有力气啦！", "小橘灵开心地蹦了一下。", "甜甜的火苗果最棒了！", "它眼巴巴地看着下一颗果子。", "能量恢复，准备继续干活！", "小橘灵向你露出大大的笑容。"],
+    feedCooldown: ["已经吃饱啦。", "先消化一下火苗果吧。", "圆肚子暂时装不下了。", "稍后再来喂食。", "它满足地拍了拍嘴角。", "火苗果的能量正在发挥。", "先活动活动再吃下一颗。", "尾巴的火苗已经够旺了。", "小橘灵摇头表示还不饿。", "留一点肚子给下一顿吧。"],
+    noTreats: ["火苗果吃完了，完成任务就能获得更多。", "没有火苗果了，一起去干活吧！", "小橘灵期待着下一份任务奖励。", "先完成一轮任务，再补充火苗果。", "它闻了闻空空的果篮。", "努力干活就会有新的火苗果。", "小橘灵已经准备好出发了。", "下一颗火苗果很快就来。", "先攒任务奖励吧。", "火苗燃起来了，开始下一轮！"],
+};
+export function builtinPetRemark(kind) {
+    return BUILTIN_PET_REMARKS[kind][0];
+}
+/**
+ * Round-robin reaction picker over the effective pools (custom overrides
+ * replace a slot's built-in pool). Counters are per slot so each slot cycles
+ * independently; picks stay deterministic for tests.
+ */
+export class PetRemarkPicker {
+    counters = new Map();
+    pools;
+    constructor(overrides) {
+        this.pools = {};
+        for (const kind of PET_REMARK_KINDS) {
+            const custom = overrides?.[kind];
+            this.pools[kind] =
+                custom !== undefined && custom.length > 0
+                    ? custom
+                    : BUILTIN_PET_REMARKS[kind];
+        }
+    }
+    next(kind, counter) {
+        const pool = this.pools[kind];
+        const index = Math.abs(Math.floor(counter)) % pool.length;
+        return pool[index] ?? builtinPetRemark(kind);
+    }
+}

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

@@ -0,0 +1,125 @@
+/**
+ * Pet HTTP routes — mounts /api/operator/v1/pet/* onto the console
+ * dispatcher. Sprite assets use the Console Vite public /pets/* path.
+ * Adapted from @linxin666/dsh-pet routes.ts.
+ * @module loop-agent/console/chat/pet/pet-routes
+ */
+export const PET_API_PREFIX = "/api/operator/v1/pet";
+function sendJson(res, status, body) {
+    const payload = JSON.stringify(body);
+    res.writeHead(status, {
+        "content-type": "application/json; charset=utf-8",
+        "cache-control": "no-store",
+    });
+    res.end(payload);
+}
+async function readBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        if (chunks.reduce((n, c) => n + c.length, 0) > 1_000_000) {
+            throw new Error("body too large");
+        }
+    }
+    if (chunks.length === 0)
+        return {};
+    const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    if (typeof parsed !== "object" || parsed === null) {
+        throw new Error("body must be an object");
+    }
+    return parsed;
+}
+/**
+ * Try to serve one pet request. Returns true when the pathname was handled.
+ * The dispatcher calls this before its fallthrough so pet paths never hit
+ * the SPA static handler.
+ */
+export async function handlePetRequest(req, res, pathname, service) {
+    const method = (req.method ?? "GET").toUpperCase();
+    if (!pathname.startsWith(PET_API_PREFIX))
+        return false;
+    if (service === undefined) {
+        sendJson(res, 503, { ok: false, error: { code: "PET_DISABLED", message: "pet service unavailable" } });
+        return true;
+    }
+    // --- JSON API ---
+    if (method === "GET" && pathname === PET_API_PREFIX + "/state") {
+        sendJson(res, 200, service.view());
+        return true;
+    }
+    if (method === "POST" && pathname === PET_API_PREFIX + "/interact") {
+        try {
+            const body = await readBody(req);
+            const kind = body.kind === "feed" ? "feed" : body.kind === "pet" ? "pet" : undefined;
+            if (kind === undefined) {
+                sendJson(res, 400, { ok: false, error: { code: "BAD_INTERACTION", message: "kind must be pet or feed" } });
+                return true;
+            }
+            sendJson(res, 200, service.interact(kind));
+        }
+        catch (error) {
+            sendJson(res, 400, { ok: false, error: { code: "BAD_REQUEST", message: error instanceof Error ? error.message : String(error) } });
+        }
+        return true;
+    }
+    if (method === "POST" && pathname === PET_API_PREFIX + "/display") {
+        try {
+            const body = await readBody(req);
+            const display = service.setDisplay({
+                ...(typeof body.visible === "boolean" ? { visible: body.visible } : {}),
+                ...(typeof body.size === "number" ? { size: body.size } : {}),
+                ...(typeof body.right === "number" ? { right: body.right } : {}),
+                ...(typeof body.bottom === "number" ? { bottom: body.bottom } : {}),
+            });
+            sendJson(res, 200, { ok: true, display });
+        }
+        catch (error) {
+            sendJson(res, 400, { ok: false, error: { code: "BAD_REQUEST", message: error instanceof Error ? error.message : String(error) } });
+        }
+        return true;
+    }
+    if (method === "POST" && pathname === PET_API_PREFIX + "/select") {
+        try {
+            const body = await readBody(req);
+            if (typeof body.petId !== "string")
+                throw new Error("petId required");
+            const ok = service.selectPet(body.petId);
+            if (!ok) {
+                sendJson(res, 404, { ok: false, error: { code: "PET_NOT_FOUND", message: "unknown petId" } });
+                return true;
+            }
+            sendJson(res, 200, service.view());
+        }
+        catch (error) {
+            sendJson(res, 400, { ok: false, error: { code: "BAD_REQUEST", message: error instanceof Error ? error.message : String(error) } });
+        }
+        return true;
+    }
+    if (method === "POST" && pathname === PET_API_PREFIX + "/rename") {
+        try {
+            const body = await readBody(req);
+            if (typeof body.name !== "string")
+                throw new Error("name required");
+            sendJson(res, 200, { ok: true, name: service.renamePet(body.name) });
+        }
+        catch (error) {
+            sendJson(res, 400, { ok: false, error: { code: "BAD_REQUEST", message: error instanceof Error ? error.message : String(error) } });
+        }
+        return true;
+    }
+    if (method === "POST" && pathname === PET_API_PREFIX + "/focus") {
+        try {
+            const body = await readBody(req);
+            service.focusSession(typeof body.sessionId === "string" && body.sessionId !== ""
+                ? body.sessionId
+                : undefined);
+            sendJson(res, 200, service.view());
+        }
+        catch (error) {
+            sendJson(res, 400, { ok: false, error: { code: "BAD_REQUEST", message: error instanceof Error ? error.message : String(error) } });
+        }
+        return true;
+    }
+    sendJson(res, 404, { ok: false, error: { code: "PET_ROUTE_NOT_FOUND", message: "unknown pet route" } });
+    return true;
+}

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

@@ -0,0 +1,262 @@
+/**
+ * Pet service — console orchestration half, adapted from @linxin666/dsh-pet
+ * service.ts. Subscribes to the chat event ring, projects turn activity
+ * onto the pet state machine, settles the treat ledger lazily, and serves
+ * the read/interact API the dock UI calls.
+ * @module loop-agent/console/chat/pet/pet-service
+ */
+import { PetStateMachine, } from "./pet-state.js";
+import { applyPetInteraction, applyPetTurnReward, petAffinityViewOf, settlePetTreatGrants, consumePetTreat, } from "./pet-affinity.js";
+import { builtinPetRemark, } from "./pet-remarks.js";
+import { DEFAULT_PET_ID, PET_DISPLAY_INSET_MAX, PET_DISPLAY_SIZE_MAX, PET_DISPLAY_SIZE_MIN, loadPetPersist, savePetPersist, } from "./pet-persist.js";
+const PET_BUBBLE_MAX = 120;
+function bubbleText(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    if (trimmed === "")
+        return undefined;
+    return trimmed.slice(0, PET_BUBBLE_MAX);
+}
+/**
+ * PetService — one instance per workspace context. The active session is the
+ * one the operator last interacted with (prompt/switch); its events drive
+ * the pet. All state is persisted to <dataDir>/pet.json atomically.
+ */
+export class PetService {
+    chatEvents;
+    registry;
+    dataDir;
+    now;
+    machine = new PetStateMachine();
+    persist;
+    unsubscribes = new Set();
+    activeSessionId;
+    lastInteractionBubble;
+    rewardedTurnIds = new Set();
+    constructor(chatEvents, registry, dataDir, now = Date.now) {
+        this.chatEvents = chatEvents;
+        this.registry = registry;
+        this.dataDir = dataDir;
+        this.now = now;
+        this.persist = loadPetPersist(dataDir);
+    }
+    /** Currently selected pet id, clamped to the registry. */
+    selectedPetId() {
+        return this.registry.has(this.persist.petId)
+            ? this.persist.petId
+            : (this.registry.keys().next().value ?? DEFAULT_PET_ID);
+    }
+    petName() {
+        const id = this.selectedPetId();
+        return this.persist.names[id] ?? this.registry.get(id)?.manifest.displayName ?? id;
+    }
+    display() {
+        return { ...this.persist.display };
+    }
+    /** Point the pet at a session (the one the operator is watching). */
+    focusSession(sessionId) {
+        if (this.activeSessionId === sessionId)
+            return;
+        for (const off of this.unsubscribes)
+            off();
+        this.unsubscribes.clear();
+        this.activeSessionId = sessionId;
+        this.rewardedTurnIds.clear();
+        if (sessionId === undefined) {
+            this.machine.onSessionDisposed();
+            return;
+        }
+        this.machine.onSessionActive();
+        // Replay recent history so a refocus lands on the real phase.
+        const recent = this.chatEvents.snapshot(sessionId).slice(-40);
+        for (const event of recent)
+            this.project(event, false);
+        const off = this.chatEvents.subscribe(sessionId, (event) => {
+            this.project(event);
+        });
+        this.unsubscribes.add(off);
+    }
+    /** Project one chat ring event onto the machine (pure dispatch). */
+    project(event, reward = true) {
+        switch (event.kind) {
+            case "agent_start":
+            case "step_start": {
+                this.machine.onActivity({ phase: "thinking" });
+                break;
+            }
+            case "user_message": {
+                this.machine.onActivity({ phase: "waiting" });
+                break;
+            }
+            case "message_update":
+            case "message_end": {
+                // Assistant text landing: short ack reads as thinking (more
+                // work may follow), a substantive reply reads as review.
+                const data = event.data;
+                const text = typeof data.text === "string" ? data.text : "";
+                this.machine.onActivity({
+                    phase: text.length > 80 ? "review" : "thinking",
+                });
+                break;
+            }
+            case "tool_call": {
+                const data = event.data;
+                const toolName = typeof data.toolName === "string" && data.toolName !== ""
+                    ? data.toolName
+                    : "工具";
+                this.machine.onActivity({
+                    phase: "tool",
+                    line: `${toolName} 进行中`,
+                });
+                break;
+            }
+            case "tool_result": {
+                const data = event.data;
+                const failed = data.isError === true;
+                const toolName = typeof data.toolName === "string" && data.toolName !== ""
+                    ? data.toolName
+                    : "工具";
+                this.machine.onActivity(failed
+                    ? { phase: "failed", line: `${toolName} 出错了` }
+                    : { phase: "tool", line: `${toolName} 完成` });
+                break;
+            }
+            case "agent_end":
+            case "agent_settled": {
+                // A settled agent turn: reward exactly once even when both lifecycle
+                // events are present in the durable ring.
+                if (reward && !this.rewardedTurnIds.has(event.turnId)) {
+                    this.rewardedTurnIds.add(event.turnId);
+                    this.persist.affinity = applyPetTurnReward(this.persist.affinity);
+                    this.save();
+                }
+                this.machine.onActivity({ phase: "done" });
+                break;
+            }
+            case "turn_error":
+            case "turn_max_tokens":
+            case "model_retry": {
+                this.machine.onActivity({ phase: "failed" });
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    /** Full read view (settles treats lazily first). */
+    view() {
+        const settle = settlePetTreatGrants(this.persist.treats, this.persist.affinity.turns, this.now());
+        if (settle.ledger !== this.persist.treats) {
+            this.persist.treats = settle.ledger;
+            this.save();
+        }
+        const state = this.machine.render();
+        const bubble = this.lastInteractionBubble !== undefined &&
+            this.now() - this.lastInteractionBubble.at < 4000
+            ? this.lastInteractionBubble.text
+            : undefined;
+        return {
+            ok: true,
+            sessionActive: state.sessionActive,
+            state: bubble === undefined ? state : { ...state, bubble },
+            affinity: petAffinityViewOf(this.persist.affinity, this.now()),
+            treats: this.persist.treats.treats,
+            petId: this.selectedPetId(),
+            petName: this.petName(),
+            display: this.display(),
+            pets: [...this.registry.entries()].map(([id, entry]) => ({
+                id,
+                displayName: entry.manifest.displayName,
+            })),
+        };
+    }
+    /** One user interaction (pet/feed). */
+    interact(kind) {
+        let reaction;
+        let delta = 0;
+        let accepted = false;
+        if (kind === "feed") {
+            const consume = consumePetTreat(this.persist.treats);
+            if (!consume.ok) {
+                reaction = builtinPetRemark("noTreats");
+            }
+            else {
+                this.persist.treats = consume.ledger;
+                const outcome = applyPetInteraction(this.persist.affinity, "feed", this.now());
+                this.persist.affinity = outcome.affinity;
+                delta = outcome.delta;
+                accepted = outcome.accepted;
+                reaction = outcome.reaction;
+            }
+        }
+        else {
+            const outcome = applyPetInteraction(this.persist.affinity, "pet", this.now());
+            this.persist.affinity = outcome.affinity;
+            delta = outcome.delta;
+            accepted = outcome.accepted;
+            reaction = outcome.reaction;
+        }
+        this.lastInteractionBubble = { text: reaction, at: this.now() };
+        this.save();
+        return {
+            ok: true,
+            reaction,
+            delta,
+            accepted,
+            affinity: petAffinityViewOf(this.persist.affinity, this.now()),
+            treats: this.persist.treats.treats,
+        };
+    }
+    /** Update display config (clamped) and persist. */
+    setDisplay(patch) {
+        const current = this.persist.display;
+        const next = {
+            visible: typeof patch.visible === "boolean"
+                ? patch.visible
+                : current.visible,
+            size: Math.round(Math.min(PET_DISPLAY_SIZE_MAX, Math.max(PET_DISPLAY_SIZE_MIN, typeof patch.size === "number" && Number.isFinite(patch.size)
+                ? patch.size
+                : current.size))),
+            right: Math.round(Math.min(PET_DISPLAY_INSET_MAX, Math.max(0, typeof patch.right === "number" && Number.isFinite(patch.right)
+                ? patch.right
+                : current.right))),
+            bottom: Math.round(Math.min(PET_DISPLAY_INSET_MAX, Math.max(0, typeof patch.bottom === "number" && Number.isFinite(patch.bottom)
+                ? patch.bottom
+                : current.bottom))),
+        };
+        this.persist.display = next;
+        this.save();
+        return { ...next };
+    }
+    /** Select another pet from the registry. */
+    selectPet(petId) {
+        if (!this.registry.has(petId))
+            return false;
+        this.persist.petId = petId;
+        this.save();
+        return true;
+    }
+    /** Rename the selected pet (persisted per-pet). */
+    renamePet(name) {
+        const trimmed = name.trim().slice(0, 20);
+        if (trimmed === "")
+            return this.petName();
+        this.persist.names[this.selectedPetId()] = trimmed;
+        this.save();
+        return trimmed;
+    }
+    save() {
+        try {
+            savePetPersist(this.persist, this.dataDir);
+        }
+        catch {
+            // Persist failures never break the pet runtime.
+        }
+    }
+    dispose() {
+        for (const off of this.unsubscribes)
+            off();
+        this.unsubscribes.clear();
+    }
+}