pi-coding-master 0.2.7

package/core/technology.phone/apps.preinstalled/steam/spy.ts

@@ -0,0 +1,302 @@
+// steam/spy.ts — Steam 游戏平台（谁是卧底 + 国际象棋）
+
+import type { PhoneApp } from "../../phone.ts";
+import { SpyGame } from "./engine.ts";
+import { ChessGame } from "./chess.ts";
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// ── LLM bot ──
+
+function getApiKey(): string | null {
+  try {
+    const cfg = JSON.parse(readFileSync(join(homedir(), ".pi/agent/models.json"), "utf8"));
+    let k = cfg?.providers?.deepseek?.apiKey;
+    if (typeof k === "string" && k.startsWith("$")) k = process.env[k.slice(1)] ?? "";
+    if (typeof k === "string" && k.trim()) return k.trim();
+  } catch {}
+  return process.env.DEEPSEEK_API_KEY || null;
+}
+
+async function llm(system: string, user: string): Promise<string> {
+  const key = getApiKey();
+  if (!key) return "";
+  try {
+    const res = await Promise.race([
+      fetch("https://api.deepseek.com/chat/completions", {
+        method: "POST",
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${key}` },
+        body: JSON.stringify({
+          model: "deepseek-v4-flash",
+          messages: [{ role: "system", content: system }, { role: "user", content: user }],
+          max_tokens: 300, temperature: 0.9,
+        }),
+        signal: AbortSignal.timeout(3000),
+      }),
+      new Promise<null>((r) => setTimeout(() => r(null), 3000)),
+    ]);
+    if (!res) return "";
+    const j = await res.json() as any;
+    return (j.choices?.[0]?.message?.content || "").trim().replace(/^["「]|["」]$/g, "");
+  } catch { return ""; }
+}
+
+// 本地 fallback：LLM 不可用时，根据词生成简单描述
+const LOCAL_FALLBACKS: Record<string, string[]> = {
+  "薯条": ["炸的", "蘸番茄酱吃"], "薯片": ["袋装", "脆的零食"],
+  "眼镜": ["戴在脸上", "帮助看清东西"], "墨镜": ["遮阳", "夏天常戴"],
+  "牛奶": ["白色液体", "补钙"], "豆浆": ["豆制品", "早餐喝"],
+  "西瓜": ["绿色外皮", "夏天吃"], "哈密瓜": ["黄色果肉", "甜瓜"],
+  "口红": ["涂抹嘴唇", "美妆"], "唇膏": ["滋润", "防干裂"],
+  "高铁": ["速度快", "出远门坐"], "动车": ["也是快的火车", "短途多"],
+  "微信": ["聊天", "绿色图标"], "QQ": ["聊天软件", "企鹅图标"],
+  "面包": ["烤的", "西式主食"], "馒头": ["蒸的", "中式主食"],
+  "咖啡": ["苦的", "提神醒脑"], "奶茶": ["甜的", "年轻人爱喝"],
+  "蜡烛": ["能点燃", "照明用"], "火把": ["手持燃烧", "古代照明"],
+  "护照": ["出国用", "一本蓝色"], "身份证": ["国内用", "随身携带"],
+  "沙发": ["软的", "客厅家具"], "椅子": ["硬的", "可以坐"],
+  "钢笔": ["蘸墨水", "写字"], "毛笔": ["软笔头", "书法"],
+  "足球": ["用脚踢", "圆的"], "篮球": ["用手拍", "橙色的"],
+  "医生": ["看病", "白大褂"], "护士": ["护理", "白衣天使"],
+  "月亮": ["晚上看", "会变圆缺"], "太阳": ["白天", "发光发热"],
+  "空调": ["制冷", "挂在墙上"], "风扇": ["转的", "吹风"],
+  "地铁": ["地下跑", "通勤"], "公交": ["地上跑", "等车"],
+  "饺子": ["皮包馅", "过年吃"], "馄饨": ["汤里", "皮更薄"],
+  "雪碧": ["柠檬味", "绿色瓶"], "七喜": ["也是柠檬味", "白瓶"],
+};
+function localFallback(word: string): string {
+  const opts = LOCAL_FALLBACKS[word];
+  if (!opts) return "这个东西挺常见的";
+  return opts[Math.floor(Math.random() * opts.length)];
+}
+
+async function botDescribe(name: string, word: string, isSpy: boolean, round: number, prevDescs: { player: string; text: string }[]): Promise<string> {
+  const history = prevDescs.length > 0 ? "前面的描述:\n" + prevDescs.map(d => `${d.player}: "${d.text}"`).join("\n") : "你是第一个。";
+  const sys = `你在玩谁是卧底。你的词是「${word}」。用一句话描述，不能说出词语本身或其中任何一个字。绝对不能抄袭或复述别人说过的描述，必须用完全不同的角度。${isSpy ? "你是卧底，描述要模糊但合理，让人觉得你拿到的词和大家一样。" : "你是平民，描述要有区分度但别太明显。"}只输出描述，限15字。`;
+  const llmResult = await llm(sys, `第${round}轮。${history}\n轮到${name}。`);
+  if (llmResult) return llmResult;
+  // 本地 fallback：取不一样的描述
+  const used = new Set(prevDescs.map(d => d.text));
+  const opts = LOCAL_FALLBACKS[word];
+  if (opts) {
+    for (const o of opts) if (!used.has(o)) return o;
+    return opts[0];
+  }
+  return "这个东西挺常见的";
+}
+
+async function botVote(name: string, word: string, isSpy: boolean, alive: string[], descs: { player: string; text: string }[]): Promise<string> {
+  const candidates = alive.filter(id => id !== name);
+  if (candidates.length === 0) return "";
+  const descText = descs.map(d => `${d.player}: "${d.text}"`).join("\n");
+  const sys = `你在玩谁是卧底。你的词是「${word}」。${isSpy ? "你是卧底，投掉一个平民。" : "找描述最不一样的人。"}只回复一个名字。`;
+  const reply = await llm(sys, `描述:\n${descText}\n从 ${candidates.join("、")} 中选。`);
+  if (reply) return candidates.find(c => reply.includes(c)) || candidates[Math.floor(Math.random() * candidates.length)];
+  return candidates[Math.floor(Math.random() * candidates.length)];
+}
+
+// ── runBots：非阻塞，后台运行，完成时自动更新状态 ──
+let botRunning = false;
+async function runBots(game: SpyGame, agentId: string, onUpdate?: () => void): Promise<void> {
+  if (botRunning) return;
+  botRunning = true;
+  try {
+    // 描述阶段：串行（每个 bot 需要看到前面的描述）
+    while (game.phase === "describe") {
+      const current = game.getState().currentTurn;
+      if (!current || current === agentId) break;
+      const p = game.players.find(x => x.id === current);
+      if (!p) break;
+      game.describe(current, await botDescribe(current, p.word, p.isSpy, game.round, game.currentRoundDescs));
+      onUpdate?.();
+    }
+    // 投票阶段：并行
+    if (game.phase === "vote") {
+      const alive = game.getState().alivePlayers;
+      await Promise.all(
+        alive.filter(pid => pid !== agentId && !game.votes.find(v => v.voter === pid))
+          .map(async pid => {
+            const p = game.players.find(x => x.id === pid)!;
+            game.vote(pid, await botVote(pid, p.word, p.isSpy, alive, game.currentRoundDescs));
+            onUpdate?.();
+          })
+      );
+    }
+    onUpdate?.();
+  } finally {
+    botRunning = false;
+  }
+}
+
+// ── Steam 状态 ──
+
+// ── 游戏注册表 ──
+
+interface SteamGameDef {
+  name: string;
+  desc: string;
+}
+
+const GAMES: SteamGameDef[] = [
+  { name: "谁是卧底", desc: "和 AI 对战的推理游戏" },
+  { name: "国际象棋", desc: "和 AI 对弈（minimax）" },
+  { name: "贪吃蛇", desc: "经典贪吃蛇" },
+];
+
+function menu(): string {
+  const lines = ["═══ Steam 游戏平台 ═══", ""];
+  for (const g of GAMES) lines.push(`  ${g.name} — ${g.desc}`);
+  lines.push("", "输入游戏名，或「返回」回主屏幕");
+  return lines.join("\n");
+}
+
+function matchGame(input: string): SteamGameDef | null {
+  return GAMES.find(g => input.includes(g.name)) || null;
+}
+
+interface SteamState {
+  cur: string | null;
+  spy: SpyGame | null;
+  chess: ChessGame | null;
+  snake: any;
+}
+
+function norm(raw: any): SteamState {
+  if (raw?.cur !== undefined) return raw;
+  if (raw?.game) return { cur: '谁是卧底', spy: raw.game, chess: null, snake: null };
+  return { cur: null, spy: null, chess: null, snake: null };
+}
+
+// ── Tool 导出（manifest 用）──
+// 游戏逻辑由 Steam 手机 app 管理；这里只提供入口引导
+export async function spyCmd(args: any, _ctx: any, _personDir: string): Promise<{ content: any[]; details: any }> {
+  return {
+    content: [{ type: "text", text: "谁是卧底\n\n请在手机 Steam 应用中打开「谁是卧底」开始游戏。\n手机 → Steam → 谁是卧底" }],
+    details: {},
+  };
+}
+
+export const app: PhoneApp = {
+  name: "Steam",
+  icon: "",
+  messageDescription: "游戏平台",
+
+  onOpen(state: any, personDir: string) {
+    const s = norm(state);
+    if (s.cur === "谁是卧底" && s.spy && s.spy.phase !== "end") return { screen: s.spy.getPlayerView("你"), state: s };
+    if (s.cur === "国际象棋") {
+      if (!s.chess || s.chess.s.over) s.chess = loadPersisted(personDir) || new ChessGame();
+      return { screen: s.chess.screen(), state: s };
+    }
+    if (s.cur === "贪吃蛇" && s.snake && !s.snake.over) return { screen: s.snake.screen(), state: s };
+    s.cur = null;
+    return { screen: menu(), state: s };
+  },
+
+  async onAction(input: string, rawState: any, personDir: string) {
+    const s = norm(rawState);
+    const trimmed = input.trim();
+    const agentId = "你";
+
+    if (/^(菜单|menu|返回|back)$/i.test(trimmed)) { s.cur = null; s.spy = null; return { screen: menu(), state: s }; }
+
+    // ── 游戏选择 ──
+    if (!s.cur) {
+      const hit = matchGame(trimmed);
+      if (!hit) return { screen: menu() + "\n\n请选择游戏。", state: s };
+      s.cur = hit.name;
+      if (hit.name === "国际象棋") {
+        s.chess = loadPersisted(personDir) || new ChessGame();
+        return { screen: s.chess.screen(), state: s };
+      }
+      if (hit.name === "贪吃蛇") {
+        s.snake = await newSnake();
+        return { screen: s.snake.screen(), state: s };
+      }
+      if (hit.name === "谁是卧底") {
+        if (s.spy && s.spy.phase !== "end") return { screen: s.spy.getPlayerView(agentId), state: s };
+        return { screen: "═══ 谁是卧底 ═══\n\n输入「新游戏」或「新游戏 5」开始\n「菜单」回 Steam", state: s };
+      }
+    }
+
+    // ── 谁是卧底 ──
+    if (s.cur === "谁是卧底") {
+      const newMatch = trimmed.match(/^新游戏\s*(\d+)?$/) || trimmed.match(/^new\s*(\d+)?$/i);
+      if (newMatch) {
+        const count = Math.max(3, Math.min(7, parseInt(newMatch[1] || "5")));
+        const botNames = ["甲", "乙", "丙", "丁", "戊", "己"].slice(0, count - 1);
+        s.spy = new SpyGame([agentId, ...botNames]);
+        // 非阻塞：bot 后台运行，不卡 UI
+        runBots(s.spy, agentId);
+        return { screen: s.spy.getPlayerView(agentId) + "\nAI 玩家思考中...", state: s };
+      }
+      if (!s.spy || s.spy.phase === "end") {
+        if (s.spy?.phase === "end") return { screen: s.spy.getPlayerView(agentId) + "\n\n输入「新游戏」再来一局，或「菜单」回 Steam。", state: s };
+        return { screen: "没有进行中的游戏。输入「新游戏」开始。", state: s };
+      }
+      const game = s.spy;
+      if (game.phase === "vote") {
+        const alive = game.getState().alivePlayers.filter((id: string) => id !== agentId);
+        const target = alive.find((name: string) => trimmed.includes(name));
+        if (target) {
+          const result = game.vote(agentId, target);
+          if (!result.ok) return { screen: `${result.error}`, state: s };
+          runBots(game, agentId);
+          return { screen: `${result.message}\n\n${game.getPlayerView(agentId)}`, state: s };
+        }
+        return { screen: `请投票: ${alive.join(", ")}`, state: s };
+      }
+      if (game.phase === "describe" && game.getState().currentTurn === agentId) {
+        const desc = trimmed.replace(/^(describe|描述)\s*/i, "").trim();
+        if (!desc) return { screen: "描述不能为空。输入你对词语的描述。", state: s };
+        const result = game.describe(agentId, desc);
+        if (!result.ok) return { screen: `${result.error}`, state: s };
+        runBots(game, agentId);
+        return { screen: `${result.message}\n\n${game.getPlayerView(agentId)}`, state: s };
+      }
+      // 默认返回当前状态
+      let screen = game.getPlayerView(agentId);
+      if (botRunning) screen += "\nAI 玩家思考中...";
+      return { screen, state: s };
+    }
+
+    // ── 贪吃蛇 ──
+    if (s.cur === "贪吃蛇") {
+      if (!s.snake) s.snake = await newSnake();
+      if (/^(新局|new)$/i.test(trimmed)) { s.snake = await newSnake(); return { screen: s.snake.screen(), state: s }; }
+      const dirMap: Record<string, 'u'|'d'|'l'|'r'> = { w: 'u', s: 'd', a: 'l', d: 'r', up: 'u', down: 'd', left: 'l', right: 'r' };
+      const dir = dirMap[trimmed.toLowerCase()];
+      if (dir) s.snake.input(dir);
+      return { screen: s.snake.screen(), state: s };
+    }
+
+    // ── 国际象棋 ──
+    if (s.cur === "国际象棋") {
+      if (!s.chess) s.chess = loadPersisted(personDir) || new ChessGame();
+      if (/^(新局|new)$/i.test(trimmed)) { s.chess = new ChessGame(); clearPersisted(personDir); return { screen: s.chess.screen(), state: s }; }
+      if (/^(认输|resign)$/i.test(trimmed)) { s.chess.resign(); persist(s.chess, personDir); return { screen: s.chess.screen(), state: s }; }
+      const r = s.chess.move(trimmed);
+      if (!r.ok) return { screen: s.chess.screen() + `\n\n${r.error}`, state: s };
+      persist(s.chess, personDir);
+      return { screen: s.chess.screen() + (r.ai ? `\n\n对手走: ${r.ai}` : ""), state: s };
+    }
+
+    return { screen: menu(), state: s };
+  },
+};
+
+// ── 持久化 ──
+function persist(game: ChessGame, personDir: string) {
+  try { mkdirSync(personDir, { recursive: true }); writeFileSync(join(personDir, "steam.json"), JSON.stringify({ chess: game.toJSON() })); } catch {}
+}
+function loadPersisted(personDir: string): ChessGame | null {
+  try { const raw = JSON.parse(readFileSync(join(personDir, "steam.json"), "utf8")); return raw?.chess ? ChessGame.fromJSON(raw.chess) : null; } catch { return null; }
+}
+function clearPersisted(personDir: string) { try { writeFileSync(join(personDir, "steam.json"), "{}"); } catch {} }
+
+// ── 动态加载蛇（破 jiti 缓存）──
+async function newSnake(): Promise<any> {
+  const { SnakeGame } = await import(`./snake.js?t=${Date.now()}`);
+  return new SnakeGame();
+}

package/core/technology.phone/apps.preinstalled/steam/steam.ts

@@ -0,0 +1,299 @@
+// spy/engine.ts — 谁是卧底游戏引擎（纯逻辑，零 LLM，零 I/O）
+// 所有状态变更通过方法调用，所有非法操作返回错误，不抛异常。
+
+export interface WordPair { spy: string; civilian: string; hint?: string }
+
+export interface Player {
+  id: string;
+  name: string;
+  isSpy: boolean;
+  word: string;
+  alive: boolean;
+  messageDescriptions: string[];
+}
+
+export type Phase = "describe" | "vote" | "end";
+export type Winner = "spy" | "civilian" | null;
+
+export interface VoteRecord { voter: string; target: string }
+export interface RoundRecord {
+  round: number;
+  messageDescriptions: { player: string; text: string }[];
+  votes: VoteRecord[];
+  eliminated: string | null;
+  tiebreak: boolean;
+}
+
+export interface GameState {
+  phase: Phase;
+  round: number;
+  alivePlayers: string[];
+  currentTurn: string | null;
+  describeOrder: string[];
+  describedThisRound: string[];
+  votedThisRound: string[];
+  winner: Winner;
+  rounds: RoundRecord[];
+}
+
+export interface ActionResult {
+  ok: boolean;
+  error?: string;
+  state: GameState;
+  message?: string;
+}
+
+const BUILTIN_WORDS: WordPair[] = [
+  { spy: "薯条", civilian: "薯片" },
+  { spy: "眼镜", civilian: "墨镜" },
+  { spy: "牛奶", civilian: "豆浆" },
+  { spy: "西瓜", civilian: "哈密瓜" },
+  { spy: "口红", civilian: "唇膏" },
+  { spy: "高铁", civilian: "动车" },
+  { spy: "微信", civilian: "QQ" },
+  { spy: "面包", civilian: "馒头" },
+  { spy: "咖啡", civilian: "奶茶" },
+  { spy: "蜡烛", civilian: "火把" },
+  { spy: "护照", civilian: "身份证" },
+  { spy: "沙发", civilian: "椅子" },
+  { spy: "钢笔", civilian: "毛笔" },
+  { spy: "足球", civilian: "篮球" },
+  { spy: "医生", civilian: "护士" },
+  { spy: "月亮", civilian: "太阳" },
+  { spy: "空调", civilian: "风扇" },
+  { spy: "地铁", civilian: "公交" },
+  { spy: "饺子", civilian: "馄饨" },
+  { spy: "雪碧", civilian: "七喜" },
+];
+
+function shuffle<T>(arr: T[]): T[] {
+  const a = [...arr];
+  for (let i = a.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [a[i], a[j]] = [a[j], a[i]];
+  }
+  return a;
+}
+
+export class SpyGame {
+  players: Player[] = [];
+  phase: Phase = "describe";
+  round = 1;
+  describeOrder: string[] = [];
+  describeIdx = 0;
+  votes: VoteRecord[] = [];
+  rounds: RoundRecord[] = [];
+  currentRoundDescs: { player: string; text: string }[] = [];
+  winner: Winner = null;
+  wordPair: WordPair;
+
+  constructor(playerNames: string[], spyCount = 1, wordPair?: WordPair) {
+    if (playerNames.length < 3) throw new Error("至少 3 个玩家");
+    if (spyCount >= playerNames.length) throw new Error("卧底数量必须少于玩家数");
+
+    this.wordPair = wordPair ?? BUILTIN_WORDS[Math.floor(Math.random() * BUILTIN_WORDS.length)];
+    const shuffled = shuffle(playerNames);
+    const spyNames = new Set(shuffled.slice(0, spyCount));
+
+    this.players = playerNames.map(name => ({
+      id: name,
+      name,
+      isSpy: spyNames.has(name),
+      word: spyNames.has(name) ? this.wordPair.spy : this.wordPair.civilian,
+      alive: true,
+      messageDescriptions: [],
+    }));
+
+    this.describeOrder = shuffle(this.alivePlayers().map(p => p.id));
+  }
+
+  private alivePlayers(): Player[] {
+    return this.players.filter(p => p.alive);
+  }
+
+  private player(id: string): Player | undefined {
+    return this.players.find(p => p.id === id);
+  }
+
+  getState(): GameState {
+    return {
+      phase: this.phase,
+      round: this.round,
+      alivePlayers: this.alivePlayers().map(p => p.id),
+      currentTurn: this.phase === "describe" ? (this.describeOrder[this.describeIdx] ?? null) : null,
+      describeOrder: this.describeOrder,
+      describedThisRound: this.currentRoundDescs.map(d => d.player),
+      votedThisRound: this.votes.map(v => v.voter),
+      winner: this.winner,
+      rounds: this.rounds,
+    };
+  }
+
+  getPlayerView(playerId: string): string {
+    const p = this.player(playerId);
+    if (!p) return "错误：你不在这局游戏里。";
+
+    const lines: string[] = [];
+    lines.push(`═══ 谁是卧底 · 第 ${this.round} 轮 ═══`);
+    lines.push(`你是: ${p.name} | 你的词: 「${p.word}」`);
+    lines.push(`存活: ${this.alivePlayers().map(a => a.id).join(", ")} (${this.alivePlayers().length}人)`);
+    lines.push("");
+
+    if (this.phase === "describe") {
+      lines.push(`── 描述阶段 ──`);
+      if (this.currentRoundDescs.length > 0) {
+        for (const d of this.currentRoundDescs) {
+          lines.push(`  ${d.player}: "${d.text}"`);
+        }
+      }
+      const currentTurn = this.describeOrder[this.describeIdx];
+      if (currentTurn === playerId) {
+        lines.push("");
+        lines.push(`→ 轮到你描述。用你自己的话描述你的词，不要直接说出词语。`);
+        lines.push(`  操作: describe <你的描述>`);
+      } else if (currentTurn) {
+        lines.push(`  等待 ${currentTurn} 描述...`);
+      }
+    } else if (this.phase === "vote") {
+      lines.push(`── 投票阶段 ──`);
+      lines.push(`本轮描述回顾:`);
+      for (const d of this.currentRoundDescs) {
+        lines.push(`  ${d.player}: "${d.text}"`);
+      }
+      lines.push("");
+      if (this.votes.find(v => v.voter === playerId)) {
+        lines.push(`你已投票。等待其他人...`);
+        lines.push(`已投: ${this.votes.map(v => v.voter).join(", ")}`);
+        const notYet = this.alivePlayers().filter(a => !this.votes.find(v => v.voter === a.id));
+        if (notYet.length > 0) lines.push(`未投: ${notYet.map(a => a.id).join(", ")}`);
+      } else {
+        const candidates = this.alivePlayers().filter(a => a.id !== playerId).map(a => a.id);
+        lines.push(`→ 投票淘汰一个你认为是卧底的人。`);
+        lines.push(`  候选: ${candidates.join(", ")}`);
+        lines.push(`  操作: vote <玩家名>`);
+      }
+    } else if (this.phase === "end") {
+      lines.push(`══ 游戏结束 ══`);
+      lines.push(`胜方: ${this.winner === "spy" ? "卧底" : "平民"}`);
+      lines.push(`卧底词: 「${this.wordPair.spy}」 | 平民词: 「${this.wordPair.civilian}」`);
+      lines.push(`卧底是: ${this.players.filter(p => p.isSpy).map(p => p.name).join(", ")}`);
+    }
+
+    if (this.rounds.length > 0 && this.phase !== "end") {
+      lines.push("");
+      lines.push(`── 历史 ──`);
+      for (const r of this.rounds) {
+        lines.push(`  第${r.round}轮: 淘汰 ${r.eliminated ?? "无"}${r.tiebreak ? " (平票重投)" : ""}`);
+      }
+    }
+
+    return lines.join("\n");
+  }
+
+  describe(playerId: string, text: string): ActionResult {
+    if (this.phase !== "describe") return { ok: false, error: "当前不是描述阶段。", state: this.getState() };
+    if (!this.player(playerId)?.alive) return { ok: false, error: "你已被淘汰。", state: this.getState() };
+    const currentTurn = this.describeOrder[this.describeIdx];
+    if (currentTurn !== playerId) return { ok: false, error: `还没轮到你，当前轮到 ${currentTurn}。`, state: this.getState() };
+
+    const trimmed = text.trim();
+    if (!trimmed) return { ok: false, error: "描述不能为空。", state: this.getState() };
+    if (trimmed.includes(this.wordPair.spy) || trimmed.includes(this.wordPair.civilian)) {
+      return { ok: false, error: "描述中不能包含任何玩家的词语！请重新描述。", state: this.getState() };
+    }
+
+    this.currentRoundDescs.push({ player: playerId, text: trimmed });
+    this.player(playerId)!.messageDescriptions.push(trimmed);
+    this.describeIdx++;
+
+    if (this.describeIdx >= this.describeOrder.length) {
+      this.phase = "vote";
+      this.votes = [];
+    }
+
+    return { ok: true, state: this.getState(), message: `描述已记录。` };
+  }
+
+  vote(voterId: string, targetId: string): ActionResult {
+    if (this.phase !== "vote") return { ok: false, error: "当前不是投票阶段。", state: this.getState() };
+    if (!this.player(voterId)?.alive) return { ok: false, error: "你已被淘汰。", state: this.getState() };
+    if (this.votes.find(v => v.voter === voterId)) return { ok: false, error: "你已经投过票了。", state: this.getState() };
+    if (voterId === targetId) return { ok: false, error: "不能投自己。", state: this.getState() };
+    const target = this.player(targetId);
+    if (!target || !target.alive) return { ok: false, error: `${targetId} 不存在或已被淘汰。`, state: this.getState() };
+
+    this.votes.push({ voter: voterId, target: targetId });
+
+    if (this.votes.length >= this.alivePlayers().length) {
+      return this.resolveVotes();
+    }
+
+    return { ok: true, state: this.getState(), message: `投票已记录。等待其他玩家投票。` };
+  }
+
+  private resolveVotes(): ActionResult {
+    const counts: Record<string, number> = {};
+    for (const v of this.votes) counts[v.target] = (counts[v.target] || 0) + 1;
+
+    const maxVotes = Math.max(...Object.values(counts));
+    const topPlayers = Object.entries(counts).filter(([, c]) => c === maxVotes).map(([id]) => id);
+
+    let eliminated: string | null = null;
+    let tiebreak = false;
+
+    if (topPlayers.length === 1) {
+      eliminated = topPlayers[0];
+    } else {
+      // 平票：随机淘汰一个（简化规则，完整版可以加PK）
+      eliminated = topPlayers[Math.floor(Math.random() * topPlayers.length)];
+      tiebreak = true;
+    }
+
+    if (eliminated) {
+      const p = this.player(eliminated);
+      if (p) p.alive = false;
+    }
+
+    this.rounds.push({
+      round: this.round,
+      messageDescriptions: [...this.currentRoundDescs],
+      votes: [...this.votes],
+      eliminated,
+      tiebreak,
+    });
+
+    const winner = this.checkWin();
+    if (winner) {
+      this.winner = winner;
+      this.phase = "end";
+      return {
+        ok: true,
+        state: this.getState(),
+        message: `${eliminated} 被淘汰！游戏结束，${winner === "spy" ? "卧底" : "平民"}获胜！`,
+      };
+    }
+
+    this.round++;
+    this.currentRoundDescs = [];
+    this.votes = [];
+    this.describeOrder = shuffle(this.alivePlayers().map(p => p.id));
+    this.describeIdx = 0;
+    this.phase = "describe";
+
+    return {
+      ok: true,
+      state: this.getState(),
+      message: `${eliminated} 被淘汰！${tiebreak ? "(平票随机)" : ""} 进入第 ${this.round} 轮。`,
+    };
+  }
+
+  private checkWin(): Winner {
+    const alive = this.alivePlayers();
+    const spiesAlive = alive.filter(p => p.isSpy).length;
+    const civiliansAlive = alive.filter(p => !p.isSpy).length;
+
+    if (spiesAlive === 0) return "civilian";
+    if (spiesAlive >= civiliansAlive) return "spy";
+    return null;
+  }
+}

package/core/technology.phone/apps.preinstalled/weather/weather.ts

@@ -0,0 +1,50 @@
+// apps.preinstalled/weather/weather.ts — Weather PhoneApp
+import type { PhoneApp } from "../../system.kernel/kernel.ts";
+
+async function fetchWeather(city: string): Promise<string> {
+  const c = encodeURIComponent(city || "Beijing");
+  try {
+    const res = await fetch(`https://wttr.in/${c}?format=%C+%t+%h+%w&lang=zh`, {
+      signal: AbortSignal.timeout(3000),
+      headers: { "User-Agent": "curl/7.79" },
+    });
+    if (res.ok) return `${city}: ${(await res.text()).trim()}`;
+  } catch {}
+  // fallback: multi-line forecast
+  try {
+    const res = await fetch(`https://wttr.in/${c}?T&lang=zh`, {
+      signal: AbortSignal.timeout(5000),
+      headers: { "User-Agent": "curl/7.79" },
+    });
+    if (res.ok) {
+      const text = await res.text();
+      return text.split("\n").filter((l: string) => l.trim()).slice(0, 8).join("\n");
+    }
+  } catch {}
+  return "天气查询失败，检查城市名";
+}
+
+export const app: PhoneApp = {
+  name: "天气",
+  icon: "天气",
+  messageDescription: "查询城市天气",
+
+  onOpen(state: any) {
+    return {
+      screen: [
+        "═══ 天气 ═══",
+        "",
+        "输入城市名查询天气",
+        "如：深圳、Tokyo、London",
+        "",
+        "「返回」退出",
+      ].join("\n"),
+      state,
+    };
+  },
+
+  async onAction(input: string, state: any) {
+    const weather = await fetchWeather(input.trim());
+    return { screen: weather + "\n\n输入其他城市继续查，或「返回」退出", state };
+  },
+};

package/core/technology.phone/apps.preinstalled/weather/weather.ts.SPEC

@@ -0,0 +1,9 @@
+source: weather.ts @ f49052d3
+
+# weather.ts SPEC
+## 用途
+天气工具——查询城市天气。按 BlueBox OS Weather.app Info.plist 定义实现。
+## 为什么需要
+用户要求实现 BlueBox OS 各 App 功能为 pi AI 工具。
+## 能力
+- query_weather: 查询城市天气（默认北京）