qlogicagent 2.13.4 → 2.13.5

package/dist/runtime/pet/pet-profile-service.d.ts

@@ -0,0 +1,91 @@
+import type { PetdexAnimation, PetdexAnimationId } from "@xiaozhiclaw/pet-core";
+import type { PetSoul } from "./pet-types.js";
+export interface PetPreferences {
+    enabled: boolean;
+    selectedPetAssetId: string;
+}
+export interface PetdexPetAssetSummary {
+    id: string;
+    assetKind: "petdex";
+    sourceKind?: "builtin" | "upload" | "forge";
+    name: string;
+    description: string;
+    createdAt: string;
+    updatedAt: string;
+    atlas: PetdexPetAssetSummaryAtlas;
+    animations?: Record<PetdexAnimationId, PetdexPetAnimation>;
+    thumbnail?: {
+        frame: number;
+    };
+}
+export interface PetdexPetAssetSummaryAtlas {
+    format: "webp";
+    columns: 8;
+    rows: 9;
+    frameCount: 72;
+    cellWidth: 192;
+    cellHeight: 208;
+    width: 1536;
+    height: 1872;
+    sha256: string;
+}
+export interface PetdexPetAssetAtlas extends PetdexPetAssetSummaryAtlas {
+    image: "spritesheet.webp";
+}
+/** Re-uses the pet-core contract animation shape (row + per-frame durations, Codex-aligned). */
+export type PetdexPetAnimation = PetdexAnimation;
+export interface PetdexPetAsset extends Omit<PetdexPetAssetSummary, "atlas"> {
+    schema: "qlogic.petdex.asset.v1";
+    atlas: PetdexPetAssetAtlas;
+    source: {
+        kind: "builtin" | "upload" | "forge";
+        prompt: string | null;
+    };
+    animations: Record<PetdexAnimationId, PetdexPetAnimation>;
+    thumbnail: {
+        frame: number;
+    };
+}
+export interface JourneySnapshot {
+    date: string;
+    day: number;
+    petName: string;
+    stateLabel: string;
+    entries: Array<Record<string, unknown>>;
+}
+export interface PetProfile {
+    version: 1;
+    ownerUserId: string;
+    soul: PetSoul | null;
+    preferences: PetPreferences;
+    customPets: PetdexPetAssetSummary[];
+    journeyDates: string[];
+    updatedAt: string;
+}
+export declare class PetProfileService {
+    private readonly ownerUserId;
+    private readonly petDir;
+    private readonly profilePath;
+    constructor(ownerUserId: string);
+    loadProfile(): PetProfile;
+    updateSoul(soul: PetSoul | null): PetProfile;
+    updatePreferences(update: Partial<PetPreferences>): PetProfile;
+    saveJourneySnapshot(snapshot: JourneySnapshot): PetProfile;
+    listJourneyDates(): string[];
+    getJourneySnapshot(date: string): JourneySnapshot | null;
+    upsertCustomPet(pet: PetdexPetAsset): PetProfile;
+    deleteCustomPet(id: string): PetProfile;
+    listCustomPets(): PetdexPetAssetSummary[];
+    getCustomPet(id: string): PetdexPetAsset | null;
+    getCustomPetSpritesheet(id: string): Buffer | null;
+    findReusableCustomPetId(params: {
+        sourceKind: "upload" | "forge";
+        name: string;
+        description: string;
+    }): string | null;
+    compactDuplicateCustomPets(): PetProfile;
+    writeCustomPetAssetFiles(pet: PetdexPetAsset, spritesheet: Buffer, validation: unknown, productionRun?: unknown): PetProfile;
+    private defaultProfile;
+    private normalizeProfile;
+    private writeProfile;
+}

package/dist/runtime/pet/pet-profile-service.js

