arona-agent 1.2.1 → 1.2.3

package/src/gui/index.ts

@@ -2,6 +2,7 @@
 // 启动条件：裸 `arona`（默认入口，src/index.ts 分流到本文件；--cli / settings.json CLIEnabled: true 时走命令行）。
 import { spawn, type ChildProcessWithoutNullStreams } from "child_process";
 import { join } from "path";
+import { existsSync } from "fs";
 import chalk from "chalk";
 import { PROJECT_ROOT, settingsExist, reloadConfig, config, verbose } from "../config.ts";
 import { t, refreshLanguage } from "../locale.ts";
@@ -21,11 +22,15 @@ class GuiBridge {
   private controller: GuiController | null = null;
   private startingMain = false;
   private exited = false;
-  // Windows 下 spawn 后立刻写 stdin 会丢数据（GUI 白屏根因：mode 事件从未到达 Electron 进程）——
-  // 等 GUI 进程回报 hello（stdin 解析器就绪的握手，gui/main.cjs 模块加载即发送）才真正下发，此前入队。
-  // macOS/Linux 不受影响，但握手在所有平台统一走一遍（幂等，且顺带验证 stdout 协议链路通）。
+  // Windows 下 spawn 后立刻写 stdin 会丢数据，且实测 GUI 子系统 Electron 的 stdin **完全不可达**
+  //（hello 握手证明进程与 stdout 均正常，数据仍不到达）——GUI 进程起 127.0.0.1 随机端口 + 随机 token
+  // 的 HTTP 服务，端口/token 随 hello 行告知；hello 前入队，收到后按序经 HTTP 下发。
+  // httpPort=0（HTTP 起失败）时退回 stdin 写入（非 Windows 平台 stdin 本来就通）。
   private helloReceived = false;
   private queuedEvents: GuiEvent[] = [];
+  private guiHttpPort = 0;
+  private guiHttpToken = "";
+  private httpChain: Promise<void> = Promise.resolve(); // 串行链保序（HTTP 异步，并发会乱序）
 
   emit(ev: GuiEvent): void {
     if (verbose) console.error(chalk.gray("[gui:verbose]"), "emit", ev.type, this.helloReceived ? "" : "(queued)");
@@ -34,6 +39,10 @@ class GuiBridge {
       return;
     }
     if (!this.proc || this.proc.killed) return;
+    if (this.guiHttpPort) {
+      this.httpChain = this.httpChain.then(() => this.postEvent(ev));
+      return;
+    }
     try {
       this.proc.stdin.write(formatGuiLine(ev));
     } catch {
@@ -41,6 +50,21 @@ class GuiBridge {
     }
   }
 
+  /** 经本地 HTTP 通道下发事件（gui/main.cjs 的 127.0.0.1 随机端口服务，token 鉴权） */
+  private async postEvent(ev: GuiEvent): Promise<void> {
+    try {
+      await fetch(`http://127.0.0.1:${this.guiHttpPort}/`, {
+        method: "POST",
+        headers: { "content-type": "application/json", "x-arona-token": this.guiHttpToken },
+        body: JSON.stringify(ev),
+      });
+    } catch (err) {
+      if (verbose) {
+        console.error(chalk.gray("[gui:verbose]"), "http emit failed:", err instanceof Error ? err.message : err);
+      }
+    }
+  }
+
   async start(): Promise<void> {
     const electronPath = await getElectronPath();
     if (!electronPath) {
@@ -136,6 +160,20 @@ class GuiBridge {
         syncSkillsFromAgentsDir();
       }
 
+      // 旧会话工作区一次性回填（按内容推断；已在启动初期完成，会话列表/侧栏分组才准确）
+      const { backfillLegacyWorkspaces } = await import("../memory.ts");
+      const migrated = backfillLegacyWorkspaces();
+      if (migrated > 0) {
+        console.error(chalk.gray(`[ws] 已将 ${migrated} 个历史会话按内容归入工作区`));
+      }
+
+      // 恢复/设定活动工作区（须在 initAgent 前，SDK cwd 跟随）。GUI 的进程启动目录
+      // 对用户无意义，不作为工作区：有上次选择用之，否则默认家目录。
+      const { getLastWorkspace } = await import("../config.ts");
+      const { setActiveWorkspace, guiDefaultWorkspace } = await import("../workspace.ts");
+      const last = getLastWorkspace();
+      setActiveWorkspace(last && existsSync(last) ? last : guiDefaultWorkspace());
+
       let current = await initAgent();
       await startPet();
       preloadGptSovitsLocal();
@@ -149,12 +187,11 @@ class GuiBridge {
           this.exited = true;
           process.exit(0);
         },
+        // 只负责创建新会话（cwd 跟随当前活动工作区）；旧会话的生命周期由 controller
+        // 槽位管理：生成中挂后台继续、空闲存盘释放，这里不得 dispose。
         async () => {
-          current.session.dispose();
-          const { resetConversationFlag } = await import("../memory.ts");
-          resetConversationFlag();
-          current = await initAgent();
-          return current;
+          const { initAgent } = await import("../agent.ts");
+          return await initAgent();
         },
       );
 
@@ -187,13 +224,15 @@ class GuiBridge {
   private async handleRequest(req: GuiRequest): Promise<void> {
     switch (req.type) {
       case "hello": {
-        // GUI 进程 stdin 解析器就绪：解锁排队中的事件（emit mode/setup_info 在 spawn 后立即调用，
-        // Windows 下彼时写入会丢失——见 emit() 注释）
+        // GUI 进程握手：解锁排队中的事件（emit mode/setup_info 在 spawn 后立即调用，Windows 下彼时
+        // stdin 写入会丢失）。端口/token 就位后，后续事件经本地 HTTP 通道下发。
         this.helloReceived = true;
+        this.guiHttpPort = Number(req.httpPort) || 0;
+        this.guiHttpToken = String(req.token || "");
         const queued = this.queuedEvents;
         this.queuedEvents = [];
         if (verbose && queued.length) {
-          console.error(chalk.gray("[gui:verbose]"), "hello received, flushing", queued.length, "queued events");
+          console.error(chalk.gray("[gui:verbose]"), "hello received (httpPort=" + this.guiHttpPort + "), flushing", queued.length, "queued events");
         }
         for (const ev of queued) this.emit(ev);
         break;
@@ -244,6 +283,13 @@ class GuiBridge {
       case "rename_session":
         this.controller?.renameSessionByPath(req.path, req.title);
         break;
+      case "set_workspace":
+        await this.controller?.setWorkspace(req.path);
+        break;
+      case "move_session":
+        this.controller?.moveSessionByPath(req.path, req.workspace);
+        break;
+      // pick_workspace_folder 在 gui/main.cjs 进程内拦截弹原生目录框，不经此处
       case "invoke_skill":
         await this.controller?.handleCommand(`/skill ${req.name}`);
         break;

package/src/gui/protocol.ts

@@ -15,8 +15,10 @@ export type GuiEvent =
   | { type: "agent_event"; agentId: string; event: Record<string, unknown> }
   // 命令/操作反馈文本
   | { type: "notice"; level: "info" | "warn" | "error" | "success"; text: string }
-  // 会话列表（侧栏数据源；currentPath=当前恢复会话，用于高亮）
-  | { type: "sessions"; currentPath: string | null; sessions: Array<{ path: string; preview: string; timestamp: string; model: string }> }
+  // 会话列表（侧栏数据源；currentPath=当前恢复会话，用于高亮；currentWorkspace=当前活动工作区；
+  // homeDir=用户家目录（前端把家目录工作区显示为「用户目录」）；knownWorkspaces=已知工作区
+  // （settings 选择历史 ∪ 会话推导，去重）；workspace=会话所属工作区，旧会话可能缺失，展示层归入「未分组」）
+  | { type: "sessions"; currentPath: string | null; currentWorkspace: string; homeDir: string; knownWorkspaces: string[]; sessions: Array<{ path: string; preview: string; timestamp: string; model: string; workspace?: string }> }
   // 技能列表（/skill 弹窗数据）
   | { type: "skills"; skills: Array<{ name: string; description: string }> }
   // STT 结果（空串=未识别到语音）与录音状态
@@ -64,6 +66,8 @@ export interface GuiState {
 // gui → backend
 // ============================================================
 export type GuiRequest =
+  // GUI 进程握手（gui/main.cjs 起好 HTTP 通道后回报；httpPort=0 表示 HTTP 不可用，backend 退回 stdin）
+  | { type: "hello"; httpPort: number; token: string }
   // 用户消息（@file/!shell 由 backend 展开）
   | { type: "input"; text: string }
   // 斜杠命令（name 不含 "/"）
@@ -83,6 +87,11 @@ export type GuiRequest =
   // 侧栏会话管理（右键菜单）
   | { type: "delete_session"; path: string }
   | { type: "rename_session"; path: string; title: string }
+  // 工作区：切换活动工作区（重建 Agent 会话）/ 把会话移动到某工作区
+  // （pick_workspace_folder 由 gui/main.cjs 拦截弹原生目录对话框，经渲染层回传 set_workspace）
+  | { type: "set_workspace"; path: string }
+  | { type: "move_session"; path: string; workspace: string }
+  | { type: "pick_workspace_folder" }
   // 调用技能
   | { type: "invoke_skill"; name: string }
   // 切换角色

package/src/gui/setup_backend.ts

@@ -1,16 +1,22 @@
 // 图形化 setup 后端：表单数据 → Python 检查 / pip 依赖 / 音色克隆 / 写盘。
 // 步骤与字段对齐 CLI src/setup.ts（该文件模块加载即跑 CLI 向导，不能 import，独立实现）。
-import { spawn, execSync } from "child_process";
+import { execFileSync } from "child_process";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { join } from "path";
 import { ARONA_DIR, SETTINGS_FILE, PROJECT_ROOT, resolveModelPrefix } from "../config.ts";
 import { VOICE_AGENT_IDS } from "../agent_registry.ts";
 import { VOICE_AUDIO, cloneVoice, setVoiceId, setGptSovitsVoice } from "../voices.ts";
-import { normalizeGptSovitsConfig } from "../tts_provider.ts";
+import { normalizeGptSovitsConfig, type GptSovitsModelVersion } from "../tts_provider.ts";
 import { installGptSovitsDeps } from "../gpt_sovits_local.ts";
 import { t } from "../locale.ts";
+import { spawnCompat } from "../utils/spawn.ts";
 import type { GuiEvent } from "./protocol.ts";
 
+/** 前端表单的 modelVersion 字符串 → 合法枚举（未知值回退 v2，与 normalizeGptSovitsConfig 一致）。 */
+function normalizeModelVersion(raw: string | undefined): GptSovitsModelVersion {
+  return raw === "v2Pro" || raw === "v3" || raw === "v4" || raw === "v2" ? raw : "v2";
+}
+
 export interface GuiSetupForm {
   language: "auto" | "zh" | "en";
   apiBaseUrl: string;
@@ -74,7 +80,8 @@ function loadExistingSettings(): ExistingSettings {
 /** Python 须为 3.12/3.13（与 CLI setup.checkPythonVersion 一致）。 */
 function checkPythonVersion(pythonPath: string): { ok: boolean; version: string } {
   try {
-    const output = execSync(`${pythonPath} --version`, { stdio: "pipe" }).toString().trim();
+    // execFileSync（不经 shell）：兼容含空格的 Python 路径（Windows C:\Program Files\...）
+    const output = execFileSync(pythonPath, ["--version"], { stdio: "pipe", encoding: "utf-8" }).trim();
     const match = output.match(/Python\s+(\d+)\.(\d+)\.(\d+)/);
     if (!match) return { ok: false, version: output || "unknown" };
     const major = parseInt(match[1]);
@@ -90,7 +97,8 @@ function checkPythonVersion(pythonPath: string): { ok: boolean; version: string
 /** 流式执行命令：逐行转发输出，resolve 退出码。 */
 function streamCommand(cmd: string, args: string[], emit: Emit, step: string): Promise<number> {
   return new Promise((resolve) => {
-    const child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+    // spawnCompat：Windows 上命令解析为 .bat/.cmd 时自动补 shell（否则 spawn 直接 EINVAL）
+    const child = spawnCompat(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
     const pump = (data: Buffer) => {
       for (const line of data.toString().split(/[\r\n]+/)) {
         if (line.trim()) emit({ type: "setup_log", step, line });
@@ -144,7 +152,7 @@ export async function runGuiSetup(form: GuiSetupForm, emit: Emit): Promise<boole
   // ---- 音色配置 / 克隆 ----
   const ttsProvider = form.ttsProvider;
   let gptSovitsConfig = normalizeGptSovitsConfig((existing.ttsConfig as Record<string, unknown>)?.["gpt-sovits"]);
-  delete (gptSovitsConfig as Record<string, unknown>).voices;
+  delete gptSovitsConfig.voices;
 
   if (ttsProvider === "gpt-sovits") {
     const gs = form.gptSovits;
@@ -159,7 +167,7 @@ export async function runGuiSetup(form: GuiSetupForm, emit: Emit): Promise<boole
       cnhubertPath: gs.mode === "local" ? (gs.cnhubertPath || "") : "",
       baseUrl: gs.baseUrl || gptSovitsConfig.baseUrl,
       textLang: gs.textLang || gptSovitsConfig.textLang,
-      modelVersion: gs.mode === "cloud" ? "v2" : (gs.modelVersion || "v2"),
+      modelVersion: gs.mode === "cloud" ? "v2" : normalizeModelVersion(gs.modelVersion),
     };
 
     // 本地部署：可选依赖安装（api_v2.py 同目录 requirements 优先）
@@ -192,7 +200,7 @@ export async function runGuiSetup(form: GuiSetupForm, emit: Emit): Promise<boole
     } else if (depsOk) {
       let dashscopeOk = false;
       try {
-        execSync(`${pythonPath} -c "import dashscope"`, { stdio: "pipe" });
+        execFileSync(pythonPath, ["-c", "import dashscope"], { stdio: "pipe" });
         dashscopeOk = true;
       } catch {
         emit({ type: "setup_log", step: "clone", line: t("dashscope 包不可用，跳过音色克隆。", "dashscope package unavailable, skipping voice cloning.") });

package/src/index.ts

@@ -16,17 +16,20 @@ import chalk from "chalk";
  * 独立进程写 settings.json，主进程随后 reloadConfig 即可（ESM 缓存无法重建单例）。
  */
 function runSetupWizard(): Promise<number> {
-  const tsxBin = process.platform === "win32"
-    ? join(PROJECT_ROOT, "node_modules", ".bin", "tsx.cmd")
-    : join(PROJECT_ROOT, "node_modules", ".bin", "tsx");
+  // 与 bin/arona.mjs 同款：用当前 node 直跑内置 tsx CLI。不依赖 node_modules/.bin shim
+  //（Windows 全局包装不出 .cmd，且 shell:true 的字符串拼接在含空格路径下易错）。
+  const tsxCli = join(PROJECT_ROOT, "node_modules", "tsx", "dist", "cli.mjs");
   const wizardArgs = process.argv.slice(2).filter((a) => a !== "--cli");
   return new Promise((resolve) => {
-    const child = spawn(tsxBin, [join(PROJECT_ROOT, "src", "setup.ts"), ...wizardArgs], {
+    const child = spawn(process.execPath, [tsxCli, join(PROJECT_ROOT, "src", "setup.ts"), ...wizardArgs], {
       cwd: process.cwd(),
       stdio: "inherit",
-      shell: process.platform === "win32",
       env: { ...process.env, ARONA_AUTO_SETUP: "1" },
     });
+    child.on("error", (err) => {
+      console.error(chalk.red(t(`无法启动初始化向导：${err.message}`, `Failed to launch setup wizard: ${err.message}`)));
+      resolve(1);
+    });
     child.on("exit", (code) => resolve(code ?? 0));
   });
 }
@@ -66,6 +69,13 @@ async function runCli() {
     }
   }
 
+  // 旧会话工作区一次性回填（按内容推断；/resume 分组展示前完成）
+  const { backfillLegacyWorkspaces } = await import("./memory.ts");
+  const migrated = backfillLegacyWorkspaces();
+  if (migrated > 0) {
+    console.log(chalk.cyan(t(`已将 ${migrated} 个历史会话按内容归入工作区`, `Assigned ${migrated} legacy session(s) to their workspaces`)));
+  }
+
   let { session, modelRuntime, loader } = await initAgent();
 
   // 首次启动需下载 Electron，须等下载完成再进入 REPL
@@ -114,6 +124,16 @@ async function runCli() {
 }
 
 async function main() {
+  // Headless Linux（无显示服务器）：GUI 窗口/桌宠都无法启动，直接回退命令行（与 pet.ts 同款守卫）。
+  const headless = process.platform === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY;
+  if (headless) {
+    console.warn(chalk.yellow(t(
+      "未检测到显示服务器，进入命令行模式。",
+      "No display server detected; falling back to CLI mode.",
+    )));
+    await runCli();
+    return;
+  }
   // 默认启动 GUI；--cli / settings.json CLIEnabled: true 时进入命令行。
   // --resume= 恢复会话历史仅在终端 REPL 里展示，也一并路由到 CLI 以保持原行为。
   if (process.argv.includes("--cli") || config.cliEnabled || process.argv.some((a) => a.startsWith("--resume="))) {

package/src/memory.ts

@@ -1,6 +1,7 @@
 import { readFileSync, writeFileSync, existsSync, readdirSync, unlinkSync, rmSync, appendFileSync } from "fs";
-import { join } from "path";
+import { basename, join, resolve } from "path";
 import { MEMORY_FILE, SESSIONS_DIR } from "./config.ts";
+import { inferWorkspaceFromContent } from "./workspace.ts";
 import { t, getLang } from "./locale.ts";
 
 // ============================================================
@@ -161,6 +162,8 @@ export interface SessionInfo {
   timestamp: string;
   preview: string;
   model: string;
+  /** 所属工作区（创建会话时的启动目录绝对路径）；旧会话可能缺失（undefined → 展示层归入「未分组」）。 */
+  workspace?: string;
 }
 
 interface SessionHeader {
@@ -169,6 +172,8 @@ interface SessionHeader {
   timestamp: string;
   model: string;
   preview: string;
+  /** 所属工作区（启动目录绝对路径）。version 2 起写入；读取不校验版本，缺失视为「未分组」。 */
+  workspace?: string;
 }
 
 /** 从首条 user 消息提取会话预览。 */
@@ -189,7 +194,7 @@ function firstUserPreview(messages: any[]): string {
   return preview;
 }
 
-export function saveSession(messages: any[], model: string, silent = false): string | null {
+export function saveSession(messages: any[], model: string, silent = false, workspace?: string): string | null {
   if (!hasConversation) {
     if (!silent) console.log(t("无对话可保存。", "No conversation to save."));
     return null;
@@ -203,16 +208,21 @@ export function saveSession(messages: any[], model: string, silent = false): str
   const filename = `${timestamp}__${safePreview}.jsonl`;
   const filepath = join(SESSIONS_DIR, filename);
 
+  // 落盘前修剪残缺尾部（生成中存盘时可能含未配对 toolCall，防 resume 后服务端 400；
+  // 对完整历史幂等）。只影响文件内容，不改内存——回合可继续，完成后以完整版覆盖。
+  const persisted = trimPartialTail(messages);
+
   const header: SessionHeader = {
     type: "arona-session",
-    version: 1,
+    version: 2,
     timestamp: new Date().toISOString(),
     model,
     preview,
+    workspace,
   };
 
   const lines: string[] = [JSON.stringify(header)];
-  for (const msg of messages) {
+  for (const msg of persisted) {
     lines.push(JSON.stringify(msg));
   }
   writeFileSync(filepath, lines.join("\n"));
@@ -223,28 +233,32 @@ export function saveSession(messages: any[], model: string, silent = false): str
 /**
  * 将会话保存到指定路径（覆盖原文件）。
  * 用于 /resume 恢复的会话退出时保存回原文件，而非另存为新文件。
- * 保留原文件的 header（timestamp/preview），仅更新 model 字段。
+ * 保留原文件的 header（timestamp/preview/workspace），仅更新 model 字段；
+ * 原 header 缺 workspace（旧会话）且调用方传入时补写——resume 保存即归入当前工作区。
  */
-export function saveSessionToPath(filepath: string, messages: any[], model: string, silent = false): void {
+export function saveSessionToPath(filepath: string, messages: any[], model: string, silent = false, workspace?: string): void {
   let header: SessionHeader;
   try {
     const content = readFileSync(filepath, "utf-8");
     header = JSON.parse(content.split("\n")[0]) as SessionHeader;
     header.model = model; // 模型可能已切换，更新之
+    if (!header.workspace && workspace) header.workspace = workspace;
   } catch {
     // 原文件不存在或损坏，生成新 header（剥离桌宠手势注入块，见 firstUserPreview）
     const preview = firstUserPreview(messages);
     header = {
       type: "arona-session",
-      version: 1,
+      version: 2,
       timestamp: new Date().toISOString(),
       model,
       preview,
+      workspace,
     };
   }
 
   const lines: string[] = [JSON.stringify(header)];
-  for (const msg of messages) {
+  // 同 saveSession：落盘前修剪残缺尾部（幂等；只影响文件，不改内存）
+  for (const msg of trimPartialTail(messages)) {
     lines.push(JSON.stringify(msg));
   }
   writeFileSync(filepath, lines.join("\n"));
@@ -269,6 +283,7 @@ export function listSessions(): SessionInfo[] {
           timestamp: header.timestamp,
           preview: header.preview,
           model: header.model,
+          workspace: header.workspace,
         });
       }
     } catch {
@@ -306,8 +321,8 @@ export function renameSession(filepath: string, title: string): string | null {
     header.preview = preview;
     lines[0] = JSON.stringify(header);
 
-    // 沿用原文件名的时间戳前缀，替换预览 slug
-    const stamp = filepath.split("/").pop()?.split("__")[0] ?? new Date().toISOString().replace(/[:.]/g, "-");
+    // 沿用原文件名的时间戳前缀，替换预览 slug（basename：Windows 路径分隔符是 \，split("/") 会把整个路径当文件名）
+    const stamp = basename(filepath).split("__")[0] || new Date().toISOString().replace(/[:.]/g, "-");
     const safePreview = preview.replace(/[^a-zA-Z0-9\u4e00-\u9fff]/g, "_").slice(0, 30);
     const newPath = join(SESSIONS_DIR, `${stamp}__${safePreview}.jsonl`);
 
@@ -332,8 +347,45 @@ export function renameSession(filepath: string, title: string): string | null {
   }
 }
 
-export function loadSession(filepath: string): any[] {
-  const content = readFileSync(filepath, "utf-8");
+/**
+ * 修剪尾部残缺回合（"未完成也存盘"场景专用）：LLM 生成中落盘时，尾部可能存在
+ * 未应答的 toolCall（没有配对的 toolResult，甚至参数只生成了半截）——直接写盘，
+ * resume 后提交服务端会 400。规则：
+ * - toolCall/toolResult 数量不配对 → 修剪回最后一条 user 消息（含）；
+ * - 数量配对但尾部停在 toolResult（模型总结还没生成）→ 同样修剪：resume 后的
+ *   新输入会与 toolResult 所在的 user 消息相邻，仍有 400 风险；
+ * - 以 assistant 文本收尾（哪怕是生成到一半的文本）→ 保留：API 合法状态，
+ *   重启恢复后能看到已生成的半成品，可让模型接着写。
+ * 只影响写盘内容，不改内存中的会话（后台回合继续跑，完成后以完整版覆盖存盘）。
+ */
+export function trimPartialTail(messages: any[]): any[] {
+  let lastUser = -1;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i]?.role === "user") {
+      lastUser = i;
+      break;
+    }
+  }
+  if (lastUser < 0) return []; // 没有用户消息：历史不完整（不该发生），退到空
+  const tail = messages.slice(lastUser + 1);
+  let calls = 0;
+  let results = 0;
+  for (const m of tail) {
+    if (m.role === "assistant") {
+      for (const b of m.content ?? []) {
+        if (b.type === "toolCall") calls++;
+      }
+    } else if (m.role === "toolResult") {
+      results++;
+    }
+  }
+  const last = tail[tail.length - 1];
+  const endsOnToolResult = last?.role === "toolResult";
+  if (calls === results && !endsOnToolResult) return messages; // 合法收尾（含半截文本），原样保存
+  return messages.slice(0, lastUser + 1);
+}
+
+export function loadSession(filepath: string): any[] {  const content = readFileSync(filepath, "utf-8");
   const lines = content.split("\n").filter((l) => l.trim());
   const messages: any[] = [];
 
@@ -346,6 +398,47 @@ export function loadSession(filepath: string): any[] {
   return messages;
 }
 
+/**
+ * 写入会话的所属工作区（就地改 header 首行，文件名不变）。
+ * force=false 时仅补写缺失的 workspace（旧会话回填）；force=true 用于「移动到工作区」。
+ */
+export function setSessionWorkspace(filepath: string, workspace: string, force = false): boolean {
+  try {
+    const content = readFileSync(filepath, "utf-8");
+    const nl = content.indexOf("\n");
+    const firstLine = nl >= 0 ? content.slice(0, nl) : content;
+    const header = JSON.parse(firstLine) as SessionHeader;
+    if (header.type !== "arona-session") return false;
+    if (header.workspace && !force) return false;
+    header.workspace = resolve(workspace);
+    const rest = nl >= 0 ? content.slice(nl) : "";
+    writeFileSync(filepath, JSON.stringify(header) + rest);
+    return true;
+  } catch (err) {
+    console.warn(`setSessionWorkspace: ${err instanceof Error ? err.message : err}`);
+    return false;
+  }
+}
+
+/**
+ * 一次性回填：为未记录工作区的旧会话按内容推断工作区（会话中出现频率最高的项目目录）。
+ * 推断不出（纯聊天、无绝对路径）保持未分组。返回回填数量。CLI/GUI 启动时各调用一次。
+ */
+export function backfillLegacyWorkspaces(): number {
+  let migrated = 0;
+  for (const s of listSessions()) {
+    if (s.workspace) continue;
+    try {
+      const content = readFileSync(s.path, "utf-8");
+      const inferred = inferWorkspaceFromContent(content);
+      if (inferred && setSessionWorkspace(s.path, inferred)) migrated++;
+    } catch {
+      // 单个文件损坏不影响其余回填
+    }
+  }
+  return migrated;
+}
+
 // ============================================================
 // 编码子代理过程留痕（sidecar：`<会话名>.coding.jsonl`）
 // 单独存放：不出现在会话列表（header 类型不同被过滤），loadSession 不读它（不进主 Agent 上下文）。

package/src/pet.ts

@@ -42,6 +42,15 @@ class PetBridge {
   private pendingSelection: { main: AgentId; subs: AgentId[] } | null = null;
   // 最近一次桌宠手势（摸头/dizzy）：只保留最新一次，供下一条用户消息注入一次后即消费清空
   private latestGesture: PetGestureType | null = null;
+  // 桌宠进程握手（hello 行）与 HTTP 下行通道：Windows 下 GUI 子系统 Electron 的 stdin 数据
+  // 不可达（GUI 白屏坑③同族问题），pet/main.cjs 起 127.0.0.1 随机端口 + 随机 token 的 HTTP
+  // 服务并经 hello 行告知；hello 前入队，收到后按序经 HTTP 串行下发。httpPort=0（HTTP 起
+  // 失败）退回 stdin 写入（非 Windows 平台 stdin 本来就通）。
+  private helloReceived = false;
+  private queuedMessages: Record<string, unknown>[] = [];
+  private petHttpPort = 0;
+  private petHttpToken = "";
+  private httpChain: Promise<void> = Promise.resolve(); // 串行链保序（HTTP 异步，并发会乱序）
 
   /**
    * Electron 42+ 把二进制下载从 postinstall 挪到了首次 require。这里在 spawn 之前
@@ -78,6 +87,12 @@ class PetBridge {
     if (!electronPath) return;
 
     this.intentionalStop = false;
+    // 重置握手状态：新进程会发新 hello（新端口/token），旧通道必须作废
+    this.helloReceived = false;
+    this.petHttpPort = 0;
+    this.petHttpToken = "";
+    this.queuedMessages = [];
+    this.httpChain = Promise.resolve();
 
     try {
       // 剔除 ELECTRON_RUN_AS_NODE，否则 Electron 会退化为纯 Node 运行；
@@ -132,11 +147,18 @@ class PetBridge {
       vlog("spawn error:", err.message);
       console.warn(chalk.yellow(t(`桌宠：进程错误（${err.message}），已降级。`, `Pet: process error (${err.message}), degraded.`)));
       this.proc = null;
+      this.helloReceived = false;
+      this.petHttpPort = 0;
+      this.queuedMessages = [];
     });
 
     this.proc.on("close", (code, signal) => {
       vlog("process closed", { code, signal, intentional: this.intentionalStop, pendingSelection: this.pendingSelection });
       this.proc = null;
+      this.helloReceived = false;
+      this.petHttpPort = 0;
+      this.petHttpToken = "";
+      this.queuedMessages = [];
       if (this.pendingSelection) {
         // 切换角色：旧进程已退出，以新角色组合重新拉起（stop 时 intentionalStop=true 不会走退避重启）
         const sel = this.pendingSelection;
@@ -183,7 +205,19 @@ class PetBridge {
       return;
     }
     vlog("recv", JSON.stringify(msg));
-    if (msg.type === "ready") {
+    if (msg.type === "hello") {
+      // 桌宠进程握手：解锁排队消息；httpPort>0 时后续消息走本机 HTTP 通道
+      //（Windows 下 GUI 子系统 Electron 的 stdin 数据不可达，根治手段与 GUI 桥同款）
+      this.helloReceived = true;
+      this.petHttpPort = Number(msg.httpPort) || 0;
+      this.petHttpToken = String(msg.token || "");
+      const queued = this.queuedMessages;
+      this.queuedMessages = [];
+      if (verbose && queued.length) {
+        console.error(chalk.gray("[pet:verbose]"), "hello received (httpPort=" + this.petHttpPort + "), flushing", queued.length, "queued messages");
+      }
+      for (const m of queued) this.send(m);
+    } else if (msg.type === "ready") {
       this.restartCount = 0; // 成功启动后重置退避计数
     } else if (msg.type === "error") {
       console.error(chalk.gray("[pet]"), msg.message);
@@ -213,7 +247,17 @@ class PetBridge {
 
   private send(msg: Record<string, unknown>): void {
     if (!this.proc || this.proc.killed) return;
+    if (!this.helloReceived) {
+      // 握手前入队（进程已起但通道未就绪）。设上限防 hello 永不到来时无限增长。
+      if (this.queuedMessages.length >= 200) this.queuedMessages.shift();
+      this.queuedMessages.push(msg);
+      return;
+    }
     vlog("send", JSON.stringify(msg));
+    if (this.petHttpPort) {
+      this.httpChain = this.httpChain.then(() => this.postEvent(msg));
+      return;
+    }
     try {
       this.proc.stdin.write(JSON.stringify(msg) + "\n");
     } catch {
@@ -221,6 +265,21 @@ class PetBridge {
     }
   }
 
+  /** 经本机 HTTP 通道下发消息（pet/main.cjs 的 127.0.0.1 随机端口服务，token 鉴权） */
+  private async postEvent(msg: Record<string, unknown>): Promise<void> {
+    try {
+      await fetch(`http://127.0.0.1:${this.petHttpPort}/`, {
+        method: "POST",
+        headers: { "content-type": "application/json", "x-arona-token": this.petHttpToken },
+        body: JSON.stringify(msg),
+      });
+    } catch (err) {
+      if (verbose) {
+        console.error(chalk.gray("[pet:verbose]"), "http send failed:", err instanceof Error ? err.message : err);
+      }
+    }
+  }
+
   setEmotion(agentId: AgentId, name: string): void {
     this.send({ type: "set_emotion", agent: agentId, name });
   }