@jack200714/mafw 4.5.1

package/packages/tui/dist/cli.js

@@ -0,0 +1,4664 @@
+#!/usr/bin/env node
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../gateway-sdk/dist/sse.js
+var require_sse = __commonJS({
+  "../gateway-sdk/dist/sse.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SSEConnection = void 0;
+    var SSEConnection = class {
+      eventSource = null;
+      listeners = /* @__PURE__ */ new Map();
+      _connected = false;
+      get connected() {
+        return this._connected;
+      }
+      connect(baseUrl) {
+        this.disconnect();
+        this.eventSource = new EventSource(`${baseUrl}/api/events`);
+        this.eventSource.onopen = () => {
+          this._connected = true;
+        };
+        this.eventSource.onerror = () => {
+          this._connected = false;
+        };
+        this.setupMessageHandler();
+      }
+      connectToSession(baseUrl, sessionID) {
+        this.disconnect();
+        this.eventSource = new EventSource(`${baseUrl}/api/events?sessionID=${encodeURIComponent(sessionID)}`);
+        this.eventSource.onopen = () => {
+          this._connected = true;
+        };
+        this.eventSource.onerror = () => {
+          this._connected = false;
+        };
+        this.setupMessageHandler();
+      }
+      setupMessageHandler() {
+        if (!this.eventSource)
+          return;
+        this.eventSource.onmessage = (e) => {
+          try {
+            let data = JSON.parse(e.data);
+            if (data && data.type === "opencode_event" && data.data && typeof data.data === "object") {
+              data = data.data;
+            }
+            const type = data.type || "message";
+            const set = this.listeners.get(type);
+            if (set)
+              for (const cb of set)
+                cb(data);
+            const wildcard = this.listeners.get("*");
+            if (wildcard)
+              for (const cb of wildcard)
+                cb(data);
+          } catch {
+          }
+        };
+      }
+      disconnect() {
+        this.eventSource?.close();
+        this.eventSource = null;
+        this._connected = false;
+      }
+      on(eventType, cb) {
+        if (!this.listeners.has(eventType)) {
+          this.listeners.set(eventType, /* @__PURE__ */ new Set());
+        }
+        this.listeners.get(eventType).add(cb);
+        return () => {
+          this.listeners.get(eventType)?.delete(cb);
+        };
+      }
+      /** @internal For testing: emit an event without a real SSE connection */
+      emit(event) {
+        const type = event.type || "message";
+        const set = this.listeners.get(type);
+        if (set)
+          for (const cb of set)
+            cb(event);
+        const wildcard = this.listeners.get("*");
+        if (wildcard)
+          for (const cb of wildcard)
+            cb(event);
+      }
+    };
+    exports.SSEConnection = SSEConnection;
+  }
+});
+
+// ../gateway-sdk/dist/client.js
+var require_client = __commonJS({
+  "../gateway-sdk/dist/client.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.MafwClient = void 0;
+    var crypto_1 = __require("crypto");
+    var sse_1 = require_sse();
+    var MafwClient2 = class {
+      baseUrl;
+      _sse;
+      fetchImpl;
+      constructor(opts) {
+        this.baseUrl = typeof opts === "string" ? opts : opts?.baseUrl || "http://localhost:3000";
+        this.fetchImpl = typeof opts === "object" && opts?.fetchImpl ? opts.fetchImpl : fetch.bind(globalThis);
+        this._sse = new sse_1.SSEConnection();
+      }
+      async request(path, init) {
+        const res = await this.fetchImpl(`${this.baseUrl}${path}`, {
+          headers: { "Content-Type": "application/json" },
+          ...init
+        });
+        if (!res.ok)
+          throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+        const ct = res.headers?.get?.("content-type") ?? "";
+        if (ct.includes("text/html")) {
+          throw new Error(`Received HTML instead of JSON from ${path} \u2014 gateway is older than the SDK (route missing). Update/restart the gateway.`);
+        }
+        return res.json();
+      }
+      // ── Session ──
+      session = {
+        create: async (params) => {
+          return this.request("/api/session", {
+            method: "POST",
+            body: JSON.stringify(params || {})
+          });
+        },
+        get: async (params) => {
+          return this.request(`/api/sessions/${params.path.id}`);
+        },
+        list: async (params) => {
+          const pid = params?.query?.projectID;
+          const query = pid ? `?projectID=${encodeURIComponent(pid)}` : "";
+          const data = await this.request(`/api/sessions${query}`);
+          if (!data || !Array.isArray(data.sessions))
+            return [];
+          return data.sessions;
+        },
+        delete: async (params) => {
+          await this.request(`/api/sessions/${params.path.id}`, { method: "DELETE" });
+        },
+        rename: async (params) => {
+          await this.request(`/api/sessions/${params.path.id}`, {
+            method: "PATCH",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ title: params.body.title })
+          });
+        },
+        messages: async (params) => {
+          const q = new URLSearchParams();
+          if (params.query?.limit)
+            q.set("limit", String(params.query.limit));
+          if (params.query?.before)
+            q.set("before", params.query.before);
+          return this.request(`/api/sessions/${params.path.id}/messages?${q}`);
+        },
+        todo: async (params) => {
+          return this.request(`/api/sessions/${params.path.id}/todo`);
+        },
+        children: async (params) => {
+          const data = await this.request(`/api/sessions/${params.path.id}/children`);
+          return data.items || [];
+        },
+        abort: async (params) => {
+          await this.request(`/api/session/${params.path.id}/abort`, { method: "POST" });
+        },
+        fork: async (params) => {
+          return this.request(`/api/sessions/${params.path.id}/fork`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(params.body ?? {})
+          });
+        },
+        revert: async (params) => {
+          await this.request(`/api/sessions/${params.path.id}/revert`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(params.body)
+          });
+        },
+        unrevert: async (params) => {
+          await this.request(`/api/sessions/${params.path.id}/unrevert`, { method: "POST" });
+        },
+        summarize: async (params) => {
+          await this.request(`/api/session/${params.path.id}/summarize`, {
+            method: "POST",
+            body: JSON.stringify(params.body ?? {})
+          });
+        },
+        prompt: async (params) => {
+          return this.request(`/api/session/${params.path.id}/prompt`, {
+            method: "POST",
+            body: JSON.stringify(params.body)
+          });
+        },
+        promptAsync: async (params) => {
+          const res = await fetch(`${this.baseUrl}/api/session/${params.path.id}/promptAsync`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              message: params.body.message,
+              parts: params.body.parts,
+              agent: params.body.agent,
+              model: params.body.model
+            })
+          });
+          if (!res.ok)
+            throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+        },
+        trajectory: async (params) => {
+          const q = new URLSearchParams();
+          if (params.query?.limit)
+            q.set("limit", String(params.query.limit));
+          if (params.query?.before_turn)
+            q.set("before_turn", String(params.query.before_turn));
+          if (params.query?.rebuild)
+            q.set("rebuild", "1");
+          return this.request(`/api/sessions/${params.path.id}/trajectory?${q}`);
+        },
+        tokenSummary: async (params) => {
+          return this.request(`/api/sessions/${params.path.id}/token-summary`);
+        },
+        usageSummary: async (params) => {
+          const q = new URLSearchParams();
+          if (params.query?.sessionID)
+            q.set("sessionID", params.query.sessionID);
+          if (params.query?.projectID)
+            q.set("projectID", params.query.projectID);
+          return this.request(`/api/usage/summary?${q}`);
+        },
+        usage: async (params) => {
+          const q = new URLSearchParams();
+          if (params?.sessionID)
+            q.set("sessionID", params.sessionID);
+          if (params?.projectID)
+            q.set("projectID", params.projectID);
+          const qs = q.toString();
+          return this.request(`/api/usage${qs ? "?" + qs : ""}`);
+        },
+        usagePlugins: async () => {
+          return this.request("/api/usage/plugins");
+        },
+        usagePluginsReload: async () => {
+          return this.request("/api/usage/plugins/reload", { method: "POST" });
+        },
+        usagePluginsCreate: async (body) => {
+          return this.request("/api/usage/plugins/create", { method: "POST", body: JSON.stringify(body) });
+        },
+        usagePluginSource: async (name) => {
+          return this.request(`/api/usage/plugins/${encodeURIComponent(name)}/source`);
+        },
+        usagePluginSourceSave: async (name, source) => {
+          return this.request(`/api/usage/plugins/${encodeURIComponent(name)}/source`, { method: "PUT", body: JSON.stringify({ source }) });
+        },
+        usagePluginDelete: async (name) => {
+          return this.request(`/api/usage/plugins/${encodeURIComponent(name)}`, { method: "DELETE" });
+        },
+        usagePluginTest: async (name) => {
+          return this.request(`/api/usage/plugins/${encodeURIComponent(name)}/test`, { method: "POST" });
+        },
+        events: async (params) => {
+          const sse = new sse_1.SSEConnection();
+          sse.connectToSession(this.baseUrl, params.path.id);
+          return {
+            on: (event, cb) => {
+              if (event === "data") {
+                sse.on("*", cb);
+              } else {
+                sse.on(event, cb);
+              }
+            }
+          };
+        },
+        command: async (params) => {
+          const res = await fetch(`${this.baseUrl}/api/session/${params.path.id}/command`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(params.body)
+          });
+          if (!res.ok)
+            throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+        }
+      };
+      // ── Commands & skills (opencode serve, proxied by the gateway) ──
+      command = {
+        list: async (directory) => {
+          const query = directory ? `?directory=${encodeURIComponent(directory)}` : "";
+          const data = await this.request(`/command${query}`);
+          if (Array.isArray(data))
+            return data;
+          return data.items || data.commands || [];
+        }
+      };
+      skill = {
+        list: async (directory) => {
+          const query = directory ? `?directory=${encodeURIComponent(directory)}` : "";
+          const data = await this.request(`/skill${query}`);
+          if (Array.isArray(data))
+            return data;
+          return data.items || data.skills || [];
+        }
+      };
+      // ── MAFW native commands (desktop slash panel) ──
+      mafwCommands = {
+        run: async (params) => {
+          return this.request("/api/mafw-commands/run", {
+            method: "POST",
+            body: JSON.stringify(params)
+          });
+        }
+      };
+      // ── Manager session (authoritative per-project manager, from gateway DB) ──
+      manager = {
+        session: async (projectDir) => {
+          const q = projectDir ? `?projectDir=${encodeURIComponent(projectDir)}` : "";
+          try {
+            return await this.request(`/api/manager/session${q}`);
+          } catch {
+            return null;
+          }
+        },
+        rotate: async (projectDir, reason) => {
+          return await this.request("/api/manager/session/rotate", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ projectDir, reason })
+          });
+        }
+      };
+      // ── Project ──
+      project = {
+        list: async () => {
+          const data = await this.request("/api/projects");
+          return data.projects || [];
+        },
+        current: async () => {
+          const data = await this.request("/api/projects/current");
+          if (data.project)
+            return data.project;
+          return { id: data.projectDir || ".", worktree: data.projectDir || "." };
+        },
+        setCurrent: async (path) => {
+          await this.request("/api/projects/register", {
+            method: "POST",
+            body: JSON.stringify({ projectDir: path, mafwDir: path + "/.mafw" })
+          });
+        }
+      };
+      // ── Event ──
+      event = {
+        subscribe: async () => {
+          this._sse.connect(this.baseUrl);
+          return {
+            on: (event, cb) => {
+              if (event === "data") {
+                this._sse.on("*", cb);
+              } else {
+                this._sse.on(event, cb);
+              }
+            }
+          };
+        },
+        subscribeToSession: async (sessionID) => {
+          this._sse.connectToSession(this.baseUrl, sessionID);
+          return {
+            on: (event, cb) => {
+              if (event === "data") {
+                this._sse.on("*", cb);
+              } else {
+                this._sse.on(event, cb);
+              }
+            }
+          };
+        },
+        /** SSE 连接状态（onopen/onerror 维护；供监督器健康轮询）。 */
+        connected: () => this._sse.connected
+      };
+      // ── Runtime ──
+      runtime = {
+        /** Get active runtime identity, capabilities, and plugin scan state. */
+        get: async () => {
+          return this.request("/api/runtime");
+        },
+        /**
+         * Switch active runtime plugin.
+         * @param plugin - Plugin name (empty string switches to builtin opencode).
+         * @returns The new active runtime state.
+         */
+        switch: async (plugin) => {
+          const res = await fetch(`${this.baseUrl}/api/runtime/switch`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ plugin })
+          });
+          if (!res.ok) {
+            const body = await res.json().catch(() => ({}));
+            throw new Error(body.error || `Runtime switch failed: ${res.status}`);
+          }
+          return res.json();
+        },
+        /** Restart the agent runtime (opencode serve). */
+        restartAgent: async () => {
+          const res = await fetch(`${this.baseUrl}/api/runtime/restart-agent`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" }
+          });
+          if (!res.ok) {
+            const body = await res.json().catch(() => ({}));
+            throw new Error(body.error || `Agent restart failed: ${res.status}`);
+          }
+          return res.json();
+        }
+      };
+      // ── Plugins Hub ──
+      plugins = {
+        list: async () => this.request("/api/plugins"),
+        install: async (input) => {
+          const res = await this.fetchImpl(`${this.baseUrl}/api/plugins/install`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ ...input, overwrite: !!input.overwrite })
+          });
+          if (!res.ok) {
+            const body = await res.json().catch(() => ({}));
+            throw new Error(body.error || `Plugin install failed: ${res.status}`);
+          }
+          return res.json();
+        },
+        enable: async (type, filename) => {
+          const res = await this.fetchImpl(`${this.baseUrl}/api/plugins/enable`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ type, filename })
+          });
+          if (!res.ok) {
+            const body = await res.json().catch(() => ({}));
+            throw new Error(body.error || `Plugin enable failed: ${res.status}`);
+          }
+          return res.json();
+        },
+        disable: async (type, filename) => {
+          const res = await this.fetchImpl(`${this.baseUrl}/api/plugins/disable`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ type, filename })
+          });
+          if (!res.ok) {
+            const body = await res.json().catch(() => ({}));
+            throw new Error(body.error || `Plugin disable failed: ${res.status}`);
+          }
+          return res.json();
+        },
+        delete: async (type, filename) => {
+          const res = await this.fetchImpl(`${this.baseUrl}/api/plugins/delete`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ type, filename })
+          });
+          if (!res.ok) {
+            const body = await res.json().catch(() => ({}));
+            throw new Error(body.error || `Plugin delete failed: ${res.status}`);
+          }
+          return res.json();
+        }
+      };
+      // ── Config ──
+      config = {
+        get: async (key) => {
+          const data = await this.request("/api/config");
+          return key ? data[key] : data;
+        },
+        set: async (key, value) => {
+          const current = await this.request("/api/config");
+          current[key] = value;
+          await fetch(`${this.baseUrl}/api/config`, {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(current)
+          });
+        }
+      };
+      // ── OpenCode config (native opencode /config) ──
+      opencodeConfig = {
+        get: async () => {
+          const data = await this.request("/api/opencode-config");
+          return data.config;
+        },
+        update: async (config) => {
+          const res = await fetch(`${this.baseUrl}/api/opencode-config`, {
+            method: "PATCH",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(config)
+          });
+          if (!res.ok)
+            throw new Error(`OpenCodeConfig update failed: ${res.status}`);
+          return res.json();
+        }
+      };
+      // ── Goals ──
+      goals = {
+        list: async () => {
+          const data = await this.request("/api/goals");
+          return data.goals || [];
+        },
+        get: async (id) => {
+          try {
+            return await this.request(`/api/goals/${id}`);
+          } catch (e) {
+            if (e.message?.includes("HTTP 404"))
+              return null;
+            throw e;
+          }
+        },
+        sessions: async (goalId) => {
+          const data = await this.request(`/api/goals/${encodeURIComponent(goalId)}/sessions`);
+          return data?.sessions ?? [];
+        },
+        validate: async (input) => {
+          return this.request(`/api/work/${input.goalId}/validate`, {
+            method: "POST",
+            body: JSON.stringify(input)
+          });
+        },
+        control: async (action) => {
+          await this.request("/api/goals/control", {
+            method: "POST",
+            body: JSON.stringify(action)
+          });
+        }
+      };
+      // ── Memory ──
+      memory = {
+        search: async (opts) => {
+          const params = new URLSearchParams({ query: opts.query });
+          if (opts.topK)
+            params.set("topK", String(opts.topK));
+          if (opts.goalId)
+            params.set("goalId", opts.goalId);
+          if (opts.retriever)
+            params.set("retriever", opts.retriever);
+          const data = await this.request(`/api/memory/search?${params}`);
+          return data.results || [];
+        },
+        mergedSearch: async (opts) => {
+          const params = new URLSearchParams({ query: opts.query });
+          if (opts.maxFacts)
+            params.set("maxFacts", String(opts.maxFacts));
+          const data = await this.request(`/api/memory/merged-search?${params}`);
+          return data.results || [];
+        },
+        getEnergyDistribution: async () => {
+          return this.request("/api/memory/energy-distribution");
+        },
+        getL5Axioms: async (topK) => {
+          const params = topK ? `?topK=${topK}` : "";
+          const data = await this.request(`/api/l5/axioms${params}`);
+          return { axioms: data.axioms || [], heuristics: data.heuristics || [] };
+        },
+        delete: async (id) => {
+          await this.request(`/api/memory/${id}`, { method: "DELETE" });
+        },
+        listSticky: async () => {
+          const data = await this.request("/api/memory/sticky");
+          return { entries: data.entries || [], budget: data.budget || { max: 10, maxChars: 800, used: 0 } };
+        },
+        setSticky: async (id, sticky, stickyDays) => {
+          await this.request("/api/memory/pin", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ id, sticky, stickyDays })
+          });
+        }
+      };
+      // ── Approvals ──
+      approvals = {
+        list: async () => {
+          const data = await this.request("/api/approvals");
+          return data.approvals || [];
+        },
+        respond: async (id, decision) => {
+          await this.request(`/api/approvals/${id}/respond`, {
+            method: "POST",
+            body: JSON.stringify({ decision })
+          });
+        }
+      };
+      // ── Triage ──
+      triage = {
+        list: async () => {
+          const data = await this.request("/api/triage");
+          return data.items || [];
+        },
+        dismiss: async (id) => {
+          await this.request(`/api/triage/${id}/dismiss`, { method: "POST" });
+        },
+        confirm: async (id) => {
+          await this.request(`/api/triage/${id}/confirm`, { method: "POST" });
+        },
+        reject: async (id) => {
+          await this.request(`/api/triage/${id}/reject`, { method: "POST" });
+        },
+        propose: async (id, suggestion, reason, priority = "medium") => {
+          return this.request(`/api/triage/${id}/propose`, {
+            method: "POST",
+            body: JSON.stringify({ suggestion, reason, priority })
+          });
+        }
+      };
+      // ── Questions (AskCard — proxies the native opencode Question API) ──
+      questions = {
+        list: async () => {
+          const data = await this.request("/api/questions");
+          return data.items || [];
+        },
+        reply: async (id, answers) => {
+          await this.request(`/api/questions/${id}/reply`, {
+            method: "POST",
+            body: JSON.stringify({ answers })
+          });
+        },
+        reject: async (id) => {
+          await this.request(`/api/questions/${id}/reject`, { method: "POST" });
+        }
+      };
+      // ── Permissions (PermissionCard — proxies the native opencode Permission API) ──
+      permissions = {
+        list: async () => {
+          const data = await this.request("/api/permissions");
+          return data.items || [];
+        },
+        reply: async (id, reply, message) => {
+          await this.request(`/api/permissions/${id}/reply`, {
+            method: "POST",
+            body: JSON.stringify({ reply, message })
+          });
+        }
+      };
+      // ── Chat ──
+      chat = {
+        send: async (message, sessionID) => {
+          const res = await fetch(`${this.baseUrl}/api/chat`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ message, sessionID })
+          });
+          if (!res.ok)
+            throw new Error(`Chat send failed: ${res.status}`);
+          return res.json();
+        },
+        sendEnriched: async (opts) => {
+          const res = await fetch(`${this.baseUrl}/api/chat/enriched`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(opts)
+          });
+          if (!res.ok)
+            throw new Error(`Chat sendEnriched failed: ${res.status}`);
+          return res.json();
+        }
+      };
+      // ── Media (A2A Media Agent) ──
+      media = {
+        /** List media engine plugins (status + modalities). */
+        plugins: async () => {
+          return this.request("/api/media/plugins");
+        },
+        /**
+         * Switch media engine per modality.
+         * @param opts - Engine overrides (top-level engine and/or per-modality).
+         * @returns The new media engine configuration.
+         */
+        switch: async (opts) => {
+          const res = await fetch(`${this.baseUrl}/api/media/switch`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(opts)
+          });
+          if (!res.ok) {
+            const body = await res.json().catch(() => ({}));
+            throw new Error(body.error || `Media switch failed: ${res.status}`);
+          }
+          return res.json();
+        },
+        createTask: async (opts) => {
+          const parts = opts.artifactId ? [{ url: `/a2a/artifacts/${opts.artifactId}`, mediaType: opts.mediaType || "application/octet-stream", filename: "upload.bin" }] : [{ raw: opts.dataUrl?.split(",")[1] || "", mediaType: opts.mediaType || "image/png", filename: "paste.bin" }];
+          if (opts.question)
+            parts.push({ text: opts.question });
+          const res = await fetch(`${this.baseUrl}/a2a`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", "A2A-Version": "1.0" },
+            body: JSON.stringify({
+              jsonrpc: "2.0",
+              id: 1,
+              method: "SendMessage",
+              params: {
+                message: {
+                  messageId: `fe-${(0, crypto_1.randomUUID)()}`,
+                  role: 1,
+                  // ROLE_USER
+                  parts
+                }
+              }
+            })
+          });
+          if (!res.ok)
+            throw new Error(`Vision createTask failed: HTTP ${res.status}`);
+          const parsed = await res.json();
+          if (parsed?.error)
+            throw new Error(`Vision createTask failed: ${parsed.error?.message || JSON.stringify(parsed.error)}`);
+          const task = parsed?.result?.task;
+          if (!task?.id)
+            throw new Error("Vision createTask failed: no task returned");
+          return { id: task.id, contextId: task.contextId, state: task.status?.state || "" };
+        }
+      };
+      // ── TTS (MiMo-V2.5-TTS speech synthesis) ──
+      tts = {
+        speak: async (opts) => {
+          const res = await fetch(`${this.baseUrl}/api/tts`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(opts)
+          });
+          if (!res.ok) {
+            let detail = "";
+            try {
+              const j = await res.json();
+              detail = j?.error || "";
+            } catch {
+            }
+            throw new Error(`TTS failed: HTTP ${res.status}${detail ? ` (${detail})` : ""}`);
+          }
+          return res.json();
+        },
+        voices: async () => {
+          const res = await fetch(`${this.baseUrl}/api/tts/voices`);
+          if (!res.ok)
+            throw new Error(`TTS voices failed: HTTP ${res.status}`);
+          return res.json();
+        },
+        /** 流式 TTS：返回 async iterable of base64 PCM16 chunks（24kHz mono）。 */
+        speakStream: (opts) => {
+          const base = this.baseUrl;
+          return (async function* () {
+            const res = await fetch(`${base}/api/tts/stream`, {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify(opts)
+            });
+            if (!res.ok || !res.body)
+              throw new Error(`TTS stream failed: HTTP ${res.status}`);
+            const reader = res.body.getReader();
+            const decoder = new TextDecoder();
+            let buf = "";
+            try {
+              while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                  break;
+                buf += decoder.decode(value, { stream: true });
+                const lines = buf.split("\n");
+                buf = lines.pop() || "";
+                for (const line of lines) {
+                  const t = line.trim();
+                  if (!t.startsWith("data:"))
+                    continue;
+                  try {
+                    const j = JSON.parse(t.slice(5).trim());
+                    if (j.data)
+                      yield { data: j.data, voice: j.voice || "" };
+                    if (j.done)
+                      return;
+                  } catch {
+                  }
+                }
+              }
+            } finally {
+              reader.releaseLock();
+            }
+          })();
+        }
+      };
+      // ── Providers & Agents (composer model pill / @agent mention) ──
+      providers = {
+        list: async () => {
+          const data = await this.request("/api/provider");
+          return data.items;
+        }
+      };
+      agents = {
+        list: async () => {
+          const data = await this.request("/api/agents");
+          return data.items || [];
+        }
+      };
+      // ── Model config (recall worker + media models) ──
+      models = {
+        get: async () => {
+          return this.request("/api/model-config");
+        },
+        update: async (opts) => {
+          const res = await fetch(`${this.baseUrl}/api/model-config`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(opts)
+          });
+          if (!res.ok) {
+            const body = await res.json().catch(() => ({}));
+            throw new Error(body.error || `Model config update failed: ${res.status}`);
+          }
+          return res.json();
+        }
+      };
+      // ── Memory embedding config (hot-swap engine, no restart) ──
+      embedding = {
+        get: async () => {
+          return this.request("/api/memory/embedding-config");
+        },
+        update: async (opts) => {
+          const res = await fetch(`${this.baseUrl}/api/memory/embedding-config`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(opts)
+          });
+          if (!res.ok) {
+            const body = await res.json().catch(() => ({}));
+            throw new Error(body.error || `Embedding config update failed: ${res.status}`);
+          }
+          return res.json();
+        }
+      };
+      // ── Automations ──
+      automations = {
+        list: async () => {
+          const data = await this.request("/api/automations");
+          return data.rules || [];
+        },
+        toggle: async (id, enabled) => {
+          await this.request(`/api/automations/${id}`, {
+            method: "PUT",
+            body: JSON.stringify({ enabled })
+          });
+        },
+        /** 起草规则（enabled=false 落盘，需手动启用）。返回校验结果。 */
+        draft: async (input) => {
+          return this.request("/api/automations/draft", {
+            method: "POST",
+            body: JSON.stringify(input)
+          });
+        }
+      };
+    };
+    exports.MafwClient = MafwClient2;
+  }
+});
+
+// ../gateway-sdk/dist/types.js
+var require_types = __commonJS({
+  "../gateway-sdk/dist/types.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.MethodNotSupportedError = void 0;
+    var MethodNotSupportedError = class extends Error {
+      constructor(method) {
+        super(`Method not supported by Gateway: ${method}`);
+        this.name = "MethodNotSupportedError";
+      }
+    };
+    exports.MethodNotSupportedError = MethodNotSupportedError;
+  }
+});
+
+// ../gateway-sdk/dist/index.js
+var require_dist = __commonJS({
+  "../gateway-sdk/dist/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SSEConnection = exports.MafwClient = void 0;
+    var client_1 = require_client();
+    Object.defineProperty(exports, "MafwClient", { enumerable: true, get: function() {
+      return client_1.MafwClient;
+    } });
+    var sse_1 = require_sse();
+    Object.defineProperty(exports, "SSEConnection", { enumerable: true, get: function() {
+      return sse_1.SSEConnection;
+    } });
+    __exportStar(require_types(), exports);
+  }
+});
+
+// src/theme.ts
+import chalk from "chalk";
+var theme;
+var init_theme = __esm({
+  "src/theme.ts"() {
+    "use strict";
+    theme = {
+      accent: (s) => chalk.cyan(s),
+      dim: (s) => chalk.gray(s),
+      active: (s) => chalk.bgCyan.black(` ${s} `),
+      inactive: (s) => chalk.gray(` ${s} `),
+      ok: (s) => chalk.green(s),
+      warn: (s) => chalk.yellow(s),
+      err: (s) => chalk.red(s),
+      border: (s) => chalk.gray(s)
+    };
+  }
+});
+
+// src/ui/tab-strip.ts
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+var TABS, TabStrip;
+var init_tab_strip = __esm({
+  "src/ui/tab-strip.ts"() {
+    "use strict";
+    init_theme();
+    TABS = [
+      { id: "chat", label: "Chat" },
+      { id: "goals", label: "Goals" },
+      { id: "memory", label: "Memory" },
+      { id: "triage", label: "Triage" }
+    ];
+    TabStrip = class {
+      active = "chat";
+      connected = false;
+      /** 点击 tab 切换（app 注入；与键盘 1-4 同路径）。 */
+      onTabClick;
+      setActive(id) {
+        this.active = id;
+      }
+      setConnected(ok) {
+        this.connected = ok;
+      }
+      invalidate() {
+      }
+      segment(i) {
+        const t = TABS[i];
+        const label = `${i + 1}:${t.label}`;
+        return t.id === this.active ? theme.active(label) : theme.inactive(label);
+      }
+      /** 列位置 → tab（分隔符与 gateway 指示区不可点）。 */
+      clickAt(col) {
+        let x = 0;
+        for (let i = 0; i < TABS.length; i++) {
+          const w = visibleWidth(this.segment(i));
+          if (col >= x && col < x + w) return TABS[i].id;
+          x += w + 1;
+        }
+        return null;
+      }
+      handleMouseClick(col, _row) {
+        const id = this.clickAt(col);
+        if (!id) return false;
+        this.onTabClick?.(id);
+        return true;
+      }
+      render(width) {
+        const tabs = TABS.map((_, i) => this.segment(i)).join(theme.dim("\u2502"));
+        const conn = this.connected ? theme.ok("\u25CF") : theme.err("\u25CF");
+        return [truncateToWidth(`${tabs} ${theme.dim("gateway:")}${conn}`, width)];
+      }
+    };
+  }
+});
+
+// src/ui/status-bar.ts
+import { truncateToWidth as truncateToWidth2 } from "@earendil-works/pi-tui";
+function formatTokens(n) {
+  if (n < 1e3) return String(n);
+  if (n < 1e6) return `${(n / 1e3).toFixed(1).replace(/\.0$/, "")}K`;
+  return `${(n / 1e6).toFixed(1).replace(/\.0$/, "")}M`;
+}
+function formatDuration(ms) {
+  const totalSec = Math.floor(ms / 1e3);
+  if (totalSec < 60) return `${totalSec}s`;
+  const m = Math.floor(totalSec / 60);
+  const s = totalSec % 60;
+  return s > 0 ? `${m}m ${s}s` : `${m}m`;
+}
+var StatusBar;
+var init_status_bar = __esm({
+  "src/ui/status-bar.ts"() {
+    "use strict";
+    init_theme();
+    StatusBar = class {
+      state = { conn: "down" };
+      setState(s) {
+        this.state = s;
+      }
+      invalidate() {
+      }
+      render(width) {
+        const s = this.state;
+        const conn = s.conn === "ok" ? theme.ok("connected") : s.conn === "reconnecting" ? theme.warn("reconnecting") : theme.err("disconnected");
+        const parts = [s.project ?? "-", s.session ? s.session.slice(0, 12) : "-", conn];
+        if (s.busy) parts.push(theme.warn("busy"));
+        if (typeof s.queued === "number" && s.queued > 0) parts.push(theme.warn(`queued ${s.queued}`));
+        if (typeof s.stashed === "number" && s.stashed > 0) parts.push(theme.dim(`\u{1F4CC}${s.stashed}`));
+        if (s.focus) parts.push(theme.accent("\u25C9 focus"));
+        const u = s.usage;
+        if (u) {
+          const usageBits = [];
+          if (u.model) usageBits.push(u.model);
+          if (typeof u.tokens === "number") usageBits.push(`${formatTokens(u.tokens)} tok`);
+          if (typeof u.costUsd === "number" && u.costUsd > 0) usageBits.push(`$${u.costUsd < 0.01 ? u.costUsd.toFixed(3) : u.costUsd.toFixed(2)}`);
+          if (typeof u.promptMs === "number") usageBits.push(theme.accent(`\u23F1 ${formatDuration(u.promptMs)}`));
+          if (typeof u.durationMs === "number") usageBits.push(formatDuration(u.durationMs));
+          if (usageBits.length > 0) parts.push(usageBits.join(" "));
+        }
+        parts.push(s.hint ?? "1-4:tab q:quit ?:help");
+        return [truncateToWidth2(theme.dim(parts.join("  \xB7  ")), width)];
+      }
+    };
+  }
+});
+
+// src/ui/app-model.ts
+var AppModel;
+var init_app_model = __esm({
+  "src/ui/app-model.ts"() {
+    "use strict";
+    AppModel = class {
+      active = "chat";
+      helpVisible = false;
+      /** 输入焦点在 Editor/Input 时，字符键（q/?/数字）归编辑器；由 app 按 tab/焦点状态注入。 */
+      editing = false;
+      switchTab(id) {
+        this.active = id;
+      }
+      toggleHelp() {
+        this.helpVisible = !this.helpVisible;
+      }
+    };
+  }
+});
+
+// src/store/connection.ts
+var BACKOFF, HEALTH_TICK_MS, KNOWN_EVENTS, ConnectionStore;
+var init_connection = __esm({
+  "src/store/connection.ts"() {
+    "use strict";
+    BACKOFF = [1e3, 2e3, 5e3, 15e3];
+    HEALTH_TICK_MS = 1e3;
+    KNOWN_EVENTS = [
+      "message.part.updated",
+      "session.idle",
+      "message.complete",
+      "message.error",
+      "session.error",
+      "permission.asked",
+      "question.asked"
+    ];
+    ConnectionStore = class {
+      backoffIdx = 0;
+      stopped = false;
+      unsubs = [];
+      schedule;
+      deps;
+      constructor(deps) {
+        this.deps = deps;
+        this.schedule = deps.schedule ?? ((fn, ms) => {
+          setTimeout(fn, ms);
+        });
+      }
+      start() {
+        this.stopped = false;
+        void this.subscribe();
+        this.schedule(() => this.healthTick(), HEALTH_TICK_MS);
+      }
+      /** 切换订阅目标会话（/sessions 切换后重订事件流）。 */
+      setSession(sessionID) {
+        if (this.stopped || sessionID === this.deps.sessionID) return;
+        this.deps.sessionID = sessionID;
+        void this.resubscribe();
+      }
+      stop() {
+        this.stopped = true;
+        for (const u of this.unsubs) u();
+        this.unsubs = [];
+      }
+      async subscribe() {
+        if (this.stopped) return;
+        try {
+          const sub = await this.deps.subscribe(this.deps.sessionID);
+          const unsubs = [];
+          const track = (u) => {
+            if (typeof u === "function") unsubs.push(u);
+          };
+          for (const e of KNOWN_EVENTS) track(sub.on(e, (d) => this.deps.onEvent(e, d)));
+          track(sub.on("*", (d) => {
+            if (d?.type && !KNOWN_EVENTS.includes(d.type)) this.deps.onEvent(d.type, d);
+          }));
+          this.unsubs = unsubs;
+        } catch {
+          this.deps.onState("down");
+        }
+      }
+      healthTick() {
+        if (this.stopped) return;
+        if (this.deps.isConnected()) {
+          this.backoffIdx = 0;
+          this.deps.onState("ok");
+          this.schedule(() => this.healthTick(), HEALTH_TICK_MS);
+          return;
+        }
+        this.deps.onState("reconnecting");
+        const delay = BACKOFF[Math.min(this.backoffIdx, BACKOFF.length - 1)];
+        this.backoffIdx++;
+        this.schedule(() => {
+          void this.resubscribe();
+        }, delay);
+      }
+      async resubscribe() {
+        if (this.stopped) return;
+        for (const u of this.unsubs) u();
+        this.unsubs = [];
+        await this.subscribe();
+        this.schedule(() => this.healthTick(), HEALTH_TICK_MS);
+      }
+    };
+  }
+});
+
+// src/store/chat-store.ts
+function historyItemsToTurns(items) {
+  const turns = [];
+  const byId = /* @__PURE__ */ new Map();
+  for (const item of items ?? []) {
+    const info = item.info ?? item;
+    const mid = info.id ?? `t-${turns.length}`;
+    let t = byId.get(mid);
+    if (!t) {
+      t = { messageID: mid, role: info.role === "user" ? "user" : "assistant", parts: [], done: true };
+      byId.set(mid, t);
+      turns.push(t);
+    }
+    for (const p of item.parts ?? []) {
+      const hp = historyPart(p);
+      if (hp) t.parts.push(hp);
+    }
+  }
+  return turns;
+}
+function isInjectionBlock(text) {
+  const t = text.trimStart();
+  return INJECTION_TAGS.some((tag) => t.startsWith(tag));
+}
+function historyPart(p) {
+  if (p.type === "tool") {
+    const st = p.state?.status;
+    const cmd = String(p.state?.input?.command ?? p.state?.input?.description ?? p.tool ?? "");
+    const out = st === "running" ? "" : String(p.state?.output ?? "");
+    return {
+      id: p.id,
+      type: "tool",
+      toolName: p.tool,
+      state: st === "completed" ? "completed" : st === "error" ? "error" : st === "running" ? "running" : "completed",
+      text: out ? `${cmd}
+${out}` : cmd
+    };
+  }
+  const text = String(p.text ?? "");
+  if (isInjectionBlock(text)) return null;
+  return { id: p.id, type: p.type ?? "text", text, state: "completed" };
+}
+function livePart(part) {
+  if (part.type === "tool") {
+    const st = part.state?.status;
+    const cmd = String(part.state?.input?.command ?? part.state?.input?.description ?? part.tool ?? "");
+    const out = st === "completed" || st === "error" ? String(part.state?.output ?? "") : "";
+    return {
+      id: part.id,
+      type: "tool",
+      toolName: part.tool,
+      state: st === "completed" ? "completed" : st === "error" ? "error" : "running",
+      text: out ? `${cmd}
+${out}` : cmd
+    };
+  }
+  const text = String(part.text ?? "");
+  if (isInjectionBlock(text)) return null;
+  return { id: part.id, type: part.type ?? "text", text };
+}
+var ChatStore, INJECTION_TAGS;
+var init_chat_store = __esm({
+  "src/store/chat-store.ts"() {
+    "use strict";
+    ChatStore = class {
+      turns = [];
+      streaming = false;
+      _sessionID;
+      cursor = null;
+      byMessage = /* @__PURE__ */ new Map();
+      queuedTurns = [];
+      deps;
+      constructor(deps) {
+        this.deps = deps;
+        this._sessionID = deps.sessionID;
+      }
+      get sessionID() {
+        return this._sessionID;
+      }
+      constructorDeps() {
+        return this.deps;
+      }
+      async loadHistory(limit = 50) {
+        try {
+          const res = await this.deps.session.messages({ path: { id: this._sessionID }, query: { limit } });
+          this.cursor = res.nextCursor ?? null;
+          this.turns.length = 0;
+          this.byMessage.clear();
+          this.queuedTurns = [];
+          for (const item of res.data ?? []) this.appendHistoryItem(item);
+          this.deps.onChange();
+        } catch (err) {
+          this.deps.onError?.(err?.message ?? String(err));
+        }
+      }
+      /** 切换会话：清空本地状态并按新 sessionID 重载历史。 */
+      async switchSession(sessionID) {
+        this._sessionID = sessionID;
+        this.cursor = null;
+        this.streaming = false;
+        this.turns.length = 0;
+        this.byMessage.clear();
+        this.queuedTurns = [];
+        this.deps.onChange();
+        await this.loadHistory();
+      }
+      /** 返回新加载的 turn 数，0 = 没有更早历史。 */
+      async loadOlder() {
+        if (!this.cursor) return 0;
+        try {
+          const res = await this.deps.session.messages({
+            path: { id: this._sessionID },
+            query: { limit: 50, before: this.cursor }
+          });
+          this.cursor = res.nextCursor ?? null;
+          const older = [];
+          const map = /* @__PURE__ */ new Map();
+          for (const item of res.data ?? []) {
+            const info = item.info ?? item;
+            const mid = info.id ?? `older-${older.length}`;
+            let t = map.get(mid);
+            if (!t) {
+              t = { messageID: mid, role: info.role === "user" ? "user" : "assistant", parts: [], done: true };
+              map.set(mid, t);
+              older.push(t);
+            }
+            for (const p of item.parts ?? []) {
+              const hp = historyPart(p);
+              if (hp) t.parts.push(hp);
+            }
+          }
+          this.turns.unshift(...older);
+          for (const t of older) this.byMessage.set(t.messageID, t);
+          this.deps.onChange();
+          return older.length;
+        } catch (err) {
+          this.deps.onError?.(err?.message ?? String(err));
+          return 0;
+        }
+      }
+      async send(text) {
+        const trimmed = text.trim();
+        if (!trimmed) return;
+        if (this.streaming) {
+          const turn = {
+            messageID: `queued-${Date.now()}-${this.queuedTurns.length}`,
+            role: "user",
+            parts: [{ id: `q-${Date.now()}`, type: "text", text: trimmed }],
+            done: true,
+            queued: true
+          };
+          this.queuedTurns.push(turn);
+          this.turns.push(turn);
+          this.deps.onChange();
+          return;
+        }
+        await this.deliver(trimmed);
+      }
+      async deliver(text, reuseTurn) {
+        const mid = reuseTurn?.messageID ?? `local-${Date.now()}`;
+        let turn = reuseTurn;
+        if (turn) {
+          turn.queued = void 0;
+        } else {
+          turn = {
+            messageID: mid,
+            role: "user",
+            parts: [{ id: `${mid}-p`, type: "text", text }],
+            done: true
+          };
+          this.turns.push(turn);
+          this.byMessage.set(mid, turn);
+        }
+        this.streaming = true;
+        this.deps.onChange();
+        try {
+          const model = this.deps.getModel?.();
+          await this.deps.session.promptAsync({
+            path: { id: this._sessionID },
+            body: { parts: [{ type: "text", text }], ...model ? { model } : {} }
+          });
+        } catch (err) {
+          this.streaming = false;
+          this.deps.onError?.(err?.message ?? String(err));
+          this.deps.onChange();
+        }
+      }
+      /** idle 后自动续发排队消息（每次一条，下一条等下一个 idle）。 */
+      flushQueue() {
+        if (this.streaming || this.queuedTurns.length === 0) return;
+        const next = this.queuedTurns.shift();
+        void this.deliver(next.parts[0]?.text ?? "", next);
+      }
+      /** 排队中的消息数。 */
+      get queuedCount() {
+        return this.queuedTurns.length;
+      }
+      /** 排队消息文本（/queue overlay 渲染用）。 */
+      get queuedTexts() {
+        return this.queuedTurns.map((t) => t.parts[0]?.text ?? "");
+      }
+      /** 收回全部排队消息（Claude Up-take-back 语义）：返回文本数组并从 turns 一并移除。 */
+      takeBackAll() {
+        const texts = this.queuedTurns.map((t) => t.parts[0]?.text ?? "");
+        for (const t of this.queuedTurns) {
+          const idx = this.turns.indexOf(t);
+          if (idx >= 0) this.turns.splice(idx, 1);
+        }
+        this.queuedTurns = [];
+        this.deps.onChange();
+        return texts;
+      }
+      /** 丢弃第 i 条排队消息（0 = 最早）；返回其文本，越界返回 null。 */
+      dropQueuedAt(i) {
+        const t = this.queuedTurns[i];
+        if (!t) return null;
+        this.queuedTurns.splice(i, 1);
+        const idx = this.turns.indexOf(t);
+        if (idx >= 0) this.turns.splice(idx, 1);
+        this.deps.onChange();
+        return t.parts[0]?.text ?? "";
+      }
+      async abort() {
+        try {
+          await this.deps.session.abort({ path: { id: this._sessionID } });
+        } catch (err) {
+          this.deps.onError?.(err?.message ?? String(err));
+        }
+        this.streaming = false;
+        this.deps.onChange();
+      }
+      /** /undo：回退到最后一条已持久化的 user 消息（连带其后的回复）。 */
+      async undo() {
+        const lastUser = [...this.turns].reverse().find((t) => t.role === "user" && !t.queued && !t.messageID.startsWith("local-") && !t.messageID.startsWith("queued-"));
+        if (!lastUser) return "\u6CA1\u6709\u53EF\u56DE\u9000\u7684\u6D88\u606F\uFF08\u672C\u5730\u672A\u6301\u4E45\u5316\u7684\u6D88\u606F\u4E0D\u7B97\uFF09";
+        if (!this.deps.session.revert) return "\u5F53\u524D runtime \u4E0D\u652F\u6301 revert";
+        try {
+          await this.deps.session.revert({ path: { id: this._sessionID }, body: { messageID: lastUser.messageID } });
+          await this.loadHistory();
+          return null;
+        } catch (err) {
+          return `undo \u5931\u8D25: ${err?.message ?? String(err)}`;
+        }
+      }
+      /** /redo：恢复上一次 revert（opencode-only；pi runtime 无 unrevert）。 */
+      async redo() {
+        if (!this.deps.session.unrevert) return "\u5F53\u524D runtime \u4E0D\u652F\u6301 unrevert";
+        try {
+          await this.deps.session.unrevert({ path: { id: this._sessionID } });
+          await this.loadHistory();
+          return null;
+        } catch (err) {
+          return `redo \u5931\u8D25: ${err?.message ?? String(err)}`;
+        }
+      }
+      applyEvent(type, data) {
+        if (type === "message.part.updated") {
+          const part = data?.properties?.part;
+          if (!part) return;
+          if (part.sessionID && part.sessionID !== this._sessionID) return;
+          this.applyPart(part);
+          this.deps.onChange();
+        } else if (type === "session.idle") {
+          this.finalizeTurn();
+        } else if (type === "message.complete") {
+          const sid = data?.sessionID;
+          if (!sid || sid === this._sessionID) this.finalizeTurn();
+        }
+      }
+      finalizeTurn() {
+        this.streaming = false;
+        const last = this.turns.at(-1);
+        if (last && last.role === "assistant") last.done = true;
+        this.deps.onChange();
+        this.flushQueue();
+      }
+      applyPart(part) {
+        const cp = livePart(part);
+        if (!cp) return;
+        let turn = this.byMessage.get(part.messageID);
+        if (!turn) {
+          turn = { messageID: part.messageID, role: "assistant", parts: [], done: false };
+          this.byMessage.set(part.messageID, turn);
+          this.turns.push(turn);
+        }
+        const idx = turn.parts.findIndex((p) => p.id === cp.id);
+        if (idx >= 0) turn.parts[idx] = cp;
+        else turn.parts.push(cp);
+      }
+      appendHistoryItem(item) {
+        const info = item.info ?? item;
+        const mid = info.id ?? `hist-${this.turns.length}`;
+        const parts = (item.parts ?? []).map(historyPart).filter((p) => p !== null);
+        const turn = {
+          messageID: mid,
+          role: info.role === "user" ? "user" : "assistant",
+          parts,
+          done: true
+        };
+        this.turns.push(turn);
+        this.byMessage.set(mid, turn);
+      }
+    };
+    INJECTION_TAGS = ["<recall>", "<note-board>", "<goal-snapshot>", "<user-profile>", "<memory-guide>"];
+  }
+});
+
+// src/ui/message-blocks.ts
+import { truncateToWidth as truncateToWidth3, wrapTextWithAnsi, Markdown } from "@earendil-works/pi-tui";
+import chalk2 from "chalk";
+function colorDiffLine(l) {
+  if (l.startsWith("+++") || l.startsWith("---")) return theme.dim(l);
+  if (l.startsWith("+")) return theme.ok(l);
+  if (l.startsWith("-")) return theme.err(l);
+  if (l.startsWith("@@")) return theme.accent(l);
+  return theme.dim(l);
+}
+function turnToLines(turn, width) {
+  const lines = [];
+  const queued = turn.role === "user" && turn.queued;
+  for (const part of turn.parts) {
+    if (part.type === "tool") {
+      const icon = part.state === "completed" ? theme.ok("\u2713") : part.state === "error" ? theme.err("\u2717") : theme.warn("\u2026");
+      const firstLine = stripAnsi(part.text).split("\n")[0] ?? "";
+      lines.push(truncateToWidth3(
+        `${theme.dim("\u25B8 ")}${theme.accent(part.toolName ?? "tool")} ${icon} ${theme.dim(firstLine)}`,
+        width
+      ));
+      if (part.state !== "running") {
+        for (const l of stripAnsi(part.text).split("\n").slice(1)) {
+          if (!l) continue;
+          for (const w of wrapTextWithAnsi(l, Math.max(4, width - 4))) {
+            lines.push(truncateToWidth3(`  ${colorDiffLine(w)}`, width));
+          }
+        }
+      }
+    } else if (part.type === "reasoning") {
+      for (const raw of stripAnsi(part.text).split("\n")) {
+        for (const w of wrapTextWithAnsi(raw, Math.max(4, width - 4))) {
+          lines.push(truncateToWidth3(theme.dim(`  \u283F ${w}`), width));
+        }
+      }
+    } else if (turn.role === "assistant") {
+      const md = new Markdown(part.text, 1, 0, markdownTheme);
+      for (const l of md.render(Math.max(8, width - 2))) {
+        lines.push(truncateToWidth3(` ${l}`, width));
+      }
+    } else {
+      const isUser = turn.role === "user";
+      const body = stripAnsi(part.text).split("\n").flatMap((l) => wrapTextWithAnsi(l, Math.max(4, width - 4)));
+      for (let i = 0; i < body.length; i++) {
+        if (queued) {
+          lines.push(truncateToWidth3(theme.dim(`${i === 0 ? "\u23F3 " : "  "}${body[i]}`), width));
+          continue;
+        }
+        const prefix = isUser ? i === 0 ? `${theme.accent(">")} ` : "  " : "  ";
+        lines.push(truncateToWidth3(`${prefix}${body[i]}`, width));
+      }
+    }
+  }
+  if (turn.role === "assistant" && !turn.done) lines.push(theme.dim("  \u2026"));
+  return lines;
+}
+var stripAnsi, markdownTheme;
+var init_message_blocks = __esm({
+  "src/ui/message-blocks.ts"() {
+    "use strict";
+    init_theme();
+    stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
+    markdownTheme = {
+      heading: (t) => chalk2.bold.cyan(t),
+      link: (t) => chalk2.cyan.underline(t),
+      linkUrl: (t) => chalk2.gray(t),
+      code: (t) => chalk2.yellow(t),
+      codeBlock: (t) => chalk2.white(t),
+      codeBlockBorder: (t) => chalk2.gray(t),
+      quote: (t) => chalk2.gray(t),
+      quoteBorder: (t) => chalk2.gray(t),
+      hr: (t) => chalk2.gray(t),
+      listBullet: (t) => chalk2.cyan(t),
+      bold: (t) => chalk2.bold(t),
+      italic: (t) => chalk2.italic(t),
+      underline: (t) => chalk2.underline(t),
+      strikethrough: (t) => chalk2.strikethrough(t)
+    };
+  }
+});
+
+// src/ui/blocks.ts
+import { Markdown as Markdown2, truncateToWidth as truncateToWidth4, wrapTextWithAnsi as wrapTextWithAnsi2 } from "@earendil-works/pi-tui";
+function buildBlock(part, turn, settings, requestRender) {
+  if (part.type === "tool") return new ToolBlock(part, settings, requestRender);
+  if (part.type === "reasoning") return new ReasoningBlock(part);
+  if (turn.role === "assistant") return new AssistantMarkdownBlock(part);
+  return new UserTextBlock(part, turn.queued === true);
+}
+var stripAnsi2, UserTextBlock, AssistantMarkdownBlock, ReasoningBlock, ToolBlock, PendingBlock;
+var init_blocks = __esm({
+  "src/ui/blocks.ts"() {
+    "use strict";
+    init_message_blocks();
+    init_theme();
+    stripAnsi2 = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
+    UserTextBlock = class {
+      part;
+      queued;
+      cachedWidth;
+      cached;
+      constructor(part, queued = false) {
+        this.part = part;
+        this.queued = queued;
+      }
+      update(part) {
+        this.part = part;
+        this.cachedWidth = void 0;
+      }
+      invalidate() {
+        this.cachedWidth = void 0;
+      }
+      render(width) {
+        if (this.cached && this.cachedWidth === width) return this.cached;
+        const lines = [];
+        const body = stripAnsi2(this.part.text).split("\n").flatMap((l) => wrapTextWithAnsi2(l, Math.max(4, width - 4)));
+        for (let i = 0; i < body.length; i++) {
+          if (this.queued) {
+            lines.push(truncateToWidth4(theme.dim(`${i === 0 ? "\u23F3 " : "  "}${body[i]}`), width));
+            continue;
+          }
+          const prefix = i === 0 ? `${theme.accent(">")} ` : "  ";
+          lines.push(truncateToWidth4(`${prefix}${body[i]}`, width));
+        }
+        this.cached = lines;
+        this.cachedWidth = width;
+        return lines;
+      }
+    };
+    AssistantMarkdownBlock = class {
+      part;
+      cachedWidth;
+      cached;
+      constructor(part) {
+        this.part = part;
+      }
+      update(part) {
+        this.part = part;
+        this.cachedWidth = void 0;
+      }
+      invalidate() {
+        this.cachedWidth = void 0;
+      }
+      render(width) {
+        if (this.cached && this.cachedWidth === width) return this.cached;
+        const md = new Markdown2(this.part.text, 1, 0, markdownTheme);
+        const lines = md.render(Math.max(8, width - 2)).map((l) => truncateToWidth4(` ${l}`, width));
+        this.cached = lines;
+        this.cachedWidth = width;
+        return lines;
+      }
+    };
+    ReasoningBlock = class {
+      part;
+      cachedWidth;
+      cached;
+      constructor(part) {
+        this.part = part;
+      }
+      update(part) {
+        this.part = part;
+        this.cachedWidth = void 0;
+      }
+      invalidate() {
+        this.cachedWidth = void 0;
+      }
+      render(width) {
+        if (this.cached && this.cachedWidth === width) return this.cached;
+        const lines = [];
+        for (const raw of stripAnsi2(this.part.text).split("\n")) {
+          for (const w of wrapTextWithAnsi2(raw, Math.max(4, width - 4))) {
+            lines.push(truncateToWidth4(theme.dim(`  \u283F ${w}`), width));
+          }
+        }
+        this.cached = lines;
+        this.cachedWidth = width;
+        return lines;
+      }
+    };
+    ToolBlock = class {
+      part;
+      settings;
+      requestRender;
+      userExpanded = null;
+      // null = 跟随全局
+      cachedWidth;
+      cachedKey;
+      cached;
+      constructor(part, settings, requestRender) {
+        this.part = part;
+        this.settings = settings;
+        this.requestRender = requestRender;
+      }
+      update(part) {
+        this.part = part;
+        this.cachedKey = void 0;
+      }
+      invalidate() {
+        this.cachedKey = void 0;
+      }
+      handleMouseClick(_col, _row) {
+        this.userExpanded = !this.expanded;
+        this.cachedKey = void 0;
+        this.requestRender();
+        return true;
+      }
+      get expanded() {
+        return this.userExpanded ?? this.settings.toolVerbosity === "all";
+      }
+      render(width) {
+        const key = `${width}|${this.expanded}|${this.settings.focus}|${this.part.state}|${this.part.text}`;
+        if (this.cached && this.cachedKey === key) return this.cached;
+        const lines = this.renderInner(width);
+        this.cached = lines;
+        this.cachedKey = key;
+        return lines;
+      }
+      renderInner(width) {
+        if (this.settings.focus) {
+          return [truncateToWidth4(theme.dim(`  \u22EF ${this.part.toolName ?? "tool"} \u8F93\u51FA\u9690\u85CF\uFF08/focus off \u663E\u793A\uFF09`), width)];
+        }
+        const icon = this.part.state === "completed" ? theme.ok("\u2713") : this.part.state === "error" ? theme.err("\u2717") : theme.warn("\u2026");
+        const firstLine = stripAnsi2(this.part.text).split("\n")[0] ?? "";
+        const summary = truncateToWidth4(
+          `${theme.dim("\u25B8 ")}${theme.accent(this.part.toolName ?? "tool")} ${icon} ${theme.dim(firstLine)}`,
+          width
+        );
+        if (!this.expanded || this.part.state === "running") return [summary];
+        const lines = [summary];
+        for (const l of stripAnsi2(this.part.text).split("\n").slice(1)) {
+          if (!l) continue;
+          for (const w of wrapTextWithAnsi2(l, Math.max(4, width - 4))) {
+            lines.push(truncateToWidth4(`  ${colorDiffLine(w)}`, width));
+          }
+        }
+        return lines;
+      }
+    };
+    PendingBlock = class {
+      invalidate() {
+      }
+      render(_width) {
+        return [theme.dim("  \u2026")];
+      }
+    };
+  }
+});
+
+// src/shell-mode.ts
+import { exec } from "node:child_process";
+import { truncateToWidth as truncateToWidth5, wrapTextWithAnsi as wrapTextWithAnsi3 } from "@earendil-works/pi-tui";
+function isShellCommand(text) {
+  return text.startsWith("!") && text.slice(1).trim().length > 0;
+}
+function parseShellCommand(text) {
+  return text.slice(1).trim();
+}
+function runShell(cmd, opts) {
+  const execFn = opts?.execFn ?? ((c, o, cb) => exec(c, o, cb));
+  return new Promise((resolve) => {
+    execFn(
+      cmd,
+      { cwd: opts?.cwd, timeout: opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS, maxBuffer: MAX_BUFFER },
+      (err, stdout, stderr) => {
+        resolve({
+          command: cmd,
+          exitCode: err?.code ?? (err ? null : 0),
+          stdout: String(stdout ?? ""),
+          stderr: String(stderr ?? ""),
+          timedOut: !!err?.killed
+        });
+      }
+    );
+  });
+}
+function shellResultToLines(r, width) {
+  const lines = [];
+  const status = r.timedOut ? theme.err("\u8D85\u65F6") : r.exitCode === 0 ? theme.ok(`exit 0`) : r.exitCode === null ? theme.warn("exit ?") : theme.err(`exit ${r.exitCode}`);
+  lines.push(truncateToWidth5(`${theme.accent("!")} ${theme.dim(r.command)} ${status}`, width));
+  const outLines = (r.stdout + (r.stderr ? `
+${r.stderr}` : "")).split("\n").filter((l) => l.length > 0);
+  const capped = outLines.slice(0, MAX_OUTPUT_LINES);
+  for (const l of capped) {
+    const isErr = r.stderr.split("\n").includes(l);
+    for (const w of wrapTextWithAnsi3(l, Math.max(4, width - 4))) {
+      lines.push(truncateToWidth5(`  ${isErr ? theme.err(w) : theme.dim(w)}`, width));
+    }
+  }
+  if (outLines.length > MAX_OUTPUT_LINES) lines.push(theme.dim(`  \u2026 \u8F93\u51FA\u622A\u65AD\uFF08${outLines.length} \u884C\uFF09`));
+  if (outLines.length === 0) lines.push(theme.dim("  \uFF08\u65E0\u8F93\u51FA\uFF09"));
+  return lines;
+}
+var DEFAULT_TIMEOUT_MS, MAX_BUFFER, MAX_OUTPUT_LINES;
+var init_shell_mode = __esm({
+  "src/shell-mode.ts"() {
+    "use strict";
+    init_theme();
+    DEFAULT_TIMEOUT_MS = 3e4;
+    MAX_BUFFER = 128 * 1024;
+    MAX_OUTPUT_LINES = 50;
+  }
+});
+
+// src/ui/command-registry.ts
+function resolveCommand(name) {
+  for (const c of COMMAND_REGISTRY) {
+    if (c.name === name) return c.name;
+    if (c.aliases?.includes(name)) return c.name;
+  }
+  return null;
+}
+function autocompleteItems() {
+  return COMMAND_REGISTRY.map((c) => ({ name: c.name, description: c.description }));
+}
+function helpLines() {
+  const lines = [];
+  for (const cat of COMMAND_CATEGORIES) {
+    const cmds = COMMAND_REGISTRY.filter((c) => c.category === cat);
+    if (cmds.length === 0) continue;
+    lines.push(theme.accent(cat));
+    for (const c of cmds) {
+      const mark = c.destructive ? theme.warn(" \u26A0") : "";
+      lines.push(`  /${c.name.padEnd(10)}${c.description}${mark}`);
+    }
+    lines.push("");
+  }
+  return lines;
+}
+var COMMAND_CATEGORIES, COMMAND_REGISTRY;
+var init_command_registry = __esm({
+  "src/ui/command-registry.ts"() {
+    "use strict";
+    init_theme();
+    COMMAND_CATEGORIES = ["\u4F1A\u8BDD", "\u4E0A\u4E0B\u6587", "\u6A21\u578B", "\u8F93\u5165", "\u5E2E\u52A9"];
+    COMMAND_REGISTRY = [
+      { name: "new", description: "\u65B0\u8BDD\u9898\uFF08rotate manager session\uFF09", category: "\u4F1A\u8BDD", aliases: ["clear"], destructive: true },
+      { name: "sessions", description: "\u4F1A\u8BDD\u5217\u8868/\u5207\u6362\uFF08/resume /switch\uFF09", category: "\u4F1A\u8BDD", aliases: ["resume", "switch"], immediate: true },
+      { name: "rename", description: "\u4F1A\u8BDD\u547D\u540D\uFF1A/rename <\u6807\u9898>", category: "\u4F1A\u8BDD", immediate: true },
+      { name: "fork", description: "\u5206\u53C9\u5F53\u524D\u4F1A\u8BDD\uFF08\u5386\u53F2\u526F\u672C\uFF09", category: "\u4F1A\u8BDD", immediate: true },
+      { name: "status", description: "\u4F1A\u8BDD\u72B6\u6001\u56DE\u987E\uFF08\u672C\u5730\u8BA1\u7B97\uFF09", category: "\u4F1A\u8BDD", immediate: true },
+      { name: "queue", description: "\u6392\u961F\u6D88\u606F\u7BA1\u7406\uFF08\u6536\u56DE/\u4E22\u5F03\uFF09", category: "\u4F1A\u8BDD", aliases: ["q"], immediate: true },
+      { name: "btw", description: "\u652F\u7EBF\u95EE\u7B54\uFF1A/btw <\u95EE\u9898>", category: "\u4F1A\u8BDD" },
+      { name: "compact", description: "\u538B\u7F29\u5F53\u524D\u4F1A\u8BDD\u4E0A\u4E0B\u6587", category: "\u4E0A\u4E0B\u6587", destructive: true, immediate: true },
+      { name: "undo", description: "\u56DE\u9000\u6700\u540E\u4E00\u8F6E\u5BF9\u8BDD", category: "\u4E0A\u4E0B\u6587", destructive: true },
+      { name: "redo", description: "\u6062\u590D\u4E0A\u4E00\u6B21\u56DE\u9000", category: "\u4E0A\u4E0B\u6587", destructive: true },
+      { name: "older", description: "\u52A0\u8F7D\u66F4\u65E9\u5386\u53F2", category: "\u4E0A\u4E0B\u6587", immediate: true },
+      { name: "verbose", description: "\u5DE5\u5177\u8F93\u51FA\u5C55\u5F00/\u6298\u53E0\u5FAA\u73AF", category: "\u4E0A\u4E0B\u6587", immediate: true },
+      { name: "focus", description: "\u9759\u89C6\u56FE\uFF08\u9690\u85CF\u5DE5\u5177\u8F93\u51FA\uFF09", category: "\u4E0A\u4E0B\u6587", immediate: true },
+      { name: "diff", description: "\u67E5\u770B git \u53D8\u66F4\uFF08/diff staged|all\uFF09", category: "\u4E0A\u4E0B\u6587", immediate: true },
+      { name: "model", description: "\u9009\u62E9\u6A21\u578B\uFF08\u4F5C\u7528\u4E8E\u540E\u7EED\u6D88\u606F\uFF09", category: "\u6A21\u578B", immediate: true },
+      { name: "editor", description: "\u5916\u90E8\u7F16\u8F91\u5668\u7F16\u8F91\u8F93\u5165\uFF08\u540C Ctrl+G\uFF09", category: "\u8F93\u5165", immediate: true },
+      { name: "help", description: "\u5FEB\u6377\u952E\u5E2E\u52A9", category: "\u5E2E\u52A9", immediate: true }
+    ];
+  }
+});
+
+// src/ui/prompt-stash.ts
+var PromptStash;
+var init_prompt_stash = __esm({
+  "src/ui/prompt-stash.ts"() {
+    "use strict";
+    PromptStash = class {
+      stack = [];
+      get size() {
+        return this.stack.length;
+      }
+      push(text) {
+        if (text.trim().length === 0) return;
+        this.stack.push(text);
+      }
+      pop() {
+        return this.stack.pop() ?? null;
+      }
+    };
+  }
+});
+
+// src/ui/chat-tab.ts
+import {
+  VStack,
+  Container,
+  Editor,
+  CombinedAutocompleteProvider,
+  ScrollView
+} from "@earendil-works/pi-tui";
+function parseSlash(text) {
+  const m = text.match(/^\/(\w+)(?:\s+([\s\S]*))?$/);
+  return m ? { cmd: m[1], args: m[2] ?? "" } : null;
+}
+var selectListTheme, editorTheme, RawLines, ChatTab;
+var init_chat_tab = __esm({
+  "src/ui/chat-tab.ts"() {
+    "use strict";
+    init_blocks();
+    init_shell_mode();
+    init_command_registry();
+    init_prompt_stash();
+    init_theme();
+    selectListTheme = {
+      selectedPrefix: (t) => theme.accent(t),
+      selectedText: (t) => theme.accent(t),
+      description: (t) => theme.dim(t),
+      scrollInfo: (t) => theme.dim(t),
+      noMatch: (t) => theme.dim(t)
+    };
+    editorTheme = {
+      borderColor: (s) => theme.border(s),
+      selectList: selectListTheme
+    };
+    RawLines = class {
+      lines;
+      constructor(lines) {
+        this.lines = lines;
+      }
+      invalidate() {
+      }
+      render(_width) {
+        return this.lines;
+      }
+    };
+    ChatTab = class extends VStack {
+      editor;
+      transcript = new Container();
+      scrollView;
+      rendered = [];
+      localBlocks = [];
+      stash = new PromptStash();
+      /** 阅读模式设置（/focus /verbose 驱动，块渲染时读取）。 */
+      display = { focus: false, toolVerbosity: "all" };
+      savedVerbosity = "all";
+      _focused = false;
+      deps;
+      get focused() {
+        return this._focused;
+      }
+      set focused(v) {
+        this._focused = v;
+        this.editor.focused = v;
+      }
+      // IME 传播
+      /** 焦点组件输入路由：TUI 只调 focusedComponent.handleInput，VStack 无此方法——
+       *  必须显式转发给 Editor，否则按键被静默丢弃（"tui 没法输入"根因之二）。
+       *  转发前拦截三个 app 级输入交互：Up 收回排队（Claude）、Ctrl+S 草稿栈（Hermes）。 */
+      handleInput(data) {
+        if (data === "\x1B[A") {
+          if (this.deps.store.queuedCount > 0 && this.getEditorText().trim() === "") {
+            const texts = this.deps.store.takeBackAll();
+            if (texts.length > 0) {
+              this.setEditorText(texts.join("\n"));
+              return;
+            }
+          }
+        }
+        if (data === "") {
+          const text = this.getEditorText();
+          if (text.trim() !== "") {
+            this.stash.push(text);
+            this.setEditorText("");
+            this.deps.tui.requestRender();
+            return;
+          }
+          const restored = this.stash.pop();
+          if (restored !== null) this.setEditorText(restored);
+          return;
+        }
+        this.editor.handleInput(data);
+      }
+      /** stash 深度（状态栏 📌N 徽标用）。 */
+      get stashCount() {
+        return this.stash.size;
+      }
+      /** 鼠标点击：未聚焦时点击即聚焦；已聚焦时放行（保留 pi-tui 拖选复制）。 */
+      handleMouseClick(_col, _row) {
+        if (!this._focused) {
+          this.deps.tui.setFocus(this);
+          return true;
+        }
+        return false;
+      }
+      constructor(deps) {
+        super([]);
+        this.deps = deps;
+        this.scrollView = new ScrollView(this.transcript, { follow: "end", primary: true });
+        this.editor = new Editor(deps.tui, editorTheme);
+        this.editor.setAutocompleteProvider(new CombinedAutocompleteProvider(
+          autocompleteItems(),
+          process.cwd()
+        ));
+        this.editor.onSubmit = (text) => {
+          void this.submit(text);
+        };
+        this.addChild(this.scrollView, { basis: 0, grow: 1, minSize: 1 });
+        this.addChild(this.editor, { basis: "auto", shrink: 1, minSize: 1 });
+        deps.store.loadHistory().then(() => this.rebuild());
+      }
+      /** 顶部（用户上翻到头）→ 自动 loadOlder。由 app 轮询调用。 */
+      get atTop() {
+        return !this.scrollView.isFollowingEnd && this.scrollView.scrollTop === 0;
+      }
+      async loadOlder() {
+        const n = await this.deps.store.loadOlder();
+        if (n > 0) {
+          this.rebuild();
+        }
+      }
+      /** 编辑器文本透传（Ctrl+G 外部编辑器用）。 */
+      getEditorText() {
+        return this.editor.getText();
+      }
+      setEditorText(text) {
+        this.editor.setText(text);
+        this.deps.tui.requestRender();
+      }
+      /** 会话切换后全量重建 transcript（本地块如 shell 结果跨重建保留）。 */
+      rebuild() {
+        this.transcript.clear();
+        this.rendered = [];
+        this.refreshTranscript();
+        for (const b of this.localBlocks) this.transcript.addChild(b);
+        this.deps.tui.requestRender();
+      }
+      async submit(text) {
+        const trimmed = text.trim();
+        if (!trimmed) return;
+        this.editor.addToHistory(trimmed);
+        if (trimmed === "!") {
+          this.addLocalLines([theme.dim("\u7528\u6CD5: ! <command>\uFF08\u672C\u5730\u6267\u884C\uFF0C\u4E0D\u8FDB\u5BF9\u8BDD\uFF09")]);
+          return;
+        }
+        if (isShellCommand(trimmed)) {
+          const cmd = parseShellCommand(trimmed);
+          this.addLocalLines([`${theme.accent("!")} ${theme.dim(cmd)} ${theme.warn("running\u2026")}`]);
+          const width = this.deps.tui.terminal?.columns ?? 80;
+          const result = await runShell(cmd);
+          this.addLocalLines(shellResultToLines(result, width));
+          return;
+        }
+        const slash = parseSlash(trimmed);
+        if (slash) {
+          const reply = await this.deps.onSlash(slash.cmd, slash.args);
+          if (reply) {
+            const turn = {
+              messageID: `slash-${Date.now()}`,
+              role: "assistant",
+              done: true,
+              parts: [{ id: `${Date.now()}`, type: "text", text: reply }]
+            };
+            for (const p of turn.parts) this.transcript.addChild(buildBlock(p, turn, this.display, () => this.deps.tui.requestRender()));
+            this.deps.tui.requestRender();
+          }
+          return;
+        }
+        await this.deps.store.send(trimmed);
+        this.refreshTranscript();
+      }
+      addLocalLines(lines) {
+        const block = new RawLines(lines);
+        this.localBlocks.push(block);
+        this.transcript.addChild(block);
+        this.deps.tui.requestRender();
+      }
+      /** store.onChange 回调：增量挂新 turn/新 part；流式快照替换；pending 移除。 */
+      refreshTranscript() {
+        const turns = this.deps.store.turns;
+        for (let i = 0; i < this.rendered.length && i < turns.length; i++) {
+          const r = this.rendered[i];
+          if (r.queued && !turns[i].queued) {
+            this.rebuild();
+            return;
+          }
+        }
+        while (this.rendered.length < turns.length) {
+          const t = turns[this.rendered.length];
+          const entry2 = { messageID: t.messageID, blocks: [], queued: t.queued };
+          for (const p of t.parts) entry2.blocks.push(this.mkBlock(p, t));
+          if (t.role === "assistant" && !t.done) entry2.pending = new PendingBlock();
+          for (const b of entry2.blocks) this.transcript.addChild(b);
+          if (entry2.pending) this.transcript.addChild(entry2.pending);
+          this.rendered.push(entry2);
+        }
+        const last = turns.at(-1);
+        const entry = this.rendered.at(-1);
+        if (!last || !entry || entry.messageID !== last.messageID) {
+          this.deps.tui.requestRender();
+          return;
+        }
+        while (entry.blocks.length < last.parts.length) {
+          const p = last.parts[entry.blocks.length];
+          const b = this.mkBlock(p, last);
+          entry.blocks.push(b);
+          if (entry.pending) this.transcript.removeChild(entry.pending);
+          this.transcript.addChild(b);
+          if (entry.pending) this.transcript.addChild(entry.pending);
+        }
+        for (let j = 0; j < entry.blocks.length; j++) entry.blocks[j].update(last.parts[j]);
+        if (entry.pending && last.done) {
+          this.transcript.removeChild(entry.pending);
+          entry.pending = void 0;
+        }
+        this.deps.tui.requestRender();
+      }
+      /** 滚动 transcript 使目标 turn 位于视口顶部（搜索跳转用）。 */
+      scrollToTurn(messageID) {
+        const entry = this.rendered.find((e) => e.messageID === messageID);
+        if (!entry || entry.blocks.length === 0) return false;
+        const first = entry.blocks[0];
+        const idx = this.transcript.children.indexOf(first);
+        if (idx < 0) return false;
+        const width = this.deps.tui.terminal?.columns ?? 80;
+        let lines = 0;
+        for (let i = 0; i < idx; i++) lines += this.transcript.children[i].render(width).length;
+        this.scrollView.scrollTo(Math.max(0, lines - 1));
+        return true;
+      }
+      mkBlock(p, t) {
+        return buildBlock(p, t, this.display, () => this.deps.tui.requestRender());
+      }
+      /** /verbose 循环：all（默认展开）↔ off（默认折叠，单击仍可展开）。 */
+      cycleVerbosity() {
+        this.display.toolVerbosity = this.display.toolVerbosity === "all" ? "off" : "all";
+        if (!this.display.focus) this.savedVerbosity = this.display.toolVerbosity;
+        this.invalidateAll();
+        return this.display.toolVerbosity;
+      }
+      /** /focus 静视图（Hermes 语义：开时收起 tool 输出并记住，关时恢复）。 */
+      toggleFocus() {
+        if (this.display.focus) {
+          this.display.focus = false;
+          this.display.toolVerbosity = this.savedVerbosity;
+        } else {
+          this.display.focus = true;
+          this.savedVerbosity = this.display.toolVerbosity;
+          this.display.toolVerbosity = "off";
+        }
+        this.invalidateAll();
+        return this.display.focus;
+      }
+      invalidateAll() {
+        for (const e of this.rendered) for (const b of e.blocks) b.invalidate();
+        this.deps.tui.requestRender();
+      }
+    };
+  }
+});
+
+// src/ui/slash-commands.ts
+function createSlashHandler(deps) {
+  return async (rawCmd, args) => {
+    const cmd = resolveCommand(rawCmd) ?? rawCmd;
+    switch (cmd) {
+      case "help":
+        deps.toggleHelp();
+        return null;
+      case "older":
+        await deps.loadOlder();
+        return null;
+      case "verbose":
+        return `\u5DE5\u5177\u8F93\u51FA: ${deps.cycleVerbosity() === "all" ? "\u5C55\u5F00" : "\u6298\u53E0"}\uFF08\u5355\u51FB tool \u5757\u53EF\u5355\u72EC\u5207\u6362\uFF09`;
+      case "focus":
+        return deps.toggleFocus() ? "\u9759\u89C6\u56FE\u5DF2\u5F00\u542F\uFF08/focus off \u6062\u590D\uFF09" : "\u9759\u89C6\u56FE\u5DF2\u5173\u95ED";
+      case "diff":
+        return deps.showDiff(args.trim());
+      case "new":
+        return deps.rotateTopic();
+      case "btw":
+        return deps.btw(args);
+      case "sessions":
+        await deps.showSessionPicker();
+        return null;
+      case "rename":
+        return deps.rename(args);
+      case "fork":
+        return deps.fork();
+      case "status":
+        deps.showStatusRecap();
+        return null;
+      case "queue":
+        await deps.showQueueManager();
+        return null;
+      case "model":
+        await deps.showModelPicker();
+        return null;
+      case "compact":
+        return deps.compact();
+      case "undo":
+        return deps.undo();
+      case "redo":
+        return deps.redo();
+      case "editor":
+        await deps.openExternalEditor();
+        return null;
+      default:
+        return `\u672A\u77E5\u547D\u4EE4 /${rawCmd}\uFF08\u53EF\u7528: ${COMMAND_REGISTRY.map((c) => `/${c.name}`).join(" ")}\uFF09`;
+    }
+  };
+}
+var init_slash_commands = __esm({
+  "src/ui/slash-commands.ts"() {
+    "use strict";
+    init_command_registry();
+  }
+});
+
+// src/external-editor.ts
+import { spawn } from "node:child_process";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+function defaultEditorCommand(env = process.env, platform = process.platform) {
+  return env.VISUAL || env.EDITOR || (platform === "win32" ? "notepad" : "nano");
+}
+async function editInExternalEditor(opts) {
+  const directory = mkdtempSync(join(tmpdir(), "mafw-tui-editor-"));
+  const filePath = join(directory, "prompt.md");
+  try {
+    writeFileSync(filePath, opts.content, "utf-8");
+    const [editor, ...editorArgs] = opts.command.split(" ").filter(Boolean);
+    const spawnFn = opts.spawnFn ?? ((ed, args, o) => spawn(ed, args, o));
+    const exitCode = await new Promise((resolve) => {
+      const child = spawnFn(editor, [...editorArgs, filePath], {
+        stdio: "inherit",
+        shell: process.platform === "win32"
+      });
+      child.on("error", () => resolve(null));
+      child.on("close", (code) => resolve(code));
+    });
+    if (exitCode !== 0) return { status: "failed" };
+    return { status: "complete", content: readFileSync(filePath, "utf-8").replace(/\n$/, "") };
+  } finally {
+    try {
+      rmSync(directory, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+var init_external_editor = __esm({
+  "src/external-editor.ts"() {
+    "use strict";
+  }
+});
+
+// src/ui/clickable-tui.ts
+function enableClickDispatch(tui) {
+  const self = tui;
+  if (typeof self.handleSelectionMouseEvent !== "function") return;
+  const original = self.handleSelectionMouseEvent.bind(tui);
+  self.handleSelectionMouseEvent = (event) => {
+    if (!event.release && (event.button & 3) === 0 && (event.button & 32) === 0) {
+      if (dispatchClick(tui, event.x, event.y)) return;
+    }
+    original(event);
+  };
+}
+function dispatchClick(tui, x, y) {
+  try {
+    const self = tui;
+    const top = typeof self.getTopmostVisibleOverlay === "function" ? self.getTopmostVisibleOverlay() : void 0;
+    if (top) return dispatchOverlayClick(tui, top, x, y);
+    return dispatchLayoutClick(tui, x, y);
+  } catch {
+    return false;
+  }
+}
+function dispatchOverlayClick(tui, entry, x, y) {
+  const self = tui;
+  const resolve = self.resolveOverlayLayout;
+  if (typeof resolve !== "function") return false;
+  const termWidth = tui.terminal.columns;
+  const termHeight = tui.terminal.rows;
+  const { width, maxHeight } = resolve.call(tui, entry.options, 0, termWidth, termHeight);
+  let lines = entry.component?.render(width) ?? [];
+  if (maxHeight !== void 0 && lines.length > maxHeight) lines = lines.slice(0, maxHeight);
+  const { row, col } = resolve.call(tui, entry.options, lines.length, termWidth, termHeight);
+  if (x >= col && x < col + width && y >= row && y < row + lines.length) {
+    const comp = entry.component;
+    if (comp && typeof comp.handleMouseClick === "function") {
+      return comp.handleMouseClick(x - col, y - row) === true;
+    }
+  }
+  return true;
+}
+function dispatchLayoutClick(tui, x, y) {
+  const root = tui.currentLayout?.root;
+  if (!root) return false;
+  const hits = [];
+  const visit = (box, depth) => {
+    const r = box?.rect;
+    if (r && x >= r.x && x < r.x + r.width && y >= r.y && y < r.y + r.height && box.component) {
+      hits.push({ comp: box.component, rect: r, depth });
+    }
+    for (const child of box?.children ?? []) visit(child, depth + 1);
+  };
+  visit(root, 0);
+  hits.sort((a, b) => b.depth - a.depth);
+  for (const hit of hits) {
+    const comp = hit.comp;
+    if (typeof comp.handleMouseClick === "function") {
+      if (comp.handleMouseClick(x - hit.rect.x, y - hit.rect.y) === true) return true;
+    }
+  }
+  return false;
+}
+var init_clickable_tui = __esm({
+  "src/ui/clickable-tui.ts"() {
+    "use strict";
+  }
+});
+
+// src/ui/clickable-select-list.ts
+var ClickableSelectList, HeaderSelectOverlay;
+var init_clickable_select_list = __esm({
+  "src/ui/clickable-select-list.ts"() {
+    "use strict";
+    ClickableSelectList = class {
+      /** 被包装的 SelectList（公开只读：调用方挂 onSelect/onCancel 用）。 */
+      list;
+      constructor(list) {
+        this.list = list;
+      }
+      render(width) {
+        return this.list.render(width);
+      }
+      invalidate() {
+        this.list.invalidate();
+      }
+      handleInput(data) {
+        this.list.handleInput(data);
+      }
+      handleMouseClick(_col, row) {
+        const items = this.list.filteredItems;
+        if (!Array.isArray(items) || items.length === 0) return false;
+        const selectedIndex = this.list.selectedIndex;
+        const maxVisible = this.list.maxVisible;
+        const start = Math.max(0, Math.min(selectedIndex - Math.floor(maxVisible / 2), items.length - maxVisible));
+        const visible = Math.min(maxVisible, items.length - start);
+        if (row < 0 || row >= visible) return false;
+        const item = items[start + row];
+        if (!item) return false;
+        this.list.setSelectedIndex(start + row);
+        this.list.onSelect?.(item);
+        return true;
+      }
+    };
+    HeaderSelectOverlay = class {
+      header;
+      wrapper;
+      headerLines = 1;
+      constructor(header, list) {
+        this.header = header;
+        this.wrapper = new ClickableSelectList(list);
+      }
+      render(width) {
+        const head = this.header.render(width);
+        this.headerLines = head.length;
+        return [...head, ...this.wrapper.render(width)];
+      }
+      invalidate() {
+        this.header.invalidate();
+        this.wrapper.invalidate();
+      }
+      handleInput(data) {
+        this.wrapper.handleInput(data);
+      }
+      handleMouseClick(col, row) {
+        return this.wrapper.handleMouseClick(col, row - this.headerLines);
+      }
+    };
+  }
+});
+
+// src/ui/keymap.ts
+import { matchesKey, Key } from "@earendil-works/pi-tui";
+function dispatchKey(data, ctx) {
+  ctx.interaction.update({
+    overlayOpen: ctx.queries.overlayOpen(),
+    streaming: ctx.queries.streaming()
+  });
+  for (const b of BINDINGS) {
+    if (b.match(data) && b.when(ctx)) {
+      b.invoke(ctx);
+      return true;
+    }
+  }
+  return false;
+}
+var TAB_IDS, ALT_DIGITS, BINDINGS;
+var init_keymap = __esm({
+  "src/ui/keymap.ts"() {
+    "use strict";
+    TAB_IDS = ["chat", "goals", "memory", "triage"];
+    ALT_DIGITS = [Key.alt("1"), Key.alt("2"), Key.alt("3"), Key.alt("4")];
+    BINDINGS = [
+      {
+        invoke: (ctx) => ctx.actions.quit(),
+        match: (d) => matchesKey(d, Key.ctrl("c")),
+        when: () => true
+      },
+      {
+        invoke: (ctx) => ctx.actions.abortTurn(),
+        match: (d) => matchesKey(d, Key.escape),
+        when: (ctx) => ctx.interaction.is("busy")
+      },
+      {
+        invoke: (ctx) => ctx.actions.blurMemorySearch(),
+        match: (d) => matchesKey(d, Key.escape),
+        when: (ctx) => ctx.queries.activeTab() === "memory" && ctx.queries.memoryInputFocused()
+      },
+      {
+        invoke: (ctx) => ctx.actions.openExternalEditor(),
+        match: (d) => matchesKey(d, Key.ctrl("g")),
+        when: (ctx) => ctx.queries.activeTab() === "chat" && ctx.queries.editing() && !ctx.queries.overlayOpen()
+      },
+      ...TAB_IDS.map((id, i) => ({
+        invoke: (ctx) => ctx.actions.switchTab(id),
+        match: (d) => d === String(i + 1),
+        when: (ctx) => !ctx.queries.editing()
+      })),
+      ...TAB_IDS.map((id, i) => ({
+        invoke: (ctx) => ctx.actions.switchTab(id),
+        match: (d) => matchesKey(d, ALT_DIGITS[i]),
+        when: () => true
+      })),
+      {
+        invoke: (ctx) => ctx.actions.openTranscriptSearch(),
+        match: (d) => matchesKey(d, Key.ctrl("o")),
+        when: (ctx) => ctx.queries.activeTab() === "chat" && !ctx.queries.overlayOpen()
+      },
+      {
+        invoke: (ctx) => ctx.actions.quit(),
+        match: (d) => d === "q",
+        when: (ctx) => !ctx.queries.editing()
+      },
+      {
+        invoke: (ctx) => ctx.actions.toggleHelp(),
+        match: (d) => d === "?",
+        when: (ctx) => !ctx.queries.editing()
+      }
+    ];
+  }
+});
+
+// src/ui/interaction-state.ts
+var InteractionStateMachine;
+var init_interaction_state = __esm({
+  "src/ui/interaction-state.ts"() {
+    "use strict";
+    InteractionStateMachine = class {
+      mode = "prompt";
+      onChange;
+      /** 由原始输入派生模式（transcript 态由显式 enter/exit 管理，update 不覆盖）。 */
+      update(inputs) {
+        if (this.mode === "transcript") return this.mode;
+        const next = inputs.overlayOpen ? "overlay" : inputs.streaming ? "busy" : "prompt";
+        this.setMode(next);
+        return this.mode;
+      }
+      enterTranscript() {
+        this.setMode("transcript");
+      }
+      exitTranscript() {
+        this.setMode("prompt");
+      }
+      is(m) {
+        return this.mode === m;
+      }
+      setMode(next) {
+        if (this.mode === next) return;
+        this.mode = next;
+        this.onChange?.(next);
+      }
+    };
+  }
+});
+
+// src/ui/queue-overlay.ts
+import { truncateToWidth as truncateToWidth6 } from "@earendil-works/pi-tui";
+var QueueOverlay;
+var init_queue_overlay = __esm({
+  "src/ui/queue-overlay.ts"() {
+    "use strict";
+    init_theme();
+    QueueOverlay = class {
+      selected = 0;
+      deps;
+      constructor(deps) {
+        this.deps = deps;
+      }
+      invalidate() {
+      }
+      render(width) {
+        const items = this.deps.getItems();
+        const lines = [theme.accent("\u6392\u961F\u6D88\u606F"), ""];
+        if (items.length === 0) {
+          lines.push(theme.dim("  \uFF08\u961F\u5217\u4E3A\u7A7A\u2014\u2014busy \u671F\u95F4\u53D1\u9001\u7684\u6D88\u606F\u4F1A\u6392\u961F\uFF09"));
+          lines.push("");
+          lines.push(theme.dim("  Esc \u5173\u95ED"));
+          return lines;
+        }
+        items.forEach((text, i) => {
+          const mark = i === this.selected ? theme.accent("\u203A ") : "  ";
+          const preview = text.length > 60 ? `${text.slice(0, 57)}...` : text;
+          lines.push(truncateToWidth6(`${mark}${i + 1}. ${preview}`, width));
+        });
+        lines.push("");
+        lines.push(theme.dim("  Enter \u6536\u56DE\u7F16\u8F91 \xB7 d \u4E22\u5F03 \xB7 Esc \u5173\u95ED"));
+        return lines;
+      }
+      handleInput(data) {
+        const items = this.deps.getItems();
+        if (items.length === 0) {
+          this.deps.onClose();
+          return;
+        }
+        if (data === "j" || data === "\x1B[B") {
+          this.selected = Math.min(items.length - 1, this.selected + 1);
+          this.deps.requestRender();
+          return;
+        }
+        if (data === "k" || data === "\x1B[A") {
+          this.selected = Math.max(0, this.selected - 1);
+          this.deps.requestRender();
+          return;
+        }
+        if (data === "\r" || data === "\n") {
+          this.deps.onTakeBack(this.selected);
+          this.deps.onClose();
+          return;
+        }
+        if (data === "d") {
+          this.deps.onDrop(this.selected);
+          this.selected = Math.min(this.selected, Math.max(0, this.deps.getItems().length - 1));
+          return;
+        }
+        if (data === "\x1B" || data === "") {
+          this.deps.onClose();
+          return;
+        }
+      }
+    };
+  }
+});
+
+// src/ui/transcript-search.ts
+import { truncateToWidth as truncateToWidth7 } from "@earendil-works/pi-tui";
+var stripAnsi3, MAX_RESULTS, SNIPPET_WIDTH, TranscriptSearchOverlay;
+var init_transcript_search = __esm({
+  "src/ui/transcript-search.ts"() {
+    "use strict";
+    init_theme();
+    stripAnsi3 = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
+    MAX_RESULTS = 8;
+    SNIPPET_WIDTH = 56;
+    TranscriptSearchOverlay = class {
+      query = "";
+      selected = 0;
+      deps;
+      constructor(deps) {
+        this.deps = deps;
+      }
+      invalidate() {
+      }
+      matches() {
+        const q = this.query.trim().toLowerCase();
+        if (!q) return [];
+        const out = [];
+        const turns = this.deps.getTurns();
+        for (let i = 0; i < turns.length && out.length < MAX_RESULTS; i++) {
+          const t = turns[i];
+          for (const p of t.parts) {
+            if (p.type === "tool") continue;
+            const text = stripAnsi3(p.text);
+            const at = text.toLowerCase().indexOf(q);
+            if (at < 0) continue;
+            const start = Math.max(0, at - 12);
+            const snippet = `${start > 0 ? "\u2026" : ""}${text.slice(start, start + SNIPPET_WIDTH).replace(/\n/g, " ")}`;
+            out.push({ turnIndex: i, role: t.role, snippet });
+            break;
+          }
+        }
+        return out;
+      }
+      render(width) {
+        const lines = [];
+        lines.push(truncateToWidth7(`${theme.accent("\u641C\u7D22: ")}${this.query}${theme.dim("\u258F")}`, width));
+        const ms = this.matches();
+        if (this.query.trim() === "") {
+          lines.push(theme.dim("  \u8F93\u5165\u5173\u952E\u8BCD\u8FC7\u6EE4\u4F1A\u8BDD\u5185\u5BB9"));
+        } else if (ms.length === 0) {
+          lines.push(theme.dim("  \u65E0\u5339\u914D"));
+        } else {
+          ms.forEach((m, i) => {
+            const mark = i === this.selected ? theme.accent("\u203A ") : "  ";
+            const role = m.role === "user" ? theme.accent("\u4F60") : theme.dim("AI");
+            lines.push(truncateToWidth7(`${mark}${role} ${theme.dim(m.snippet)}`, width));
+          });
+        }
+        lines.push(theme.dim("  \u2191/\u2193 \u9009\u62E9 \xB7 Enter \u8DF3\u8F6C \xB7 Esc \u5173\u95ED"));
+        return lines;
+      }
+      handleInput(data) {
+        if (data === "\x1B" || data === "") {
+          this.deps.onClose();
+          return;
+        }
+        if (data === "\r" || data === "\n") {
+          const ms = this.matches();
+          const m = ms[this.selected];
+          if (m) this.deps.onJump(m.turnIndex);
+          this.deps.onClose();
+          return;
+        }
+        if (data === "\x1B[A" || data === "k") {
+          this.selected = Math.max(0, this.selected - 1);
+          this.deps.requestRender();
+          return;
+        }
+        if (data === "\x1B[B" || data === "j") {
+          this.selected = Math.min(this.matches().length - 1, this.selected + 1);
+          this.deps.requestRender();
+          return;
+        }
+        if (data === "\x7F" || data === "\b") {
+          this.query = this.query.slice(0, -1);
+          this.selected = 0;
+          this.deps.requestRender();
+          return;
+        }
+        if (data.length === 1 && data >= " ") {
+          this.query += data;
+          this.selected = 0;
+          this.deps.requestRender();
+          return;
+        }
+      }
+    };
+  }
+});
+
+// src/ui/confirm-overlay.ts
+import { truncateToWidth as truncateToWidth8 } from "@earendil-works/pi-tui";
+var ConfirmOverlay;
+var init_confirm_overlay = __esm({
+  "src/ui/confirm-overlay.ts"() {
+    "use strict";
+    init_theme();
+    ConfirmOverlay = class {
+      selected = 0;
+      deps;
+      constructor(deps) {
+        this.deps = deps;
+      }
+      invalidate() {
+      }
+      options() {
+        return [
+          { key: "once", label: "\u672C\u6B21\u6267\u884C" },
+          { key: "always", label: "\u672C\u4F1A\u8BDD\u603B\u662F\u6267\u884C" },
+          { key: "cancel", label: "\u53D6\u6D88" }
+        ];
+      }
+      render(width) {
+        const lines = [truncateToWidth8(theme.warn(this.deps.title), width)];
+        if (this.deps.description) lines.push(truncateToWidth8(theme.dim(this.deps.description), width));
+        lines.push("");
+        this.options().forEach((o, i) => {
+          const mark = i === this.selected ? theme.accent("\u203A ") : "  ";
+          lines.push(truncateToWidth8(`${mark}${o.label}`, width));
+        });
+        lines.push("");
+        lines.push(theme.dim("  Enter \u6267\u884C \xB7 l \u603B\u662F \xB7 d \u53D6\u6D88 \xB7 j/k \u9009\u62E9"));
+        return lines;
+      }
+      handleInput(data) {
+        const opts = this.options();
+        if (data === "\r" || data === "\n") {
+          this.deps.onAnswer(opts[this.selected].key);
+          return;
+        }
+        if (data === "l") {
+          this.deps.onAnswer("always");
+          return;
+        }
+        if (data === "d" || data === "c" || data === "\x1B" || data === "") {
+          this.deps.onAnswer("cancel");
+          return;
+        }
+        if (data === "j" || data === "\x1B[B") {
+          this.selected = Math.min(opts.length - 1, this.selected + 1);
+          this.deps.requestRender();
+          return;
+        }
+        if (data === "k" || data === "\x1B[A") {
+          this.selected = Math.max(0, this.selected - 1);
+          this.deps.requestRender();
+        }
+      }
+    };
+  }
+});
+
+// src/ui/session-recap.ts
+import { truncateToWidth as truncateToWidth9 } from "@earendil-works/pi-tui";
+function computeRecap(turns) {
+  let userTurns = 0;
+  let assistantTurns = 0;
+  let toolCalls = 0;
+  const toolCounts = /* @__PURE__ */ new Map();
+  let lastUserPrompt = null;
+  let lastAssistantText = null;
+  for (const t of turns) {
+    if (t.queued) continue;
+    if (t.role === "user") {
+      userTurns++;
+      const text = t.parts.find((p) => p.type === "text")?.text;
+      if (text) lastUserPrompt = stripAnsi4(text);
+    } else {
+      assistantTurns++;
+      const text = t.parts.filter((p) => p.type === "text").map((p) => p.text).join("\n").trim();
+      if (text) lastAssistantText = stripAnsi4(text);
+      for (const p of t.parts) {
+        if (p.type !== "tool") continue;
+        toolCalls++;
+        const name = p.toolName ?? "tool";
+        toolCounts.set(name, (toolCounts.get(name) ?? 0) + 1);
+      }
+    }
+  }
+  const topTools = [...toolCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3);
+  return { userTurns, assistantTurns, toolCalls, topTools, lastUserPrompt, lastAssistantText };
+}
+function recapLines(recap, sessionID, project) {
+  const lines = [];
+  lines.push(theme.accent("\u4F1A\u8BDD\u72B6\u6001"));
+  lines.push(theme.dim(`  ${project} \xB7 ${sessionID.slice(0, 16)}`));
+  lines.push("");
+  lines.push("\u8F6E\u6B21");
+  lines.push(theme.dim(`  user ${recap.userTurns} \xB7 assistant ${recap.assistantTurns} \xB7 \u5DE5\u5177\u8C03\u7528 ${recap.toolCalls}`));
+  if (recap.topTools.length > 0) {
+    lines.push(theme.dim(`  top: ${recap.topTools.map(([n, c]) => `${n}\xD7${c}`).join(" ")}`));
+  }
+  lines.push("");
+  lines.push("\u6700\u8FD1\u4EA4\u4E92");
+  lines.push(truncateToWidth9(theme.dim(`  \u4F60: ${recap.lastUserPrompt ?? "\uFF08\u65E0\uFF09"}`), 78));
+  lines.push(truncateToWidth9(theme.dim(`  AI: ${recap.lastAssistantText ? trunc(recap.lastAssistantText, 100) : "\uFF08\u65E0\uFF09"}`), 78));
+  return lines;
+}
+var stripAnsi4, trunc;
+var init_session_recap = __esm({
+  "src/ui/session-recap.ts"() {
+    "use strict";
+    init_theme();
+    stripAnsi4 = (s) => s.replace(/\x1b\[[0-9;]*m/g, "");
+    trunc = (s, n) => s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
+  }
+});
+
+// src/ui/overlays.ts
+import { Text, SelectList } from "@earendil-works/pi-tui";
+function permissionSummary(req) {
+  const patterns = req.patterns.length > 0 ? req.patterns.join(", ") : "(\u65E0 patterns)";
+  return `${req.permission}: ${patterns}`;
+}
+function permissionToItems() {
+  return [
+    { value: "once", label: "\u5141\u8BB8\u4E00\u6B21", description: "\u4EC5\u672C\u6B21" },
+    { value: "always", label: "\u603B\u662F\u5141\u8BB8", description: "\u672C\u4F1A\u8BDD\u5185" },
+    { value: "reject", label: "\u62D2\u7EDD", description: "\u62D2\u7EDD\u6B64\u8BF7\u6C42" }
+  ];
+}
+function showPermissionOverlay(tui, req, reply) {
+  const list = new SelectList(permissionToItems(), 3, selectListTheme);
+  const overlay = new HeaderSelectOverlay(
+    new Text(theme.warn("\u6743\u9650\u8BF7\u6C42") + "  " + permissionSummary(req), 1, 1),
+    list
+  );
+  const handle = tui.showOverlay(overlay, { width: "70%", maxHeight: 10, anchor: "center" });
+  const done = () => handle.hide();
+  list.onSelect = (item) => {
+    void reply(item.value).catch(() => {
+    }).finally(done);
+  };
+  list.onCancel = done;
+  return handle;
+}
+var init_overlays = __esm({
+  "src/ui/overlays.ts"() {
+    "use strict";
+    init_theme();
+    init_chat_tab();
+    init_clickable_select_list();
+  }
+});
+
+// src/store/goals-store.ts
+var TERMINAL_PHASES, GoalsStore;
+var init_goals_store = __esm({
+  "src/store/goals-store.ts"() {
+    "use strict";
+    TERMINAL_PHASES = ["COMPLETED", "FAILED", "ARCHIVED", "CANCELLED"];
+    GoalsStore = class _GoalsStore {
+      rows = [];
+      questions = [];
+      stopped = false;
+      cleanup;
+      schedule;
+      deps;
+      constructor(deps) {
+        this.deps = deps;
+        this.schedule = deps.schedule ?? ((fn, ms) => {
+          const t = setInterval(fn, ms);
+          return () => clearInterval(t);
+        });
+      }
+      static isActive(g) {
+        return !TERMINAL_PHASES.includes(g.phase);
+      }
+      start() {
+        this.stopped = false;
+        void this.poll();
+        this.cleanup = this.schedule(() => {
+          if (!this.stopped) void this.poll();
+        }, 1e4);
+      }
+      stop() {
+        this.stopped = true;
+        this.cleanup?.();
+      }
+      async poll() {
+        try {
+          const [goals, questions] = await Promise.all([
+            this.deps.goals.list(),
+            this.deps.questions.list().catch(() => [])
+          ]);
+          this.rows.length = 0;
+          const rows = [...goals];
+          rows.sort((a, b) => Number(_GoalsStore.isActive(b)) - Number(_GoalsStore.isActive(a)));
+          this.rows.push(...rows);
+          this.questions.length = 0;
+          this.questions.push(...questions);
+          this.deps.onChange();
+        } catch {
+        }
+      }
+    };
+  }
+});
+
+// src/ui/goals-tab.ts
+import {
+  Text as Text2,
+  SelectList as SelectList2,
+  matchesKey as matchesKey2,
+  Key as Key2,
+  truncateToWidth as truncateToWidth10
+} from "@earendil-works/pi-tui";
+function formatGoalSessions(sessions) {
+  if (sessions.length === 0) return [theme.dim("  \uFF08\u65E0 session \u8BB0\u5F55\uFF09")];
+  return sessions.map((s) => `${theme.accent("\u203A")} ${s.phase} \xB7 loop ${s.loop}${s.title ? theme.dim(` \xB7 ${s.title}`) : ""} ${theme.dim(s.sessionID)}`);
+}
+function escCloser(tui, close) {
+  const off = tui.addInputListener((data) => {
+    if (matchesKey2(data, Key2.escape)) {
+      off();
+      close();
+      return { consume: true };
+    }
+    return void 0;
+  });
+  return off;
+}
+var GoalsTab;
+var init_goals_tab = __esm({
+  "src/ui/goals-tab.ts"() {
+    "use strict";
+    init_goals_store();
+    init_chat_store();
+    init_message_blocks();
+    init_theme();
+    init_chat_tab();
+    init_clickable_select_list();
+    GoalsTab = class {
+      selected = 0;
+      deps;
+      constructor(deps) {
+        this.deps = deps;
+      }
+      invalidate() {
+      }
+      get rowCount() {
+        return this.deps.store.rows.length;
+      }
+      get questionCount() {
+        return this.deps.store.questions.length;
+      }
+      get totalSelectable() {
+        return this.rowCount + this.questionCount;
+      }
+      render(width) {
+        const { store } = this.deps;
+        const lines = [];
+        const active = store.rows.filter(GoalsStore.isActive).length;
+        lines.push(truncateToWidth10(
+          theme.accent(`Goals `) + theme.dim(`${active} active / ${store.rows.length} total \xB7 Enter \u8BE6\u60C5 \xB7 x \u53D6\u6D88`),
+          width
+        ));
+        if (store.rows.length === 0) lines.push(theme.dim("  \uFF08\u65E0 goal\uFF09"));
+        store.rows.forEach((g, i) => {
+          const mark = GoalsStore.isActive(g) ? theme.ok("\u25CF") : theme.dim("\u25CB");
+          const qMark = i === this.selected ? theme.accent("\u203A ") : "  ";
+          const line = `${qMark}${mark} ${g.goalId} ${theme.dim(`\xB7 ${g.phase} \xB7 loop ${g.loop} \xB7 wave ${g.currentWave}/${g.totalWaves}`)}`;
+          lines.push(truncateToWidth10(line, width));
+        });
+        if (store.questions.length > 0) {
+          lines.push("");
+          lines.push(truncateToWidth10(theme.warn(`? \u5F85\u51B3\u95EE\u7B54 (${store.questions.length}) \xB7 Enter \u4F5C\u7B54`), width));
+          store.questions.forEach((q, i) => {
+            const idx = this.rowCount + i;
+            const qMark = idx === this.selected ? theme.accent("\u203A ") : "  ";
+            const text = q.questions[0]?.question ?? q.id;
+            lines.push(truncateToWidth10(`${qMark}${theme.warn("?")} ${text}`, width));
+          });
+        }
+        return lines;
+      }
+      /** 鼠标点击行选中（Enter 仍负责激活；行映射与 render 同构：header/空行/header 不可点）。 */
+      handleMouseClick(_col, row) {
+        const goalsRows = this.rowCount;
+        if (goalsRows > 0 && row >= 1 && row <= goalsRows) {
+          this.selected = row - 1;
+          this.deps.tui.requestRender();
+          return true;
+        }
+        if (this.questionCount > 0) {
+          const qStart = 1 + Math.max(goalsRows, 1) + 2;
+          if (row >= qStart && row < qStart + this.questionCount) {
+            this.selected = goalsRows + (row - qStart);
+            this.deps.tui.requestRender();
+            return true;
+          }
+        }
+        return false;
+      }
+      /** 返回 true 表示按键已消费（app 层据此不再转发）。 */
+      handleTabKey(data) {
+        if (matchesKey2(data, Key2.up)) {
+          this.selected = Math.max(0, this.selected - 1);
+          this.deps.tui.requestRender();
+          return true;
+        }
+        if (matchesKey2(data, Key2.down)) {
+          this.selected = Math.min(this.totalSelectable - 1, this.selected + 1);
+          this.deps.tui.requestRender();
+          return true;
+        }
+        if (matchesKey2(data, Key2.enter)) {
+          if (this.selected < this.rowCount) this.openGoalDetail(this.deps.store.rows[this.selected].goalId);
+          else this.openQuestionOverlay(this.deps.store.questions[this.selected - this.rowCount]);
+          return true;
+        }
+        if (data === "x" && this.selected < this.rowCount) {
+          this.confirmAbort(this.deps.store.rows[this.selected].goalId);
+          return true;
+        }
+        return false;
+      }
+      openGoalDetail(goalId) {
+        void this.deps.client.goals.get(goalId).then((g) => {
+          if (!g) return;
+          const body = [
+            `goalId: ${g.goalId}`,
+            `phase:  ${g.phase}`,
+            `loop:   ${g.loop}`,
+            `wave:   ${g.currentWave}/${g.totalWaves}`,
+            g.nextAction ? `next:   ${g.nextAction}` : "",
+            g.updatedAt ? `\u66F4\u65B0:   ${g.updatedAt}` : "",
+            "",
+            theme.dim("s: \u67E5\u770B session \u5217\u8868 \xB7 Esc: \u5173\u95ED")
+          ].filter(Boolean).join("\n");
+          const overlay = this.deps.tui.showOverlay(new Text2(body, 1, 1), { width: 64, maxHeight: 16, anchor: "center" });
+          const close = () => {
+            offKey();
+            offEsc();
+            overlay.hide();
+          };
+          const offEsc = escCloser(this.deps.tui, close);
+          const offKey = this.deps.tui.addInputListener((data) => {
+            if (data === "s") {
+              close();
+              void this.openGoalSessions(goalId);
+              return { consume: true };
+            }
+            return void 0;
+          });
+        });
+      }
+      /** goal → sessions 下钻（编排可视化：plan/execute/review 会话列表）。 */
+      async openGoalSessions(goalId) {
+        let sessions;
+        try {
+          sessions = await this.deps.client.goals.sessions(goalId);
+        } catch (e) {
+          this.deps.setStatus({ hint: theme.err(`sessions \u83B7\u53D6\u5931\u8D25: ${String(e?.message ?? e).slice(0, 60)}`) });
+          return;
+        }
+        if (sessions.length === 0) {
+          const overlay = this.deps.tui.showOverlay(
+            new Text2(`goal ${goalId}
+${formatGoalSessions(sessions).join("\n")}`, 1, 1),
+            { width: 56, maxHeight: 6, anchor: "center" }
+          );
+          const close2 = () => {
+            off2();
+            overlay.hide();
+          };
+          const off2 = escCloser(this.deps.tui, close2);
+          return;
+        }
+        const list = new SelectList2(
+          sessions.map((s) => ({
+            value: s.sessionID,
+            label: `${s.phase} \xB7 loop ${s.loop}`,
+            description: s.title ?? s.sessionID
+          })),
+          Math.min(sessions.length, 8),
+          selectListTheme
+        );
+        const handle = this.deps.tui.showOverlay(new ClickableSelectList(list), { width: "70%", maxHeight: 12, anchor: "center" });
+        const close = () => {
+          off();
+          handle.hide();
+        };
+        const off = escCloser(this.deps.tui, close);
+        list.onSelect = (item) => {
+          close();
+          void this.openTranscript(String(item.value));
+        };
+        list.onCancel = close;
+      }
+      /** 只读 transcript overlay（最近 50 条消息）。 */
+      async openTranscript(sessionID) {
+        let messages;
+        try {
+          const res = await this.deps.client.session.messages({ path: { id: sessionID }, query: { limit: 50 } });
+          messages = res.data ?? [];
+        } catch (e) {
+          this.deps.setStatus({ hint: theme.err(`transcript \u83B7\u53D6\u5931\u8D25: ${String(e?.message ?? e).slice(0, 60)}`) });
+          return;
+        }
+        const turns = historyItemsToTurns(messages);
+        const lines = turns.flatMap((t) => turnToLines(t, 76));
+        const body = lines.length > 0 ? lines.join("\n") : theme.dim("\uFF08\u7A7A\u4F1A\u8BDD\uFF09");
+        const overlay = this.deps.tui.showOverlay(
+          new Text2(`${theme.accent("transcript")} ${theme.dim(sessionID)}
+
+${body}`, 1, 1),
+          { width: "80%", maxHeight: "70%", anchor: "center" }
+        );
+        const close = () => {
+          off();
+          overlay.hide();
+        };
+        const off = escCloser(this.deps.tui, close);
+      }
+      confirmAbort(goalId) {
+        const list = new SelectList2(
+          [{ value: "yes", label: "\u786E\u8BA4\u53D6\u6D88", description: goalId }, { value: "no", label: "\u8FD4\u56DE" }],
+          2,
+          selectListTheme
+        );
+        const handle = this.deps.tui.showOverlay(new ClickableSelectList(list), { width: 44, maxHeight: 6, anchor: "center" });
+        const close = () => {
+          off();
+          handle.hide();
+        };
+        const off = escCloser(this.deps.tui, close);
+        list.onSelect = (item) => {
+          close();
+          if (item.value === "yes") {
+            void this.deps.client.goals.control({ goalId, action: "ABORT" }).then(() => this.deps.setStatus({ hint: theme.ok(`\u5DF2\u53D6\u6D88 ${goalId}`) })).catch((e) => this.deps.setStatus({ hint: theme.err(`\u53D6\u6D88\u5931\u8D25: ${e.message}`) }));
+          }
+        };
+        list.onCancel = close;
+      }
+      openQuestionOverlay(q) {
+        const first = q.questions[0];
+        if (!first) return;
+        if (q.questions.length > 1) {
+          const handle = this.deps.tui.showOverlay(
+            new Text2(theme.warn("\u591A\u95EE\u9898\u8BF7\u6C42") + "\uFF08v1 \u8BF7\u5728\u684C\u9762\u7AEF\u5904\u7406\uFF09\nEsc \u5173\u95ED", 1, 1),
+            { width: 52, maxHeight: 6, anchor: "center" }
+          );
+          const close = () => {
+            off();
+            handle.hide();
+          };
+          const off = escCloser(this.deps.tui, close);
+          return;
+        }
+        const finish = (answer) => {
+          void this.deps.client.questions.reply(q.id, answer).then(() => this.deps.setStatus({ hint: theme.ok("\u5DF2\u56DE\u7B54") })).catch((e) => this.deps.setStatus({ hint: theme.err(`\u56DE\u7B54\u5931\u8D25: ${e.message}`) }));
+        };
+        if (first.options.length > 0) {
+          const list = new SelectList2(
+            first.options.map((o) => ({ value: o.label, label: o.label, description: o.description })),
+            Math.min(first.options.length, 6),
+            selectListTheme
+          );
+          const handle = this.deps.tui.showOverlay(new ClickableSelectList(list), { width: "70%", maxHeight: 12, anchor: "center" });
+          const close = () => {
+            off();
+            handle.hide();
+          };
+          const off = escCloser(this.deps.tui, close);
+          list.onSelect = (item) => {
+            close();
+            finish([[item.value]]);
+          };
+          list.onCancel = close;
+        } else {
+          const overlay = this.deps.tui.showOverlay(
+            new Text2(`${first.question}
+
+\uFF08\u5F00\u653E\u95EE\u9898\u8BF7\u5728\u684C\u9762\u7AEF\u56DE\u7B54\uFF1Br \u62D2\u7EDD\uFF09`, 1, 1),
+            { width: 60, maxHeight: 8, anchor: "center" }
+          );
+          const off = this.deps.tui.addInputListener((data) => {
+            if (data === "r") {
+              off();
+              overlay.hide();
+              void this.deps.client.questions.reject(q.id).catch(() => {
+              });
+              return { consume: true };
+            }
+            if (matchesKey2(data, Key2.escape)) {
+              off();
+              overlay.hide();
+              return { consume: true };
+            }
+            return void 0;
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/store/memory-store.ts
+var MemoryStore;
+var init_memory_store = __esm({
+  "src/store/memory-store.ts"() {
+    "use strict";
+    MemoryStore = class {
+      results = [];
+      sticky = [];
+      budget;
+      deps;
+      retriever;
+      constructor(deps, retriever = "bm25") {
+        this.deps = deps;
+        this.retriever = retriever;
+      }
+      async search(query) {
+        try {
+          const r = await this.deps.memory.search({ query, topK: 20, retriever: this.retriever });
+          this.results.length = 0;
+          this.results.push(...r);
+          this.deps.onChange();
+        } catch (err) {
+          this.deps.onError?.(err?.message ?? String(err));
+        }
+      }
+      async refreshSticky() {
+        try {
+          const s = await this.deps.memory.listSticky();
+          this.sticky.length = 0;
+          this.sticky.push(...s.entries);
+          this.budget = s.budget;
+          this.deps.onChange();
+        } catch (err) {
+          this.deps.onError?.(err?.message ?? String(err));
+        }
+      }
+      async unstick(id) {
+        try {
+          await this.deps.memory.setSticky(id, false);
+        } catch (err) {
+          this.deps.onError?.(err?.message ?? String(err));
+        }
+        await this.refreshSticky();
+      }
+    };
+  }
+});
+
+// src/ui/memory-tab.ts
+import {
+  Container as Container3,
+  Input,
+  Text as Text3,
+  matchesKey as matchesKey3,
+  Key as Key3
+} from "@earendil-works/pi-tui";
+function memoryLine(item, selected) {
+  const mark = selected ? "\u203A " : "  ";
+  return `${mark}[${item.type}] ${item.primary_abstraction} ${theme.dim(`E:${item.energy.toFixed(1)}`)} ${theme.dim(item.id.slice(-6))}`;
+}
+var MemoryTab;
+var init_memory_tab = __esm({
+  "src/ui/memory-tab.ts"() {
+    "use strict";
+    init_theme();
+    MemoryTab = class extends Container3 {
+      searchInput = new Input();
+      list = new Container3();
+      selected = 0;
+      deps;
+      _focused = false;
+      get focused() {
+        return this._focused;
+      }
+      set focused(v) {
+        this._focused = v;
+        this.searchInput.focused = v;
+      }
+      // IME 传播
+      get inputFocused() {
+        return this._focused;
+      }
+      constructor(deps) {
+        super();
+        this.deps = deps;
+        this.searchInput.onSubmit = (text) => {
+          const q = text.trim();
+          if (q) void this.deps.store.search(q);
+        };
+        this.addChild(this.searchInput);
+        this.addChild(this.list);
+        void this.deps.store.refreshSticky();
+        this.refresh();
+      }
+      invalidate() {
+        this.refresh();
+      }
+      get resultCount() {
+        return this.deps.store.results.length;
+      }
+      get stickyCount() {
+        return this.deps.store.sticky.length;
+      }
+      get totalSelectable() {
+        return this.resultCount + this.stickyCount;
+      }
+      /** 由 store.onChange / invalidate 触发：重建列表文本块。 */
+      refresh() {
+        const { store } = this.deps;
+        const lines = [];
+        const budget = store.budget ? `\u{1F4DD} ${store.sticky.length}/${store.budget.max}` : "";
+        lines.push(theme.accent("\u641C\u7D22: ") + (this._focused ? theme.dim("\u8F93\u5165\u540E Enter \u68C0\u7D22 \xB7 Esc \u5230\u5217\u8868") : theme.dim("i \u805A\u7126\u8F93\u5165\u6846")) + theme.dim(`  \xB7  ${budget}`));
+        lines.push(theme.accent(`\u68C0\u7D22\u7ED3\u679C (${store.results.length})`));
+        if (store.results.length === 0) lines.push(theme.dim("  \uFF08\u7A7A\u2014\u2014\u5728\u4E0A\u65B9\u8F93\u5165\u5173\u952E\u8BCD\uFF09"));
+        store.results.forEach((u, i) => lines.push(memoryLine(u, i === this.selected)));
+        if (store.sticky.length > 0) {
+          lines.push("");
+          lines.push(theme.warn(`\u{1F4DD} \u4FBF\u7B7E\u677F (${store.sticky.length}) \xB7 u \u4E0B\u67B6`));
+          store.sticky.forEach((n, i) => {
+            const idx = this.resultCount + i;
+            lines.push(memoryLine(n, idx === this.selected));
+          });
+        }
+        this.list.clear();
+        this.list.addChild(new Text3(lines.join("\n"), 0, 0));
+        this.deps.tui.requestRender();
+      }
+      /** 鼠标点击行选中（Enter 仍负责看全文 / u 下架；行映射与 refresh() 同构）。 */
+      handleMouseClick(_col, row) {
+        const rc = this.resultCount;
+        if (rc > 0 && row >= 2 && row < 2 + rc) {
+          this.selected = row - 2;
+          this.refresh();
+          return true;
+        }
+        const sc = this.stickyCount;
+        if (sc > 0) {
+          const stickyStart = 2 + Math.max(rc, 1) + 2;
+          if (row >= stickyStart && row < stickyStart + sc) {
+            this.selected = rc + (row - stickyStart);
+            this.refresh();
+            return true;
+          }
+        }
+        return false;
+      }
+      /** 列表态按键（Input 聚焦时返回 false 让输入框处理）。 */
+      handleTabKey(data) {
+        if (this._focused) return false;
+        if (matchesKey3(data, Key3.up)) {
+          this.selected = Math.max(0, this.selected - 1);
+          this.refresh();
+          return true;
+        }
+        if (matchesKey3(data, Key3.down)) {
+          this.selected = Math.min(this.totalSelectable - 1, this.selected + 1);
+          this.refresh();
+          return true;
+        }
+        if (matchesKey3(data, Key3.enter)) {
+          const r = this.selected;
+          const s = this.deps.store;
+          if (r < s.results.length) this.showFull(s.results[r]);
+          else if (r - s.results.length < s.sticky.length) this.showFull(s.sticky[r - s.results.length]);
+          return true;
+        }
+        if (data === "u" && this.selected >= this.resultCount && this.selected - this.resultCount < this.stickyCount) {
+          const note = this.deps.store.sticky[this.selected - this.resultCount];
+          if (note) {
+            void this.deps.store.unstick(note.id).then(() => this.deps.setStatus({ hint: theme.ok("\u5DF2\u4E0B\u67B6\u4FBF\u7B7E") }));
+            return true;
+          }
+        }
+        if (data === "i" || data === "/") {
+          this.setSearchFocus(true);
+          return true;
+        }
+        return false;
+      }
+      /** 聚焦/失焦搜索框。 */
+      setSearchFocus(on) {
+        this._focused = on;
+        this.searchInput.focused = on;
+        this.deps.setEditing(on);
+        this.deps.tui.setFocus(on ? this.searchInput : null);
+        this.refresh();
+      }
+      blurSearch() {
+        if (this._focused) this.setSearchFocus(false);
+      }
+      showFull(item) {
+        const body = [
+          `${theme.dim("id:")} ${item.id}  ${theme.dim("type:")} ${item.type}  ${theme.dim("E:")} ${item.energy.toFixed(2)}`,
+          "",
+          item.primary_abstraction,
+          "",
+          item.memory_value || theme.dim("(\u7A7A)")
+        ].join("\n");
+        const overlay = this.deps.tui.showOverlay(new Text3(body, 1, 1), { width: "80%", maxHeight: "70%", anchor: "center" });
+        const close = () => {
+          off();
+          overlay.hide();
+        };
+        const off = this.deps.tui.addInputListener((data) => {
+          if (matchesKey3(data, Key3.escape) || matchesKey3(data, Key3.enter)) {
+            close();
+            return { consume: true };
+          }
+          return void 0;
+        });
+      }
+    };
+  }
+});
+
+// src/store/triage-store.ts
+var TriageStore;
+var init_triage_store = __esm({
+  "src/store/triage-store.ts"() {
+    "use strict";
+    TriageStore = class {
+      approvals = [];
+      items = [];
+      stopped = false;
+      cleanup;
+      schedule;
+      deps;
+      constructor(deps) {
+        this.deps = deps;
+        this.schedule = deps.schedule ?? ((fn, ms) => {
+          const t = setInterval(fn, ms);
+          return () => clearInterval(t);
+        });
+      }
+      start() {
+        this.stopped = false;
+        void this.poll();
+        this.cleanup = this.schedule(() => {
+          if (!this.stopped) void this.poll();
+        }, 1e4);
+      }
+      stop() {
+        this.stopped = true;
+        this.cleanup?.();
+      }
+      async poll() {
+        try {
+          const [a, t] = await Promise.all([this.deps.approvals.list(), this.deps.triage.list()]);
+          this.approvals.length = 0;
+          this.approvals.push(...a);
+          this.items.length = 0;
+          this.items.push(...t);
+          this.deps.onChange();
+        } catch {
+        }
+      }
+      async act(kind, id, action) {
+        if (kind === "approval") {
+          await this.deps.approvals.respond(id, action === "approve" ? "approve" : "reject");
+        } else if (action === "confirm") {
+          await this.deps.triage.confirm(id);
+        } else if (action === "dismiss") {
+          await this.deps.triage.dismiss(id);
+        } else {
+          await this.deps.triage.reject(id);
+        }
+        await this.poll();
+      }
+    };
+  }
+});
+
+// src/ui/triage-tab.ts
+import {
+  Text as Text4,
+  matchesKey as matchesKey4,
+  Key as Key4,
+  truncateToWidth as truncateToWidth11
+} from "@earendil-works/pi-tui";
+var TriageTab;
+var init_triage_tab = __esm({
+  "src/ui/triage-tab.ts"() {
+    "use strict";
+    init_theme();
+    init_chat_tab();
+    TriageTab = class {
+      selected = 0;
+      deps;
+      constructor(deps) {
+        this.deps = deps;
+      }
+      invalidate() {
+      }
+      get approvalCount() {
+        return this.deps.store.approvals.length;
+      }
+      get itemCount() {
+        return this.deps.store.items.length;
+      }
+      get totalSelectable() {
+        return this.approvalCount + this.itemCount;
+      }
+      render(width) {
+        const { store } = this.deps;
+        const lines = [];
+        lines.push(truncateToWidth11(
+          theme.accent("Approvals ") + theme.dim(`${store.approvals.length} pending \xB7 a \u6279\u51C6 \xB7 r \u62D2\u7EDD`),
+          width
+        ));
+        if (store.approvals.length === 0) lines.push(theme.dim("  \uFF08\u65E0\u5F85\u5BA1\u6279\uFF09"));
+        store.approvals.forEach((a, i) => {
+          const mark = i === this.selected ? theme.accent("\u203A ") : "  ";
+          lines.push(truncateToWidth11(`${mark}[A] ${a.question || a.id} ${theme.dim(a.goalId)}`, width));
+        });
+        lines.push("");
+        lines.push(truncateToWidth11(
+          theme.accent("Triage ") + theme.dim(`${store.items.length} items \xB7 c \u786E\u8BA4 \xB7 r \u62D2\u7EDD \xB7 d \u5FFD\u7565`),
+          width
+        ));
+        if (store.items.length === 0) lines.push(theme.dim("  \uFF08\u65E0 triage \u9879\uFF09"));
+        store.items.forEach((t, i) => {
+          const idx = this.approvalCount + i;
+          const mark = idx === this.selected ? theme.accent("\u203A ") : "  ";
+          const sev = t.severity === "high" ? theme.err(t.severity) : t.severity === "medium" ? theme.warn(t.severity) : theme.dim(t.severity);
+          lines.push(truncateToWidth11(`${mark}[${sev}] ${t.reason} ${theme.dim(t.goalId)}`, width));
+        });
+        return lines;
+      }
+      /** 鼠标点击行选中（a/r/c/d/Enter 仍负责动作；行映射与 render 同构、占位行不可点）。 */
+      handleMouseClick(_col, row) {
+        if (this.approvalCount > 0 && row >= 1 && row <= this.approvalCount) {
+          this.selected = row - 1;
+          this.deps.tui.requestRender();
+          return true;
+        }
+        const itemCount = this.itemCount;
+        if (itemCount > 0) {
+          const itemsStart = 1 + Math.max(this.approvalCount, 1) + 2;
+          if (row >= itemsStart && row < itemsStart + itemCount) {
+            this.selected = this.approvalCount + (row - itemsStart);
+            this.deps.tui.requestRender();
+            return true;
+          }
+        }
+        return false;
+      }
+      handleTabKey(data) {
+        if (matchesKey4(data, Key4.up)) {
+          this.selected = Math.max(0, this.selected - 1);
+          this.deps.tui.requestRender();
+          return true;
+        }
+        if (matchesKey4(data, Key4.down)) {
+          this.selected = Math.min(this.totalSelectable - 1, this.selected + 1);
+          this.deps.tui.requestRender();
+          return true;
+        }
+        const isApproval = this.selected < this.approvalCount;
+        const kind = isApproval ? "approval" : "triage";
+        const id = isApproval ? this.deps.store.approvals[this.selected]?.id : this.deps.store.items[this.selected - this.approvalCount]?.id;
+        if (!id) return false;
+        let action = null;
+        if (isApproval) {
+          if (data === "a") action = "approve";
+          if (data === "r") action = "reject";
+        } else {
+          if (data === "c") action = "confirm";
+          if (data === "d") action = "dismiss";
+          if (data === "r") action = "reject";
+        }
+        if (action) {
+          this.apply(kind, id, action);
+          return true;
+        }
+        if (matchesKey4(data, Key4.enter)) {
+          this.showDetail(kind, id);
+          return true;
+        }
+        return false;
+      }
+      apply(kind, id, action) {
+        void this.deps.store.act(kind, id, action).then(() => this.deps.setStatus({ hint: theme.ok(`${kind} ${action} \u2713`) })).catch((e) => this.deps.setStatus({ hint: theme.err(`${action} \u5931\u8D25: ${e.message}`) }));
+      }
+      showDetail(kind, id) {
+        const isApproval = kind === "approval";
+        const item = isApproval ? this.deps.store.approvals.find((a) => a.id === id) : this.deps.store.items.find((t) => t.id === id);
+        if (!item) return;
+        const body = isApproval ? `\u7C7B\u578B: approval
+question: ${item.question}
+goalId: ${item.goalId}
+
+a \u6279\u51C6 \xB7 r \u62D2\u7EDD` : `\u7C7B\u578B: triage
+severity: ${item.severity}
+reason: ${item.reason}
+goalId: ${item.goalId}
+
+c \u786E\u8BA4 \xB7 r \u62D2\u7EDD \xB7 d \u5FFD\u7565`;
+        const overlay = this.deps.tui.showOverlay(new Text4(body, 1, 1), { width: 64, maxHeight: 12, anchor: "center" });
+        const close = () => {
+          off();
+          overlay.hide();
+        };
+        const off = this.deps.tui.addInputListener((data) => {
+          if (matchesKey4(data, Key4.escape)) {
+            close();
+            return { consume: true };
+          }
+          if (isApproval && (data === "a" || data === "r")) {
+            close();
+            this.apply("approval", id, data === "a" ? "approve" : "reject");
+            return { consume: true };
+          }
+          if (!isApproval && (data === "c" || data === "r" || data === "d")) {
+            close();
+            this.apply("triage", id, data === "c" ? "confirm" : data === "d" ? "dismiss" : "reject");
+            return { consume: true };
+          }
+          return void 0;
+        });
+        void selectListTheme;
+      }
+    };
+  }
+});
+
+// src/ui/app.ts
+var app_exports = {};
+__export(app_exports, {
+  runApp: () => runApp
+});
+import {
+  ProcessTerminal,
+  TuiAltScreen,
+  VStack as VStack2,
+  Text as Text5,
+  SelectList as SelectList4,
+  matchesKey as matchesKey5,
+  Key as Key5
+} from "@earendil-works/pi-tui";
+import { basename } from "node:path";
+async function runApp(opts) {
+  const client = new import_sdk.MafwClient(opts.baseUrl);
+  const model = new AppModel();
+  const terminal = new ProcessTerminal();
+  const tui = new TuiAltScreen(terminal);
+  enableClickDispatch(tui);
+  const tabStrip = new TabStrip();
+  const statusBar = new StatusBar();
+  const appStart = Date.now();
+  const project = await client.project.current().catch(() => null);
+  const projectDir = project?.worktree ?? null;
+  const projectID = project?.id ?? null;
+  const mgr = !opts.sessionID && projectDir ? await client.manager.session(projectDir).catch(() => null) : null;
+  const managerSessionID = opts.sessionID ?? mgr?.sessionId ?? null;
+  const status = {
+    project: projectDir ? basename(projectDir) : void 0,
+    session: managerSessionID ?? void 0,
+    conn: "ok"
+  };
+  const setStatus = (patch) => {
+    Object.assign(status, patch);
+    statusBar.setState(status);
+    tui.requestRender();
+  };
+  statusBar.setState(status);
+  tabStrip.setConnected(true);
+  let modelSelection = null;
+  let defaultModelLabel = "";
+  void client.providers.list().then((p) => {
+    const d = p?.default;
+    if (d?.modelID) {
+      defaultModelLabel = String(d.modelID);
+      setStatus({ usage: { ...status.usage ?? {}, model: defaultModelLabel } });
+    }
+  }).catch(() => {
+  });
+  const interaction = new InteractionStateMachine();
+  const chatStore = new ChatStore({
+    session: client.session,
+    sessionID: managerSessionID ?? "none",
+    onChange: () => {
+      tui.requestRender();
+      syncInteraction();
+    },
+    onError: (message) => setStatus({ hint: theme.err(`\u26A0 ${message.slice(0, 60)}`) }),
+    getModel: () => modelSelection
+  });
+  const chatTab = new ChatTab({
+    tui,
+    store: chatStore,
+    onSlash: (cmd, args) => handleSlashWithConfirm(cmd, args),
+    onError: (m) => setStatus({ hint: theme.err(`\u26A0 ${m.slice(0, 60)}`) })
+  });
+  const goalsStore = new GoalsStore({
+    goals: client.goals,
+    questions: client.questions,
+    onChange: () => tui.requestRender()
+  });
+  const goalsTab = new GoalsTab({ tui, store: goalsStore, client, setStatus });
+  goalsStore.start();
+  const memoryStore = new MemoryStore({
+    memory: client.memory,
+    onChange: () => memoryTab.refresh(),
+    onError: (m) => setStatus({ hint: theme.err(`\u26A0 ${m.slice(0, 60)}`) })
+  }, opts.retriever);
+  const memoryTab = new MemoryTab({ tui, store: memoryStore, client, setStatus, setEditing: (v) => {
+    model.editing = v;
+  } });
+  const triageStore = new TriageStore({
+    approvals: client.approvals,
+    triage: client.triage,
+    onChange: () => tui.requestRender()
+  });
+  const triageTab = new TriageTab({ tui, store: triageStore, client, setStatus });
+  triageStore.start();
+  let helpHandle = null;
+  function toggleHelp() {
+    if (helpHandle) {
+      helpHandle.hide();
+      helpHandle = null;
+      model.helpVisible = false;
+      applyTab();
+      return;
+    }
+    const body = [
+      "\u5FEB\u6377\u952E",
+      "",
+      "  1-4 / Alt+1-4   \u5207\u6362 Chat / Goals / Memory / Triage",
+      "  q / Ctrl+C      \u9000\u51FA\uFF08\u8F93\u5165\u6001\u5F52\u7F16\u8F91\u5668\uFF09",
+      "  Esc             busy \u65F6\u4E2D\u6B62\u56DE\u5408 / \u5173\u95ED overlay",
+      "  Ctrl+G          \u5916\u90E8\u7F16\u8F91\u5668\u7F16\u8F91\u8F93\u5165\uFF08$EDITOR\uFF09",
+      "  \u2191 / \u2193           \u8F93\u5165\u5386\u53F2\uFF08\u63D0\u4EA4\u8FC7\u624D\u6709\uFF09",
+      "",
+      "Chat \u8F93\u5165",
+      "  ! <command>     \u672C\u5730 shell\uFF08\u96F6\u6210\u672C\uFF0C\u4E0D\u8FDB\u5BF9\u8BDD\uFF09",
+      "  @\u8DEF\u5F84 / /\u547D\u4EE4   \u7F16\u8F91\u5668\u8865\u5168",
+      "",
+      ...helpLines(),
+      theme.dim("\u26A0 = \u7834\u574F\u6027\u64CD\u4F5C")
+    ].join("\n");
+    model.helpVisible = true;
+    applyTab();
+    helpHandle = tui.showOverlay(new Text5(body, 1, 1), { width: 62, maxHeight: 32, anchor: "center" });
+  }
+  let conn = null;
+  function ensureConn(_sessionID) {
+    if (conn) {
+      return conn;
+    }
+    conn = new ConnectionStore({
+      sessionID: "global",
+      subscribe: () => client.event.subscribe(),
+      isConnected: () => client.event.connected(),
+      onEvent,
+      onState: (s) => {
+        setStatus({ conn: s });
+        tabStrip.setConnected(s === "ok");
+      }
+    });
+    conn.start();
+    return conn;
+  }
+  async function switchToSession(sessionID) {
+    await chatStore.switchSession(sessionID);
+    chatTab.rebuild();
+    ensureConn(sessionID);
+    setStatus({ session: sessionID });
+    void refreshUsage();
+  }
+  async function showSessionPicker() {
+    let sessions;
+    try {
+      sessions = await client.session.list(projectID ? { query: { projectID } } : void 0);
+    } catch (e) {
+      setStatus({ hint: theme.err(`\u4F1A\u8BDD\u5217\u8868\u5931\u8D25: ${String(e?.message ?? e).slice(0, 50)}`) });
+      return;
+    }
+    if (!sessions || sessions.length === 0) {
+      setStatus({ hint: theme.dim("\uFF08\u5F53\u524D\u9879\u76EE\u65E0\u4F1A\u8BDD\uFF09") });
+      return;
+    }
+    const items = sessions.map((s) => ({
+      value: s.id,
+      label: `${s.title || String(s.id).slice(0, 20)}${s.id === managerSessionID ? theme.ok(" \u2605manager") : ""}`,
+      description: s.time?.updated ? new Date(s.time.updated).toLocaleString() : ""
+    }));
+    const list = new SelectList4(items, Math.min(items.length, 10), selectListTheme);
+    const handle = tui.showOverlay(new ClickableSelectList(list), { width: "70%", maxHeight: 16, anchor: "center" });
+    const close = () => {
+      off();
+      handle.hide();
+    };
+    const off = tui.addInputListener((data) => {
+      if (matchesKey5(data, Key5.escape)) {
+        close();
+        return { consume: true };
+      }
+      return void 0;
+    });
+    list.onSelect = (item) => {
+      close();
+      void switchToSession(String(item.value));
+    };
+    list.onCancel = close;
+  }
+  async function showModelPicker() {
+    const p = await client.providers.list().catch(() => null);
+    const all = p?.all ?? [];
+    const connected = new Set(p?.connected ?? []);
+    const items = [];
+    for (const prov of all) {
+      if (connected.size > 0 && !connected.has(prov.id)) continue;
+      for (const [mid, m] of Object.entries(prov.models ?? {})) {
+        items.push({ value: `${prov.id}/${mid}`, label: m?.name || mid, description: prov.id });
+      }
+    }
+    if (items.length === 0) {
+      setStatus({ hint: theme.dim("\uFF08\u65E0\u53EF\u7528\u6A21\u578B\u2014\u2014\u68C0\u67E5 provider \u8FDE\u63A5\uFF09") });
+      return;
+    }
+    const list = new SelectList4(items, 10, selectListTheme);
+    const handle = tui.showOverlay(new ClickableSelectList(list), { width: "60%", maxHeight: 16, anchor: "center" });
+    const close = () => {
+      off();
+      handle.hide();
+    };
+    const off = tui.addInputListener((data) => {
+      if (matchesKey5(data, Key5.escape)) {
+        close();
+        return { consume: true };
+      }
+      return void 0;
+    });
+    list.onSelect = (item) => {
+      close();
+      const slash = String(item.value).indexOf("/");
+      if (slash <= 0) return;
+      modelSelection = {
+        providerID: String(item.value).slice(0, slash),
+        modelID: String(item.value).slice(slash + 1)
+      };
+      setStatus({ usage: { ...status.usage ?? {}, model: modelSelection.modelID } });
+      setStatus({ hint: theme.ok(`\u6A21\u578B: ${modelSelection.providerID}/${modelSelection.modelID}`) });
+    };
+    list.onCancel = close;
+  }
+  let promptStart = null;
+  let lastPromptMs = 0;
+  async function refreshUsage() {
+    const sid = chatStore.sessionID;
+    if (!sid || sid === "none") return;
+    try {
+      const t = await client.session.tokenSummary({ path: { id: sid } });
+      const total = t.totalTokens.input + t.totalTokens.output + t.totalTokens.reasoning;
+      setStatus({
+        usage: {
+          model: modelSelection?.modelID ?? defaultModelLabel,
+          tokens: total,
+          costUsd: t.totalCost ?? null,
+          promptMs: promptStart !== null ? Date.now() - promptStart : lastPromptMs,
+          durationMs: Date.now() - appStart
+        }
+      });
+    } catch {
+    }
+  }
+  setInterval(() => {
+    if (model.active === "chat") void refreshUsage();
+  }, 15e3);
+  void refreshUsage();
+  async function openInExternalEditor() {
+    const command = defaultEditorCommand();
+    tui.stop();
+    try {
+      const result = await editInExternalEditor({ command, content: chatTab.getEditorText() });
+      if (result.status === "complete" && result.content !== void 0) chatTab.setEditorText(result.content);
+    } finally {
+      tui.start();
+      tui.requestRender(true);
+    }
+  }
+  function showQueueManager() {
+    const overlay = new QueueOverlay({
+      getItems: () => chatStore.queuedTexts,
+      onTakeBack: (i) => {
+        const text = chatStore.dropQueuedAt(i);
+        if (text !== null) chatTab.setEditorText(text);
+      },
+      onDrop: (i) => {
+        chatStore.dropQueuedAt(i);
+      },
+      onClose: () => {
+        handle.hide();
+        syncInteraction();
+      },
+      requestRender: () => tui.requestRender()
+    });
+    const handle = tui.showOverlay(overlay, { width: "60%", maxHeight: 14, anchor: "center" });
+    syncInteraction();
+    return Promise.resolve();
+  }
+  function openTranscriptSearch() {
+    const overlay = new TranscriptSearchOverlay({
+      getTurns: () => chatStore.turns,
+      onJump: (turnIndex) => {
+        const t = chatStore.turns[turnIndex];
+        if (t) chatTab.scrollToTurn(t.messageID);
+      },
+      onClose: () => handle.hide(),
+      requestRender: () => tui.requestRender()
+    });
+    const handle = tui.showOverlay(overlay, { width: "70%", maxHeight: 14, anchor: "center" });
+  }
+  async function showDiff(scope) {
+    const arg = scope === "staged" ? " --staged" : scope === "all" ? " HEAD" : "";
+    const r = await runShell(`git diff${arg}`, { timeoutMs: 15e3 });
+    if (r.exitCode !== 0 && r.stderr) return `git diff \u5931\u8D25: ${r.stderr.split("\n")[0].slice(0, 80)}`;
+    const raw = (r.stdout || "").split("\n");
+    if (raw.length <= 1 && !r.stdout) {
+      showDiffOverlay(["\uFF08\u65E0\u672A\u63D0\u4EA4\u53D8\u66F4\uFF09"], scope);
+      return null;
+    }
+    const MAX_DIFF_LINES = 150;
+    const lines = raw.slice(0, MAX_DIFF_LINES).map((l) => colorDiffLine(l));
+    if (raw.length > MAX_DIFF_LINES) lines.push(theme.dim(`\u2026 \u622A\u65AD\uFF08\u5171 ${raw.length} \u884C\uFF09`));
+    showDiffOverlay(lines, scope);
+    return null;
+  }
+  function showDiffOverlay(lines, scope) {
+    const title = theme.accent(`git diff${scope ? ` (${scope})` : ""}`) + theme.dim(" \xB7 Esc \u5173\u95ED");
+    const overlay = tui.showOverlay(new Text5([title, "", ...lines].join("\n"), 1, 1), { width: "90%", maxHeight: "70%", anchor: "center" });
+    const close = () => {
+      off();
+      overlay.hide();
+    };
+    const off = tui.addInputListener((data) => {
+      if (matchesKey5(data, Key5.escape)) {
+        close();
+        return { consume: true };
+      }
+      return void 0;
+    });
+  }
+  const sessionApproved = /* @__PURE__ */ new Set();
+  function showConfirm(title, description) {
+    return new Promise((resolve) => {
+      const overlay = new ConfirmOverlay({
+        title,
+        description,
+        onAnswer: (mode) => {
+          handle.hide();
+          resolve(mode);
+        },
+        requestRender: () => tui.requestRender()
+      });
+      const handle = tui.showOverlay(overlay, { width: 52, maxHeight: 12, anchor: "center" });
+    });
+  }
+  async function handleSlashWithConfirm(rawCmd, args) {
+    const name = resolveCommand(rawCmd);
+    const def = COMMAND_REGISTRY.find((c) => c.name === name);
+    const inlineSkip = /^(now|--yes|-y)(\s|$)/i.test(args.trim());
+    if (def?.destructive && !inlineSkip && !sessionApproved.has(def.name)) {
+      const answer = await showConfirm(`\u786E\u8BA4\u6267\u884C /${def.name}\uFF1F`, def.description);
+      if (answer === "cancel") return "\u5DF2\u53D6\u6D88";
+      if (answer === "always") sessionApproved.add(def.name);
+    }
+    return slashHandler(rawCmd, inlineSkip ? args.trim().replace(/^(now|--yes|-y)\s+/i, "") : args);
+  }
+  const slashHandler = createSlashHandler({
+    loadOlder: () => chatTab.loadOlder(),
+    toggleHelp,
+    rotateTopic: async () => {
+      if (!projectDir) return "\u5F53\u524D\u65E0\u9879\u76EE\u4E0A\u4E0B\u6587\uFF0C\u65E0\u6CD5 rotate";
+      const r = await client.manager.rotate(projectDir, "tui /new").catch((e) => ({ error: e.message }));
+      if ("error" in r) return `rotate \u5931\u8D25: ${r.error}`;
+      const next = await client.manager.session(projectDir).catch(() => null);
+      if (next?.sessionId) await switchToSession(next.sessionId);
+      return "\u5DF2\u5F00\u65B0\u8BDD\u9898\uFF08manager session \u5DF2\u8F6E\u6362\u5E76\u5207\u6362\uFF09";
+    },
+    btw: async (args) => {
+      if (!args.trim()) return "\u7528\u6CD5: /btw <\u95EE\u9898>";
+      const r = await client.mafwCommands.run({ command: "btw", args }).catch((e) => ({ error: e.message }));
+      if ("error" in r) return `btw \u5931\u8D25: ${r.error}`;
+      return null;
+    },
+    showSessionPicker,
+    showQueueManager,
+    showModelPicker,
+    cycleVerbosity: () => {
+      const v = chatTab.cycleVerbosity();
+      setStatus({ focus: chatTab.display.focus });
+      return v;
+    },
+    toggleFocus: () => {
+      const f = chatTab.toggleFocus();
+      setStatus({ focus: f });
+      return f;
+    },
+    showDiff,
+    rename: async (args) => {
+      const title = args.trim();
+      if (!title) return "\u7528\u6CD5: /rename <\u6807\u9898>";
+      try {
+        await client.session.rename({ path: { id: chatStore.sessionID }, body: { title } });
+        return `\u5DF2\u547D\u540D: ${title}`;
+      } catch (e) {
+        return `rename \u5931\u8D25: ${String(e?.message ?? e).slice(0, 80)}`;
+      }
+    },
+    fork: async () => {
+      try {
+        const r = await client.session.fork({ path: { id: chatStore.sessionID } });
+        const newId = r?.session?.id;
+        if (!newId) return "fork \u5931\u8D25: \u65E0\u65B0\u4F1A\u8BDD\u8FD4\u56DE";
+        await switchToSession(String(newId));
+        return `\u5DF2\u5206\u53C9 \u2192 ${String(newId).slice(0, 16)}`;
+      } catch (e) {
+        return `fork \u5931\u8D25: ${String(e?.message ?? e).slice(0, 80)}`;
+      }
+    },
+    showStatusRecap: () => {
+      const body = recapLines(
+        computeRecap(chatStore.turns),
+        chatStore.sessionID,
+        status.project ?? "-"
+      ).join("\n");
+      const overlay = tui.showOverlay(new Text5(body, 1, 1), { width: "70%", maxHeight: 20, anchor: "center" });
+      const close = () => {
+        off();
+        overlay.hide();
+      };
+      const off = tui.addInputListener((data) => {
+        if (matchesKey5(data, Key5.escape) || matchesKey5(data, Key5.enter)) {
+          close();
+          return { consume: true };
+        }
+        return void 0;
+      });
+    },
+    compact: async () => {
+      const sid = chatStore.sessionID;
+      if (!sid || sid === "none") return "\u5F53\u524D\u65E0\u4F1A\u8BDD";
+      try {
+        await client.session.summarize({ path: { id: sid } });
+        await chatStore.loadHistory();
+        chatTab.rebuild();
+        return null;
+      } catch (e) {
+        return `compact \u5931\u8D25: ${String(e?.message ?? e).slice(0, 80)}`;
+      }
+    },
+    undo: () => chatStore.undo(),
+    redo: () => chatStore.redo(),
+    openExternalEditor: openInExternalEditor
+  });
+  const bodies = /* @__PURE__ */ new Map([
+    ["chat", chatTab],
+    ["goals", goalsTab],
+    ["memory", memoryTab],
+    ["triage", triageTab]
+  ]);
+  let currentBody = bodies.get(model.active);
+  const contentHost = new VStack2([]);
+  contentHost.addChild(currentBody, { basis: 0, grow: 1, minSize: 1 });
+  tui.setLayoutRoot(new VStack2([
+    { component: tabStrip, basis: "auto", minSize: 1 },
+    { component: contentHost, basis: 0, grow: 1, minSize: 1 },
+    { component: statusBar, basis: "auto", minSize: 1 }
+  ]));
+  const onEvent = (type, data) => {
+    if (type === "permission.asked") {
+      const req = data?.properties ?? data;
+      if (req?.id) {
+        showPermissionOverlay(tui, req, (r) => client.permissions.reply(req.id, r));
+      }
+    } else if (type === "session.idle") {
+      void refreshUsage();
+    }
+  };
+  if (managerSessionID) ensureConn(managerSessionID);
+  function applyTab() {
+    contentHost.removeChild(currentBody);
+    currentBody = bodies.get(model.active);
+    contentHost.addChild(currentBody, { basis: 0, grow: 1, minSize: 1 });
+    model.editing = model.active === "chat" && !model.helpVisible;
+    if (model.active === "chat") {
+      tui.setFocus(chatTab);
+      memoryTab.blurSearch();
+    } else if (model.active === "memory") {
+      if (!memoryTab.inputFocused) tui.setFocus(null);
+    } else {
+      tui.setFocus(null);
+      memoryTab.blurSearch();
+    }
+    tabStrip.setActive(model.active);
+    tui.requestRender();
+  }
+  tabStrip.onTabClick = (id) => {
+    model.switchTab(id);
+    applyTab();
+  };
+  const topTimer = setInterval(() => {
+    syncInteraction();
+    if (model.active === "chat" && chatTab.atTop) void chatTab.loadOlder();
+  }, 1e3);
+  function syncInteraction() {
+    const wasStreaming = chatStore.streaming;
+    interaction.update({ overlayOpen: tui.hasOverlay(), streaming: chatStore.streaming });
+    setStatus({ busy: interaction.is("busy"), queued: chatStore.queuedCount, stashed: chatTab.stashCount });
+    if (chatStore.streaming && promptStart === null) promptStart = Date.now();
+    if (!chatStore.streaming && promptStart !== null) {
+      lastPromptMs = Date.now() - promptStart;
+      promptStart = null;
+      if (process.env.MAFW_TUI_BELL !== "0") tui.terminal.write("\x07");
+    }
+    void wasStreaming;
+  }
+  function quitApp() {
+    clearInterval(topTimer);
+    goalsStore.stop();
+    triageStore.stop();
+    tui.stop();
+    process.exit(0);
+  }
+  const keyCtx = {
+    model,
+    interaction,
+    actions: {
+      quit: quitApp,
+      switchTab: (id) => {
+        model.switchTab(id);
+        applyTab();
+      },
+      toggleHelp: () => toggleHelp(),
+      abortTurn: () => {
+        void chatStore.abort();
+      },
+      openExternalEditor: () => {
+        void openInExternalEditor();
+      },
+      blurMemorySearch: () => memoryTab.blurSearch(),
+      openTranscriptSearch: () => openTranscriptSearch()
+    },
+    queries: {
+      activeTab: () => model.active,
+      editing: () => model.editing,
+      overlayOpen: () => tui.hasOverlay(),
+      streaming: () => chatStore.streaming,
+      memoryInputFocused: () => memoryTab.inputFocused
+    }
+  };
+  tui.addInputListener((data) => {
+    if (dispatchKey(data, keyCtx)) return { consume: true };
+    if (!model.editing && !tui.hasOverlay() && model.active !== "chat") {
+      const tab = currentBody;
+      if (typeof tab.handleTabKey === "function" && tab.handleTabKey(data)) return { consume: true };
+    }
+    return void 0;
+  });
+  applyTab();
+  tui.start();
+}
+var import_sdk;
+var init_app = __esm({
+  "src/ui/app.ts"() {
+    "use strict";
+    import_sdk = __toESM(require_dist(), 1);
+    init_tab_strip();
+    init_status_bar();
+    init_app_model();
+    init_connection();
+    init_chat_store();
+    init_chat_tab();
+    init_slash_commands();
+    init_external_editor();
+    init_clickable_tui();
+    init_clickable_select_list();
+    init_keymap();
+    init_interaction_state();
+    init_command_registry();
+    init_command_registry();
+    init_queue_overlay();
+    init_transcript_search();
+    init_confirm_overlay();
+    init_session_recap();
+    init_message_blocks();
+    init_shell_mode();
+    init_overlays();
+    init_goals_store();
+    init_goals_tab();
+    init_memory_store();
+    init_memory_tab();
+    init_triage_store();
+    init_triage_tab();
+    init_theme();
+  }
+});
+
+// ../../node_modules/eventsource-parser/dist/index.js
+var ParseError = class extends Error {
+  constructor(message, options) {
+    super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+  }
+};
+var LF = 10;
+var CR = 13;
+var SPACE = 32;
+function noop(_arg) {
+}
+function createParser(config) {
+  if (typeof config == "function")
+    throw new TypeError(
+      "`config` must be an object, got a function instead. Did you mean `createParser({onEvent: fn})`?"
+    );
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment, maxBufferSize } = config, pendingFragments = [];
+  let pendingFragmentsLength = 0, isFirstChunk = true, id, data = "", dataLines = 0, eventType, terminated = false;
+  function feed(chunk) {
+    if (terminated)
+      throw new Error(
+        "Cannot feed parser: it was terminated after exceeding the configured max buffer size. Call `reset()` to resume parsing."
+      );
+    if (isFirstChunk && (isFirstChunk = false, chunk.charCodeAt(0) === 239 && chunk.charCodeAt(1) === 187 && chunk.charCodeAt(2) === 191 && (chunk = chunk.slice(3))), pendingFragments.length === 0) {
+      const trailing2 = processLines(chunk);
+      trailing2 !== "" && (pendingFragments.push(trailing2), pendingFragmentsLength = trailing2.length), checkBufferSize();
+      return;
+    }
+    if (chunk.indexOf(`
+`) === -1 && chunk.indexOf("\r") === -1) {
+      pendingFragments.push(chunk), pendingFragmentsLength += chunk.length, checkBufferSize();
+      return;
+    }
+    pendingFragments.push(chunk);
+    const input = pendingFragments.join("");
+    pendingFragments.length = 0, pendingFragmentsLength = 0;
+    const trailing = processLines(input);
+    trailing !== "" && (pendingFragments.push(trailing), pendingFragmentsLength = trailing.length), checkBufferSize();
+  }
+  function checkBufferSize() {
+    maxBufferSize !== void 0 && (pendingFragmentsLength + data.length <= maxBufferSize || (terminated = true, pendingFragments.length = 0, pendingFragmentsLength = 0, id = void 0, data = "", dataLines = 0, eventType = void 0, onError(
+      new ParseError(`Buffered data exceeded max buffer size of ${maxBufferSize} characters`, {
+        type: "max-buffer-size-exceeded"
+      })
+    )));
+  }
+  function processLines(chunk) {
+    let searchIndex = 0;
+    if (chunk.indexOf("\r") === -1) {
+      let lfIndex = chunk.indexOf(`
+`, searchIndex);
+      for (; lfIndex !== -1; ) {
+        if (searchIndex === lfIndex) {
+          dataLines > 0 && onEvent({ id, event: eventType, data }), id = void 0, data = "", dataLines = 0, eventType = void 0, searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+          continue;
+        }
+        const firstCharCode = chunk.charCodeAt(searchIndex);
+        if (isDataPrefix(chunk, searchIndex, firstCharCode)) {
+          const valueStart = chunk.charCodeAt(searchIndex + 5) === SPACE ? searchIndex + 6 : searchIndex + 5, value = chunk.slice(valueStart, lfIndex);
+          if (dataLines === 0 && chunk.charCodeAt(lfIndex + 1) === LF) {
+            onEvent({ id, event: eventType, data: value }), id = void 0, data = "", eventType = void 0, searchIndex = lfIndex + 2, lfIndex = chunk.indexOf(`
+`, searchIndex);
+            continue;
+          }
+          data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+        } else isEventPrefix(chunk, searchIndex, firstCharCode) ? eventType = chunk.slice(
+          chunk.charCodeAt(searchIndex + 6) === SPACE ? searchIndex + 7 : searchIndex + 6,
+          lfIndex
+        ) || void 0 : parseLine(chunk, searchIndex, lfIndex);
+        searchIndex = lfIndex + 1, lfIndex = chunk.indexOf(`
+`, searchIndex);
+      }
+      return chunk.slice(searchIndex);
+    }
+    for (; searchIndex < chunk.length; ) {
+      const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+      let lineEnd = -1;
+      if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = crIndex < lfIndex ? crIndex : lfIndex : crIndex !== -1 ? crIndex === chunk.length - 1 ? lineEnd = -1 : lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1)
+        break;
+      parseLine(chunk, searchIndex, lineEnd), searchIndex = lineEnd + 1, chunk.charCodeAt(searchIndex - 1) === CR && chunk.charCodeAt(searchIndex) === LF && searchIndex++;
+    }
+    return chunk.slice(searchIndex);
+  }
+  function parseLine(chunk, start, end) {
+    if (start === end) {
+      dispatchEvent();
+      return;
+    }
+    const firstCharCode = chunk.charCodeAt(start);
+    if (isDataPrefix(chunk, start, firstCharCode)) {
+      const valueStart = chunk.charCodeAt(start + 5) === SPACE ? start + 6 : start + 5, value2 = chunk.slice(valueStart, end);
+      data = dataLines === 0 ? value2 : `${data}
+${value2}`, dataLines++;
+      return;
+    }
+    if (isEventPrefix(chunk, start, firstCharCode)) {
+      eventType = chunk.slice(chunk.charCodeAt(start + 6) === SPACE ? start + 7 : start + 6, end) || void 0;
+      return;
+    }
+    if (firstCharCode === 105 && chunk.charCodeAt(start + 1) === 100 && chunk.charCodeAt(start + 2) === 58) {
+      const value2 = chunk.slice(chunk.charCodeAt(start + 3) === SPACE ? start + 4 : start + 3, end);
+      id = value2.includes("\0") ? void 0 : value2;
+      return;
+    }
+    if (firstCharCode === 58) {
+      if (onComment) {
+        const line2 = chunk.slice(start, end);
+        onComment(line2.slice(chunk.charCodeAt(start + 1) === SPACE ? 2 : 1));
+      }
+      return;
+    }
+    const line = chunk.slice(start, end), fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex === -1) {
+      processField(line, "", line);
+      return;
+    }
+    const field = line.slice(0, fieldSeparatorIndex), offset = line.charCodeAt(fieldSeparatorIndex + 1) === SPACE ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+    processField(field, value, line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value || void 0;
+        break;
+      case "data":
+        data = dataLines === 0 ? value : `${data}
+${value}`, dataLines++;
+        break;
+      case "id":
+        id = value.includes("\0") ? void 0 : value;
+        break;
+      case "retry":
+        /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
+          new ParseError(`Invalid \`retry\` value: "${value}"`, {
+            type: "invalid-retry",
+            value,
+            line
+          })
+        );
+        break;
+      default:
+        onError(
+          new ParseError(
+            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
+            { type: "unknown-field", field, value, line }
+          )
+        );
+        break;
+    }
+  }
+  function dispatchEvent() {
+    dataLines > 0 && onEvent({
+      id,
+      event: eventType,
+      data
+    }), id = void 0, data = "", dataLines = 0, eventType = void 0;
+  }
+  function reset(options = {}) {
+    if (options.consume && pendingFragments.length > 0) {
+      const incompleteLine = pendingFragments.join("");
+      parseLine(incompleteLine, 0, incompleteLine.length);
+    }
+    isFirstChunk = true, id = void 0, data = "", dataLines = 0, eventType = void 0, pendingFragments.length = 0, pendingFragmentsLength = 0, terminated = false;
+  }
+  return { feed, reset };
+}
+function isDataPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 100 && chunk.charCodeAt(i + 1) === 97 && chunk.charCodeAt(i + 2) === 116 && chunk.charCodeAt(i + 3) === 97 && chunk.charCodeAt(i + 4) === 58;
+}
+function isEventPrefix(chunk, i, firstCharCode) {
+  return firstCharCode === 101 && chunk.charCodeAt(i + 1) === 118 && chunk.charCodeAt(i + 2) === 101 && chunk.charCodeAt(i + 3) === 110 && chunk.charCodeAt(i + 4) === 116 && chunk.charCodeAt(i + 5) === 58;
+}
+
+// ../../node_modules/eventsource/dist/index.js
+var ErrorEvent = class extends Event {
+  /**
+   * Constructs a new `ErrorEvent` instance. This is typically not called directly,
+   * but rather emitted by the `EventSource` object when an error occurs.
+   *
+   * @param type - The type of the event (should be "error")
+   * @param errorEventInitDict - Optional properties to include in the error event
+   */
+  constructor(type, errorEventInitDict) {
+    var _a, _b;
+    super(type), this.code = (_a = errorEventInitDict == null ? void 0 : errorEventInitDict.code) != null ? _a : void 0, this.message = (_b = errorEventInitDict == null ? void 0 : errorEventInitDict.message) != null ? _b : void 0;
+  }
+  /**
+   * Node.js "hides" the `message` and `code` properties of the `ErrorEvent` instance,
+   * when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging,
+   * we explicitly include the properties in the `inspect` method.
+   *
+   * This is automatically called by Node.js when you `console.log` an instance of this class.
+   *
+   * @param _depth - The current depth
+   * @param options - The options passed to `util.inspect`
+   * @param inspect - The inspect function to use (prevents having to import it from `util`)
+   * @returns A string representation of the error
+   */
+  [Symbol.for("nodejs.util.inspect.custom")](_depth, options, inspect) {
+    return inspect(inspectableError(this), options);
+  }
+  /**
+   * Deno "hides" the `message` and `code` properties of the `ErrorEvent` instance,
+   * when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging,
+   * we explicitly include the properties in the `inspect` method.
+   *
+   * This is automatically called by Deno when you `console.log` an instance of this class.
+   *
+   * @param inspect - The inspect function to use (prevents having to import it from `util`)
+   * @param options - The options passed to `Deno.inspect`
+   * @returns A string representation of the error
+   */
+  [Symbol.for("Deno.customInspect")](inspect, options) {
+    return inspect(inspectableError(this), options);
+  }
+};
+function syntaxError(message) {
+  const DomException = globalThis.DOMException;
+  return typeof DomException == "function" ? new DomException(message, "SyntaxError") : new SyntaxError(message);
+}
+function flattenError(err) {
+  return err instanceof Error ? "errors" in err && Array.isArray(err.errors) ? err.errors.map(flattenError).join(", ") : "cause" in err && err.cause instanceof Error ? `${err}: ${flattenError(err.cause)}` : err.message : `${err}`;
+}
+function inspectableError(err) {
+  return {
+    type: err.type,
+    message: err.message,
+    code: err.code,
+    defaultPrevented: err.defaultPrevented,
+    cancelable: err.cancelable,
+    timeStamp: err.timeStamp
+  };
+}
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _readyState;
+var _url;
+var _redirectUrl;
+var _withCredentials;
+var _fetch;
+var _reconnectInterval;
+var _reconnectTimer;
+var _lastEventId;
+var _controller;
+var _parser;
+var _onError;
+var _onMessage;
+var _onOpen;
+var _EventSource_instances;
+var connect_fn;
+var _onFetchResponse;
+var _onFetchError;
+var getRequestOptions_fn;
+var _onEvent;
+var _onRetryChange;
+var failConnection_fn;
+var scheduleReconnect_fn;
+var _reconnect;
+var EventSource2 = class extends EventTarget {
+  constructor(url, eventSourceInitDict) {
+    var _a, _b;
+    super(), __privateAdd(this, _EventSource_instances), this.CONNECTING = 0, this.OPEN = 1, this.CLOSED = 2, __privateAdd(this, _readyState), __privateAdd(this, _url), __privateAdd(this, _redirectUrl), __privateAdd(this, _withCredentials), __privateAdd(this, _fetch), __privateAdd(this, _reconnectInterval), __privateAdd(this, _reconnectTimer), __privateAdd(this, _lastEventId, null), __privateAdd(this, _controller), __privateAdd(this, _parser), __privateAdd(this, _onError, null), __privateAdd(this, _onMessage, null), __privateAdd(this, _onOpen, null), __privateAdd(this, _onFetchResponse, async (response) => {
+      var _a2;
+      __privateGet(this, _parser).reset();
+      const { body, redirected, status, headers } = response;
+      if (status === 204) {
+        __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Server sent HTTP 204, not reconnecting", 204), this.close();
+        return;
+      }
+      if (redirected ? __privateSet(this, _redirectUrl, new URL(response.url)) : __privateSet(this, _redirectUrl, void 0), status !== 200) {
+        __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, `Non-200 status code (${status})`, status);
+        return;
+      }
+      if (!(headers.get("content-type") || "").startsWith("text/event-stream")) {
+        __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, 'Invalid content type, expected "text/event-stream"', status);
+        return;
+      }
+      if (__privateGet(this, _readyState) === this.CLOSED)
+        return;
+      __privateSet(this, _readyState, this.OPEN);
+      const openEvent = new Event("open");
+      if ((_a2 = __privateGet(this, _onOpen)) == null || _a2.call(this, openEvent), this.dispatchEvent(openEvent), typeof body != "object" || !body || !("getReader" in body)) {
+        __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Invalid response body, expected a web ReadableStream", status), this.close();
+        return;
+      }
+      const decoder = new TextDecoder(), reader = body.getReader();
+      let open = true;
+      do {
+        const { done, value } = await reader.read();
+        value && __privateGet(this, _parser).feed(decoder.decode(value, { stream: !done })), done && (open = false, __privateGet(this, _parser).reset(), __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this));
+      } while (open);
+    }), __privateAdd(this, _onFetchError, (err) => {
+      __privateSet(this, _controller, void 0), !(err.name === "AbortError" || err.type === "aborted") && __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this, flattenError(err));
+    }), __privateAdd(this, _onEvent, (event) => {
+      typeof event.id == "string" && __privateSet(this, _lastEventId, event.id);
+      const messageEvent = new MessageEvent(event.event || "message", {
+        data: event.data,
+        origin: __privateGet(this, _redirectUrl) ? __privateGet(this, _redirectUrl).origin : __privateGet(this, _url).origin,
+        lastEventId: event.id || ""
+      });
+      __privateGet(this, _onMessage) && (!event.event || event.event === "message") && __privateGet(this, _onMessage).call(this, messageEvent), this.dispatchEvent(messageEvent);
+    }), __privateAdd(this, _onRetryChange, (value) => {
+      __privateSet(this, _reconnectInterval, value);
+    }), __privateAdd(this, _reconnect, () => {
+      __privateSet(this, _reconnectTimer, void 0), __privateGet(this, _readyState) === this.CONNECTING && __privateMethod(this, _EventSource_instances, connect_fn).call(this);
+    });
+    try {
+      if (url instanceof URL)
+        __privateSet(this, _url, url);
+      else if (typeof url == "string")
+        __privateSet(this, _url, new URL(url, getBaseURL()));
+      else
+        throw new Error("Invalid URL");
+    } catch {
+      throw syntaxError("An invalid or illegal string was specified");
+    }
+    __privateSet(this, _parser, createParser({
+      onEvent: __privateGet(this, _onEvent),
+      onRetry: __privateGet(this, _onRetryChange)
+    })), __privateSet(this, _readyState, this.CONNECTING), __privateSet(this, _reconnectInterval, 3e3), __privateSet(this, _fetch, (_a = eventSourceInitDict == null ? void 0 : eventSourceInitDict.fetch) != null ? _a : globalThis.fetch), __privateSet(this, _withCredentials, (_b = eventSourceInitDict == null ? void 0 : eventSourceInitDict.withCredentials) != null ? _b : false), __privateMethod(this, _EventSource_instances, connect_fn).call(this);
+  }
+  /**
+   * Returns the state of this EventSource object's connection. It can have the values described below.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/readyState)
+   *
+   * Note: typed as `number` instead of `0 | 1 | 2` for compatibility with the `EventSource` interface,
+   * defined in the TypeScript `dom` library.
+   *
+   * @public
+   */
+  get readyState() {
+    return __privateGet(this, _readyState);
+  }
+  /**
+   * Returns the URL providing the event stream.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/url)
+   *
+   * @public
+   */
+  get url() {
+    return __privateGet(this, _url).href;
+  }
+  /**
+   * Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/withCredentials)
+   */
+  get withCredentials() {
+    return __privateGet(this, _withCredentials);
+  }
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/error_event) */
+  get onerror() {
+    return __privateGet(this, _onError);
+  }
+  set onerror(value) {
+    __privateSet(this, _onError, value);
+  }
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/message_event) */
+  get onmessage() {
+    return __privateGet(this, _onMessage);
+  }
+  set onmessage(value) {
+    __privateSet(this, _onMessage, value);
+  }
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/open_event) */
+  get onopen() {
+    return __privateGet(this, _onOpen);
+  }
+  set onopen(value) {
+    __privateSet(this, _onOpen, value);
+  }
+  addEventListener(type, listener, options) {
+    const listen = listener;
+    super.addEventListener(type, listen, options);
+  }
+  removeEventListener(type, listener, options) {
+    const listen = listener;
+    super.removeEventListener(type, listen, options);
+  }
+  /**
+   * Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/close)
+   *
+   * @public
+   */
+  close() {
+    __privateGet(this, _reconnectTimer) && clearTimeout(__privateGet(this, _reconnectTimer)), __privateGet(this, _readyState) !== this.CLOSED && (__privateGet(this, _controller) && __privateGet(this, _controller).abort(), __privateSet(this, _readyState, this.CLOSED), __privateSet(this, _controller, void 0));
+  }
+};
+_readyState = /* @__PURE__ */ new WeakMap(), _url = /* @__PURE__ */ new WeakMap(), _redirectUrl = /* @__PURE__ */ new WeakMap(), _withCredentials = /* @__PURE__ */ new WeakMap(), _fetch = /* @__PURE__ */ new WeakMap(), _reconnectInterval = /* @__PURE__ */ new WeakMap(), _reconnectTimer = /* @__PURE__ */ new WeakMap(), _lastEventId = /* @__PURE__ */ new WeakMap(), _controller = /* @__PURE__ */ new WeakMap(), _parser = /* @__PURE__ */ new WeakMap(), _onError = /* @__PURE__ */ new WeakMap(), _onMessage = /* @__PURE__ */ new WeakMap(), _onOpen = /* @__PURE__ */ new WeakMap(), _EventSource_instances = /* @__PURE__ */ new WeakSet(), /**
+* Connect to the given URL and start receiving events
+*
+* @internal
+*/
+connect_fn = function() {
+  __privateSet(this, _readyState, this.CONNECTING), __privateSet(this, _controller, new AbortController()), __privateGet(this, _fetch)(__privateGet(this, _url), __privateMethod(this, _EventSource_instances, getRequestOptions_fn).call(this)).then(__privateGet(this, _onFetchResponse)).catch(__privateGet(this, _onFetchError));
+}, _onFetchResponse = /* @__PURE__ */ new WeakMap(), _onFetchError = /* @__PURE__ */ new WeakMap(), /**
+* Get request options for the `fetch()` request
+*
+* @returns The request options
+* @internal
+*/
+getRequestOptions_fn = function() {
+  var _a;
+  const init = {
+    // [spec] Let `corsAttributeState` be `Anonymous`…
+    // [spec] …will have their mode set to "cors"…
+    mode: "cors",
+    redirect: "follow",
+    headers: { Accept: "text/event-stream", ...__privateGet(this, _lastEventId) ? { "Last-Event-ID": __privateGet(this, _lastEventId) } : void 0 },
+    cache: "no-store",
+    signal: (_a = __privateGet(this, _controller)) == null ? void 0 : _a.signal
+  };
+  return "window" in globalThis && (init.credentials = this.withCredentials ? "include" : "same-origin"), init;
+}, _onEvent = /* @__PURE__ */ new WeakMap(), _onRetryChange = /* @__PURE__ */ new WeakMap(), /**
+* Handles the process referred to in the EventSource specification as "failing a connection".
+*
+* @param error - The error causing the connection to fail
+* @param code - The HTTP status code, if available
+* @internal
+*/
+failConnection_fn = function(message, code) {
+  var _a;
+  __privateGet(this, _readyState) !== this.CLOSED && __privateSet(this, _readyState, this.CLOSED);
+  const errorEvent = new ErrorEvent("error", { code, message });
+  (_a = __privateGet(this, _onError)) == null || _a.call(this, errorEvent), this.dispatchEvent(errorEvent);
+}, /**
+* Schedules a reconnection attempt against the EventSource endpoint.
+*
+* @param message - The error causing the connection to fail
+* @param code - The HTTP status code, if available
+* @internal
+*/
+scheduleReconnect_fn = function(message, code) {
+  var _a;
+  if (__privateGet(this, _readyState) === this.CLOSED)
+    return;
+  __privateSet(this, _readyState, this.CONNECTING);
+  const errorEvent = new ErrorEvent("error", { code, message });
+  (_a = __privateGet(this, _onError)) == null || _a.call(this, errorEvent), this.dispatchEvent(errorEvent), __privateSet(this, _reconnectTimer, setTimeout(__privateGet(this, _reconnect), __privateGet(this, _reconnectInterval)));
+}, _reconnect = /* @__PURE__ */ new WeakMap(), /**
+* ReadyState representing an EventSource currently trying to connect
+*
+* @public
+*/
+EventSource2.CONNECTING = 0, /**
+* ReadyState representing an EventSource connection that is open (eg connected)
+*
+* @public
+*/
+EventSource2.OPEN = 1, /**
+* ReadyState representing an EventSource connection that is closed (eg disconnected)
+*
+* @public
+*/
+EventSource2.CLOSED = 2;
+function getBaseURL() {
+  const doc = "document" in globalThis ? globalThis.document : void 0;
+  return doc && typeof doc == "object" && "baseURI" in doc && typeof doc.baseURI == "string" ? doc.baseURI : void 0;
+}
+
+// src/cli.ts
+import { pathToFileURL } from "node:url";
+
+// src/probe.ts
+async function probeGateway(fetchFn = fetch, candidates = defaultCandidates(), timeoutMs = 2e3) {
+  for (const base of candidates) {
+    try {
+      const res = await fetchFn(`${base}/health`, { signal: AbortSignal.timeout(timeoutMs) });
+      if (res.ok) return base;
+    } catch {
+    }
+  }
+  return null;
+}
+function defaultCandidates() {
+  const override = process.env.MAFW_TUI_PORTS;
+  if (override) return override.split(",").map((p) => `http://localhost:${p.trim()}`).filter(Boolean);
+  const port = process.env.MAFW_SERVER_API_PORT || process.env.MAFW_GATEWAY_PORT;
+  const urls = [];
+  if (port) urls.push(`http://localhost:${port}`);
+  urls.push("http://localhost:3000");
+  return [...new Set(urls)];
+}
+
+// src/cli.ts
+if (typeof globalThis.EventSource === "undefined") {
+  ;
+  globalThis.EventSource = EventSource2;
+}
+function parseArgs(argv) {
+  const args = { retriever: "bm25" };
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--hybrid") args.retriever = "hybrid";
+    else if (argv[i] === "--session" && argv[i + 1]) {
+      args.sessionID = argv[i + 1];
+      i++;
+    }
+  }
+  return args;
+}
+async function main() {
+  const baseUrl = await probeGateway();
+  if (!baseUrl) {
+    console.error("[mafw tui] gateway \u672A\u8FD0\u884C\uFF08/health \u63A2\u6D4B\u5931\u8D25\uFF09\u3002\u8BF7\u5148\u542F\u52A8\uFF1Amafw daemon");
+    process.exit(1);
+  }
+  const args = parseArgs(process.argv.slice(2));
+  const { runApp: runApp2 } = await Promise.resolve().then(() => (init_app(), app_exports));
+  await runApp2({ baseUrl, retriever: args.retriever, ...args.sessionID ? { sessionID: args.sessionID } : {} });
+}
+var isEntry = !!process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (isEntry) {
+  main().catch((err) => {
+    console.error(`[mafw tui] ${err instanceof Error ? err.message : err}`);
+    process.exit(1);
+  });
+}
+export {
+  parseArgs
+};