dsh-agentic-pet 0.4.6 → 0.4.8

package/README.zh.md

@@ -9,10 +9,16 @@ kind: "package-bundle"
 
 ## 简介
 
-`dsh-agentic-pet` 是 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 生态的桌面宠物插件：宠物以透明置顶窗常驻桌面，跟随 agent 会话状态（idle / thinking / working / error），与 web 界面竞速应答审批与提问（先答者赢），维护每宠独立的触摸好感账本，并向模型暴露表达工具（`pet_say`、`pet_do`、`pet_digest`、`pet_interactions`、`pet_state`）——模型可以借宠物说话、做动作、感知被触摸。说话内容可通过 [BreezeBlue](https://breezeblue.ai) TTS 朗读——carrier 侧合成每条 `/say` 文本，语音就绪后与气泡同时下发；合成失败或超时静默降级为只显示（桌面设置页可配）。多只宠物实现可以并存：目录注册表（`~/.dsh/pet-http.d/`）发现全部在线宠物，状态、交互、账本按宠路由。
+`dsh-agentic-pet` 是 [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) 生态的桌面宠物插件：宠物以透明置顶窗常驻桌面，跟随 agent 会话状态（idle / thinking / working / error），与 web 界面竞速应答审批与提问（先答者赢），维护每宠独立的触摸好感账本，并向模型暴露表达工具（`pet_say`、`pet_do`、`pet_digest`、`pet_interactions`、`pet_state`、`pet_schedule_wake`、`pet_cancel_wake`）——模型可以借宠物说话、做动作、感知被触摸、给自己定作息。说话内容可通过 [BreezeBlue](https://breezeblue.ai) TTS 朗读——carrier 侧合成每条 `/say` 文本，语音就绪后与气泡同时下发；合成失败或超时静默降级为只显示（桌面设置页可配）。多只宠物实现可以并存：目录注册表（`~/.dsh/whale598/pet-http.d/`）发现全部在线宠物，状态、交互、账本按宠路由。
 
 宠物本身是零 DSH 知识的纯显示端。理解运行时的一切——事件收敛、交互瀑布、多宠路由、模型工具——都在插件的 driver 里，宠物只实现一个小型本地 HTTP 控制接口。任何讲同一 HTTP 契约的宠物实现都能被采纳，插件零改动。
 
+### 多宠会话路由（session ↔ 宠物）
+
+- **宠自己的内心戏会话**（每宠一个：boot greeting 自动创建，或设置页「指定会话」手动绑定）：driver 用 `voiceOwners` 映射表记录会话→宠物，模型在会话里的 `pet_say`/`pet_do` 不点名也自动落回这只宠；这些回合不画状态灯（呼吸不是工作状态）。
+- **工作会话**：有绑定宠时状态灯只亮在它身上（宠物在交互竞速里答过题即赢得绑定）；无绑定或绑定宠离线时，状态广播到全部在线宠。审批/问答永远全员广播。工作会话没有宠物工具，不涉及说话/动作的分发。
+- **手动在侧栏开的宠物模式会话**：driver 不认识它（不在映射表里），按普通工作会话对待——状态灯上身，表演类工具（`pet_say`/`pet_do`/定撤闹钟）直接拒答、不分发。这不是预期用法：想跟宠物说话，请用宠物表面的输入卡，直达她自己的会话。
+
 ## 仓库结构
 
 | 路径 | 内容 |

package/lib/index.js

@@ -1,8 +1,8 @@
-import { c as globalFilePath, d as readJsonl, f as readPetName, h as writePetName, i as installPetDriver, l as readAffectionRaw, m as writeGlobalJson, n as installPetService, p as writeAffectionRaw, r as petHome, s as eventsFile, u as readGlobalJson } from "./service-R8qwDx1Q.js";
+import { c as globalFilePath, d as readJsonl, f as readPetName, h as writePetName, i as installPetDriver, l as readAffectionRaw, m as writeGlobalJson, n as installPetService, p as writeAffectionRaw, r as petHome, s as eventsFile, u as readGlobalJson } from "./service-Df8olC1E.js";
 import { createRequire } from "node:module";
 import { execFileSync, spawn } from "node:child_process";
 import { createHash } from "node:crypto";
-import { appendFileSync, existsSync, readFileSync } from "node:fs";
+import { appendFileSync, existsSync, readFileSync, statSync, unlinkSync, writeFileSync } from "node:fs";
 import { mkdir, readFile, rm, unlink, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, extname, join, normalize, resolve, sep } from "node:path";
@@ -656,46 +656,169 @@ function apply(ctx) {
 		return binary;
 	};
 	/**
-	* Auto-start the pet window. A bare Electron binary runs any app directory
-	* (`electron.exe <dir>`), but a PACKAGED one (the installed desktop) loads
-	* its own app and dies on its single-instance lock instead — so the host's
-	* `process.execPath` is only a last resort and the resolution order is an
-	* explicit env override, a binary staged beside this package, then the
-	* `electron` npm dependency (its module resolves to the binary path).
-	* The carrier's single-instance lock collapses duplicates.
+	* Locate the npm `electron` package WITHOUT loading it. Loading the module
+	* (`require('electron')`) runs its lazy installer synchronously — a ~250 MB
+	* download inside the host's event loop — so only the manifest is resolved
+	* here; installing is a separate, background step.
 	*/
-	const resolveElectronBinary = () => {
-		const override = process.env.DSH_PET_ELECTRON;
-		if (override !== void 0 && override !== "") {
-			if (existsSync(override)) return override;
-			logCarrier(`DSH_PET_ELECTRON is set but missing, falling back: ${override}`);
-		}
-		const pkgRoot = resolve(join(dirname(fileURLToPath(import.meta.url)), ".."));
-		const staged = join(pkgRoot, "electron-bin", process.platform === "win32" ? "electron.exe" : process.platform === "darwin" ? join("Electron.app", "Contents", "MacOS", "Electron") : "electron");
-		if (existsSync(staged)) return staged;
+	const findNpmElectronPackage = () => {
 		try {
 			const require = createRequire(import.meta.url);
-			const candidate = String(require("electron"));
-			if (existsSync(candidate)) return ensureElectronUsable(candidate);
+			const pkgDir = dirname(require.resolve("electron/package.json"));
+			if (existsSync(join(pkgDir, "package.json"))) return pkgDir;
 		} catch {}
 		try {
 			let dir = dirname(fileURLToPath(import.meta.url));
 			for (let i = 0; i < 8; i += 1) {
 				const pkgDir = join(dir, "node_modules", "electron");
-				const exe = readFileSync(join(pkgDir, "path.txt"), "utf8").trim();
-				const binary = join(pkgDir, "dist", exe);
-				if (existsSync(binary)) return ensureElectronUsable(binary);
+				if (existsSync(join(pkgDir, "package.json"))) return pkgDir;
 				const parent = dirname(dir);
 				if (parent === dir) break;
 				dir = parent;
 			}
 		} catch {}
-		return process.versions.electron !== void 0 ? process.execPath : void 0;
 	};
-	const spawnPetCarrier = (url) => {
-		const carrierDir = resolve(join(dirname(fileURLToPath(import.meta.url)), "..", "carrier"));
-		const electronBinary = resolveElectronBinary();
-		if (process.env.DSH_PET_NO_SPAWN === "1" || electronBinary === void 0 || !existsSync(join(carrierDir, "package.json"))) return;
+	const npmElectronBinary = (pkgDir) => {
+		try {
+			const exe = readFileSync(join(pkgDir, "path.txt"), "utf8").trim();
+			const binary = join(pkgDir, "dist", exe);
+			return existsSync(binary) ? binary : void 0;
+		} catch {
+			return;
+		}
+	};
+	const INSTALL_LOCK_STALE_MS = 18e5;
+	const installLockPath = (pkgDir) => join(pkgDir, ".dsh-pet-install.lock");
+	const acquireInstallLock = (pkgDir) => {
+		const lock = installLockPath(pkgDir);
+		const write = () => {
+			writeFileSync(lock, JSON.stringify({
+				pid: process.pid,
+				at: Date.now()
+			}), { flag: "wx" });
+		};
+		try {
+			write();
+			return true;
+		} catch {
+			try {
+				if (Date.now() - statSync(lock).mtimeMs > INSTALL_LOCK_STALE_MS) {
+					unlinkSync(lock);
+					write();
+					return true;
+				}
+			} catch {}
+			return false;
+		}
+	};
+	const releaseInstallLock = (pkgDir) => {
+		try {
+			unlinkSync(installLockPath(pkgDir));
+		} catch {}
+	};
+	/**
+	* Install the npm electron binary off the activation path. The package's
+	* lazy installer is a ~250 MB download; running it synchronously (which
+	* `require('electron')` does) freezes the host, so it runs as a child with
+	* progress in the spawn log and a mirror hint on failure.
+	*/
+	const installNpmElectron = async (pkgDir) => {
+		const installer = join(pkgDir, "install.js");
+		if (!existsSync(installer)) {
+			logCarrier(`electron binary missing and install.js not found: ${pkgDir}`);
+			return;
+		}
+		if (!acquireInstallLock(pkgDir)) {
+			logCarrier(`electron install already in progress (lock present): ${pkgDir}`);
+			return;
+		}
+		logCarrier(`electron binary missing; installing in background: ${pkgDir}`);
+		return await new Promise((resolveInstall) => {
+			let settled = false;
+			const finish = (value) => {
+				if (settled) return;
+				settled = true;
+				releaseInstallLock(pkgDir);
+				resolveInstall(value);
+			};
+			let stderr = "";
+			let stdout = "";
+			let lastProgress = 0;
+			const child = spawn(process.execPath, [installer], {
+				cwd: pkgDir,
+				env: {
+					...process.env,
+					ELECTRON_RUN_AS_NODE: "1"
+				},
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				],
+				windowsHide: true
+			});
+			child.stdout?.setEncoding("utf8");
+			child.stdout?.on("data", (chunk) => {
+				stdout = `${stdout}${chunk}`.slice(-2e3);
+				const now = Date.now();
+				if (now - lastProgress > 5e3) {
+					lastProgress = now;
+					const line = stdout.split(/\r?\n/).map((part) => part.trim()).filter(Boolean).pop();
+					if (line !== void 0) logCarrier(`electron install: ${line}`);
+				}
+			});
+			child.stderr?.setEncoding("utf8");
+			child.stderr?.on("data", (chunk) => {
+				stderr = `${stderr}${chunk}`.slice(-2e3);
+			});
+			child.on("error", (error) => {
+				logCarrier(`electron install failed to start: ${error.message}`);
+				finish(void 0);
+			});
+			child.on("exit", (code) => {
+				if (code !== 0) {
+					logCarrier(`electron install failed (exit ${String(code)}): ${stderr.trim() || "no stderr"}. Set ELECTRON_MIRROR=https://npmmirror.com/mirrors/electron/ (or electron_mirror in .npmrc) and restart DSH; or run "node ${installer}" manually.`);
+					finish(void 0);
+					return;
+				}
+				const binary = npmElectronBinary(pkgDir);
+				if (binary === void 0) {
+					logCarrier(`electron install exited 0 but the binary is still missing: ${pkgDir}`);
+					finish(void 0);
+					return;
+				}
+				logCarrier(`electron installed: ${binary}`);
+				finish(ensureElectronUsable(binary));
+			});
+		});
+	};
+	/**
+	* Auto-start the pet window. A bare Electron binary runs any app directory
+	* (`electron.exe <dir>`), but a PACKAGED one (the installed desktop) loads
+	* its own app and dies on its single-instance lock instead — so the
+	* resolution order is an explicit env override, a binary staged beside this
+	* package, then the `electron` npm dependency. The carrier's single-instance
+	* lock collapses duplicates.
+	*/
+	const resolveElectron = () => {
+		const override = process.env.DSH_PET_ELECTRON;
+		if (override !== void 0 && override !== "") {
+			if (existsSync(override)) return { binary: override };
+			logCarrier(`DSH_PET_ELECTRON is set but missing, falling back: ${override}`);
+		}
+		const pkgRoot = resolve(join(dirname(fileURLToPath(import.meta.url)), ".."));
+		const staged = join(pkgRoot, "electron-bin", process.platform === "win32" ? "electron.exe" : process.platform === "darwin" ? join("Electron.app", "Contents", "MacOS", "Electron") : "electron");
+		if (existsSync(staged)) return { binary: staged };
+		const npmPackageDir = findNpmElectronPackage();
+		if (npmPackageDir !== void 0) {
+			const binary = npmElectronBinary(npmPackageDir);
+			if (binary !== void 0) return { binary: ensureElectronUsable(binary) };
+			return { npmPackageDir };
+		}
+		logCarrier("no electron binary: no staged electron-bin, no npm electron dependency, and DSH_PET_ELECTRON is unset");
+		return {};
+	};
+	const launchCarrier = (url, carrierDir, electronBinary) => {
 		const launchArgs = [carrierDir];
 		if (process.env.DSH_PET_NO_SANDBOX === "1") launchArgs.push("--no-sandbox");
 		logCarrier(`spawn binary=${electronBinary} args=${JSON.stringify(launchArgs)} pid=${String(process.pid)}`);
@@ -742,6 +865,21 @@ function apply(ctx) {
 			child.kill();
 		}, "pet-surface: carrier shutdown");
 	};
+	const spawnPetCarrier = (url) => {
+		const carrierDir = resolve(join(dirname(fileURLToPath(import.meta.url)), "..", "carrier"));
+		if (process.env.DSH_PET_NO_SPAWN === "1" || !existsSync(join(carrierDir, "package.json"))) return;
+		const resolution = resolveElectron();
+		if (resolution.binary !== void 0) {
+			launchCarrier(url, carrierDir, resolution.binary);
+			return;
+		}
+		if (resolution.npmPackageDir === void 0) return;
+		installNpmElectron(resolution.npmPackageDir).then((binary) => {
+			if (binary !== void 0) launchCarrier(url, carrierDir, binary);
+		}).catch((error) => {
+			logCarrier(`electron install failed: ${error instanceof Error ? error.message : String(error)}`);
+		});
+	};
 	const settledReady = () => {
 		const url = authenticatedRoot();
 		if (url === void 0) return;

package/lib/{service-R8qwDx1Q.js → service-Df8olC1E.js}

@@ -5395,19 +5395,16 @@ function buildChatPrompt(text, mergedPlan) {
 }
 // lib/types/registry.js
 /**
-* The pet registry: a directory of per-pet control manifests, replacing the
-* last-writer-wins single files whose races caused repeated swap incidents
-* (a dying carrier's late write burying a live pet's registration). Each pet
-* implementation owns its own file under whale598/pet-http.d/ (legacy
-* pet-http.d/ still scanned) and re-asserts it on a
-* cadence; entries whose publisher pid is dead expire by omission. The
-* driver reads the whole table and routes per the multi-pet design: the
-* session's bound pet if alive, else the default pet (first alive entry),
-* plus an all-notify broadcast mode for interactions.
+* The pet registry: a directory of per-pet control manifests. Each pet
+* implementation owns its own file under whale598/pet-http.d/ (named by its
+* pet id) and re-asserts it on a cadence; entries whose publisher pid is dead
+* expire by omission. The driver reads the whole table and routes per the
+* multi-pet design: a session's state rides its bound pet when that pet is
+* alive and broadcasts to every live pet otherwise; interactions broadcast to
+* all; the default pet (earliest-booted) resolves unnamed expression targets.
 * @module dsh-agentic-pet/registry
 */
 const REGISTRY_DIR = `${WHALE_DIR}/pet-http.d`;
-const LEGACY_REGISTRY_DIR = "pet-http.d";
 /**
 * A live pet is one whose control plane ANSWERS, not merely one whose pid
 * exists — and not merely one whose port accepts TCP: a frozen pet (stuck
@@ -5438,94 +5435,65 @@ async function probeControlPlane(port) {
 		return false;
 	}
 }
-/** Read every live entry in the registry. Dead-pid entries are skipped —
-* they expire by omission the next time their file is rewritten — and so are
-* silent entries (pid alive, control plane unresponsive). */
-async function readLivePets(home) {
-	const candidates = /* @__PURE__ */ new Map();
-	for (const dir of [join(home, REGISTRY_DIR), join(home, LEGACY_REGISTRY_DIR)]) {
-		let names = [];
-		try {
-			names = (await readdir(dir)).filter((name) => name.endsWith(".json"));
-		} catch {
-			continue;
-		}
-		for (const name of names) {
-			const id = name.slice(0, -5);
-			if (id !== "" && !candidates.has(id)) candidates.set(id, join(dir, name));
-		}
-	}
-	const live = [];
-	for (const [id, file] of candidates) try {
-		const raw = JSON.parse(await readFile(file, "utf8"));
-		const port = typeof raw.port === "number" ? raw.port : NaN;
-		const pid = typeof raw.pid === "number" ? raw.pid : NaN;
-		if (!Number.isFinite(port) || !Number.isFinite(pid)) continue;
-		try {
-			process.kill(pid, 0);
-		} catch {
-			continue;
-		}
-		if (!await probeControlPlane(port)) continue;
-		live.push({
-			id,
-			port,
-			pid,
-			since: typeof raw.since === "number" ? raw.since : 0
-		});
-	} catch {}
-	return live;
-}
-/** Legacy single-file manifests folded into the registry: the electron
-* carrier's dedicated file and the pure pet's shared file, identity-validated
-* and probe-validated, so pre-registry publishers stay drivable. */
-const LEGACY_SOURCES = [{
-	id: "electron",
-	file: "pet-http-electron.json",
-	identity: "electron"
-}, {
-	id: "pure",
-	file: "pet-http.json",
-	identity: "python"
-}];
-/** Every live pet: registry entries plus legacy single-file manifests folded
-* under their pet ids (registry entries win on id collision). */
+/**
+* The default-pet order: earliest booted first (`since` ascending). A missing
+* or mistyped `since` (0) reads as "unknown boot time" and sorts LAST — it
+* must never outrank a publisher that stated its boot time. This turns the
+* multi-pet design's de-facto rule ("the default pet is the first STARTED")
+* into an actual guarantee: discovery output IS boot order, so every
+* `pets[0]` consumer (defaultPet, pet_state's defaultPet) reads the
+* same pet. Stable sort: equal `since` values keep registry listing order.
+*/
+function bootOrder(pets) {
+	return [...pets].sort((a, b) => (a.since > 0 ? a.since : Number.POSITIVE_INFINITY) - (b.since > 0 ? b.since : Number.POSITIVE_INFINITY));
+}
+/** Every live pet in boot order. Dead-pid entries are skipped — they expire
+* by omission the next time their file is rewritten — and so are silent
+* entries (pid alive, control plane unresponsive). Probes run CONCURRENTLY:
+* wall time per pass is the slowest pet (≤800ms frozen budget), not the
+* serial sum. */
 async function readAllPets(home) {
-	const pets = await readLivePets(home);
-	for (const { id, file, identity } of LEGACY_SOURCES) {
-		if (pets.some((pet) => pet.id === id)) continue;
+	let names = [];
+	try {
+		names = (await readdir(join(home, REGISTRY_DIR))).filter((name) => name.endsWith(".json"));
+	} catch {
+		return [];
+	}
+	return bootOrder((await Promise.all(names.map(async (name) => {
+		const id = name.slice(0, -5);
+		if (id === "") return null;
 		try {
-			const manifest = JSON.parse(await readFile(join(home, file), "utf8"));
-			if (manifest.pet !== identity) continue;
-			if (typeof manifest.port !== "number" || typeof manifest.pid !== "number") continue;
+			const raw = JSON.parse(await readFile(join(home, REGISTRY_DIR, name), "utf8"));
+			const port = typeof raw.port === "number" ? raw.port : NaN;
+			const pid = typeof raw.pid === "number" ? raw.pid : NaN;
+			if (!Number.isFinite(port) || !Number.isFinite(pid)) return null;
 			try {
-				process.kill(manifest.pid, 0);
+				process.kill(pid, 0);
 			} catch {
-				continue;
+				return null;
 			}
-			if (!await probeControlPlane(manifest.port)) continue;
-			pets.push({
+			if (!await probeControlPlane(port)) return null;
+			return {
 				id,
-				port: manifest.port,
-				pid: manifest.pid,
-				since: 0
-			});
-		} catch {}
-	}
-	return pets;
+				port,
+				pid,
+				since: typeof raw.since === "number" ? raw.since : 0
+			};
+		} catch {
+			return null;
+		}
+	}))).filter((entry) => entry !== null));
 }
 /**
-* Resolve the pet that should carry STATE for the given session, per the
-* multi-pet design: the session's bound pet when alive, else the default pet
-* (the first live entry — de facto "first started"). Single-pet deployments
-* degenerate correctly: one live entry is both bound and default.
+* The default pet for UNNAMED targets: the earliest-booted live entry
+* (`pets[0]` — discovery's bootOrder guarantees start order, not listing
+* accident). State routing does NOT go through here anymore: an unbound
+* (or bound-but-offline) session broadcasts its state to every live pet —
+* the driver computes that audience itself. Used by the tools'
+* resolveTarget when neither a named pet nor the owning session resolves.
 * @returns the entry, or undefined when no pet is alive.
 */
-function routePet(pets, boundPetId) {
-	if (boundPetId !== void 0) {
-		const bound = pets.find((pet) => pet.id === boundPetId);
-		if (bound !== void 0) return bound;
-	}
+function defaultPet(pets) {
 	return pets[0];
 }
 /** The pets that receive an INTERACTION (all-notify mode): every live pet,
@@ -5834,34 +5802,39 @@ function installPetDriver(ctx, home, pet) {
 	};
 	const pushState = async (state) => {
 		currentState = state;
-		const target = await pet.route(boundPetId);
-		if (target === void 0) return;
+		const pets = await pet.list();
+		const bound = pets.filter((pet) => pet.id === boundPetId);
+		const audience = bound.length > 0 ? bound : pets;
+		if (audience.length === 0) return;
 		const autonomy = await readAutonomy();
 		const autonomyKey = JSON.stringify(autonomy);
-		const last = lastPushedByPet.get(target.id);
-		if (last !== void 0 && last.state === state && last.since === target.since && last.autonomy === autonomyKey) return;
-		lastPushedByPet.set(target.id, {
-			state,
-			since: target.since,
-			autonomy: autonomyKey
-		});
-		try {
-			const response = await fetch(`http://127.0.0.1:${String(target.port)}/state`, {
-				method: "POST",
-				headers: { "content-type": "application/json" },
-				body: JSON.stringify({
-					state,
-					autonomy
-				})
+		await Promise.all(audience.map(async (target) => {
+			const last = lastPushedByPet.get(target.id);
+			if (last !== void 0 && last.state === state && last.since === target.since && last.autonomy === autonomyKey) return;
+			lastPushedByPet.set(target.id, {
+				state,
+				since: target.since,
+				autonomy: autonomyKey
 			});
-			if (!response.ok) {
-				console.error(`pet-surface driver: /state answered HTTP ${String(response.status)}`);
+			try {
+				const response = await fetch(`http://127.0.0.1:${String(target.port)}/state`, {
+					method: "POST",
+					headers: { "content-type": "application/json" },
+					body: JSON.stringify({
+						state,
+						autonomy
+					}),
+					signal: AbortSignal.timeout(5e3)
+				});
+				if (!response.ok) {
+					console.error(`pet-surface driver: /state answered HTTP ${String(response.status)}`);
+					lastPushedByPet.delete(target.id);
+				} else if (state === "error") lastPushedByPet.delete(target.id);
+			} catch {
+				console.error(`pet-surface driver: /state to ${target.id} failed`);
 				lastPushedByPet.delete(target.id);
-			} else if (state === "error") lastPushedByPet.delete(target.id);
-		} catch {
-			console.error(`pet-surface driver: /state to ${target.id} failed`);
-			lastPushedByPet.delete(target.id);
-		}
+			}
+		}));
 	};
 	events.on("api-session/status", (sessionId, running) => {
 		if (isVoiceSession(sessionId)) return;
@@ -6471,7 +6444,8 @@ ${text}`;
 			if (target !== void 0) fetch(`http://127.0.0.1:${String(target.port)}/action`, {
 				method: "POST",
 				headers: { "content-type": "application/json" },
-				body: JSON.stringify({ action: "celebrate" })
+				body: JSON.stringify({ action: "celebrate" }),
+				signal: AbortSignal.timeout(5e3)
 			}).catch(() => {});
 		}
 		triggerTouchReply(petId, part);
@@ -6582,10 +6556,14 @@ function registerPetTools(ctx, home, pet) {
 				}
 			}
 			const focus = await readFocus();
-			const target = (focus !== void 0 ? pets.find((entry) => entry.id === focus) : void 0) ?? routePet(pets, void 0);
+			const target = (focus !== void 0 ? pets.find((entry) => entry.id === focus) : void 0) ?? defaultPet(pets);
 			if (target === void 0) throw new Error("no pet is running");
 			return target;
 		};
+		const requireOwnedSession = (exec) => {
+			const sessionId = exec?.agent?.id;
+			if (typeof sessionId === "string" && !voiceOwners.has(sessionId)) throw new Error("本会话没有绑定宠物（不是宠物自己的内心戏会话），pet 工具不分发。想和宠物说话，请用宠物表面的输入卡。");
+		};
 		const classify = (error) => {
 			if (error instanceof Error) {
 				if (/fetch failed|ECONNREFUSED|ENOTFOUND/i.test(error.message)) return /* @__PURE__ */ new Error(`offline: the pet is not reachable (${error.message})`);
@@ -6616,6 +6594,7 @@ function registerPetTools(ctx, home, pet) {
 				}]
 			},
 			async execute(args, exec) {
+				requireOwnedSession(exec);
 				const text = String(args.text).slice(0, 200);
 				console.log(`pet-surface driver: pet_say ${JSON.stringify(text).slice(0, 60)}`);
 				try {
@@ -6661,6 +6640,7 @@ function registerPetTools(ctx, home, pet) {
 				}]
 			},
 			async execute(args, exec) {
+				requireOwnedSession(exec);
 				try {
 					const entry = await resolveTarget(args.pet, exec?.agent?.id);
 					const requested = String(args.action);
@@ -6973,6 +6953,7 @@ function registerPetTools(ctx, home, pet) {
 				}]
 			},
 			async execute(args, exec) {
+				requireOwnedSession(exec);
 				try {
 					const entry = await resolveTarget(args.pet, exec?.agent?.id);
 					const id = typeof args.id === "string" ? args.id.trim().slice(0, WAKE_PLAN_ID_MAX) : "";
@@ -7057,6 +7038,7 @@ function registerPetTools(ctx, home, pet) {
 				}]
 			},
 			async execute(args, exec) {
+				requireOwnedSession(exec);
 				try {
 					const entry = await resolveTarget(args.pet, exec?.agent?.id);
 					const list = voiceWakePlans.get(entry.id) ?? [];
@@ -7168,8 +7150,8 @@ function registerPetTools(ctx, home, pet) {
 * The `ctx.petService` capability seam — the dsh three-roles pattern applied
 * inside the process boundary. Pets are separate processes by design, so this
 * service is NOT the pet itself: it is the typed in-process seam over the
-* out-of-process HTTP control plane. Discovery (pet-http.d/ registry plus
-* legacy folding), liveness (pid + two-layer probe), retry policy, and the
+* out-of-process HTTP control plane. Discovery (the whale598/pet-http.d/
+* registry), liveness (pid + two-layer probe), retry policy, and the
 * /status field matrix (per-implementation extras) are normalized HERE —
 * consumers (the driver, the model tools, the settings page, the upcoming
 * proactivity scheduler) never see registry files, ports, or raw payloads.
@@ -7189,11 +7171,12 @@ function petHome() {
 *
 * Implementations must honor these semantics:
 * - {@link list} returns only pets whose control plane ANSWERS: a dead pid
-*   and a frozen publisher (listening socket, silent HTTP) are both skipped.
-* - {@link route} resolves the STATE carrier for a session: the named bound
-*   pet when alive, else the default pet (the first live entry — de facto
-*   "first started"). Interaction BROADCAST is not a route; see
-*   `notifyPets` in the registry module for the all-notify view.
+*   and a frozen publisher (listening socket, silent HTTP) are both skipped,
+*   in boot order (earliest `since` first).
+* - Interaction BROADCAST is not a route: see `notifyPets` in the registry
+*   module for the all-notify view, and `defaultPet` for unnamed targets.
+*   State audiences are computed by the driver (bound pet alive → that pet,
+*   otherwise every live pet).
 * - {@link snapshot} never throws on an unreachable pet — it resolves with
 *   `online: false`. Field-matrix differences stay here.
 * - {@link call} retries once through a fresh discovery pass, so a pet
@@ -7291,7 +7274,7 @@ function normalizeLastAction(raw) {
 }
 /**
 * HTTP control-plane provider: talks to pet processes over the frozen wire
-* contract, folding legacy single-file manifests into the registry. A new
+* contract, discovering pets through the whale598/pet-http.d/ registry. A new
 * pet implementation is adopted by publishing the same contract — this
 * class does not change for it.
 */
@@ -7299,15 +7282,23 @@ var PetHttpService = class PetHttpService extends PetService {
 	home;
 	capsCache = /* @__PURE__ */ new Map();
 	static CAPS_TTL_MS = 3e4;
+	listCache;
+	static LIST_TTL_MS = 1e3;
 	constructor(ctx, home = petHome()) {
 		super(ctx);
 		this.home = home;
 	}
+	/** Every live pet in boot order, served from the 1s single-flight cache:
+	* concurrent callers share the running probe pass. */
 	list() {
-		return readAllPets(this.home);
-	}
-	async route(boundPetId) {
-		return routePet(await this.list(), boundPetId);
+		const hit = this.listCache;
+		if (hit !== void 0 && Date.now() - hit.at < PetHttpService.LIST_TTL_MS) return hit.flight;
+		const flight = readAllPets(this.home);
+		this.listCache = {
+			at: Date.now(),
+			flight
+		};
+		return flight;
 	}
 	async snapshot(entry) {
 		try {
@@ -7348,25 +7339,27 @@ var PetHttpService = class PetHttpService extends PetService {
 	async call(entry, path, init) {
 		const { timeoutMs, retry } = callBudget(path);
 		const attempts = retry ? 2 : 1;
+		const callerSignal = init?.signal ?? void 0;
 		for (let attempt = 0; attempt < attempts; attempt++) {
 			const current = attempt === 0 ? entry : (await readAllPets(this.home)).find((pet) => pet.id === entry.id);
 			if (current === void 0) throw new Error(`pet "${entry.id}" is no longer running`);
+			let response;
 			try {
 				const timeout = AbortSignal.timeout(timeoutMs);
-				const callerSignal = init?.signal ?? void 0;
 				const signal = callerSignal !== void 0 ? AbortSignal.any([callerSignal, timeout]) : timeout;
-				const response = await fetch(`http://127.0.0.1:${String(current.port)}${path}`, {
+				response = await fetch(`http://127.0.0.1:${String(current.port)}${path}`, {
 					...init,
 					signal
 				});
-				if (!response.ok) {
-					const detail = await response.text().catch(() => "");
-					throw new Error(`pet control ${path} answered HTTP ${String(response.status)}${detail ? `: ${detail.slice(0, 300)}` : ""}`);
-				}
-				return await response.json();
 			} catch (error) {
-				if (attempt === attempts - 1) throw error;
+				if (attempt === attempts - 1 || callerSignal?.aborted === true) throw error;
+				continue;
+			}
+			if (!response.ok) {
+				const detail = await response.text().catch(() => "");
+				throw new Error(`pet control ${path} answered HTTP ${String(response.status)}${detail ? `: ${detail.slice(0, 300)}` : ""}`);
 			}
+			return await response.json();
 		}
 		throw new Error("unreachable");
 	}
@@ -7411,6 +7404,7 @@ function createUnregisteredPetHttp(home = petHome()) {
 	const instance = Object.create(PetHttpService.prototype);
 	instance.home = home;
 	instance.capsCache = /* @__PURE__ */ new Map();
+	instance.listCache = void 0;
 	return instance;
 }
 /**

package/lib/tools.js

@@ -1,4 +1,4 @@
-import { a as logStamp, o as registerPetTools, r as petHome, t as createUnregisteredPetHttp } from "./service-R8qwDx1Q.js";
+import { a as logStamp, o as registerPetTools, r as petHome, t as createUnregisteredPetHttp } from "./service-Df8olC1E.js";
 import { appendFile } from "node:fs/promises";
 import { join } from "node:path";
 // lib/types/tools.js

package/lib/types/registry.d.ts

@@ -1,13 +1,11 @@
 /**
- * The pet registry: a directory of per-pet control manifests, replacing the
- * last-writer-wins single files whose races caused repeated swap incidents
- * (a dying carrier's late write burying a live pet's registration). Each pet
- * implementation owns its own file under whale598/pet-http.d/ (legacy
- * pet-http.d/ still scanned) and re-asserts it on a
- * cadence; entries whose publisher pid is dead expire by omission. The
- * driver reads the whole table and routes per the multi-pet design: the
- * session's bound pet if alive, else the default pet (first alive entry),
- * plus an all-notify broadcast mode for interactions.
+ * The pet registry: a directory of per-pet control manifests. Each pet
+ * implementation owns its own file under whale598/pet-http.d/ (named by its
+ * pet id) and re-asserts it on a cadence; entries whose publisher pid is dead
+ * expire by omission. The driver reads the whole table and routes per the
+ * multi-pet design: a session's state rides its bound pet when that pet is
+ * alive and broadcasts to every live pet otherwise; interactions broadcast to
+ * all; the default pet (earliest-booted) resolves unnamed expression targets.
  * @module dsh-agentic-pet/registry
  */
 /** One pet's published control facts. */
@@ -30,21 +28,32 @@ export interface PetEntry {
  * HTTP probe catches the frozen-but-listening zombies.
  */
 export declare function probeControlPlane(port: number): Promise<boolean>;
-/** Read every live entry in the registry. Dead-pid entries are skipped —
- * they expire by omission the next time their file is rewritten — and so are
- * silent entries (pid alive, control plane unresponsive). */
-export declare function readLivePets(home: string): Promise<PetEntry[]>;
-/** Every live pet: registry entries plus legacy single-file manifests folded
- * under their pet ids (registry entries win on id collision). */
+/**
+ * The default-pet order: earliest booted first (`since` ascending). A missing
+ * or mistyped `since` (0) reads as "unknown boot time" and sorts LAST — it
+ * must never outrank a publisher that stated its boot time. This turns the
+ * multi-pet design's de-facto rule ("the default pet is the first STARTED")
+ * into an actual guarantee: discovery output IS boot order, so every
+ * `pets[0]` consumer (defaultPet, pet_state's defaultPet) reads the
+ * same pet. Stable sort: equal `since` values keep registry listing order.
+ */
+export declare function bootOrder(pets: PetEntry[]): PetEntry[];
+/** Every live pet in boot order. Dead-pid entries are skipped — they expire
+ * by omission the next time their file is rewritten — and so are silent
+ * entries (pid alive, control plane unresponsive). Probes run CONCURRENTLY:
+ * wall time per pass is the slowest pet (≤800ms frozen budget), not the
+ * serial sum. */
 export declare function readAllPets(home: string): Promise<PetEntry[]>;
 /**
- * Resolve the pet that should carry STATE for the given session, per the
- * multi-pet design: the session's bound pet when alive, else the default pet
- * (the first live entry — de facto "first started"). Single-pet deployments
- * degenerate correctly: one live entry is both bound and default.
+ * The default pet for UNNAMED targets: the earliest-booted live entry
+ * (`pets[0]` — discovery's bootOrder guarantees start order, not listing
+ * accident). State routing does NOT go through here anymore: an unbound
+ * (or bound-but-offline) session broadcasts its state to every live pet —
+ * the driver computes that audience itself. Used by the tools'
+ * resolveTarget when neither a named pet nor the owning session resolves.
  * @returns the entry, or undefined when no pet is alive.
  */
-export declare function routePet(pets: PetEntry[], boundPetId: string | undefined): PetEntry | undefined;
+export declare function defaultPet(pets: PetEntry[]): PetEntry | undefined;
 /** The pets that receive an INTERACTION (all-notify mode): every live pet,
  * the session-bound one included. The binding routes STATE — it must never
  * mute interactions: excluding the bound pet would silence the only body

package/lib/types/service.d.ts

@@ -2,8 +2,8 @@
  * The `ctx.petService` capability seam — the dsh three-roles pattern applied
  * inside the process boundary. Pets are separate processes by design, so this
  * service is NOT the pet itself: it is the typed in-process seam over the
- * out-of-process HTTP control plane. Discovery (pet-http.d/ registry plus
- * legacy folding), liveness (pid + two-layer probe), retry policy, and the
+ * out-of-process HTTP control plane. Discovery (the whale598/pet-http.d/
+ * registry), liveness (pid + two-layer probe), retry policy, and the
  * /status field matrix (per-implementation extras) are normalized HERE —
  * consumers (the driver, the model tools, the settings page, the upcoming
  * proactivity scheduler) never see registry files, ports, or raw payloads.
@@ -77,11 +77,12 @@ export interface PetLastAction {
  *
  * Implementations must honor these semantics:
  * - {@link list} returns only pets whose control plane ANSWERS: a dead pid
- *   and a frozen publisher (listening socket, silent HTTP) are both skipped.
- * - {@link route} resolves the STATE carrier for a session: the named bound
- *   pet when alive, else the default pet (the first live entry — de facto
- *   "first started"). Interaction BROADCAST is not a route; see
- *   `notifyPets` in the registry module for the all-notify view.
+ *   and a frozen publisher (listening socket, silent HTTP) are both skipped,
+ *   in boot order (earliest `since` first).
+ * - Interaction BROADCAST is not a route: see `notifyPets` in the registry
+ *   module for the all-notify view, and `defaultPet` for unnamed targets.
+ *   State audiences are computed by the driver (bound pet alive → that pet,
+ *   otherwise every live pet).
  * - {@link snapshot} never throws on an unreachable pet — it resolves with
  *   `online: false`. Field-matrix differences stay here.
  * - {@link call} retries once through a fresh discovery pass, so a pet
@@ -90,11 +91,9 @@ export interface PetLastAction {
  */
 export declare abstract class PetService extends Service {
     constructor(ctx: Context);
-    /** Every live pet (registry entries plus legacy manifests folded under
-     * their pet ids). */
+    /** Every live pet in boot order (earliest `since` first — the default-pet
+     * rule is a discovery guarantee, not a listing accident). */
     abstract list(): Promise<PetEntry[]>;
-    /** The STATE carrier: the bound pet when alive, else the default pet. */
-    abstract route(boundPetId?: string): Promise<PetEntry | undefined>;
     /** The normalized mirror of one pet, or `online: false` when unreachable. */
     abstract snapshot(entry: PetEntry): Promise<PetSnapshot>;
     /** One JSON call to a pet endpoint, with a single fresh-discovery retry. */
@@ -112,7 +111,7 @@ export declare abstract class PetService extends Service {
 export declare function normalizeStatus(id: string, raw: Record<string, unknown>, online: boolean): PetSnapshot;
 /**
  * HTTP control-plane provider: talks to pet processes over the frozen wire
- * contract, folding legacy single-file manifests into the registry. A new
+ * contract, discovering pets through the whale598/pet-http.d/ registry. A new
  * pet implementation is adopted by publishing the same contract — this
  * class does not change for it.
  */
@@ -120,9 +119,12 @@ export declare class PetHttpService extends PetService {
     readonly home: string;
     private readonly capsCache;
     private static readonly CAPS_TTL_MS;
+    private listCache;
+    private static readonly LIST_TTL_MS;
     constructor(ctx: Context, home?: string);
+    /** Every live pet in boot order, served from the 1s single-flight cache:
+     * concurrent callers share the running probe pass. */
     list(): Promise<PetEntry[]>;
-    route(boundPetId?: string): Promise<PetEntry | undefined>;
     snapshot(entry: PetEntry): Promise<PetSnapshot>;
     capabilities(entry: PetEntry): Promise<PetCapabilities>;
     call(entry: PetEntry, path: string, init?: RequestInit): Promise<unknown>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-agentic-pet",
   "description": "The pet-surface bundle: serves the desktop pet renderer over the web composition, turning dsh into a surface the desktop pet attaches to as an authenticated client",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "publishConfig": {
     "access": "public"
   },