@@ -0,0 +1,296 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getDefaultPathService } from "../infra/default-path-service.js";
+const DEFAULT_PREFERENCES = {
+    enabled: true,
+    selectedPetAssetId: "builtin-anime-horse-girl",
+};
+const MAX_JOURNEY_DAYS = 120;
+export class PetProfileService {
+    ownerUserId;
+    petDir;
+    profilePath;
+    constructor(ownerUserId) {
+        this.ownerUserId = ownerUserId;
+        this.petDir = path.join(getDefaultPathService().getOwnerProfileDir(ownerUserId), "pet");
+        this.profilePath = path.join(this.petDir, "profile.json");
+    }
+    loadProfile() {
+        if (!fs.existsSync(this.profilePath))
+            return this.defaultProfile();
+        try {
+            const parsed = JSON.parse(fs.readFileSync(this.profilePath, "utf-8"));
+            return this.normalizeProfile(parsed);
+        }
+        catch {
+            return this.defaultProfile();
+        }
+    }
+    updateSoul(soul) {
+        const profile = this.loadProfile();
+        profile.soul = soul;
+        return this.writeProfile(profile);
+    }
+    updatePreferences(update) {
+        const profile = this.loadProfile();
+        profile.preferences = {
+            ...profile.preferences,
+            ...update,
+            selectedPetAssetId: update.selectedPetAssetId ?? profile.preferences.selectedPetAssetId,
+        };
+        return this.writeProfile(profile);
+    }
+    saveJourneySnapshot(snapshot) {
+        const profile = this.loadProfile();
+        const journeyDir = path.join(this.petDir, "journey");
+        fs.mkdirSync(journeyDir, { recursive: true });
+        fs.writeFileSync(path.join(journeyDir, `${snapshot.date}.json`), JSON.stringify(snapshot, null, 2), "utf-8");
+        const dates = new Set(profile.journeyDates);
+        dates.add(snapshot.date);
+        const sorted = [...dates].sort();
+        while (sorted.length > MAX_JOURNEY_DAYS) {
+            const oldest = sorted.shift();
+            if (oldest)
+                fs.rmSync(path.join(journeyDir, `${oldest}.json`), { force: true });
+        }
+        profile.journeyDates = sorted;
+        return this.writeProfile(profile);
+    }
+    listJourneyDates() {
+        return this.loadProfile().journeyDates;
+    }
+    getJourneySnapshot(date) {
+        const file = path.join(this.petDir, "journey", `${date}.json`);
+        if (!fs.existsSync(file))
+            return null;
+        try {
+            return JSON.parse(fs.readFileSync(file, "utf-8"));
+        }
+        catch {
+            return null;
+        }
+    }
+    upsertCustomPet(pet) {
+        const profile = this.loadProfile();
+        const assetDir = path.join(this.petDir, "assets", pet.id);
+        fs.mkdirSync(assetDir, { recursive: true });
+        fs.writeFileSync(path.join(assetDir, "pet.json"), JSON.stringify(pet, null, 2), "utf-8");
+        const summary = toCustomPetSummary(pet);
+        const existing = profile.customPets.find((item) => item.id === pet.id);
+        profile.customPets = existing
+            ? profile.customPets.map((item) => item.id === pet.id ? summary : item)
+            : [summary, ...profile.customPets];
+        profile.preferences = {
+            ...profile.preferences,
+            selectedPetAssetId: pet.id,
+        };
+        return this.writeProfile(profile);
+    }
+    deleteCustomPet(id) {
+        const profile = this.loadProfile();
+        profile.customPets = profile.customPets.filter((pet) => pet.id !== id);
+        fs.rmSync(path.join(this.petDir, "assets", id), { recursive: true, force: true });
+        if (profile.preferences.selectedPetAssetId === id) {
+            profile.preferences = {
+                ...profile.preferences,
+                selectedPetAssetId: "builtin-anime-horse-girl",
+            };
+        }
+        return this.writeProfile(profile);
+    }
+    listCustomPets() {
+        return this.loadProfile().customPets;
+    }
+    getCustomPet(id) {
+        const file = path.join(this.petDir, "assets", id, "pet.json");
+        if (!fs.existsSync(file))
+            return null;
+        try {
+            const parsed = JSON.parse(fs.readFileSync(file, "utf-8"));
+            return isPetdexPetAsset(parsed) ? parsed : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    getCustomPetSpritesheet(id) {
+        const file = path.join(this.petDir, "assets", id, "spritesheet.webp");
+        return fs.existsSync(file) ? fs.readFileSync(file) : null;
+    }
+    findReusableCustomPetId(params) {
+        const profile = this.loadProfile();
+        const matches = profile.customPets.filter((pet) => pet.sourceKind === params.sourceKind
+            && normalizeAssetText(pet.name) === normalizeAssetText(params.name)
+            && normalizeAssetText(pet.description) === normalizeAssetText(params.description));
+        if (matches.length === 0)
+            return null;
+        const selected = matches.find((pet) => pet.id === profile.preferences.selectedPetAssetId);
+        return (selected ?? matches[0])?.id ?? null;
+    }
+    compactDuplicateCustomPets() {
+        const profile = this.loadProfile();
+        const kept = new Map();
+        const removedIds = [];
+        for (const pet of profile.customPets) {
+            const key = customPetIdentityKey(pet);
+            const existing = kept.get(key);
+            if (!existing) {
+                kept.set(key, pet);
+                continue;
+            }
+            const keepIncoming = pet.id === profile.preferences.selectedPetAssetId;
+            const removed = keepIncoming ? existing : pet;
+            removedIds.push(removed.id);
+            if (keepIncoming)
+                kept.set(key, pet);
+        }
+        if (removedIds.length === 0)
+            return profile;
+        profile.customPets = [...kept.values()];
+        for (const id of removedIds) {
+            fs.rmSync(path.join(this.petDir, "assets", id), { recursive: true, force: true });
+        }
+        if (!profile.customPets.some((pet) => pet.id === profile.preferences.selectedPetAssetId)) {
+            profile.preferences = {
+                ...profile.preferences,
+                selectedPetAssetId: profile.customPets[0]?.id ?? "builtin-anime-horse-girl",
+            };
+        }
+        return this.writeProfile(profile);
+    }
+    writeCustomPetAssetFiles(pet, spritesheet, validation, productionRun) {
+        const assetDir = path.join(this.petDir, "assets", pet.id);
+        fs.mkdirSync(assetDir, { recursive: true });
+        fs.writeFileSync(path.join(assetDir, "pet.json"), JSON.stringify(pet, null, 2), "utf-8");
+        fs.writeFileSync(path.join(assetDir, "spritesheet.webp"), spritesheet);
+        fs.writeFileSync(path.join(assetDir, "validation.json"), JSON.stringify(validation, null, 2), "utf-8");
+        if (productionRun) {
+            fs.writeFileSync(path.join(assetDir, "production-run.json"), JSON.stringify(productionRun, null, 2), "utf-8");
+        }
+        return this.upsertCustomPet(pet);
+    }
+    defaultProfile() {
+        return {
+            version: 1,
+            ownerUserId: this.ownerUserId,
+            soul: null,
+            preferences: { ...DEFAULT_PREFERENCES },
+            customPets: [],
+            journeyDates: [],
+            updatedAt: new Date().toISOString(),
+        };
+    }
+    normalizeProfile(input) {
+        return {
+            version: 1,
+            ownerUserId: this.ownerUserId,
+            soul: input.soul ?? null,
+            preferences: {
+                ...DEFAULT_PREFERENCES,
+                ...(input.preferences ?? {}),
+                selectedPetAssetId: normalizeSelectedPetAssetId(input.preferences),
+            },
+            customPets: Array.isArray(input.customPets) ? input.customPets.filter(isPetdexPetAssetSummary).map(toCustomPetSummary) : [],
+            journeyDates: Array.isArray(input.journeyDates) ? [...new Set(input.journeyDates)].sort() : [],
+            updatedAt: typeof input.updatedAt === "string" ? input.updatedAt : new Date().toISOString(),
+        };
+    }
+    writeProfile(profile) {
+        const next = {
+            ...profile,
+            version: 1,
+            ownerUserId: this.ownerUserId,
+            updatedAt: new Date().toISOString(),
+        };
+        fs.mkdirSync(this.petDir, { recursive: true });
+        fs.writeFileSync(this.profilePath, JSON.stringify(next, null, 2), "utf-8");
+        return next;
+    }
+}
+function toCustomPetSummary(pet) {
+    return {
+        id: pet.id,
+        assetKind: "petdex",
+        sourceKind: pet.sourceKind ?? ("source" in pet && pet.source && typeof pet.source === "object" ? pet.source.kind : "forge"),
+        name: pet.name,
+        description: pet.description,
+        createdAt: pet.createdAt,
+        updatedAt: pet.updatedAt,
+        atlas: {
+            format: pet.atlas.format,
+            columns: pet.atlas.columns,
+            rows: pet.atlas.rows,
+            frameCount: pet.atlas.frameCount,
+            cellWidth: pet.atlas.cellWidth,
+            cellHeight: pet.atlas.cellHeight,
+            width: pet.atlas.width,
+            height: pet.atlas.height,
+            sha256: pet.atlas.sha256,
+        },
+        animations: pet.animations,
+        thumbnail: pet.thumbnail,
+    };
+}
+function customPetIdentityKey(pet) {
+    return [
+        pet.sourceKind ?? "forge",
+        normalizeAssetText(pet.name),
+        normalizeAssetText(pet.description),
+    ].join("\n");
+}
+function normalizeAssetText(value) {
+    return value.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function isPetdexPetAssetSummary(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const item = value;
+    return item.assetKind === "petdex"
+        && typeof item.id === "string"
+        && (item.sourceKind === "builtin" || item.sourceKind === "upload" || item.sourceKind === "forge" || item.sourceKind === undefined)
+        && typeof item.name === "string"
+        && typeof item.description === "string"
+        && typeof item.createdAt === "string"
+        && typeof item.updatedAt === "string"
+        && isPetdexSummaryAtlas(item.atlas);
+}
+function normalizeSelectedPetAssetId(preferences) {
+    if (typeof preferences?.selectedPetAssetId === "string") {
+        const id = preferences.selectedPetAssetId.trim();
+        if (id === "builtin-anime-horse-girl")
+            return id;
+        if (id && !id.startsWith("builtin-"))
+            return id;
+    }
+    return "builtin-anime-horse-girl";
+}
+function isPetdexPetAsset(value) {
+    if (!isPetdexPetAssetSummary(value))
+        return false;
+    const item = value;
+    return item.schema === "qlogic.petdex.asset.v1"
+        && isPetdexAssetAtlas(item.atlas)
+        && typeof item.source === "object"
+        && item.source !== null
+        && typeof item.animations === "object"
+        && item.animations !== null
+        && typeof item.thumbnail === "object"
+        && item.thumbnail !== null;
+}
+function isPetdexSummaryAtlas(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const atlas = value;
+    return atlas.format === "webp"
+        && atlas.columns === 8
+        && atlas.rows === 9
+        && atlas.frameCount === 72
+        && atlas.cellWidth === 192
+        && atlas.cellHeight === 208
+        && atlas.width === 1536
+        && atlas.height === 1872
+        && typeof atlas.sha256 === "string";
+}
+function isPetdexAssetAtlas(value) {
+    return isPetdexSummaryAtlas(value) && value.image === "spritesheet.webp";
+}

package/dist/runtime/pet/pet-profile-service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/pet/pet-profile-service.test.js

@@ -0,0 +1,171 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createDefaultPetdexAnimations } from "@xiaozhiclaw/pet-core";
+import { PetProfileService } from "./pet-profile-service.js";
+const tmpDirs = [];
+function makeTempDir(prefix) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+    tmpDirs.push(dir);
+    return dir;
+}
+function profilePath(home, owner = "user%2Falice") {
+    return path.join(home, "profiles", owner, "pet", "profile.json");
+}
+function petdexAsset(overrides = {}) {
+    return {
+        schema: "qlogic.petdex.asset.v1",
+        id: "petdex-1",
+        assetKind: "petdex",
+        name: "Spark",
+        description: "Generated display pet",
+        createdAt: "2026-06-03T00:00:00.000Z",
+        updatedAt: "2026-06-03T00:00:00.000Z",
+        source: { kind: "forge", prompt: "round desk companion" },
+        atlas: {
+            image: "spritesheet.webp",
+            format: "webp",
+            columns: 8,
+            rows: 9,
+            frameCount: 72,
+            cellWidth: 192,
+            cellHeight: 208,
+            width: 1536,
+            height: 1872,
+            sha256: "sha256-petdex-1",
+        },
+        animations: createDefaultPetdexAnimations(),
+        thumbnail: { frame: 0 },
+        ...overrides,
+    };
+}
+function baseSoul() {
+    return {
+        name: "Blue",
+        species: "display companion",
+        personality: "calm",
+        catchphrase: "ready",
+        stats: { grip: 1, patience: 2, curiosity: 3, appetite: 4, humor: 5 },
+        rarity: "common",
+        breed: "default",
+        breedColors: { primary: "#5A7EFF", secondary: "#1E3A8A" },
+        level: 1,
+        experience: 0,
+        hatchedAt: "2026-06-03T00:00:00.000Z",
+    };
+}
+afterEach(() => {
+    vi.unstubAllEnvs();
+    for (const dir of tmpDirs.splice(0)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe("PetProfileService", () => {
+    it("persists the profile under the explicit owner archive", () => {
+        const home = makeTempDir("pet-profile-home-");
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        const service = new PetProfileService("user/alice");
+        const profile = service.updateSoul(baseSoul());
+        expect(profile.soul?.name).toBe("Blue");
+        expect(fs.existsSync(profilePath(home))).toBe(true);
+        expect(new PetProfileService("user/bob").loadProfile().soul).toBeNull();
+    });
+    it("persists preferences in the same profile document", () => {
+        const home = makeTempDir("pet-profile-home-");
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        const profile = new PetProfileService("user/alice").updatePreferences({
+            enabled: false,
+            selectedPetAssetId: "builtin-anime-horse-girl",
+        });
+        expect(profile.preferences).toEqual({
+            enabled: false,
+            selectedPetAssetId: "builtin-anime-horse-girl",
+        });
+        expect(new PetProfileService("user/alice").loadProfile().preferences.selectedPetAssetId).toBe("builtin-anime-horse-girl");
+    });
+    it("stores journey snapshots in the backend pet archive and keeps dates on the profile", () => {
+        const home = makeTempDir("pet-profile-home-");
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        const service = new PetProfileService("user/alice");
+        const snapshot = {
+            date: "2026-06-03",
+            day: 7,
+            petName: "Blue",
+            stateLabel: "working",
+            entries: [{ kind: "done", title: "State", detail: "Finished" }],
+        };
+        service.saveJourneySnapshot(snapshot);
+        expect(service.listJourneyDates()).toEqual(["2026-06-03"]);
+        expect(service.getJourneySnapshot("2026-06-03")).toEqual(snapshot);
+        expect(JSON.parse(fs.readFileSync(profilePath(home), "utf-8")).journeyDates).toEqual(["2026-06-03"]);
+    });
+    it("stores Petdex assets under the backend pet assets archive as profile summaries", () => {
+        const home = makeTempDir("pet-profile-home-");
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        const service = new PetProfileService("user/alice");
+        const pet = petdexAsset();
+        const profile = service.upsertCustomPet(pet);
+        const persisted = JSON.parse(fs.readFileSync(path.join(home, "profiles", "user%2Falice", "pet", "assets", "petdex-1", "pet.json"), "utf-8"));
+        expect(persisted).toEqual(pet);
+        expect(profile.customPets[0]).toMatchObject({
+            id: "petdex-1",
+            assetKind: "petdex",
+            sourceKind: "forge",
+            name: "Spark",
+            description: "Generated display pet",
+            createdAt: "2026-06-03T00:00:00.000Z",
+            updatedAt: "2026-06-03T00:00:00.000Z",
+            atlas: {
+                format: "webp",
+                columns: 8,
+                rows: 9,
+                frameCount: 72,
+                cellWidth: 192,
+                cellHeight: 208,
+                width: 1536,
+                height: 1872,
+                sha256: "sha256-petdex-1",
+            },
+        });
+        expect(profile.customPets[0]?.animations).toBeDefined();
+        expect(profile.preferences).toMatchObject({
+            selectedPetAssetId: "petdex-1",
+        });
+        expect(service.listCustomPets()).toEqual(profile.customPets);
+        expect(service.getCustomPet("petdex-1")).toEqual(pet);
+        expect(fs.existsSync(path.join(home, "profiles", "user%2Falice", "pet", "custom" + "-pets", "petdex-1", "manifest.json"))).toBe(false);
+    });
+    it("deletes selected Petdex assets from pet assets and clears selection", () => {
+        const home = makeTempDir("pet-profile-home-");
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        const service = new PetProfileService("user/alice");
+        const pet = petdexAsset();
+        service.upsertCustomPet(pet);
+        service.updatePreferences({ selectedPetAssetId: "petdex-1" });
+        const deleted = service.deleteCustomPet("petdex-1");
+        expect(deleted.customPets).toEqual([]);
+        expect(deleted.preferences.selectedPetAssetId).toBe("builtin-anime-horse-girl");
+        expect(fs.existsSync(path.join(home, "profiles", "user%2Falice", "pet", "assets", "petdex-1"))).toBe(false);
+    });
+    it("reuses and compacts duplicate Petdex forge assets by owner identity", () => {
+        const home = makeTempDir("pet-profile-home-");
+        vi.stubEnv("QLOGICAGENT_HOME", home);
+        const service = new PetProfileService("user/alice");
+        const first = petdexAsset({ id: "petdex-first", name: "Pika", description: "Pika" });
+        const second = petdexAsset({
+            id: "petdex-second",
+            name: "Pika",
+            description: "Pika",
+            atlas: { ...petdexAsset().atlas, sha256: "sha256-second" },
+        });
+        service.upsertCustomPet(first);
+        service.upsertCustomPet(second);
+        service.updatePreferences({ selectedPetAssetId: "petdex-second" });
+        expect(service.findReusableCustomPetId({ sourceKind: "forge", name: " Pika ", description: "Pika" })).toBe("petdex-second");
+        const compacted = service.compactDuplicateCustomPets();
+        expect(compacted.customPets.map((pet) => pet.id)).toEqual(["petdex-second"]);
+        expect(compacted.preferences.selectedPetAssetId).toBe("petdex-second");
+        expect(fs.existsSync(path.join(home, "profiles", "user%2Falice", "pet", "assets", "petdex-first"))).toBe(false);
+    });
+});

package/dist/runtime/pet/pet-reaction-engine.d.ts

@@ -0,0 +1,11 @@
+import { ReactionEngine } from "@xiaozhiclaw/pet-core";
+/**
+ * Host-side shared ReactionEngine singleton.
+ *
+ * pet-core moved the original module-level `recentReactions` dedup buffer to a
+ * ReactionEngine instance field. The original behaviour was a module singleton
+ * shared by both pet-runtime and pet-handler, so the host keeps exactly one
+ * shared instance here (seeded with defaultPetRng = Math.random) to preserve the
+ * cross-call dedup semantics byte-for-byte.
+ */
+export declare const petReactionEngine: ReactionEngine;

package/dist/runtime/pet/pet-reaction-engine.js

@@ -0,0 +1,11 @@
+import { ReactionEngine, defaultPetRng } from "@xiaozhiclaw/pet-core";
+/**
+ * Host-side shared ReactionEngine singleton.
+ *
+ * pet-core moved the original module-level `recentReactions` dedup buffer to a
+ * ReactionEngine instance field. The original behaviour was a module singleton
+ * shared by both pet-runtime and pet-handler, so the host keeps exactly one
+ * shared instance here (seeded with defaultPetRng = Math.random) to preserve the
+ * cross-call dedup semantics byte-for-byte.
+ */
+export const petReactionEngine = new ReactionEngine(defaultPetRng);

package/dist/runtime/pet/pet-reaction-engine.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/pet/pet-reaction-engine.test.js

@@ -0,0 +1,12 @@
+import { describe, it, expect } from "vitest";
+import { petReactionEngine } from "./pet-reaction-engine.js";
+describe("petReactionEngine (host shared singleton)", () => {
+    it("is a single shared ReactionEngine instance across imports", async () => {
+        const again = (await import("./pet-reaction-engine.js")).petReactionEngine;
+        expect(again).toBe(petReactionEngine);
+    });
+    it("maybeGenerate returns a pool reaction or null for a known event", () => {
+        const r = petReactionEngine.maybeGenerate("turn.end");
+        expect(r === null || (typeof r.text === "string" && typeof r.style === "string")).toBe(true);
+    });
+});

package/dist/runtime/pet/pet-soul-service.d.ts

@@ -0,0 +1,21 @@
+import { hasPetAgentBoundaryViolationText, type PetSoul, type PetStats } from "@xiaozhiclaw/pet-core";
+export { hasPetAgentBoundaryViolationText };
+export declare class PetSoulService {
+    private soul;
+    private profileService;
+    constructor(_workspaceDir: string, ownerUserId?: string);
+    load(): PetSoul | null;
+    ensureSoul(userId: string, generateSoul?: (rarity: string, stats: PetStats) => Promise<{
+        name: string;
+        personality: string;
+        catchphrase: string;
+    }>, requestedBreedId?: string): Promise<PetSoul>;
+    addExperience(xp: number): {
+        leveledUp: boolean;
+        level: number;
+        experience: number;
+    };
+    getSoul(): PetSoul | null;
+    updateSoul(soul: PetSoul): void;
+    private persist;
+}