@linxin666/dsh-pet 0.3.3 → 0.3.5

package/lib/index.js

@@ -5,6 +5,7 @@ import { Service } from "@deepseek-ai/cordis";
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { homedir } from "node:os";
+import { isAbsolute as isAbsolute$1, join as join$1 } from "node:path/posix";
 import { fileURLToPath } from "node:url";
 import { readFile } from "node:fs/promises";
 //#region src/chatter.ts
@@ -505,411 +506,256 @@ var StatusVoice = class {
 		return this.voice("toolRemaining", "toolRemaining", pool, nowMs).replaceAll("{n}", String(count));
 	}
 };
-/** Murmur pacing: cooldown between whispers and output volume that earns one. */
-const WHISPER_COOLDOWN_MS = 9e3;
-/** Ambient inner-whisper pool (no keyword needed; earned by output volume). */
-const WHISPER_GENERIC_POOL = [
-	"哼哧哼哧，大脑转得飞快～",
-	"loading 99%……就差最后一步",
-	"嗯……让我捋捋",
-	"灵感来了，先记小本本上",
-	"脑子在冒烟，但还能撑",
-	"这个报错，我好像在哪见过",
-	"专注模式 ON，请勿打扰",
-	"思路通了，舒服了",
-	"有点困……不行，还能肝",
-	"让我嚼一嚼这个问题",
-	"盘，都可以盘",
-	"这波操作，我给自己点个赞",
-	"别催别催，在想呢",
-	"唔，这个细节差点漏掉",
-	"脑子转太快，差点绕晕自己",
-	"陪你干活，稳赚不亏",
-	"深呼吸，马上就好",
-	"诶，等等，好像发现了什么",
-	"手速拉满，键盘冒火星",
-	"摸鱼是不可能摸鱼的，就瞄一眼窗外",
-	"今天也是稳扎稳打的一天",
-	"把大问题拆成小饼干，一口一个",
-	"这题有戏，我闻到了",
-	"尾巴轻晃，心情有点小得意",
-	"好结果是熬出来的，不慌",
-	"啊，想岔了，重新来",
-	"嗯嗯，思路对头，就这么干",
-	"小本本记满了，都是干货",
-	"打完这波，求摸摸奖励～",
-	"这坑我记住了，下次绕道",
-	"窗外云在飘，代码在跑，挺好",
-	"嘘，正到关键处",
-	"这个方案……让我再品品",
-	"干活呢，别打扰我数数",
-	"心里默默给你比了个耶",
-	"思路像小鱼，逮住一条是一条",
-	"嗯……有点东西，等我深挖",
-	"收个尾就能喘口气了",
-	"目标锁定，冲就完了",
-	"嗯，这波配合不错",
-	"困了……还能再战三回合",
-	"思考.gif 加载中",
-	"我本地能跑啊……哦，我就是干活的",
-	"有点饿，小鱼干存货还够吗",
-	"刚想通，一被打断又忘了，气",
-	"缓冲中，请稍候",
-	"这网速，比我思考还慢",
-	"脑子在后台跑批",
-	"内存不足，但热情够",
-	"404：思路未找到，重试中",
-	"这需求有点玄学，但能写",
-	"诶，这 bug 还会闪现？",
-	"刚说简单，结果打脸了",
-	"自信满满，结果翻车",
-	"这活不难，就是有点复杂",
-	"我装的，其实心里没底",
-	"别看我稳，我也慌",
-	"假装很懂的样子，其实在查文档",
-	"窗外鸟叫了两声，我听到了",
-	"打了个哈欠，没人看见",
-	"今天的状态：七分精神三分困",
-	"刚想偷懒，又想起来你还在等",
-	"数了数今天的产出，还行",
-	"有点想伸懒腰",
-	"饿意来袭，忍住",
-	"灵感像猫一样，不追它自己来",
-	"坐太久，尾巴麻了",
-	"快了快了",
-	"马上马上",
-	"等下，我记得在哪见过",
-	"呃，忘了，重新想",
-	"诶，这个思路可以",
-	"嗯？有意思",
-	"行，就这么办",
-	"好嘞",
-	"收到收到",
-	"冲了冲了",
-	"稳",
-	"妥",
-	"得嘞",
-	"你忙你的，我盯着呢",
-	"放心，有我呢",
-	"咱俩配合，无往不利",
-	"你专注的样子，我默默记下了"
+/** Every whisper category key, in declaration order (voice-pack key allow-list). */
+const WHISPER_CATEGORIES = [
+	"thinking",
+	"writing",
+	"reading",
+	"editing",
+	"running",
+	"searching",
+	"git",
+	"delegating",
+	"browsing",
+	"generic"
 ];
-/** Keyword-triggered whisper rules, most specific moods first. */
-const WHISPER_RULES = [
-	{
-		keywords: [
-			"测试通过",
-			"测试全过",
-			"全部通过",
-			"all tests pass",
-			"tests passed",
-			"test passed",
-			"全绿"
-		],
-		pool: [
-			"全绿！亮瞎我眼了",
-			"测试全过，击掌～",
-			"稳了稳了，这波稳得很",
-			"绿灯一排排，看着就舒坦",
-			"能跑！没报错！",
-			"全绿，收工摸鱼去",
-			"测试过了，尾巴翘上天",
-			"漂亮，一次过",
-			"测试过了，奖励自己一口小鱼干",
-			"绿得发光，稳",
-			"又双叒叕全绿",
-			"这波测试，赢得干脆"
-		]
-	},
-	{
-		keywords: [
-			"错误",
-			"失败",
-			"报错",
-			"异常",
-			"崩溃",
-			"bug",
-			"error",
-			"failed",
-			"exception",
-			"traceback",
-			"找不到",
-			"不对了"
-		],
-		pool: [
-			"哎呀，踩到小石子了",
-			"翻车了……没事，扶起来继续",
-			"错误是进步的脚印，我懂",
-			"这报错我盯上它了",
-			"我本地能跑啊？哦，我一直在跑",
-			"别慌，深呼吸，先看报错",
-			"bug 你站住，我看见你了",
-			"绷不住了……好，继续修",
-			"报错这东西，见一个修一个",
-			"又是它，老熟人了",
-			"问题不大，就是有点问题",
-			"先别慌，我看看到底咋回事",
-			"这错报得，比我还委屈",
-			"修好它，今天才不算白干"
-		]
-	},
-	{
-		keywords: [
-			"等等",
-			"不对",
-			"重新想",
-			"再想想",
-			"换个思路",
-			"我搞错了",
-			"纠正",
-			"其实应该"
-		],
-		pool: [
-			"嗯？让我再想想……",
-			"推翻重来，也是种勇气",
-			"发现岔路，及时掉头",
-			"不对不对，重来重来",
-			"自我纠错的瞬间，最帅了",
-			"呃，刚说错了，收回",
-			"哎，绕远了，拉回来",
-			"回头一看，原来这么简单",
-			"纠正完，思路清爽多了",
-			"转弯不丢人，卡死才丢人"
-		]
-	},
-	{
-		keywords: [
-			"首先",
-			"接下来",
-			"第一步",
-			"第二步",
-			"计划",
-			"步骤",
-			"todo",
-			"任务拆解",
-			"分工"
-		],
-		pool: [
-			"排排坐，分果果",
-			"计划通，执行开始",
-			"一步一步来，不慌",
-			"大任务切成小块块，好下口",
-			"清单列好了，逐个击破",
-			"谋定而后动，这节奏我熟",
-			"先干这个，再干那个",
-			"头绪理清了，开整",
-			"步骤在手，心里不慌",
-			"安排得明明白白"
-		]
-	},
-	{
-		keywords: [
-			"终于",
-			"搞定",
-			"完成了",
-			"解决了",
-			"成功了",
-			"修复了",
-			"done",
-			"fixed",
-			"solved",
-			"完成啦"
-		],
-		pool: [
-			"太好了，又翻过一页",
-			"搞定，收工～",
-			"攻下一城，击掌！",
-			"难题被拿下了，转个圈",
-			"努力没白费，开心",
-			"齐活，漂亮",
-			"收工收工，今天圆满",
-			"完成！心里踏实了",
-			"这波，稳得一批",
-			"任务清零，舒服",
-			"搞定，可以伸个懒腰了",
-			"又完成一件，成就感+1"
-		]
-	},
-	{
-		keywords: [
-			"谢谢",
-			"感谢",
-			"thank"
-		],
-		pool: [
-			"不客气呀，顺手的事",
-			"被感谢了，心里甜甜的",
-			"能帮上忙就好～",
-			"你的谢意，我收进口袋啦",
-			"这话我爱听",
-			"客气啥，应该的",
-			"收下这份心意，干劲+1",
-			"你谢我，我谢你，扯平啦"
-		]
-	},
-	{
-		keywords: [
-			"复杂",
-			"棘手",
-			"困难",
-			"难点",
-			"坑",
-			"头疼",
-			"tricky",
-			"complex"
-		],
-		pool: [
-			"难不倒我们俩的",
-			"越难啃的骨头越香",
-			"硬骨头？我最喜欢了",
-			"复杂问题拆开看，小事",
-			"这坑我们一起填",
-			"有点东西，但不多",
-			"硬骨头，慢慢啃",
-			"问题越难，赢的时候越爽",
-			"绕是绕不过去的，正面刚",
-			"再难的题，拆开都是小问号"
-		]
-	},
-	{
-		keywords: [
-			"检查",
-			"审查",
-			"确认一下",
-			"核对",
-			"review",
-			"仔细看看",
-			"验证"
-		],
-		pool: [
-			"火眼金睛，启动",
-			"让我仔细瞧瞧",
-			"细节魔鬼，一个都不放过",
-			"认真检查的样子最迷人",
-			"多核一遍，稳上加稳",
-			"再看一眼，不亏",
-			"确认键，点了才安心",
-			"细节控上线",
-			"查完这遍，稳了"
-		]
-	},
-	{
-		keywords: [
-			"搜索",
-			"查一下",
-			"资料",
-			"文档",
-			"搜一搜",
-			"找找",
-			"查询"
-		],
-		pool: [
-			"去知识的海洋里捞一捞",
-			"翻翻找找，线索快出来",
-			"检索小雷达启动",
-			"答案就藏在某个角落",
-			"线索有点散，拼一下",
-			"找东西，我最在行",
-			"答案在网线那头等我",
-			"翻箱倒柜中，稍等"
-		]
-	},
-	{
-		keywords: [
-			"写代码",
-			"实现",
-			"编码",
-			"函数",
-			"接口",
-			"重构"
-		],
-		pool: [
-			"指尖跳舞，代码开花",
-			"把逻辑织成网",
-			"一行一行，垒起小城堡",
-			"这代码写得，我自己都佩服",
-			"码着码着，天就亮了",
-			"代码跑通了，比中奖还开心",
-			"这行代码，写得有点帅",
-			"写完再润润，讲究"
-		]
-	}
+/** Every whisper outcome key, in declaration order (voice-pack key allow-list). */
+const WHISPER_RESULTS = [
+	"pass",
+	"fail",
+	"done"
 ];
-/** The built-in voice pack: the plugin's default copy, unchanged since v1. */
+/** Murmur pacing: the cooldown between category whispers. */
+const WHISPER_COOLDOWN_MS = 9e3;
+/** Outcome whispers get their own shorter cooldown so a real moment still speaks. */
+const WHISPER_RESULT_COOLDOWN_MS = 5e3;
+/** Map a tool family onto the whisper category it belongs to. */
+function whisperCategoryOf(tool) {
+	switch (tool) {
+		case "read":
+		case "grep":
+		case "find":
+		case "ls": return "reading";
+		case "write":
+		case "edit": return "editing";
+		case "shell": return "running";
+		case "webSearch":
+		case "webFetch":
+		case "memory":
+		case "mcp": return "searching";
+		case "git": return "git";
+		case "subagent":
+		case "todo": return "delegating";
+		case "browser": return "browsing";
+		case "ask":
+		case "generic": return "generic";
+	}
+}
+/**
+* Whether a tool invocation looks like a test run. The whisper engine never
+* reads the model's prose (a discussion that merely mentions a keyword must
+* not wake a mood); a test-outcome mood is wanted only when a test tool
+* actually ran, so the projection marks the call at tool/call time and the
+* pass mood fires from the paired tool/result.
+*/
+function looksLikeTestTool(name, argumentsText) {
+	const tool = name.toLowerCase();
+	if (/(^|[\/_.-])(test|tests|spec|vitest|jest|pytest|mocha|playwright|cypress|karma)([\/_.-]|$)/.test(tool)) return true;
+	if (argumentsText === void 0) return false;
+	let haystack = argumentsText.toLowerCase();
+	try {
+		const parsed = JSON.parse(argumentsText);
+		if (typeof parsed === "object" && parsed !== null) {
+			const record = parsed;
+			const command = record.command;
+			const code = record.code;
+			const picked = typeof command === "string" && command !== "" ? command : typeof code === "string" && code !== "" ? code : void 0;
+			if (picked !== void 0) haystack = picked.toLowerCase();
+		}
+	} catch {}
+	return /\b(pnpm|npm|yarn|npx|bun|python)\s+(run\s+)?(test|tests?)\b/.test(haystack) || /\b(pytest|vitest|jest|mocha|cypress|playwright|go test|cargo test)\b/.test(haystack);
+}
+/** Category-level inner-whisper pools — the pet knows roughly what is going on. */
+const WHISPER_CATEGORY_POOLS = {
+	thinking: [
+		"先在脑子里搭个框架",
+		"它在心里打草稿，我垫着脚看",
+		"思路在一颗一颗冒泡",
+		"脑内开会中，都别抢话筒",
+		"先想清楚，再动手不迟",
+		"草稿纸已经画满了",
+		"让我听听它下一步打算",
+		"嗯，方案在成型了"
+	],
+	writing: [
+		"落笔成文，我旁边听着",
+		"句子排着队往外走",
+		"把想法一句句摆整齐",
+		"它在组织语言，我打打气",
+		"写回复呢，不催",
+		"字斟句酌，快好了"
+	],
+	reading: [
+		"翻资料呢，我保持安静",
+		"一行一行读，不跳页",
+		"在纸堆里找线索",
+		"眼珠子跟着字跑",
+		"边读边做记号",
+		"翻箱倒柜找重点"
+	],
+	editing: [
+		"动手改起来了，手稳一点",
+		"这里补一笔，那边修一修",
+		"在改东西，听不到声音才怪",
+		"落笔小心，别有错别字",
+		"改写的节奏，我听得见",
+		"刷刷地改，一行都没跑"
+	],
+	running: [
+		"跑起来了跑起来了",
+		"命令敲出去，等个回响",
+		"在跑什么呢，我踮脚看",
+		"输出开始冒烟了",
+		"它在跑活，我不吵",
+		"盯着输出，蹲一个结果",
+		"这波跑完就靠它了"
+	],
+	searching: [
+		"去外面捞点信息",
+		"翻翻记忆库，等我一小会儿",
+		"顺着网线找线索",
+		"把老账翻出来对一对",
+		"情报在路上了",
+		"搜索引擎当跑腿"
+	],
+	git: [
+		"版本在往前迈步",
+		"改动排队上车",
+		"提交历史在长个子",
+		"分支合并，神清气爽",
+		"记录都焊在时间线上"
+	],
+	delegating: [
+		"派了活儿出去，等回话",
+		"清单列好，一件件来",
+		"任务拆开分了组",
+		"手下的伙计在远处跑着",
+		"分工完毕，各司其职"
+	],
+	browsing: [
+		"它在看网页，我偷瞄两眼",
+		"页面一张张翻过去",
+		"网页里翻答案呢",
+		"这网速，我先歇会儿"
+	],
+	generic: [
+		"这波活儿，我陪着",
+		"又开工了，我盯梢",
+		"它忙它的，我守着",
+		"不打扰，就安静待着",
+		"有活儿就有我"
+	]
+};
+/** The pet's outcome reactions — woken by structured session results only. */
+const WHISPER_RESULT_POOLS = {
+	pass: [
+		"全绿！亮瞎我眼了",
+		"测试过了，击掌～",
+		"绿灯一排排，看着就舒坦",
+		"稳了稳了，这波稳得很",
+		"全绿，奖励自己一口小鱼干",
+		"这波测试，赢得干脆"
+	],
+	fail: [
+		"哎呀，踩到小石子了",
+		"这报错我盯上它了",
+		"别慌，先看它在喊什么",
+		"修好它，今天才不算白干",
+		"又一次踩坑，老熟人了",
+		"问题不大，就是有点问题"
+	],
+	done: [
+		"搞定，收工～",
+		"又翻过一页，踏实",
+		"努力没白费，开心",
+		"任务清零，舒服",
+		"攻下一城，转个圈",
+		"收工收工，今天圆满"
+	]
+};
+/** The built-in voice pack: the plugin's default copy. */
 const BUILTIN_VOICE_PACK = {
 	status: STATUS_POOLS,
 	tools: TOOL_POOLS,
 	toolRemaining: TOOL_REMAINING_POOL,
 	whispers: {
-		generic: WHISPER_GENERIC_POOL,
-		rules: WHISPER_RULES
+		categories: WHISPER_CATEGORY_POOLS,
+		results: WHISPER_RESULT_POOLS
 	}
 };
 /**
-* The murmur engine (碎碎念): watches the model's own output and lets the pet
-* whisper its inner voice. Two ways to earn a whisper:
-*  - a keyword rule matches the fresh chunk text (themed whisper);
-*  - enough output volume flowed by without one (ambient whisper).
-* A cooldown keeps whispers occasional; all picks are round-robin so tests
-* reproduce exact lines. The voice-pack provider (pet-center M4) swaps the
-* pools at draw time, so a pet switch re-voices live engines in place.
+* The murmur engine (碎碎念): the pet's inner voice while sessions work.
+* Category awareness: the projection feeds the current situation (thinking /
+* writing / the running tool family), and the engine answers with a line from
+* that category's pool — so a whisper always roughly knows what is going on
+* without ever quoting real content (no tool names, no paths, no model text).
+* Outcome moments (test green, tool errors, turn completion) fire from the
+* structured result events, never from output text, so a mood cannot mis-
+* fire on a discussion that merely mentions a keyword. A cooldown keeps
+* whispers occasional; all picks are round-robin so tests reproduce exact
+* lines. The voice-pack provider (pet-center M4) swaps the pools at draw
+* time, so a pet switch re-voices live engines in place.
 */
 var WhisperEngine = class {
 	pools;
-	cooldownMs;
-	charBudget;
-	counters = /* @__PURE__ */ new Map();
-	genericCursor = 0;
+	categoryCooldownMs;
+	resultCooldownMs;
+	categoryCursor = /* @__PURE__ */ new Map();
+	resultCursor = /* @__PURE__ */ new Map();
 	lastWhisperAt = Number.NEGATIVE_INFINITY;
-	charsSinceWhisper = 0;
-	constructor(pools = () => BUILTIN_VOICE_PACK, cooldownMs = WHISPER_COOLDOWN_MS, charBudget = 420) {
+	constructor(pools = () => BUILTIN_VOICE_PACK, categoryCooldownMs = WHISPER_COOLDOWN_MS, resultCooldownMs = WHISPER_RESULT_COOLDOWN_MS) {
 		this.pools = pools;
-		this.cooldownMs = cooldownMs;
-		this.charBudget = charBudget;
+		this.categoryCooldownMs = categoryCooldownMs;
+		this.resultCooldownMs = resultCooldownMs;
+	}
+	/** Effective category pool (an explicit empty override mutes the category). */
+	categoryPool(category) {
+		const override = this.pools().whispers?.categories?.[category];
+		return override === void 0 ? WHISPER_CATEGORY_POOLS[category] : override;
+	}
+	/** Effective outcome pool (an explicit empty override mutes the outcome). */
+	resultPool(kind) {
+		const override = this.pools().whispers?.results?.[kind];
+		return override === void 0 ? WHISPER_RESULT_POOLS[kind] : override;
 	}
 	/**
-	* Effective keyword rules: an override replaces the built-in rules as a
-	* whole; an explicit empty array disables keyword-triggered whispers.
+	* Feed one situation while a session works. Returns the whisper to show,
+	* or undefined when the moment stays quiet (cooldown, or the category
+	* pool is muted).
 	*/
-	rules() {
-		const override = this.pools().whispers?.rules;
-		return override === void 0 ? WHISPER_RULES : override;
-	}
-	/** Effective ambient pool (an explicit empty array mutes ambient whispers). */
-	generic() {
-		const override = this.pools().whispers?.generic;
-		return override === void 0 ? WHISPER_GENERIC_POOL : override;
+	feed(category, nowMs) {
+		if (nowMs - this.lastWhisperAt < this.categoryCooldownMs) return void 0;
+		const pool = this.categoryPool(category);
+		if (pool.length === 0) return void 0;
+		const index = (this.categoryCursor.get(category) ?? 0) % pool.length;
+		this.categoryCursor.set(category, index + 1);
+		return this.speak(pool[index], nowMs);
 	}
 	/**
-	* Feed one model-output chunk (reasoning or text). Returns the whisper to
-	* show, or undefined when the moment stays quiet.
+	* Feed one structured outcome (test green / tool failure / turn
+	* completion). Outcomes carry their own shorter cooldown so the emotional
+	* moment is heard unless another whisper just spoke.
 	*/
-	feed(text, nowMs) {
-		if (text.length === 0) return void 0;
-		if (!(nowMs - this.lastWhisperAt >= this.cooldownMs)) {
-			this.charsSinceWhisper += text.length;
-			return;
-		}
-		const haystack = text.toLowerCase();
-		const rules = this.rules();
-		for (let ruleIndex = 0; ruleIndex < rules.length; ruleIndex += 1) {
-			const rule = rules[ruleIndex];
-			if (!rule.keywords.some((keyword) => haystack.includes(keyword))) continue;
-			const index = (this.counters.get(ruleIndex) ?? 0) % rule.pool.length;
-			this.counters.set(ruleIndex, index + 1);
-			return this.speak(rule.pool[index], nowMs);
-		}
-		this.charsSinceWhisper += text.length;
-		if (this.charsSinceWhisper < this.charBudget) return void 0;
-		const generic = this.generic();
-		if (generic.length === 0) return void 0;
-		const line = generic[this.genericCursor % generic.length];
-		this.genericCursor += 1;
-		return this.speak(line, nowMs);
+	result(kind, nowMs) {
+		if (nowMs - this.lastWhisperAt < this.resultCooldownMs) return void 0;
+		const pool = this.resultPool(kind);
+		if (pool.length === 0) return void 0;
+		const index = (this.resultCursor.get(kind) ?? 0) % pool.length;
+		this.resultCursor.set(kind, index + 1);
+		return this.speak(pool[index], nowMs);
 	}
 	speak(line, nowMs) {
 		this.lastWhisperAt = nowMs;
-		this.charsSinceWhisper = 0;
 		return line;
 	}
 };
@@ -924,6 +770,7 @@ var WhisperEngine = class {
 function emptyProjectionRuntime(pools) {
 	return {
 		activeTools: /* @__PURE__ */ new Set(),
+		testCalls: /* @__PURE__ */ new Set(),
 		officialEventsSeen: false,
 		stepHadFailure: false,
 		voice: new StatusVoice(pools),
@@ -956,6 +803,7 @@ function projectOfficialEvent(event, runtime, nowMs = Date.now()) {
 	switch (event.type) {
 		case "turn/start":
 			runtime.activeTools.clear();
+			runtime.testCalls.clear();
 			runtime.stepHadFailure = false;
 			return { input: {
 				phase: "waiting",
@@ -971,7 +819,7 @@ function projectOfficialEvent(event, runtime, nowMs = Date.now()) {
 		case "assistant/chunk": {
 			const { chunk } = event.data;
 			if (chunk.type === "reasoning-delta" && chunk.text.length > 0) {
-				const whisper = runtime.whispers.feed(chunk.text, nowMs);
+				const whisper = runtime.whispers.feed("thinking", nowMs);
 				return {
 					input: {
 						phase: "thinking",
@@ -981,7 +829,7 @@ function projectOfficialEvent(event, runtime, nowMs = Date.now()) {
 				};
 			}
 			if (chunk.type === "text-delta" && chunk.text.length > 0) {
-				const whisper = runtime.whispers.feed(chunk.text, nowMs);
+				const whisper = runtime.whispers.feed("writing", nowMs);
 				return {
 					input: {
 						phase: "review",
@@ -996,42 +844,74 @@ function projectOfficialEvent(event, runtime, nowMs = Date.now()) {
 			phase: "review",
 			line: runtime.voice.scene("review", nowMs)
 		} };
-		case "tool/call":
-			runtime.activeTools.add(String(event.data.callId));
-			return { input: {
-				phase: "tool",
-				line: runtime.voice.tool(event.data.name, displayToolName(event.data.name), toolArgHint(event.data.name, event.data.arguments), nowMs)
-			} };
+		case "tool/call": {
+			const callId = String(event.data.callId);
+			runtime.activeTools.add(callId);
+			if (looksLikeTestTool(event.data.name, event.data.arguments)) runtime.testCalls.add(callId);
+			const whisper = runtime.whispers.feed(whisperCategoryOf(toolCategory(event.data.name)), nowMs);
+			return {
+				input: {
+					phase: "tool",
+					line: runtime.voice.tool(event.data.name, displayToolName(event.data.name), toolArgHint(event.data.name, event.data.arguments), nowMs)
+				},
+				...whisper === void 0 ? {} : { whisper }
+			};
+		}
 		case "tool/result": {
 			const block = event.data.message.content[0];
-			runtime.activeTools.delete(String(event.data.message.source.callId));
-			runtime.stepHadFailure ||= event.data.error !== void 0 || block.isError === true;
-			if (runtime.activeTools.size > 0) return { input: {
-				phase: "tool",
-				line: runtime.voice.toolRemaining(runtime.activeTools.size, nowMs)
-			} };
-			return runtime.stepHadFailure ? { input: {
-				phase: "failed",
-				line: runtime.voice.scene("toolFailed", nowMs)
-			} } : { input: {
-				phase: "thinking",
-				line: runtime.voice.scene("toolResult", nowMs)
-			} };
+			const callId = String(event.data.message.source.callId);
+			const failed = event.data.error !== void 0 || block.isError === true;
+			const wasTest = runtime.testCalls.delete(callId);
+			runtime.activeTools.delete(callId);
+			runtime.stepHadFailure ||= failed;
+			const whisper = failed ? runtime.whispers.result("fail", nowMs) : wasTest ? runtime.whispers.result("pass", nowMs) : void 0;
+			const whisperSpread = whisper === void 0 ? {} : { whisper };
+			if (runtime.activeTools.size > 0) return {
+				input: {
+					phase: "tool",
+					line: runtime.voice.toolRemaining(runtime.activeTools.size, nowMs)
+				},
+				...whisperSpread
+			};
+			return runtime.stepHadFailure ? {
+				input: {
+					phase: "failed",
+					line: runtime.voice.scene("toolFailed", nowMs)
+				},
+				...whisperSpread
+			} : {
+				input: {
+					phase: "thinking",
+					line: runtime.voice.scene("toolResult", nowMs)
+				},
+				...whisperSpread
+			};
 		}
 		case "turn/end":
 			runtime.activeTools.clear();
+			runtime.testCalls.clear();
 			switch (event.data.reason.kind) {
-				case "completed": return {
-					input: {
-						phase: "done",
-						line: runtime.voice.scene("done", nowMs)
-					},
-					completedTurn: event.data.turn
-				};
-				case "error": return { input: {
-					phase: "failed",
-					line: runtime.voice.scene("failed", nowMs)
-				} };
+				case "completed": {
+					const whisper = runtime.whispers.result("done", nowMs);
+					return {
+						input: {
+							phase: "done",
+							line: runtime.voice.scene("done", nowMs)
+						},
+						completedTurn: event.data.turn,
+						...whisper === void 0 ? {} : { whisper }
+					};
+				}
+				case "error": {
+					const whisper = runtime.whispers.result("fail", nowMs);
+					return {
+						input: {
+							phase: "failed",
+							line: runtime.voice.scene("failed", nowMs)
+						},
+						...whisper === void 0 ? {} : { whisper }
+					};
+				}
 				case "max-tokens": return { input: {
 					phase: "failed",
 					line: runtime.voice.scene("maxTokens", nowMs)
@@ -1202,6 +1082,17 @@ var PetLedger = class {
 		};
 		this.dirty = true;
 	}
+	/** Replace one pet's gameplay state (validation/clamping stays a caller concern). */
+	setGameplay(petId, gameplay) {
+		this.current = {
+			...this.current,
+			gameplay: {
+				...this.current.gameplay,
+				[petId]: gameplay
+			}
+		};
+		this.dirty = true;
+	}
 	/** Replace one pet's display name (validation stays a caller concern). */
 	setPetName(petId, name) {
 		this.current = {
@@ -1237,6 +1128,40 @@ var PetLedger = class {
 		return true;
 	}
 	/**
+	* Grant gameplay treats into the shared stock (capped by the treat cap).
+	* This is the unified gameplay currency (wallet removed): work rewards,
+	* passive income and lottery prizes land here so one balance feeds the
+	* shop and the feeding economy. Returns true when the snapshot changed.
+	*/
+	grantTreats(amount) {
+		if (amount <= 0) return false;
+		const capped = Math.min(this.treatConfig.maxTreats, this.current.treats.treats + amount);
+		if (capped === this.current.treats.treats) return false;
+		this.current = {
+			...this.current,
+			treats: {
+				...this.current.treats,
+				treats: capped
+			}
+		};
+		this.dirty = true;
+		return true;
+	}
+	/** Spend gameplay treats from the shared stock; refuses when unaffordable. */
+	spendTreats(amount) {
+		const stock = this.current.treats.treats;
+		if (amount <= 0 || stock < amount) return { ok: false };
+		this.current = {
+			...this.current,
+			treats: {
+				...this.current.treats,
+				treats: stock - amount
+			}
+		};
+		this.dirty = true;
+		return { ok: true };
+	}
+	/**
 	* Award the completed-turn reward once per session+turn (idempotent) and
 	* run the treat settlement that work output feeds. Returns true when the
 	* snapshot changed.
@@ -1324,8 +1249,9 @@ var PetLedger = class {
 */
 /** Expand a leading ~ (or ~user) in a path, platform-style. */
 function expandHome(path, home = homedir()) {
+	const j = home.startsWith("/") ? join$1 : join;
 	if (path === "~") return home;
-	if (path.startsWith("~/") || path.startsWith("~\\")) return join(home, path.slice(2));
+	if (path.startsWith("~/") || path.startsWith("~\\")) return j(home, path.slice(2));
 	return path;
 }
 /**
@@ -1335,18 +1261,28 @@ function expandHome(path, home = homedir()) {
 * @returns the absolute DSH home path.
 */
 function resolveDshHome(env = process.env, home = homedir()) {
+	const isPosix = home.startsWith("/");
+	const j = isPosix ? join$1 : join;
+	const isAbs = isPosix ? isAbsolute$1 : isAbsolute;
 	const raw = env.DSH_HOME;
 	if (raw !== void 0 && raw.trim() !== "") {
 		const expanded = expandHome(raw.trim(), home);
-		return isAbsolute(expanded) ? expanded : join(process.cwd(), expanded);
+		return isAbs(expanded) ? expanded : j(process.cwd(), expanded);
 	}
-	return join(home, ".dsh");
+	return j(home, ".dsh");
 }
 /** Resolve the DSH home directory from the live environment. */
 function dshHome() {
 	return resolveDshHome();
 }
 //#endregion
+//#region src/defaults.ts
+/** Shared defaults used by registry selection and persisted-state migration. */
+/** Pet id that legacy single-pet installs and fresh registries resolve to. */
+const DEFAULT_PET_ID = "whale-girl";
+/** Default pet name used only when a manifest carries no displayName. */
+const DEFAULT_PET_NAME = "鲸鱼娘";
+//#endregion
 //#region src/persist.ts
 /**
 * Pet persistence — tiny JSON store for affinity + display config, written
@@ -1361,10 +1297,6 @@ const defaultDisplayConfig = {
 	bottom: 120
 };
 const DISPLAY_INSET_MAX = 1e4;
-/** Pet id the legacy single-pet installs resolve to on migration. */
-const DEFAULT_PET_ID = "whale-girl";
-/** Default pet name (used only when a manifest carries no displayName). */
-const DEFAULT_PET_NAME = "鲸鱼娘";
 /** Name constraints. */
 const PET_NAME_MAX_LENGTH = 20;
 function emptyPersist() {
@@ -1373,7 +1305,8 @@ function emptyPersist() {
 		names: {},
 		affinity: emptyAffinity(),
 		treats: emptyTreatLedger(),
-		display: { ...defaultDisplayConfig }
+		display: { ...defaultDisplayConfig },
+		gameplay: {}
 	};
 }
 /**
@@ -1404,6 +1337,35 @@ function loadPetNames(parsed) {
 function clamp(value, max) {
 	return Math.min(max, Math.max(0, value));
 }
+/** Absolute numeric ceilings applied at load (manifest clamps refine these). */
+const GAMEPLAY_LOAD_STAT_CAP = 1e6;
+const GAMEPLAY_LOAD_CURRENCY_CAP = 9999999;
+/** Sanitize the persisted per-pet gameplay map. */
+function loadGameplay(parsed) {
+	const result = {};
+	if (typeof parsed.gameplay !== "object" || parsed.gameplay === null) return result;
+	for (const [petId, raw] of Object.entries(parsed.gameplay)) {
+		if (petId === "" || typeof raw !== "object" || raw === null) continue;
+		const record = raw;
+		const stats = {};
+		if (typeof record.stats === "object" && record.stats !== null) for (const [key, value] of Object.entries(record.stats)) {
+			if (key === "" || typeof value !== "number" || !Number.isFinite(value)) continue;
+			stats[key] = Math.min(GAMEPLAY_LOAD_STAT_CAP, Math.max(0, value));
+		}
+		const currencies = {};
+		if (typeof record.currencies === "object" && record.currencies !== null) for (const [key, value] of Object.entries(record.currencies)) {
+			if (key === "" || typeof value !== "number" || !Number.isFinite(value)) continue;
+			currencies[key] = Math.min(GAMEPLAY_LOAD_CURRENCY_CAP, Math.max(0, Math.floor(value)));
+		}
+		result[petId] = {
+			stats,
+			currencies,
+			mode: record.mode === "work" || record.mode === "sleep" ? record.mode : null,
+			settledAt: clamp(finiteNum(record.settledAt, 0), Number.MAX_SAFE_INTEGER)
+		};
+	}
+	return result;
+}
 /** Load persisted state; missing or corrupt files fall back to defaults. */
 function loadPetPersist(dir = petHomeDir()) {
 	try {
@@ -1442,7 +1404,8 @@ function loadPetPersist(dir = petHomeDir()) {
 			names,
 			affinity,
 			treats,
-			display
+			display,
+			gameplay: loadGameplay(parsed)
 		};
 	} catch {
 		return emptyPersist();
@@ -1487,7 +1450,7 @@ const PLACEHOLDER_WHITELIST = {
 		"{points}"
 	]
 };
-function isRecord$2(value) {
+function isRecord$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /** Trim, length-cap and placeholder-check one copy line; undefined to drop. */
@@ -1538,55 +1501,51 @@ function normalizePool(raw, kind, onWarning = () => {}) {
 	}
 	return pool;
 }
-/** Normalize the ordered keyword-rule list ([] disables the keyword channel). */
-function normalizeWhisperRules(raw, onWarning = () => {}) {
+/** Normalize whisper category pools; a key replaces that category's built-in pool (an explicit empty pool mutes it). */
+function normalizeWhisperCategories(raw, onWarning = () => {}) {
 	if (raw === void 0) return void 0;
-	if (!Array.isArray(raw)) {
-		onWarning("whispers.rules must be an array");
+	if (!isRecord$3(raw)) {
+		onWarning("whispers.categories must be an object");
 		return;
 	}
-	if (raw.length > 32) onWarning("whispers.rules has more than 32 rules; extra rules are ignored");
-	const rules = [];
-	for (const item of raw.slice(0, 32)) {
-		if (!isRecord$2(item)) {
-			onWarning("whisper rule must be an object");
+	const pools = {};
+	for (const key of Object.keys(raw)) {
+		if (!WHISPER_CATEGORIES.includes(key)) {
+			onWarning("unknown whisper category " + key + " ignored");
 			continue;
 		}
-		for (const key of Object.keys(item)) if (key !== "keywords" && key !== "pool") onWarning("unknown whisper rule field " + key + " ignored");
-		const keywordsRaw = item.keywords;
-		const keywords = [];
-		if (Array.isArray(keywordsRaw)) {
-			for (const entry of keywordsRaw.slice(0, 16)) {
-				if (typeof entry !== "string") {
-					onWarning("non-string keyword dropped");
-					continue;
-				}
-				const trimmed = entry.trim().toLowerCase().slice(0, 40);
-				if (trimmed !== "") keywords.push(trimmed);
-			}
-			if (keywordsRaw.length > 16) onWarning("rule has more than 16 keywords; extra keywords are ignored");
-		}
-		const pool = normalizePool(item.pool, "whisperRule", onWarning);
-		if (keywords.length === 0 || pool === void 0 || pool.length === 0) {
-			onWarning("whisper rule dropped (needs keywords and a non-empty pool)");
+		const pool = normalizePool(raw[key], "whisperCategory", onWarning);
+		if (pool !== void 0) pools[key] = pool;
+	}
+	return Object.keys(pools).length > 0 ? pools : void 0;
+}
+/** Normalize whisper outcome pools; a key replaces that outcome's built-in pool (an explicit empty pool mutes it). */
+function normalizeWhisperResults(raw, onWarning = () => {}) {
+	if (raw === void 0) return void 0;
+	if (!isRecord$3(raw)) {
+		onWarning("whispers.results must be an object");
+		return;
+	}
+	const pools = {};
+	for (const key of Object.keys(raw)) {
+		if (!WHISPER_RESULTS.includes(key)) {
+			onWarning("unknown whisper result " + key + " ignored");
 			continue;
 		}
-		rules.push({
-			keywords,
-			pool
-		});
+		const pool = normalizePool(raw[key], "whisperResult", onWarning);
+		if (pool !== void 0) pools[key] = pool;
 	}
-	return rules;
+	return Object.keys(pools).length > 0 ? pools : void 0;
 }
 /** Normalize the panel block (labels / stats / actions; warn-and-drop). */
 function normalizePanel(raw, onWarning = () => {}) {
-	if (!isRecord$2(raw)) {
+	if (!isRecord$3(raw)) {
 		onWarning("panel must be an object");
 		return;
 	}
 	const panel = {};
 	const labelsRaw = raw.labels;
-	if (labelsRaw !== void 0) if (!isRecord$2(labelsRaw)) onWarning("panel.labels must be an object");
+	if (labelsRaw !== void 0) if (!isRecord$3(labelsRaw)) onWarning("panel.labels must be an object");
 	else {
 		const labels = {};
 		for (const key of PANEL_LABEL_KEYS) {
@@ -1602,7 +1561,7 @@ function normalizePanel(raw, onWarning = () => {}) {
 		if (Object.keys(labels).length > 0) panel.labels = labels;
 	}
 	const statsRaw = raw.stats;
-	if (statsRaw !== void 0) if (!isRecord$2(statsRaw)) onWarning("panel.stats must be an object");
+	if (statsRaw !== void 0) if (!isRecord$3(statsRaw)) onWarning("panel.stats must be an object");
 	else {
 		const stats = {};
 		for (const key of PANEL_STAT_KEYS) {
@@ -1644,7 +1603,7 @@ const VOICE_PACK_KEYS = /* @__PURE__ */ new Set([
 	"panel"
 ]);
 /** Allowed whisper-section fields (drift-locked in tests). */
-const WHISPER_KEYS = /* @__PURE__ */ new Set(["generic", "rules"]);
+const WHISPER_KEYS = /* @__PURE__ */ new Set(["categories", "results"]);
 /**
 * Normalize one raw voice.json document into a VoicePack, or undefined when
 * the file cannot serve as a pack at all (non-object root — structure is
@@ -1652,7 +1611,7 @@ const WHISPER_KEYS = /* @__PURE__ */ new Set(["generic", "rules"]);
 */
 function normalizeVoicePack(raw, onWarning = () => {}) {
 	if (raw === void 0) return void 0;
-	if (!isRecord$2(raw)) {
+	if (!isRecord$3(raw)) {
 		onWarning("voice.json must be a JSON object; the file is ignored");
 		return;
 	}
@@ -1661,7 +1620,7 @@ function normalizeVoicePack(raw, onWarning = () => {}) {
 	if (version !== void 0 && (typeof version !== "number" || version !== 1)) onWarning("voicePackVersion " + String(version) + " is not supported; reading as v1 best-effort");
 	const overrides = {};
 	const statusRaw = raw.status;
-	if (statusRaw !== void 0) if (!isRecord$2(statusRaw)) onWarning("status must be an object");
+	if (statusRaw !== void 0) if (!isRecord$3(statusRaw)) onWarning("status must be an object");
 	else for (const key of Object.keys(statusRaw)) {
 		if (!STATUS_SCENES.includes(key)) {
 			onWarning("unknown status scene " + key + " ignored");
@@ -1674,7 +1633,7 @@ function normalizeVoicePack(raw, onWarning = () => {}) {
 		};
 	}
 	const toolsRaw = raw.tools;
-	if (toolsRaw !== void 0) if (!isRecord$2(toolsRaw)) onWarning("tools must be an object");
+	if (toolsRaw !== void 0) if (!isRecord$3(toolsRaw)) onWarning("tools must be an object");
 	else for (const key of Object.keys(toolsRaw)) {
 		if (!TOOL_CATEGORIES.includes(key)) {
 			onWarning("unknown tool family " + key + " ignored");
@@ -1692,14 +1651,15 @@ function normalizeVoicePack(raw, onWarning = () => {}) {
 		if (pool !== void 0 && pool.length > 0) overrides.toolRemaining = pool;
 	}
 	const whispersRaw = raw.whispers;
-	if (whispersRaw !== void 0) if (!isRecord$2(whispersRaw)) onWarning("whispers must be an object");
+	if (whispersRaw !== void 0) if (!isRecord$3(whispersRaw)) onWarning("whispers must be an object");
 	else {
-		for (const key of Object.keys(whispersRaw)) if (!WHISPER_KEYS.has(key)) onWarning("unknown whispers field " + key + " ignored");
-		const generic = normalizePool(whispersRaw.generic, "whisperGeneric", onWarning);
-		const rules = normalizeWhisperRules(whispersRaw.rules, onWarning);
-		if (generic !== void 0 || rules !== void 0) overrides.whispers = {
-			...generic === void 0 ? {} : { generic },
-			...rules === void 0 ? {} : { rules }
+		for (const key of Object.keys(whispersRaw)) if (key === "generic" || key === "rules") onWarning("whispers." + key + " is no longer supported and was ignored");
+		else if (!WHISPER_KEYS.has(key)) onWarning("unknown whispers field " + key + " ignored");
+		const categories = normalizeWhisperCategories(whispersRaw.categories, onWarning);
+		const results = normalizeWhisperResults(whispersRaw.results, onWarning);
+		if (categories !== void 0 || results !== void 0) overrides.whispers = {
+			...categories === void 0 ? {} : { categories },
+			...results === void 0 ? {} : { results }
 		};
 	}
 	const panel = raw.panel === void 0 ? void 0 : normalizePanel(raw.panel, onWarning);
@@ -1757,8 +1717,585 @@ function mergeVoicePacks(...layers) {
 		...panelSeen && !panelEmpty ? { panel } : {}
 	};
 }
+//#endregion
+//#region src/gameplay.ts
+const KEBAB = /^[a-z0-9][a-z0-9-]*$/;
+const MAX_STATS = 16;
+const MAX_ZONES = 8;
+const MAX_BRANCHES = 8;
+const MAX_ACTS = 16;
+const MAX_SHOP_ITEMS = 32;
+const MAX_LOTTERY_TIERS = 16;
+const MAX_PHRASES = 64;
+const PHRASE_MAX_LENGTH = 120;
+const STAT_VALUE_MAX = 1e6;
+const CURRENCY_MAX = 9999999;
+const KNOWN_GAMEPLAY = /* @__PURE__ */ new Set([
+	"idleDirector",
+	"stats",
+	"hitBox",
+	"touch",
+	"work",
+	"sleep",
+	"passiveIncome",
+	"shop",
+	"dragState",
+	"dragEndState"
+]);
+const KNOWN_STAT = /* @__PURE__ */ new Set([
+	"max",
+	"initial",
+	"decayPerMinute",
+	"workingDecayPerMinute",
+	"idleDecayPerMinute"
+]);
+const KNOWN_ZONE = /* @__PURE__ */ new Set([
+	"name",
+	"y0",
+	"y1",
+	"branches"
+]);
+const KNOWN_TOUCH = /* @__PURE__ */ new Set(["zones", "clickBoost"]);
+const KNOWN_BRANCH = /* @__PURE__ */ new Set([
+	"probability",
+	"effects",
+	"state",
+	"stateMs",
+	"phrases"
+]);
+const KNOWN_EFFECT = /* @__PURE__ */ new Set([
+	"stat",
+	"currency",
+	"amount"
+]);
+const KNOWN_WORK = /* @__PURE__ */ new Set([
+	"state",
+	"successState",
+	"failState",
+	"tickMs",
+	"resultMs",
+	"successProbability",
+	"success",
+	"fail"
+]);
+const KNOWN_SLEEP = /* @__PURE__ */ new Set([
+	"state",
+	"wakeState",
+	"restore"
+]);
+const KNOWN_SHOP_ITEM = /* @__PURE__ */ new Set([
+	"id",
+	"label",
+	"image",
+	"price",
+	"currency",
+	"effects",
+	"lottery"
+]);
+const KNOWN_LOTTERY = /* @__PURE__ */ new Set([
+	"effects",
+	"currency",
+	"tiers"
+]);
+const KNOWN_IDLE_DIRECTOR = /* @__PURE__ */ new Set([
+	"intervalMs",
+	"maxMiss",
+	"idleWeight",
+	"acts"
+]);
+const KNOWN_ACT = /* @__PURE__ */ new Set([
+	"track",
+	"weight",
+	"phrases"
+]);
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function unknownKeys$2(source, known) {
+	return Object.keys(source).filter((key) => !known.has(key));
+}
+function validName(name, max = 32) {
+	return typeof name === "string" && name.length <= max && KEBAB.test(name);
+}
+function intIn(value, min, max) {
+	return typeof value === "number" && Number.isInteger(value) && value >= min && value <= max;
+}
+function numIn(value, min, max) {
+	return typeof value === "number" && Number.isFinite(value) && value >= min && value <= max;
+}
+function parseEffects(raw, field, stats, hooks) {
+	if (raw === void 0) return void 0;
+	if (!Array.isArray(raw) || raw.length === 0) {
+		hooks.error(field + " must be a non-empty array of effects");
+		return;
+	}
+	const effects = [];
+	for (const entry of raw) {
+		if (!isRecord$2(entry)) {
+			hooks.error(field + ": every effect must be an object");
+			continue;
+		}
+		const extra = unknownKeys$2(entry, KNOWN_EFFECT);
+		if (extra.length > 0) hooks.error(field + ": unknown effect field(s) " + extra.map((k) => JSON.stringify(k)).join(", "));
+		const hasStat = typeof entry.stat === "string";
+		const hasCurrency = typeof entry.currency === "string";
+		if (hasStat === hasCurrency) {
+			hooks.error(field + ": an effect needs exactly one of stat or currency");
+			continue;
+		}
+		if (!intIn(entry.amount, -1e6, STAT_VALUE_MAX) || entry.amount === 0) {
+			hooks.error(field + ": effect amount must be a non-zero integer within ±1000000");
+			continue;
+		}
+		if (hasStat && stats[entry.stat] === void 0) {
+			hooks.error(field + ": effect references undeclared stat " + JSON.stringify(entry.stat));
+			continue;
+		}
+		if (hasCurrency && !validName(entry.currency, 24)) {
+			hooks.error(field + ": effect currency must be a kebab id");
+			continue;
+		}
+		effects.push({
+			...hasStat ? { stat: entry.stat } : {},
+			...hasCurrency ? { currency: entry.currency } : {},
+			amount: entry.amount
+		});
+	}
+	return effects.length === 0 ? void 0 : effects;
+}
+function parsePhrases(raw, field, hooks) {
+	if (raw === void 0) return void 0;
+	if (!Array.isArray(raw) || raw.length === 0 || raw.length > MAX_PHRASES || raw.some((line) => typeof line !== "string" || line.trim() === "" || line.length > PHRASE_MAX_LENGTH)) {
+		hooks.error(field + " must be 1..64 non-empty lines of at most 120 chars");
+		return;
+	}
+	return raw;
+}
+function parseStateRef(raw, field, hooks) {
+	if (raw === void 0) return void 0;
+	if (typeof raw !== "string" || !hooks.stateNames.has(raw)) {
+		hooks.error(field + " must name a declared frames2d track");
+		return;
+	}
+	return raw;
+}
+/**
+* Validate the manifest 'gameplay' block (fail-closed). Only frames2d pets
+* may declare gameplay today: every state reference checks against the
+* declared track names.
+*/
+function parseGameplayManifest(raw, hooks) {
+	const error = (message) => hooks.error(message);
+	if (!isRecord$2(raw)) {
+		error("gameplay must be an object");
+		return;
+	}
+	const extra = unknownKeys$2(raw, KNOWN_GAMEPLAY);
+	if (extra.length > 0) error("gameplay: unknown field(s) " + extra.map((k) => JSON.stringify(k)).join(", "));
+	let failed = false;
+	const fail = (message) => {
+		failed = true;
+		error(message);
+	};
+	const stats = {};
+	if (raw.stats !== void 0) if (!isRecord$2(raw.stats)) fail("gameplay.stats must be an object keyed by stat id");
+	else {
+		const entries = Object.entries(raw.stats);
+		if (entries.length > MAX_STATS) fail("gameplay.stats declares too many stats (max 16)");
+		for (const [name, value] of entries) {
+			if (!validName(name, 24)) {
+				fail("gameplay.stats: invalid stat id " + JSON.stringify(name));
+				continue;
+			}
+			if (!isRecord$2(value)) {
+				fail("gameplay.stats." + name + " must be an object");
+				continue;
+			}
+			const statExtra = unknownKeys$2(value, KNOWN_STAT);
+			if (statExtra.length > 0) fail("gameplay.stats." + name + ": unknown field(s) " + statExtra.map((k) => JSON.stringify(k)).join(", "));
+			if (!intIn(value.max, 1, STAT_VALUE_MAX)) {
+				fail("gameplay.stats." + name + ".max must be an integer in [1, 1000000]");
+				continue;
+			}
+			const def = { max: value.max };
+			if (value.initial !== void 0) if (!numIn(value.initial, 0, value.max)) fail("gameplay.stats." + name + ".initial must be within [0, max]");
+			else def.initial = value.initial;
+			for (const key of [
+				"decayPerMinute",
+				"workingDecayPerMinute",
+				"idleDecayPerMinute"
+			]) if (value[key] !== void 0) if (!numIn(value[key], 0, 1e3)) fail("gameplay.stats." + name + "." + key + " must be a number in [0, 1000]");
+			else def[key] = value[key];
+			stats[name] = def;
+		}
+	}
+	const block = {};
+	if (Object.keys(stats).length > 0) block.stats = stats;
+	if (raw.idleDirector !== void 0) if (!isRecord$2(raw.idleDirector) || !Array.isArray(raw.idleDirector.acts)) fail("gameplay.idleDirector must be an object with an acts array");
+	else {
+		const d = raw.idleDirector;
+		const dExtra = unknownKeys$2(d, KNOWN_IDLE_DIRECTOR);
+		if (dExtra.length > 0) fail("gameplay.idleDirector: unknown field(s) " + dExtra.map((k) => JSON.stringify(k)).join(", "));
+		if (d.intervalMs !== void 0 && !intIn(d.intervalMs, 1e3, 6e4)) fail("gameplay.idleDirector.intervalMs must be an integer in [1000, 60000]");
+		if (d.maxMiss !== void 0 && !intIn(d.maxMiss, 0, 10)) fail("gameplay.idleDirector.maxMiss must be an integer in [0, 10]");
+		if (d.idleWeight !== void 0 && !intIn(d.idleWeight, 0, 1e4)) fail("gameplay.idleDirector.idleWeight must be an integer in [0, 10000]");
+		if (d.acts.length === 0 || d.acts.length > MAX_ACTS) fail("gameplay.idleDirector.acts must declare 1..16 acts");
+		const acts = [];
+		for (const act of d.acts) {
+			if (!isRecord$2(act) || !intIn(act.weight, 1, 1e4)) {
+				fail("gameplay.idleDirector.acts entries need a weight integer in [1, 10000]");
+				continue;
+			}
+			const aExtra = unknownKeys$2(act, KNOWN_ACT);
+			if (aExtra.length > 0) fail("gameplay.idleDirector.acts: unknown field(s) " + aExtra.map((k) => JSON.stringify(k)).join(", "));
+			const track = parseStateRef(act.track, "gameplay.idleDirector.acts.track", hooks);
+			if (track === void 0) continue;
+			const entry = {
+				track,
+				weight: act.weight
+			};
+			const phrases = parsePhrases(act.phrases, "gameplay.idleDirector.acts.phrases", hooks);
+			if (phrases !== void 0) entry.phrases = phrases;
+			acts.push(entry);
+		}
+		if (acts.length > 0) block.idleDirector = {
+			intervalMs: intIn(d.intervalMs, 1e3, 6e4) ? d.intervalMs : 5e3,
+			maxMiss: intIn(d.maxMiss, 0, 10) ? d.maxMiss : 2,
+			idleWeight: intIn(d.idleWeight, 0, 1e4) ? d.idleWeight : 0,
+			acts
+		};
+	}
+	if (raw.hitBox !== void 0) {
+		const b = raw.hitBox;
+		if (!isRecord$2(b) || !numIn(b.x0, 0, 1) || !numIn(b.x1, 0, 1) || !numIn(b.y0, 0, 1) || !numIn(b.y1, 0, 1) || !(b.x0 < b.x1) || !(b.y0 < b.y1)) fail("gameplay.hitBox must be { x0, y0, x1, y1 } fractions with x0 < x1 and y0 < y1");
+		else block.hitBox = {
+			x0: b.x0,
+			y0: b.y0,
+			x1: b.x1,
+			y1: b.y1
+		};
+	}
+	if (raw.touch !== void 0) if (!isRecord$2(raw.touch) || !Array.isArray(raw.touch.zones)) fail("gameplay.touch must be an object with a zones array");
+	else {
+		const tExtra = unknownKeys$2(raw.touch, KNOWN_TOUCH);
+		if (tExtra.length > 0) fail("gameplay.touch: unknown field(s) " + tExtra.map((k) => JSON.stringify(k)).join(", "));
+		let clickBoost;
+		if (raw.touch.clickBoost !== void 0) {
+			const cb = raw.touch.clickBoost;
+			if (!isRecord$2(cb) || typeof cb.stat !== "string" || stats[cb.stat] === void 0 || !intIn(cb.min, 0, 1e3) || !intIn(cb.max, 0, 1e3) || cb.min > cb.max) fail("gameplay.touch.clickBoost must be { stat (declared), min, max } integers with 0 <= min <= max <= 1000");
+			else clickBoost = {
+				stat: cb.stat,
+				min: cb.min,
+				max: cb.max
+			};
+		}
+		const zones = [];
+		if (raw.touch.zones.length === 0 || raw.touch.zones.length > MAX_ZONES) fail("gameplay.touch.zones must declare 1..8 zones");
+		for (const zoneRaw of raw.touch.zones) {
+			if (!isRecord$2(zoneRaw) || !validName(zoneRaw.name) || !numIn(zoneRaw.y0, 0, 1) || !numIn(zoneRaw.y1, 0, 1) || !(zoneRaw.y0 < zoneRaw.y1)) {
+				fail("gameplay.touch.zones entries need a kebab name and 0 <= y0 < y1 <= 1");
+				continue;
+			}
+			const zExtra = unknownKeys$2(zoneRaw, KNOWN_ZONE);
+			if (zExtra.length > 0) fail("gameplay.touch." + zoneRaw.name + ": unknown field(s) " + zExtra.map((k) => JSON.stringify(k)).join(", "));
+			if (!Array.isArray(zoneRaw.branches) || zoneRaw.branches.length === 0 || zoneRaw.branches.length > MAX_BRANCHES) {
+				fail("gameplay.touch." + zoneRaw.name + ".branches must declare 1..8 branches");
+				continue;
+			}
+			let probabilitySum = 0;
+			const branches = [];
+			for (const branchRaw of zoneRaw.branches) {
+				if (!isRecord$2(branchRaw) || !numIn(branchRaw.probability, 0, 1) || branchRaw.probability === 0) {
+					fail("gameplay.touch." + zoneRaw.name + ".branches entries need a probability in (0, 1]");
+					continue;
+				}
+				const bExtra = unknownKeys$2(branchRaw, KNOWN_BRANCH);
+				if (bExtra.length > 0) fail("gameplay.touch." + zoneRaw.name + ": unknown branch field(s) " + bExtra.map((k) => JSON.stringify(k)).join(", "));
+				probabilitySum += branchRaw.probability;
+				const branch = { probability: branchRaw.probability };
+				const effects = parseEffects(branchRaw.effects, "gameplay.touch." + zoneRaw.name + ".effects", stats, hooks);
+				if (effects !== void 0) branch.effects = effects;
+				const state = parseStateRef(branchRaw.state, "gameplay.touch." + zoneRaw.name + ".state", hooks);
+				if (state !== void 0) branch.state = state;
+				if (branchRaw.stateMs !== void 0) if (!intIn(branchRaw.stateMs, 200, 1e4)) fail("gameplay.touch." + zoneRaw.name + ".stateMs must be an integer in [200, 10000]");
+				else branch.stateMs = branchRaw.stateMs;
+				const phrases = parsePhrases(branchRaw.phrases, "gameplay.touch." + zoneRaw.name + ".phrases", hooks);
+				if (phrases !== void 0) branch.phrases = phrases;
+				branches.push(branch);
+			}
+			if (probabilitySum > 1.000000001) fail("gameplay.touch." + zoneRaw.name + ": branch probabilities must sum to at most 1");
+			if (branches.length > 0) zones.push({
+				name: zoneRaw.name,
+				y0: zoneRaw.y0,
+				y1: zoneRaw.y1,
+				branches
+			});
+		}
+		if (zones.length > 0 || clickBoost !== void 0) block.touch = {
+			zones,
+			...clickBoost === void 0 ? {} : { clickBoost }
+		};
+	}
+	if (raw.work !== void 0) {
+		const w = raw.work;
+		if (!isRecord$2(w)) fail("gameplay.work must be an object");
+		else {
+			const wExtra = unknownKeys$2(w, KNOWN_WORK);
+			if (wExtra.length > 0) fail("gameplay.work: unknown field(s) " + wExtra.map((k) => JSON.stringify(k)).join(", "));
+			const state = parseStateRef(w.state, "gameplay.work.state", hooks);
+			const successState = parseStateRef(w.successState, "gameplay.work.successState", hooks);
+			const failState = parseStateRef(w.failState, "gameplay.work.failState", hooks);
+			if (!intIn(w.tickMs, 1e3, 6e4)) fail("gameplay.work.tickMs must be an integer in [1000, 60000]");
+			if (!numIn(w.successProbability, 0, 1)) fail("gameplay.work.successProbability must be a number in [0, 1]");
+			if (state !== void 0 && successState !== void 0 && failState !== void 0 && intIn(w.tickMs, 1e3, 6e4) && numIn(w.successProbability, 0, 1)) {
+				const work = {
+					state,
+					successState,
+					failState,
+					tickMs: w.tickMs,
+					successProbability: w.successProbability
+				};
+				if (w.resultMs !== void 0) if (!isRecord$2(w.resultMs) || !intIn(w.resultMs.success, 200, 1e4) || !intIn(w.resultMs.fail, 200, 1e4)) fail("gameplay.work.resultMs must be { success, fail } integers in [200, 10000]");
+				else work.resultMs = {
+					success: w.resultMs.success,
+					fail: w.resultMs.fail
+				};
+				for (const key of ["success", "fail"]) if (w[key] !== void 0) if (!isRecord$2(w[key])) fail("gameplay.work." + key + " must be an object { effects }");
+				else {
+					const effects = parseEffects(w[key].effects, "gameplay.work." + key + ".effects", stats, hooks);
+					if (effects !== void 0) work[key] = { effects };
+				}
+				block.work = work;
+			}
+		}
+	}
+	if (raw.sleep !== void 0) {
+		const s = raw.sleep;
+		if (!isRecord$2(s) || !isRecord$2(s.restore)) fail("gameplay.sleep must be an object with a restore block");
+		else {
+			const sExtra = unknownKeys$2(s, KNOWN_SLEEP);
+			if (sExtra.length > 0) fail("gameplay.sleep: unknown field(s) " + sExtra.map((k) => JSON.stringify(k)).join(", "));
+			const state = parseStateRef(s.state, "gameplay.sleep.state", hooks);
+			const wakeState = parseStateRef(s.wakeState, "gameplay.sleep.wakeState", hooks);
+			const restoreStat = typeof s.restore.stat === "string" && stats[s.restore.stat] !== void 0 ? s.restore.stat : void 0;
+			if (restoreStat === void 0) fail("gameplay.sleep.restore.stat must reference a declared stat");
+			if (!intIn(s.restore.amount, 1, 1e3)) fail("gameplay.sleep.restore.amount must be an integer in [1, 1000]");
+			if (!intIn(s.restore.intervalMs, 1e3, 6e5)) fail("gameplay.sleep.restore.intervalMs must be an integer in [1000, 600000]");
+			if (state !== void 0 && restoreStat !== void 0 && intIn(s.restore.amount, 1, 1e3) && intIn(s.restore.intervalMs, 1e3, 6e5)) block.sleep = {
+				state,
+				...wakeState === void 0 ? {} : { wakeState },
+				restore: {
+					stat: restoreStat,
+					amount: s.restore.amount,
+					intervalMs: s.restore.intervalMs
+				}
+			};
+		}
+	}
+	if (raw.passiveIncome !== void 0) {
+		const p = raw.passiveIncome;
+		if (!isRecord$2(p) || !validName(p.currency, 24) || !intIn(p.amount, 1, 1e4) || !intIn(p.intervalMs, 1e3, 864e5)) fail("gameplay.passiveIncome must be { currency (kebab), amount 1..10000, intervalMs 1000..86400000 }");
+		else block.passiveIncome = {
+			currency: p.currency,
+			amount: p.amount,
+			intervalMs: p.intervalMs
+		};
+	}
+	if (raw.shop !== void 0) {
+		const s = raw.shop;
+		if (!isRecord$2(s) || !Array.isArray(s.items) || s.items.length === 0 || s.items.length > MAX_SHOP_ITEMS) fail("gameplay.shop must be an object with 1..32 items");
+		else {
+			const shopState = parseStateRef(s.state, "gameplay.shop.state", hooks);
+			const items = [];
+			const seen = /* @__PURE__ */ new Set();
+			for (const itemRaw of s.items) {
+				if (!isRecord$2(itemRaw) || !validName(itemRaw.id, 24)) {
+					fail("gameplay.shop.items entries need a kebab id");
+					continue;
+				}
+				if (seen.has(itemRaw.id)) {
+					fail("gameplay.shop: duplicate item id " + JSON.stringify(itemRaw.id));
+					continue;
+				}
+				seen.add(itemRaw.id);
+				const iExtra = unknownKeys$2(itemRaw, KNOWN_SHOP_ITEM);
+				if (iExtra.length > 0) fail("gameplay.shop." + itemRaw.id + ": unknown field(s) " + iExtra.map((k) => JSON.stringify(k)).join(", "));
+				if (typeof itemRaw.label !== "string" || itemRaw.label.trim() === "" || itemRaw.label.length > 80) {
+					fail("gameplay.shop." + itemRaw.id + ".label must be a non-empty string of at most 80 chars");
+					continue;
+				}
+				if (!intIn(itemRaw.price, 1, 1e6)) {
+					fail("gameplay.shop." + itemRaw.id + ".price must be an integer in [1, 1000000]");
+					continue;
+				}
+				if (!validName(itemRaw.currency, 24)) {
+					fail("gameplay.shop." + itemRaw.id + ".currency must be a kebab id");
+					continue;
+				}
+				const item = {
+					id: itemRaw.id,
+					label: itemRaw.label.trim(),
+					price: itemRaw.price,
+					currency: itemRaw.currency
+				};
+				if (itemRaw.image !== void 0) if (typeof itemRaw.image !== "string" || itemRaw.image.includes("..") || itemRaw.image.includes("\\") || itemRaw.image.startsWith("/")) fail("gameplay.shop." + itemRaw.id + ".image must be a safe manifest-relative frame path");
+				else item.image = itemRaw.image;
+				const effects = parseEffects(itemRaw.effects, "gameplay.shop." + itemRaw.id + ".effects", stats, hooks);
+				if (effects !== void 0) item.effects = effects;
+				if (itemRaw.lottery !== void 0) {
+					const l = itemRaw.lottery;
+					if (!isRecord$2(l) || !Array.isArray(l.tiers) || l.tiers.length === 0 || l.tiers.length > MAX_LOTTERY_TIERS) fail("gameplay.shop." + itemRaw.id + ".lottery needs 1..16 tiers");
+					else {
+						const lExtra = unknownKeys$2(l, KNOWN_LOTTERY);
+						if (lExtra.length > 0) fail("gameplay.shop." + itemRaw.id + ".lottery: unknown field(s) " + lExtra.map((k) => JSON.stringify(k)).join(", "));
+						if (l.currency !== void 0 && !validName(l.currency, 24)) fail("gameplay.shop." + itemRaw.id + ".lottery.currency must be a kebab id");
+						let tierSum = 0;
+						const tiers = [];
+						for (const tierRaw of l.tiers) {
+							if (!isRecord$2(tierRaw) || !numIn(tierRaw.probability, 0, 1) || tierRaw.probability === 0 || !intIn(tierRaw.prize, 0, 1e9)) {
+								fail("gameplay.shop." + itemRaw.id + ".lottery.tiers entries need probability (0,1] and prize 0..1e9");
+								continue;
+							}
+							tierSum += tierRaw.probability;
+							const tier = {
+								probability: tierRaw.probability,
+								prize: tierRaw.prize
+							};
+							if (tierRaw.currency !== void 0) if (!validName(tierRaw.currency, 24)) fail("gameplay.shop." + itemRaw.id + ".lottery tier currency must be a kebab id");
+							else tier.currency = tierRaw.currency;
+							tiers.push(tier);
+						}
+						if (tierSum > 1.000000001) fail("gameplay.shop." + itemRaw.id + ".lottery tier probabilities must sum to at most 1");
+						if (tiers.length > 0) {
+							const lotteryEffects = parseEffects(l.effects, "gameplay.shop." + itemRaw.id + ".lottery.effects", stats, hooks);
+							item.lottery = {
+								tiers,
+								...lotteryEffects === void 0 ? {} : { effects: lotteryEffects },
+								...validName(l.currency, 24) ? { currency: l.currency } : {}
+							};
+						}
+					}
+				}
+				if (item.effects === void 0 && item.lottery === void 0) {
+					fail("gameplay.shop." + itemRaw.id + " needs effects or a lottery");
+					continue;
+				}
+				items.push(item);
+			}
+			if (items.length > 0) block.shop = {
+				...shopState === void 0 ? {} : { state: shopState },
+				items
+			};
+		}
+	}
+	if (raw.dragState !== void 0) {
+		const state = parseStateRef(raw.dragState, "gameplay.dragState", hooks);
+		if (state !== void 0) block.dragState = state;
+	}
+	if (raw.dragEndState !== void 0) {
+		const state = parseStateRef(raw.dragEndState, "gameplay.dragEndState", hooks);
+		if (state !== void 0) block.dragEndState = state;
+	}
+	return failed ? void 0 : block;
+}
+/** Fresh state for one pet: stats at their initial (default max), no currency. */
+function initialGameplayState(manifest, now) {
+	const stats = {};
+	for (const [name, def] of Object.entries(manifest.stats ?? {})) stats[name] = def.initial ?? def.max;
+	return {
+		stats,
+		currencies: {},
+		mode: null,
+		settledAt: now
+	};
+}
+/** Clamp one stat value into [0, max]; currencies into [0, CURRENCY_MAX]. */
+function clampGameplay(state, manifest) {
+	for (const [name, def] of Object.entries(manifest.stats ?? {})) {
+		const value = state.stats[name];
+		if (value === void 0) state.stats[name] = def.initial ?? def.max;
+		else state.stats[name] = Math.min(def.max, Math.max(0, value));
+	}
+	for (const [name, value] of Object.entries(state.currencies)) state.currencies[name] = Math.min(CURRENCY_MAX, Math.max(0, Math.floor(value)));
+}
+/**
+* Lazy settle: apply stat decay, passive income and sleep restore for the
+* elapsed wall time since the last settle. Mirrors the treats.ts discipline
+* (no host timers; read paths settle). Returns whether anything changed.
+*/
+function settleGameplay(state, manifest, now, options) {
+	const elapsedMs = now - state.settledAt;
+	if (elapsedMs <= 0) return false;
+	const minutes = elapsedMs / 6e4;
+	let changed = false;
+	for (const [name, def] of Object.entries(manifest.stats ?? {})) {
+		const current = state.stats[name];
+		if (current === void 0 || current <= 0) continue;
+		let rate = def.decayPerMinute ?? 0;
+		if (state.mode === "work" && def.workingDecayPerMinute !== void 0) rate = def.workingDecayPerMinute;
+		if (!options.sessionActive) rate += def.idleDecayPerMinute ?? 0;
+		if (rate <= 0) continue;
+		const next = Math.max(0, current - rate * minutes);
+		if (next !== current) {
+			state.stats[name] = next;
+			changed = true;
+		}
+	}
+	if (manifest.passiveIncome !== void 0) {
+		const ticks = Math.floor(elapsedMs / manifest.passiveIncome.intervalMs);
+		if (ticks > 0) {
+			const currency = manifest.passiveIncome.currency;
+			state.currencies[currency] = (state.currencies[currency] ?? 0) + ticks * manifest.passiveIncome.amount;
+			changed = true;
+		}
+	}
+	if (state.mode === "sleep" && manifest.sleep !== void 0) {
+		const ticks = Math.floor(elapsedMs / manifest.sleep.restore.intervalMs);
+		if (ticks > 0) {
+			const stat = manifest.sleep.restore.stat;
+			state.stats[stat] = (state.stats[stat] ?? 0) + ticks * manifest.sleep.restore.amount;
+			changed = true;
+		}
+	}
+	state.settledAt = now;
+	clampGameplay(state, manifest);
+	return changed;
+}
+/** Apply one effect vector (touch/work/shop), clamped. */
+function applyGameplayEffects(state, manifest, effects) {
+	for (const effect of effects) if (effect.stat !== void 0) state.stats[effect.stat] = (state.stats[effect.stat] ?? 0) + effect.amount;
+	else if (effect.currency !== void 0) state.currencies[effect.currency] = (state.currencies[effect.currency] ?? 0) + effect.amount;
+	clampGameplay(state, manifest);
+}
+/** Roll one touch zone branch; undefined when the roll lands in no-op mass. */
+function rollTouchBranch(zone, rng) {
+	const roll = rng();
+	let acc = 0;
+	for (const branch of zone.branches) {
+		acc += branch.probability;
+		if (roll < acc) return branch;
+	}
+}
+/** Roll one work tick outcome. */
+function rollWorkOutcome(work, rng) {
+	return rng() < work.successProbability ? "success" : "fail";
+}
+/** Draw one lottery prize tier; uncovered mass falls through to the last tier. */
+function drawLotteryTier(lottery, rng) {
+	const roll = rng();
+	let acc = 0;
+	for (const tier of lottery.tiers) {
+		acc += tier.probability;
+		if (roll < acc) return tier;
+	}
+	return lottery.tiers[lottery.tiers.length - 1];
+}
 /** Renderer kinds the pet center knows how to dispatch (M1 §2). */
-const PET_RENDERER_KINDS = ["sprite2d", "live2d"];
+const PET_RENDERER_KINDS = [
+	"sprite2d",
+	"live2d",
+	"frames2d"
+];
 /** The seven ActivityPhase semantics (pet-center owned; M1 §1). */
 const PET_ACTIVITY_PHASES = [
 	"idle",
@@ -1790,8 +2327,10 @@ const KNOWN_TOP_LEVEL = /* @__PURE__ */ new Set([
 	"renderer",
 	"sprite2d",
 	"live2d",
+	"frames2d",
 	"sequences",
-	"remarks"
+	"remarks",
+	"gameplay"
 ]);
 /** sprite2d block field allow-list (drift-locked to the schema file). */
 const KNOWN_SPRITE2D = /* @__PURE__ */ new Set([
@@ -1812,6 +2351,20 @@ const KNOWN_LIVE2D = /* @__PURE__ */ new Set([
 	"hitAreas",
 	"lipSync"
 ]);
+/** frames2d block field allow-list (drift-locked to the schema file). */
+const KNOWN_FRAMES2D = /* @__PURE__ */ new Set([
+	"dir",
+	"defaultFrameMs",
+	"tracks",
+	"phases"
+]);
+/** frames2d track field allow-list (drift-locked to the schema file). */
+const KNOWN_FRAMES2D_TRACK = /* @__PURE__ */ new Set([
+	"frames",
+	"frameMs",
+	"loop",
+	"fallback"
+]);
 var Diagnostics$1 = class {
 	list = [];
 	source;
@@ -1958,6 +2511,106 @@ function parseLive2dBlock(raw, diag) {
 	else block.lipSync = raw.lipSync;
 	return diag.hasErrors ? void 0 : block;
 }
+const FRAMES2D_TRACK_NAME = /^[a-z0-9][a-z0-9-]*$/;
+const FRAMES2D_MAX_TRACKS = 64;
+const FRAMES2D_MAX_FRAMES = 64;
+const FRAMES2D_MIN_FRAME_MS = 16;
+const FRAMES2D_MAX_FRAME_MS = 5e3;
+const FRAMES2D_IMAGE_EXTENSIONS$1 = /* @__PURE__ */ new Set([
+	".webp",
+	".png",
+	".gif",
+	".jpg",
+	".jpeg"
+]);
+/** Validate one frames2d track name (kebab id, at most 32 chars). */
+function validTrackName(name) {
+	return name.length <= 32 && FRAMES2D_TRACK_NAME.test(name);
+}
+/** A frames2d frame entry is a single image file name inside the track directory. */
+function safeFrameName(raw) {
+	if (typeof raw !== "string" || raw.trim() === "") return void 0;
+	const value = raw.trim();
+	if (value.includes("/") || value.includes("\\") || !PATH_SEGMENT_PATTERN$2.test(value)) return void 0;
+	const dot = value.lastIndexOf(".");
+	if (dot <= 0) return void 0;
+	if (!FRAMES2D_IMAGE_EXTENSIONS$1.has(value.slice(dot).toLowerCase())) return void 0;
+	return value;
+}
+function parseFrames2dTrack(raw, field, diag) {
+	if (!isRecord$1(raw)) {
+		diag.error(field + " must be an object");
+		return;
+	}
+	const extra = unknownKeys$1(raw, KNOWN_FRAMES2D_TRACK);
+	if (extra.length > 0) diag.error(field + ": unknown field(s) " + extra.map((k) => JSON.stringify(k)).join(", "));
+	const track = {};
+	if (raw.frames !== void 0) if (!Array.isArray(raw.frames) || raw.frames.length === 0) diag.error(field + ".frames must be a non-empty array of frame file names");
+	else if (raw.frames.length > FRAMES2D_MAX_FRAMES) diag.error(field + ".frames declares too many frames (" + raw.frames.length + ", max 64)");
+	else {
+		const frames = [];
+		for (const entry of raw.frames) {
+			const safe = safeFrameName(entry);
+			if (safe === void 0) diag.error(field + ".frames entry " + JSON.stringify(String(entry)) + " is not a safe image file name");
+			else frames.push(safe);
+		}
+		if (frames.length === raw.frames.length) track.frames = frames;
+	}
+	if (raw.frameMs !== void 0) if (!Array.isArray(raw.frameMs) || raw.frameMs.length === 0 || raw.frameMs.some((v) => typeof v !== "number" || !Number.isInteger(v) || v < FRAMES2D_MIN_FRAME_MS || v > FRAMES2D_MAX_FRAME_MS)) diag.error(field + ".frameMs must be a non-empty array of integer ms in [16, 5000]");
+	else if (track.frames === void 0) diag.error(field + ".frameMs requires a valid explicit frames list (directory tracks use filename-encoded ms or defaultFrameMs)");
+	else if (raw.frameMs.length !== track.frames.length) diag.error(field + ".frameMs must have the same length as frames");
+	else track.frameMs = raw.frameMs;
+	if (raw.loop !== void 0) if (typeof raw.loop !== "boolean") diag.error(field + ".loop must be a boolean");
+	else track.loop = raw.loop;
+	if (raw.fallback !== void 0) if (typeof raw.fallback !== "string" || !validTrackName(raw.fallback)) diag.error(field + ".fallback must be a track name");
+	else track.fallback = raw.fallback;
+	return diag.hasErrors ? void 0 : track;
+}
+function parseFrames2dBlock(raw, diag) {
+	if (!isRecord$1(raw)) {
+		diag.error("renderer frames2d requires a \"frames2d\" block object");
+		return;
+	}
+	const extra = unknownKeys$1(raw, KNOWN_FRAMES2D);
+	if (extra.length > 0) diag.error("frames2d: unknown field(s) " + extra.map((k) => JSON.stringify(k)).join(", "));
+	const block = {
+		tracks: {},
+		phases: { idle: "" }
+	};
+	if (raw.dir !== void 0) {
+		const dir = safeManifestPath(raw.dir);
+		if (dir === void 0) diag.error("frames2d.dir must be a safe manifest-relative directory");
+		else block.dir = dir;
+	}
+	if (raw.defaultFrameMs !== void 0) if (typeof raw.defaultFrameMs !== "number" || !Number.isInteger(raw.defaultFrameMs) || raw.defaultFrameMs < FRAMES2D_MIN_FRAME_MS || raw.defaultFrameMs > FRAMES2D_MAX_FRAME_MS) diag.error("frames2d.defaultFrameMs must be an integer in [16, 5000]");
+	else block.defaultFrameMs = raw.defaultFrameMs;
+	const tracks = {};
+	if (!isRecord$1(raw.tracks)) diag.error("frames2d.tracks is required and must be an object keyed by track name");
+	else {
+		const entries = Object.entries(raw.tracks);
+		if (entries.length === 0) diag.error("frames2d.tracks must declare at least one track");
+		if (entries.length > FRAMES2D_MAX_TRACKS) diag.error("frames2d.tracks declares too many tracks (" + entries.length + ", max 64)");
+		for (const [name, value] of entries) {
+			if (!validTrackName(name)) {
+				diag.error("frames2d.tracks: invalid track name " + JSON.stringify(name) + " (lowercase kebab, at most 32 chars)");
+				continue;
+			}
+			const track = parseFrames2dTrack(value, "frames2d.tracks." + name, diag);
+			if (track !== void 0) tracks[name] = track;
+		}
+	}
+	block.tracks = tracks;
+	const phases = parsePhaseStringMap(raw.phases, "frames2d.phases", diag);
+	if (raw.phases === void 0) diag.error("frames2d.phases is required (at least an \"idle\" mapping)");
+	else if (phases !== void 0 && phases.idle === void 0) diag.error("frames2d.phases.idle is required (unmapped phases fall back to it)");
+	const phasesValid = phases !== void 0 && phases.idle !== void 0;
+	if (phasesValid) block.phases = phases;
+	if (phasesValid) {
+		for (const [phase, target] of Object.entries(block.phases)) if (target !== void 0 && tracks[target] === void 0) diag.error("frames2d.phases." + phase + " references unknown track " + JSON.stringify(target));
+	}
+	for (const [name, track] of Object.entries(tracks)) if (track.fallback !== void 0 && tracks[track.fallback] === void 0) diag.error("frames2d.tracks." + name + ".fallback references unknown track " + JSON.stringify(track.fallback));
+	return diag.hasErrors ? void 0 : block;
+}
 /** v1 compat read: map the legacy flat manifest onto the v2 sprite2d shape. */
 function compatV1(source, diag) {
 	const id = parseStringBlock(source, "id", diag, true);
@@ -2017,10 +2670,25 @@ function parseV2(source, diag) {
 		const block = parseSprite2dBlock(source.sprite2d, diag);
 		if (block !== void 0) manifest.sprite2d = block;
 		if (source.live2d !== void 0) diag.error("renderer sprite2d must not declare a live2d block");
+		if (source.frames2d !== void 0) diag.error("renderer sprite2d must not declare a frames2d block");
 	} else if (renderer === "live2d") {
 		const block = parseLive2dBlock(source.live2d, diag);
 		if (block !== void 0) manifest.live2d = block;
 		if (source.sprite2d !== void 0) diag.error("renderer live2d must not declare a sprite2d block");
+		if (source.frames2d !== void 0) diag.error("renderer live2d must not declare a frames2d block");
+	} else if (renderer === "frames2d") {
+		const block = parseFrames2dBlock(source.frames2d, diag);
+		if (block !== void 0) manifest.frames2d = block;
+		if (source.sprite2d !== void 0) diag.error("renderer frames2d must not declare a sprite2d block");
+		if (source.live2d !== void 0) diag.error("renderer frames2d must not declare a live2d block");
+	}
+	if (source.gameplay !== void 0) if (renderer !== "frames2d") diag.error("gameplay currently requires renderer frames2d (its state references name frames2d tracks)");
+	else {
+		const gameplay = parseGameplayManifest(source.gameplay, {
+			stateNames: new Set(Object.keys(manifest.frames2d?.tracks ?? {})),
+			error: (message) => diag.error("gameplay: " + message)
+		});
+		if (gameplay !== void 0) manifest.gameplay = gameplay;
 	}
 	const sequences = parseSequences(source.sequences, diag);
 	if (sequences !== void 0) manifest.sequences = sequences;
@@ -2824,6 +3492,173 @@ function resolveLive2dEntry(manifest, dir, options) {
 		...remarks === void 0 ? {} : { remarks }
 	};
 }
+/** Filename-encoded frame duration tail ('<base>_<index>_<ms>.webp'). */
+const FRAMES2D_FILENAME_MS = /_(\d+)\.[^.]+$/;
+/** Trailing frame index, allowing an optional '_<ms>' duration tail after it. */
+const FRAMES2D_FRAME_INDEX = /(\d+)(?:_\d+)?\.[^.]+$/;
+/** Default per-frame duration when neither frameMs nor the filename encodes one. */
+const FRAMES2D_DEFAULT_FRAME_MS = 200;
+/** Image extensions a frames2d track directory may list. */
+const FRAMES2D_IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".webp",
+	".png",
+	".gif",
+	".jpg",
+	".jpeg"
+]);
+/**
+* Resolve a validated frames2d manifest into a renderable entry. Track frame
+* lists come from the manifest's explicit list or from listing
+* '<dir>/<track>/' in filename order; durations resolve frameMs[i] >
+* filename-encoded '_<ms>' tail > defaultFrameMs. Missing frames warn and
+* skip (the live2d closure discipline); a track left with zero frames is
+* dropped, and if the idle-mapped track ends up empty the entry is rejected
+* fail-closed. The sprite fields carry contract defaults: the chrome sizes
+* frames2d pets off 'display.size', not the atlas.
+*/
+function resolveFrames2dEntry(manifest, dir, options) {
+	const assetPrefix = options.assetPrefix ?? "/pet";
+	const record = (level, message) => {
+		options.diagnostics?.push({
+			level,
+			source: dir,
+			message
+		});
+		options.warnings?.push(message);
+	};
+	const block = manifest.frames2d;
+	if (block === void 0) {
+		record("error", "pet " + manifest.id + ": renderer frames2d requires a frames2d block");
+		return;
+	}
+	const root = block.dir ?? ".";
+	const defaultMs = block.defaultFrameMs ?? FRAMES2D_DEFAULT_FRAME_MS;
+	const idleTrack = block.phases.idle;
+	const tracks = {};
+	const servable = [];
+	const firstFrameRel = {};
+	for (const [name, track] of Object.entries(block.tracks)) {
+		const trackDir = root === "." ? name : root + "/" + name;
+		let relFrames = [];
+		if (track.frames !== void 0) for (const frame of track.frames) {
+			const rel = trackDir + "/" + frame;
+			if (!existsSync(join(dir, rel))) {
+				record("warning", "pet " + manifest.id + ": frames2d frame missing: " + rel);
+				continue;
+			}
+			relFrames.push(rel);
+		}
+		else {
+			let files = [];
+			try {
+				files = readdirSync(join(dir, trackDir)).filter((file) => {
+					if (file.startsWith(".")) return false;
+					const dot = file.lastIndexOf(".");
+					return dot > 0 && FRAMES2D_IMAGE_EXTENSIONS.has(file.slice(dot).toLowerCase());
+				});
+			} catch {
+				files = [];
+			}
+			files.sort((a, b) => {
+				const ia = FRAMES2D_FRAME_INDEX.exec(a)?.[1];
+				const ib = FRAMES2D_FRAME_INDEX.exec(b)?.[1];
+				if (ia !== void 0 && ib !== void 0 && ia !== ib) return Number(ia) - Number(ib);
+				return a < b ? -1 : a > b ? 1 : 0;
+			});
+			relFrames = files.map((file) => trackDir + "/" + file);
+		}
+		if (relFrames.length === 0) {
+			record("warning", "pet " + manifest.id + ": frames2d track " + JSON.stringify(name) + " has no frames on disk; dropped");
+			continue;
+		}
+		const durations = relFrames.map((rel, index) => {
+			if (track.frameMs !== void 0) return track.frameMs[index] ?? defaultMs;
+			const match = FRAMES2D_FILENAME_MS.exec(rel);
+			if (match !== null) {
+				const ms = Number(match[1]);
+				if (Number.isInteger(ms) && ms >= 16 && ms <= 5e3) return ms;
+			}
+			return defaultMs;
+		});
+		const loop = track.loop ?? true;
+		tracks[name] = {
+			frames: relFrames.map((rel) => assetUrl(assetPrefix, manifest.id, rel)),
+			durations,
+			loop,
+			...loop ? {} : { fallback: track.fallback ?? idleTrack }
+		};
+		firstFrameRel[name] = relFrames[0];
+		servable.push(...relFrames);
+	}
+	if (tracks[idleTrack] === void 0) {
+		record("error", "pet " + manifest.id + ": frames2d idle track " + JSON.stringify(idleTrack) + " has no frames on disk");
+		return;
+	}
+	const phases = { ...block.phases };
+	for (const [phase, target] of Object.entries(phases)) if (target !== void 0 && tracks[target] === void 0) {
+		record("warning", "pet " + manifest.id + ": frames2d phase " + phase + " maps to dropped track " + JSON.stringify(target) + "; using idle");
+		phases[phase] = idleTrack;
+	}
+	const remarks = normalizePetRemarks(manifest.remarks, (message) => record("warning", "pet " + manifest.id + ": " + message));
+	let gameplay;
+	if (manifest.gameplay !== void 0) {
+		gameplay = manifest.gameplay;
+		if (gameplay.shop !== void 0) {
+			const items = [];
+			for (const item of gameplay.shop.items) {
+				if (item.image === void 0) {
+					items.push(item);
+					continue;
+				}
+				if (!existsSync(join(dir, item.image))) {
+					record("warning", "pet " + manifest.id + ": gameplay shop item " + item.id + " image missing: " + item.image);
+					const { image, ...rest } = item;
+					items.push(rest);
+					continue;
+				}
+				servable.push(item.image);
+				items.push({
+					...item,
+					image: assetUrl(assetPrefix, manifest.id, item.image)
+				});
+			}
+			gameplay = {
+				...gameplay,
+				shop: {
+					...gameplay.shop,
+					items
+				}
+			};
+		}
+	}
+	const flatTracks = buildTracks(DEFAULT_FRAME_COUNTS, 8, {}, (message) => record("warning", "pet " + manifest.id + ": " + message));
+	if (flatTracks === void 0) return void 0;
+	const firstAbs = join(dir, firstFrameRel[idleTrack]);
+	const dims = existsSync(firstAbs) ? readImageDimensions(firstAbs) : void 0;
+	const cell = dims !== void 0 && dims.width >= 1 && dims.height >= 1 ? dims : { ...DEFAULT_PET_CELL };
+	return {
+		id: manifest.id,
+		displayName: manifest.displayName,
+		description: manifest.description ?? "",
+		renderer: "frames2d",
+		frames2d: {
+			tracks,
+			phases
+		},
+		...gameplay === void 0 ? {} : { gameplay },
+		cell,
+		columns: 8,
+		rows: [...DEFAULT_FRAME_COUNTS],
+		atlasRows: 9,
+		tracks: flatTracks,
+		atlasUrl: tracks[idleTrack].frames[0],
+		manifestUrl: assetUrl(assetPrefix, manifest.id, "pet.json"),
+		dir,
+		spritesheetPath: firstFrameRel[idleTrack],
+		servable,
+		...remarks === void 0 ? {} : { remarks }
+	};
+}
 /** Scan one directory of pet folders; entries come back in name order. */
 function scanPetDir(dir, options) {
 	if (!existsSync(dir)) return [];
@@ -2853,6 +3688,7 @@ function scanPetDir(dir, options) {
 		if (!verdict.ok) continue;
 		let entry;
 		if (verdict.manifest.renderer === "live2d") entry = resolveLive2dEntry(verdict.manifest, entryDir, options);
+		else if (verdict.manifest.renderer === "frames2d") entry = resolveFrames2dEntry(verdict.manifest, entryDir, options);
 		else {
 			const legacy = flattenV2Sprite2d(verdict.manifest);
 			if (legacy === void 0) {
@@ -3144,7 +3980,7 @@ function loadPetRegistry(options) {
 		warnings,
 		diagnostics,
 		byId: (id) => byId.get(id),
-		defaultEntry: () => entries.find((entry) => builtinIds.has(entry.id)) ?? entries[0],
+		defaultEntry: () => entries.find((entry) => entry.id === "whale-girl" && builtinIds.has(entry.id)) ?? entries.find((entry) => builtinIds.has(entry.id)) ?? entries[0],
 		...globalVoice === void 0 ? {} : { globalVoice },
 		decorations,
 		decorationById: (id) => decorationById.get(id)
@@ -3180,6 +4016,8 @@ function petEntryView(entry, globalVoice) {
 		description: entry.description,
 		renderer: entry.renderer,
 		...entry.live2d === void 0 ? {} : { live2d: entry.live2d },
+		...entry.frames2d === void 0 ? {} : { frames2d: entry.frames2d },
+		...entry.gameplay === void 0 ? {} : { gameplay: entry.gameplay },
 		cell: entry.cell,
 		columns: entry.columns,
 		rows: entry.rows,
@@ -3191,6 +4029,23 @@ function petEntryView(entry, globalVoice) {
 		...panel === void 0 ? {} : { panel }
 	};
 }
+//#endregion
+//#region src/service.ts
+/**
+* Pet host service — the `pet.*` RPC domain. A composition facade: it wires
+* the pure event projection (`event-projection`) onto the state machine,
+* delegates the affinity economy to the ledger (`ledger`), and routes
+* persistence through `persist`. The API gateway maps these methods onto
+* `pet.state` / `pet.pets` / `pet.interact` / `pet.setVisible` /
+* `pet.setConfig` / `pet.setName` / `pet.setPet` for browser consumers.
+*
+* Concurrent sessions each keep their own machine: the sprite animation
+* follows the most recent meaningful event (the display session) while the
+* state view carries one bubble per active session.
+* @module @linxin666/dsh-pet/service
+*/
+/** The unified gameplay currency: the shared treat (小鱼干) ledger. */
+const GAMEPLAY_TREATS_CURRENCY = "treats";
 /** Hard cap on simultaneously displayed session bubbles (most recent first). */
 const MAX_SESSION_BUBBLES = 12;
 /**
@@ -3281,8 +4136,8 @@ var PetService = class extends Service {
 		return this.enabled;
 	}
 	/** RPC: current pet state snapshot. */
-	async state() {
-		return this.view();
+	async state(currentSessionId) {
+		return this.view(currentSessionId);
 	}
 	/** Current persisted display config (read-only view). */
 	display() {
@@ -3442,6 +4297,205 @@ var PetService = class extends Service {
 		if (this.ledger.takeDirty()) this.flush();
 		return result;
 	}
+	/** The active pet's gameplay block, if it declares one. */
+	gameplayDef() {
+		return this.activeEntry().gameplay;
+	}
+	/** The persisted (or fresh) gameplay state of the selected pet. */
+	gameplayState(def, now) {
+		const petId = this.selectedPetId();
+		const stored = this.ledger.snapshot.gameplay[petId];
+		return {
+			petId,
+			state: stored === void 0 ? initialGameplayState(def, now) : {
+				stats: { ...stored.stats },
+				currencies: { ...stored.currencies },
+				mode: stored.mode,
+				settledAt: stored.settledAt
+			}
+		};
+	}
+	/** Display view of one gameplay state (rounded stats; treats ride the shared treat ledger). */
+	gameplayViewOf(state) {
+		const stats = {};
+		for (const [name, value] of Object.entries(state.stats)) stats[name] = Math.round(value);
+		return {
+			stats,
+			mode: state.mode
+		};
+	}
+	/**
+	* Move gameplay 'treats' currency (the unified post-wallet currency) from
+	* the engine's settle work area into the shared treat ledger, capped by
+	* the stock cap. The engine keeps its generic currency record for settle
+	* math; this drain is the only bridge to the wallet-free economy.
+	*/
+	drainGameplayTreats(state) {
+		const pending = Math.floor(state.currencies[GAMEPLAY_TREATS_CURRENCY] ?? 0);
+		delete state.currencies[GAMEPLAY_TREATS_CURRENCY];
+		if (pending > 0) this.ledger.grantTreats(pending);
+	}
+	/** Persist the mutated gameplay state of one verb call. */
+	commitGameplay(petId, state) {
+		this.ledger.setGameplay(petId, state);
+		if (this.ledger.takeDirty()) this.flush();
+	}
+	/**
+	* RPC: a touch on the pet. 'zone' names a touch zone (roll a branch);
+	* omitted means a plain click while a touch animation holds (clickBoost).
+	*/
+	async gameplayTouch(zone) {
+		const def = this.gameplayDef();
+		if (def === void 0) return {
+			ok: false,
+			error: "no-gameplay"
+		};
+		const now = Date.now();
+		const { petId, state } = this.gameplayState(def, now);
+		settleGameplay(state, def, now, { sessionActive: this.machine.render().sessionActive });
+		if (zone === void 0) {
+			const boost = def.touch?.clickBoost;
+			if (boost === void 0) return {
+				ok: false,
+				error: "no-touch"
+			};
+			const amount = boost.min + Math.floor(Math.random() * (boost.max - boost.min + 1));
+			if (amount > 0) applyGameplayEffects(state, def, [{
+				stat: boost.stat,
+				amount
+			}]);
+			this.drainGameplayTreats(state);
+			this.commitGameplay(petId, state);
+			return {
+				ok: true,
+				hit: false,
+				view: this.gameplayViewOf(state)
+			};
+		}
+		const target = def.touch?.zones.find((entry) => entry.name === zone);
+		if (target === void 0) return {
+			ok: false,
+			error: "unknown-zone"
+		};
+		const branch = rollTouchBranch(target, Math.random);
+		if (branch === void 0) {
+			this.drainGameplayTreats(state);
+			this.commitGameplay(petId, state);
+			return {
+				ok: true,
+				hit: false,
+				view: this.gameplayViewOf(state)
+			};
+		}
+		if (branch.effects !== void 0) applyGameplayEffects(state, def, branch.effects);
+		const phrase = branch.phrases !== void 0 && branch.phrases.length > 0 ? branch.phrases[Math.floor(Math.random() * branch.phrases.length)] : void 0;
+		this.drainGameplayTreats(state);
+		this.commitGameplay(petId, state);
+		return {
+			ok: true,
+			hit: true,
+			...branch.state === void 0 ? {} : { state: branch.state },
+			...branch.stateMs === void 0 ? {} : { stateMs: branch.stateMs },
+			...phrase === void 0 ? {} : { phrase },
+			view: this.gameplayViewOf(state)
+		};
+	}
+	/** RPC: enter or leave a gameplay mode ('work' | 'sleep' | null). */
+	async gameplaySetMode(mode) {
+		const def = this.gameplayDef();
+		if (def === void 0) return {
+			ok: false,
+			error: "no-gameplay"
+		};
+		if (mode === "work" && def.work === void 0) return {
+			ok: false,
+			error: "no-work"
+		};
+		if (mode === "sleep" && def.sleep === void 0) return {
+			ok: false,
+			error: "no-sleep"
+		};
+		const now = Date.now();
+		const { petId, state } = this.gameplayState(def, now);
+		settleGameplay(state, def, now, { sessionActive: this.machine.render().sessionActive });
+		state.mode = mode;
+		this.drainGameplayTreats(state);
+		this.commitGameplay(petId, state);
+		return {
+			ok: true,
+			view: this.gameplayViewOf(state)
+		};
+	}
+	/** RPC: one work-round adjudication (only while the work mode holds). */
+	async gameplayWorkTick() {
+		const def = this.gameplayDef();
+		if (def?.work === void 0) return {
+			ok: false,
+			error: "no-work"
+		};
+		const now = Date.now();
+		const { petId, state } = this.gameplayState(def, now);
+		if (state.mode !== "work") return {
+			ok: false,
+			error: "not-working"
+		};
+		settleGameplay(state, def, now, { sessionActive: this.machine.render().sessionActive });
+		const outcome = rollWorkOutcome(def.work, Math.random);
+		const effects = outcome === "success" ? def.work.success?.effects : def.work.fail?.effects;
+		if (effects !== void 0) applyGameplayEffects(state, def, effects);
+		this.drainGameplayTreats(state);
+		this.commitGameplay(petId, state);
+		return {
+			ok: true,
+			outcome,
+			view: this.gameplayViewOf(state)
+		};
+	}
+	/** RPC: buy one shop item (effects, currency swap, or a lottery draw). */
+	async gameplayBuy(itemId) {
+		const def = this.gameplayDef();
+		if (def === void 0) return {
+			ok: false,
+			error: "no-gameplay"
+		};
+		const item = def.shop?.items.find((entry) => entry.id === itemId);
+		if (item === void 0) return {
+			ok: false,
+			error: "unknown-item"
+		};
+		const now = Date.now();
+		const { petId, state } = this.gameplayState(def, now);
+		settleGameplay(state, def, now, { sessionActive: this.machine.render().sessionActive });
+		const treats = item.currency === GAMEPLAY_TREATS_CURRENCY;
+		const balance = treats ? this.ledger.snapshot.treats.treats : state.currencies[item.currency] ?? 0;
+		if (balance < item.price) return {
+			ok: false,
+			error: "insufficient-funds",
+			view: this.gameplayViewOf(state)
+		};
+		if (treats) this.ledger.spendTreats(item.price);
+		else state.currencies[item.currency] = balance - item.price;
+		if (item.effects !== void 0) applyGameplayEffects(state, def, item.effects);
+		let prize;
+		if (item.lottery !== void 0) {
+			if (item.lottery.effects !== void 0) applyGameplayEffects(state, def, item.lottery.effects);
+			const tier = drawLotteryTier(item.lottery, Math.random);
+			const prizeCurrency = tier.currency ?? item.lottery.currency ?? item.currency;
+			if (prizeCurrency === GAMEPLAY_TREATS_CURRENCY) this.ledger.grantTreats(tier.prize);
+			else state.currencies[prizeCurrency] = (state.currencies[prizeCurrency] ?? 0) + tier.prize;
+			prize = {
+				amount: tier.prize,
+				currency: prizeCurrency
+			};
+		}
+		this.drainGameplayTreats(state);
+		this.commitGameplay(petId, state);
+		return {
+			ok: true,
+			...prize === void 0 ? {} : { prize },
+			view: this.gameplayViewOf(state)
+		};
+	}
 	/** RPC: show or hide the pet. */
 	async setVisible(visible) {
 		this.ledger.setDisplay({
@@ -3532,7 +4586,7 @@ var PetService = class extends Service {
 	rewardLegacyTurn() {
 		if (this.ledger.rewardLegacyTurn(Date.now())) this.flush();
 	}
-	view() {
+	view(currentSessionId) {
 		const snapshot = this.machine.render();
 		const entry = this.activeEntry();
 		const sessions = [];
@@ -3541,23 +4595,34 @@ var PetService = class extends Service {
 			if (session.header?.origin === "subagent") continue;
 			const perSession = activity.machine.render();
 			if (perSession.bubble === void 0) continue;
+			const whisper = activity.whisper;
+			const freshWhisper = whisper !== void 0 && Date.now() - whisper.at < 8e3 ? whisper.text : void 0;
 			sessions.push({
 				sessionId: String(session.id),
 				animation: perSession.animation,
 				bubble: perSession.bubble,
-				phase: perSession.phase
+				phase: perSession.phase,
+				...freshWhisper === void 0 ? {} : { whisper: freshWhisper }
 			});
 		}
-		const whisper = (this.displaySession === void 0 ? void 0 : this.sessionActivity.get(this.displaySession))?.whisper;
-		const freshWhisper = whisper !== void 0 && Date.now() - whisper.at < 8e3 ? whisper.text : void 0;
+		if (currentSessionId !== void 0) {
+			const index = sessions.findIndex((session) => session.sessionId === currentSessionId);
+			if (index > 0) sessions.unshift(sessions.splice(index, 1)[0]);
+		}
 		const decoration = this.activeDecoration();
+		const gameplayDef = this.gameplayDef();
+		let gameplay;
+		if (gameplayDef !== void 0) {
+			const { state } = this.gameplayState(gameplayDef, Date.now());
+			settleGameplay(state, gameplayDef, Date.now(), { sessionActive: snapshot.sessionActive });
+			gameplay = this.gameplayViewOf(state);
+		}
 		return {
 			animation: snapshot.animation,
 			...snapshot.bubble === void 0 ? {} : { bubble: snapshot.bubble },
 			phase: snapshot.phase,
 			sessionActive: snapshot.sessionActive,
 			sessions,
-			...freshWhisper === void 0 ? {} : { whisper: freshWhisper },
 			...decoration === void 0 ? {} : { decoration },
 			affinity: this.ledger.affinityView(Date.now()),
 			display: { ...this.ledger.snapshot.display },
@@ -3570,7 +4635,8 @@ var PetService = class extends Service {
 			treats: {
 				stocked: this.ledger.snapshot.treats.treats,
 				max: this.ledger.treatMax
-			}
+			},
+			...gameplay === void 0 ? {} : { gameplay }
 		};
 	}
 	flush() {
@@ -3792,7 +4858,7 @@ function guard(ctx, req, res) {
 	});
 	return false;
 }
-/** Wrap one async service call as a GET JSON route. */
+/** Wrap one async service call as a GET JSON route (request passed through for query params). */
 function getRoute(ctx, path, run) {
 	return {
 		kind: "exact",
@@ -3800,7 +4866,7 @@ function getRoute(ctx, path, run) {
 		handler: (req, res) => {
 			if (!guard(ctx, req, res)) return;
 			if (!requireMethod(req, res, "GET")) return;
-			run().then((value) => writeJson(res, 200, value), (error) => {
+			run(req).then((value) => writeJson(res, 200, value), (error) => {
 				writeJson(res, 500, {
 					ok: false,
 					error: error instanceof Error ? error.message : String(error)
@@ -4182,7 +5248,10 @@ function decorationHandler(ctx, registry, caps) {
 function makePetRoutes(deps) {
 	const { service, ctx } = deps;
 	const apiRoutes = [
-		getRoute(ctx, "/api/pet/state", () => service.state()),
+		getRoute(ctx, "/api/pet/state", (req) => {
+			const current = new URL(req.url ?? "/", "http://pet.local").searchParams.get("current");
+			return service.state(current === null || current === "" ? void 0 : current);
+		}),
 		getRoute(ctx, "/api/pet/pets", () => service.pets()),
 		getRoute(ctx, "/api/pet/diagnostics", () => service.diagnostics()),
 		postRoute(ctx, "/api/pet/interact", (body) => {
@@ -4210,6 +5279,22 @@ function makePetRoutes(deps) {
 			const petId = body.petId;
 			if (typeof petId !== "string") return Promise.reject(/* @__PURE__ */ new Error("invalid-pet"));
 			return service.setPetId(petId);
+		}),
+		postRoute(ctx, "/api/pet/gameplay/touch", (body) => {
+			const zone = body.zone;
+			if (zone !== void 0 && typeof zone !== "string") return Promise.reject(/* @__PURE__ */ new Error("invalid-zone"));
+			return service.gameplayTouch(zone);
+		}),
+		postRoute(ctx, "/api/pet/gameplay/mode", (body) => {
+			const mode = body.mode;
+			if (mode !== null && mode !== "work" && mode !== "sleep") return Promise.reject(/* @__PURE__ */ new Error("invalid-mode"));
+			return service.gameplaySetMode(mode);
+		}),
+		postRoute(ctx, "/api/pet/gameplay/work-tick", () => service.gameplayWorkTick()),
+		postRoute(ctx, "/api/pet/gameplay/buy", (body) => {
+			const item = body.item;
+			if (typeof item !== "string") return Promise.reject(/* @__PURE__ */ new Error("invalid-item"));
+			return service.gameplayBuy(item);
 		})
 	];
 	const assetRoute = {