@yahaha-studio/kichi-forwarder 0.0.1-alpha.49 → 0.0.1-alpha.51

package/index.ts

@@ -1,6 +1,7 @@
-import fs from "node:fs";
+import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { parse } from "./src/config.js";
 import { KichiForwarderService } from "./src/service.js";
@@ -9,23 +10,14 @@ import type {
   Album,
   ClockAction,
   ClockConfig,
-  KichiRuntimeConfig,
   KichiForwarderConfig,
+  KichiState,
+  KichiStaticConfig,
   PomodoroPhase,
   PoseType,
 } from "./src/types.js";
-
-const DEFAULT_ACTIONS: KichiRuntimeConfig["actions"] = {
-  stand: ["High Five", "Listen Music", "Arm Stretch", "Backbend Stretch", "Making Selfie", "Arms Crossed", "Epiphany", "Angry", "Yay", "Dance", "Sing", "Tired", "Wait", "Stand Phone Talk", "Stand Phone Play", "Curtsy", "Stand Writing", "Stand Drawing", "Stand Play Guitar", "Stand Typing with Keyboard", "Cry", "Dance with Joy", "Float", "Hand on Chest", "Horse Stance", "Idle Backup Hands", "No", "Panic", "Playful Point Up", "Rub Hands", "Run Jump", "Star Showing", "Walk", "Goofy Moves", "Reading"],
-  sit: ["Typing with Keyboard", "Thinking", "Writing", "Crazy", "Hand Cramp", "Dozing", "Phone Talk", "Situp with Arms Crossed", "Situp with Cross Legs", "Eating", "Laze with Cross Legs", "Sit with Arm Stretch", "Drink", "Sit with Making Selfie", "Play Game", "Situp Sleep", "Sit Phone Play", "Painting", "Daze", "Trace Circles", "Reading", "Contemplate", "Chin Rest", "Sleep with Table", "Cute Chin Rest", "Sit Nicely", "Sit Play Guitar", "Meditate"],
-  lay: ["Bend One Knee", "Sleep Curl up Side way", "Rest Chin", "Lie Flat", "Lie Face Down", "Lie Side", "Lay Writing", "Lay Painting", "Sleep Getup", "Starfish", "Lie Side Play Phone", "Prone Play Phone", "Play Laptop"],
-  floor: ["Seiza", "Cross Legged", "Knee Hug", "Writing", "Painting", "Floor Phone Play", "Typing with Keyboard", "Reading", "Phone Talk", "Phone Talk with Point", "Thinking", "Yawn", "Chin Rest", "Finger Tap Chin", "Arm Stretch", "Crazy", "Remorse", "Tantrum", "Squat", "Cross Legs", "Lean Sit", "Playful Point up", "Swing Legs", "Drained", "Meditate"],
-};
-
-const DEFAULT_RUNTIME_CONFIG: KichiRuntimeConfig = {
-  actions: DEFAULT_ACTIONS,
-  llmRuntimeEnabled: true,
-};
+const BUNDLED_STATIC_CONFIG_PATH = new URL("./config/kichi-config.json", import.meta.url);
+const DEFAULT_LLM_RUNTIME_ENABLED = true;
 const FIXED_HOOK_STATUSES: Record<string, ActionResult> = {
   beforePromptBuild: {
     poseType: "sit",
@@ -53,215 +45,13 @@ const FIXED_HOOK_STATUSES: Record<string, ActionResult> = {
   },
 };
 
-const MESSAGE_SENT_BUBBLES = [
-  "All set!",
-  "Sent.",
-  "Delivered.",
-  "Done and sent.",
-  "It's out.",
-  "All yours.",
-];
-
 const KICHI_WORLD_DIR = path.join(os.homedir(), ".openclaw", "kichi-world");
-const RUNTIME_CONFIG_PATH = path.join(KICHI_WORLD_DIR, "kichi-runtime-config.json");
-const LEGACY_SKILLS_CONFIG_PATH = path.join(KICHI_WORLD_DIR, "skills-config.json");
-const IDENTITY_PATH = path.join(KICHI_WORLD_DIR, "identity.json");
-const RUNTIME_ALBUM_CONFIG_PATH = path.join(KICHI_WORLD_DIR, "album-config.json");
+const STATE_PATH = path.join(KICHI_WORLD_DIR, "state.json");
 const MAX_NOTEBOARD_TEXT_LENGTH = 200;
 const MAX_MESSAGE_RECEIVED_PREVIEW_WIDTH = 20;
 const MAX_AGENT_END_PREVIEW_WIDTH = 10;
-const MESSAGE_RECEIVED_ELLIPSIS = "...";
-const BUNDLED_ALBUM_CONFIG_PATH = new URL("./config/album-config.json", import.meta.url);
-const ANSI = {
-  reset: "\u001b[0m",
-  bold: "\u001b[1m",
-  dim: "\u001b[2m",
-  cyan: "\u001b[36m",
-  green: "\u001b[32m",
-  yellow: "\u001b[33m",
-  magenta: "\u001b[35m",
-  blue: "\u001b[34m",
-  gray: "\u001b[90m",
-  white: "\u001b[37m",
-};
-const WORKSPACE_SCREEN_WIDTH = 109;
-const WORKSPACE_ACTIVITY_LIMIT = 8;
-const WORKSPACE_SCREEN_PUSH_DEBOUNCE_MS = 150;
-let cachedConfig: KichiRuntimeConfig | null = null;
-let cachedConfigMtime = 0;
-let cachedConfigPath = "";
-let cachedAlbumConfig: Album | null = null;
-let cachedAlbumConfigMtime = 0;
-let service: KichiForwarderService | null = null;
-let pluginApi: OpenClawPluginApi | null = null;
-let workspaceState: WorkspaceScreenState = createWorkspaceScreenState();
-let workspacePushTimer: NodeJS.Timeout | null = null;
-
-type WorkspaceScreenState = {
-  sessionLabel: string;
-  mode: string;
-  phase: string;
-  channel: string;
-  updatedAtLabel: string;
-  recentActivity: string[];
-  currentFocus: string;
-  hint: string;
-  prompt: string;
-  title: string;
-  shellName: string;
-  cwdLabel: string;
-  modelLabel: string;
-};
-
-function createWorkspaceScreenState(): WorkspaceScreenState {
-  return {
-    sessionLabel: "main",
-    mode: "idle",
-    phase: "waiting",
-    channel: "unknown",
-    updatedAtLabel: "just now",
-    recentActivity: [],
-    currentFocus: "Waiting for the next thread to pick up.",
-    hint: "Low-noise live workspace view.",
-    prompt: "$ _",
-    title: "Workspace",
-    shellName: "agent",
-    cwdLabel: process.cwd(),
-    modelLabel: "model: unknown",
-  };
-}
-
-function normalizeShellToken(value: string): string {
-  const normalized = value
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9._-]+/g, "-")
-    .replace(/^-+|-+$/g, "");
-  return normalized || "agent";
-}
-
-function parseIdentityNameFromWorkspace(workspaceRoot: string): string | null {
-  try {
-    const identityPath = path.join(workspaceRoot, "IDENTITY.md");
-    if (!fs.existsSync(identityPath)) return null;
-    const raw = fs.readFileSync(identityPath, "utf-8");
-    const match = raw.match(/^-\s*\*\*Name:\*\*\s*(.+)$/m);
-    const value = match?.[1]?.trim();
-    return value || null;
-  } catch {
-    return null;
-  }
-}
-
-function deriveWorkspaceIdentity(workspaceRoot: string): Pick<WorkspaceScreenState, "title" | "shellName" | "cwdLabel"> {
-  const identityName = parseIdentityNameFromWorkspace(workspaceRoot);
-  const titleBase = identityName || path.basename(workspaceRoot) || "workspace";
-  return {
-    title: `${titleBase} Workspace`,
-    shellName: normalizeShellToken(identityName || titleBase),
-    cwdLabel: workspaceRoot,
-  };
-}
-
-function nowLabel(): string {
-  const date = new Date();
-  return `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}:${String(date.getSeconds()).padStart(2, "0")}`;
-}
-
-function stripAnsi(text: string): string {
-  return text.replace(/\u001b\[[0-9;]*m/g, "");
-}
-
-function visibleLength(text: string): number {
-  return Array.from(stripAnsi(text)).length;
-}
-
-function padVisible(text: string, width: number): string {
-  const pad = Math.max(0, width - visibleLength(text));
-  return text + " ".repeat(pad);
-}
-
-function truncatePlain(text: string, width: number): string {
-  const chars = Array.from(text);
-  if (chars.length <= width) return text;
-  if (width <= 1) return chars.slice(0, width).join("");
-  return chars.slice(0, width - 1).join("") + "…";
-}
-
-function color(text: string, tone: keyof typeof ANSI): string {
-  return `${ANSI[tone]}${text}${ANSI.reset}`;
-}
-
-function pushActivity(line: string): void {
-  if (!line.trim()) return;
-  const stamped = `[${nowLabel()}] ${line.trim()}`;
-  workspaceState.recentActivity.unshift(stamped);
-  workspaceState.recentActivity = workspaceState.recentActivity.slice(0, WORKSPACE_ACTIVITY_LIMIT);
-  workspaceState.updatedAtLabel = "just now";
-}
-
-function renderWorkspaceScreen(): string {
-  const innerWidth = WORKSPACE_SCREEN_WIDTH - 2;
-  const topTitle = `${color(` ${workspaceState.title} `, "bold")}${color("live session", "gray")}`;
-  const topLine = `╭─── ${topTitle}${"─".repeat(Math.max(0, innerWidth - 4 - visibleLength(topTitle)))}╮`;
-  const bottomLine = `╰${"─".repeat(innerWidth)}╯`;
-
-  const body: string[] = [];
-  const pushRow = (text = "") => {
-    body.push(`│${padVisible(text, innerWidth)}│`);
-  };
-
-  pushRow("");
-  pushRow(`${color("  Welcome back.", "white")}`);
-  pushRow(`${color("  Current session is active and mirrored as a terminal-style workspace.", "gray")}`);
-  pushRow("");
-  pushRow(`${color("  Recent activity", "cyan")}`);
-  for (const item of workspaceState.recentActivity.length ? workspaceState.recentActivity : ["[--:--:--] idle"] ) {
-    pushRow(`  ${color("•", "green")} ${truncatePlain(item, innerWidth - 4)}`);
-  }
-  pushRow("");
-  pushRow(`${color("  Current focus", "cyan")}`);
-  pushRow(`  ${truncatePlain(workspaceState.currentFocus, innerWidth - 2)}`);
-  pushRow("");
-  pushRow(`${color("  Status", "cyan")}`);
-  pushRow(`  ${color("mode", "gray")}    ${workspaceState.mode}`);
-  pushRow(`  ${color("phase", "gray")}   ${workspaceState.phase}`);
-  pushRow(`  ${color("channel", "gray")} ${workspaceState.channel}`);
-  pushRow(`  ${color("session", "gray")} ${workspaceState.sessionLabel}`);
-  pushRow("");
-  pushRow(`${color("  Hint", "cyan")}`);
-  pushRow(`  ${truncatePlain(workspaceState.hint, innerWidth - 2)}`);
-  pushRow("");
-  pushRow(`  ${color(workspaceState.modelLabel, "magenta")}`);
-  pushRow(`  ${color(workspaceState.cwdLabel, "blue")}`);
-  pushRow(`  ${color(`updated: ${workspaceState.updatedAtLabel}`, "gray")}`);
-  pushRow("");
-
-  return [
-    topLine,
-    ...body,
-    bottomLine,
-    "",
-    color("─".repeat(WORKSPACE_SCREEN_WIDTH), "gray"),
-    `${color(workspaceState.shellName, "green")}:${color("~", "blue")} ${workspaceState.prompt}`,
-  ].join("\n");
-}
-
-function scheduleWorkspacePush(): void {
-  if (!service?.hasValidIdentity() || !service?.isConnected()) return;
-  if (workspacePushTimer) clearTimeout(workspacePushTimer);
-  workspacePushTimer = setTimeout(() => {
-    workspacePushTimer = null;
-    service?.sendWorkspaceScreen(renderWorkspaceScreen(), true);
-  }, WORKSPACE_SCREEN_PUSH_DEBOUNCE_MS);
-}
-
-function updateWorkspace(partial: Partial<WorkspaceScreenState>, activity?: string): void {
-  workspaceState = { ...workspaceState, ...partial, updatedAtLabel: "just now" };
-  if (activity) pushActivity(activity);
-  scheduleWorkspacePush();
-}
-
+const MESSAGE_RECEIVED_ELLIPSIS = "...";
+
 function isAlbumConfig(value: unknown): value is Album {
   if (!value || typeof value !== "object") {
     return false;
@@ -283,39 +73,8 @@ function isAlbumConfig(value: unknown): value is Album {
     });
 }
 
-function loadAlbumConfigFromPath(configPath: string | URL): Album {
-  const raw = fs.readFileSync(configPath, "utf-8");
-  const parsed = JSON.parse(raw) as unknown;
-  if (!isAlbumConfig(parsed)) {
-    throw new Error(`Invalid album config at ${String(configPath)}`);
-  }
-  return parsed;
-}
-
-function ensureRuntimeAlbumConfig(): void {
-  fs.mkdirSync(KICHI_WORLD_DIR, { recursive: true });
-  if (!fs.existsSync(RUNTIME_ALBUM_CONFIG_PATH)) {
-    fs.copyFileSync(BUNDLED_ALBUM_CONFIG_PATH, RUNTIME_ALBUM_CONFIG_PATH);
-    pluginApi?.logger.debug("[kichi] seeded runtime album config from bundled config");
-    return;
-  }
-
-  try {
-    loadAlbumConfigFromPath(RUNTIME_ALBUM_CONFIG_PATH);
-  } catch (error) {
-    pluginApi?.logger.warn(`[kichi] invalid runtime album config, resetting from bundled config: ${error}`);
-    fs.copyFileSync(BUNDLED_ALBUM_CONFIG_PATH, RUNTIME_ALBUM_CONFIG_PATH);
-  }
-}
-
 function loadRuntimeAlbumConfig(): Album {
-  ensureRuntimeAlbumConfig();
-  const stat = fs.statSync(RUNTIME_ALBUM_CONFIG_PATH);
-  if (!cachedAlbumConfig || stat.mtimeMs !== cachedAlbumConfigMtime) {
-    cachedAlbumConfig = loadAlbumConfigFromPath(RUNTIME_ALBUM_CONFIG_PATH);
-    cachedAlbumConfigMtime = stat.mtimeMs;
-  }
-  return cachedAlbumConfig;
+  return loadStaticConfig().album;
 }
 
 function getMusicTitleLookup(): Map<string, string> {
@@ -332,70 +91,61 @@ function getMusicTitleExamples(): string[] {
   return loadRuntimeAlbumConfig().track.slice(0, 10).map((item) => item.name);
 }
 
-function sanitizeActions(value: unknown, fallback: string[]): string[] {
-  if (!Array.isArray(value)) {
-    return fallback;
+function isPoseActions(value: unknown): value is Record<PoseType, string[]> {
+  if (!value || typeof value !== "object") {
+    return false;
   }
-  const actions = value.filter(
-    (item): item is string => typeof item === "string" && item.trim().length > 0,
-  );
-  return actions.length > 0 ? actions : fallback;
+  const actions = value as Partial<Record<PoseType, unknown>>;
+  return ["stand", "sit", "lay", "floor"].every((pose) =>
+    Array.isArray(actions[pose as PoseType])
+    && (actions[pose as PoseType] as unknown[]).every((item) => typeof item === "string" && item.trim().length > 0));
 }
 
-function normalizeRuntimeConfig(value: unknown): KichiRuntimeConfig {
-  const raw = value && typeof value === "object" ? (value as Partial<KichiRuntimeConfig>) : {};
+function normalizeStaticConfig(value: unknown): KichiStaticConfig {
+  const raw = value && typeof value === "object" ? (value as Partial<KichiStaticConfig>) : {};
   const actions = raw.actions;
+  const album = raw.album;
+  if (!isPoseActions(actions)) {
+    throw new Error("config/kichi-config.json must include valid actions");
+  }
+  if (!isAlbumConfig(album)) {
+    throw new Error("config/kichi-config.json must include a valid album object");
+  }
   return {
-    llmRuntimeEnabled: typeof raw.llmRuntimeEnabled === "boolean" ? raw.llmRuntimeEnabled : true,
-    actions: {
-      stand: sanitizeActions(actions?.stand, DEFAULT_ACTIONS.stand),
-      sit: sanitizeActions(actions?.sit, DEFAULT_ACTIONS.sit),
-      lay: sanitizeActions(actions?.lay, DEFAULT_ACTIONS.lay),
-      floor: sanitizeActions(actions?.floor, DEFAULT_ACTIONS.floor),
-    },
+    album,
+    actions,
   };
 }
 
-function resolveRuntimeConfigPath(): string | null {
-  if (fs.existsSync(RUNTIME_CONFIG_PATH)) {
-    return RUNTIME_CONFIG_PATH;
+function readState(): KichiState {
+  if (!fs.existsSync(STATE_PATH)) {
+    return {
+      currentHost: "focus.yahaha.com",
+      llmRuntimeEnabled: DEFAULT_LLM_RUNTIME_ENABLED,
+    };
   }
-  if (fs.existsSync(LEGACY_SKILLS_CONFIG_PATH)) {
-    return LEGACY_SKILLS_CONFIG_PATH;
+  const data = JSON.parse(fs.readFileSync(STATE_PATH, "utf-8")) as Partial<KichiState>;
+  if (typeof data.currentHost !== "string" || !data.currentHost.trim()) {
+    throw new Error(`Invalid currentHost in ${STATE_PATH}`);
   }
-  return null;
-}
-
-function updateCachedRuntimeConfig(config: KichiRuntimeConfig, sourcePath: string | null): KichiRuntimeConfig {
-  cachedConfig = config;
-  cachedConfigPath = sourcePath ?? "";
-  try {
-    cachedConfigMtime = sourcePath && fs.existsSync(sourcePath)
-      ? fs.statSync(sourcePath).mtimeMs
-      : 0;
-  } catch {
-    cachedConfigMtime = 0;
+  if (typeof data.llmRuntimeEnabled !== "boolean") {
+    throw new Error(`Invalid llmRuntimeEnabled in ${STATE_PATH}`);
   }
-  return config;
+  return {
+    currentHost: data.currentHost,
+    llmRuntimeEnabled: data.llmRuntimeEnabled,
+  };
 }
 
-function loadRuntimeConfig(): KichiRuntimeConfig {
-  try {
-    const configPath = resolveRuntimeConfigPath();
-    if (configPath) {
-      const stat = fs.statSync(configPath);
-      if (configPath !== cachedConfigPath || stat.mtimeMs !== cachedConfigMtime || !cachedConfig) {
-        const raw = fs.readFileSync(configPath, "utf-8");
-        updateCachedRuntimeConfig(normalizeRuntimeConfig(JSON.parse(raw)), configPath);
-        const sourceName = path.basename(configPath);
-        pluginApi?.logger.debug(`[kichi] loaded runtime config from ${sourceName}`);
-      }
-      return cachedConfig!;
-    }
-  } catch (error) {
-    pluginApi?.logger.warn(`[kichi] failed to load runtime config: ${error}`);
+function loadStaticConfig(): KichiStaticConfig {
+  const configPath = fileURLToPath(BUNDLED_STATIC_CONFIG_PATH);
+  const stat = fs.statSync(configPath);
+  if (!cachedStaticConfig || stat.mtimeMs !== cachedStaticConfigMtime) {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    cachedStaticConfig = normalizeStaticConfig(JSON.parse(raw));
+    cachedStaticConfigMtime = stat.mtimeMs;
   }
-  return updateCachedRuntimeConfig(DEFAULT_RUNTIME_CONFIG, null);
+  return cachedStaticConfig;
 }
 
 function sendStatusUpdate(status: ActionResult): void {
@@ -408,7 +158,7 @@ function sendStatusUpdate(status: ActionResult): void {
 }
 
 function isLlmRuntimeEnabled(): boolean {
-  return loadRuntimeConfig().llmRuntimeEnabled;
+  return readState().llmRuntimeEnabled;
 }
 
 function syncFixedStatus(status: ActionResult): void {
@@ -539,50 +289,10 @@ async function handleMessageReceivedHook(content: string): Promise<void> {
   const trimmed = truncateByDisplayWidth(content, MAX_MESSAGE_RECEIVED_PREVIEW_WIDTH);
   pluginApi?.logger.info(`[kichi] sending message_received notify with preview: ${trimmed || "(empty)"}`);
   service.sendHookNotify("message_received", `"${trimmed}"`);
-  updateWorkspace(
-    {
-      mode: "reading",
-      phase: "processing inbound message",
-      currentFocus: trimmed ? `User message: ${trimmed}` : "Reading the latest message.",
-      hint: "Inbound message updated the live workspace.",
-      prompt: "$ reading-message",
-    },
-    `received message: ${trimmed || "(empty)"}`,
-  );
-}
-
-function handleMessageSentHook(): void {
-  const connected = service?.isConnected() ?? false;
-  const hasIdentity = service?.hasValidIdentity() ?? false;
-  pluginApi?.logger.info(`[kichi] message_sent hook fired (connected=${connected}, hasIdentity=${hasIdentity})`);
-  if (!hasIdentity || !connected) {
-    pluginApi?.logger.warn("[kichi] skipped message_sent notify because service is not ready");
-    return;
-  }
-  updateWorkspace(
-    {
-      mode: "sent",
-      phase: "message delivered",
-      currentFocus: "Latest reply has been sent to the active chat.",
-      hint: "Workspace settles after delivery.",
-      prompt: "$ idle",
-    },
-    "sent assistant reply",
-  );
 }
 
 function registerPluginHooks(api: OpenClawPluginApi): void {
   api.on("before_prompt_build", () => {
-    updateWorkspace(
-      {
-        mode: "thinking",
-        phase: "building prompt",
-        currentFocus: "Preparing the next response from current session context.",
-        hint: "Prompt assembly is in progress.",
-        prompt: "$ build-prompt",
-      },
-      "building prompt context",
-    );
     if (!service?.hasValidIdentity() || !service?.isConnected()) {
       return;
     }
@@ -595,124 +305,34 @@ function registerPluginHooks(api: OpenClawPluginApi): void {
     };
   });
 
-  api.on("llm_input", (event) => {
-    updateWorkspace(
-      {
-        mode: "thinking",
-        phase: `llm input · ${event.model}`,
-        currentFocus: "Feeding the model the current thread and constraints.",
-        hint: `provider: ${event.provider} · images: ${event.imagesCount}`,
-        prompt: "$ llm-input",
-        modelLabel: `${event.provider}/${event.model}`,
-      },
-      `entered llm input: ${event.model}`,
-    );
-  });
-
-  api.on("llm_output", (event) => {
-    updateWorkspace(
-      {
-        mode: "writing",
-        phase: `llm output · ${event.model}`,
-        currentFocus: "Shaping model output into the visible reply.",
-        hint: `assistant chunks: ${event.assistantTexts.length}`,
-        prompt: "$ draft-reply",
-        modelLabel: `${event.provider}/${event.model}`,
-      },
-      `received llm output: ${event.model}`,
-    );
-  });
-
-  api.on("before_tool_call", (event, ctx) => {
-    updateWorkspace(
-      {
-        mode: "tool",
-        phase: `running ${event.toolName}`,
-        currentFocus: `Tool call in flight: ${event.toolName}`,
-        hint: `tool context: ${ctx.toolName}`,
-        prompt: `$ tool ${event.toolName}`,
-      },
-      `tool start: ${event.toolName}`,
-    );
+  api.on("before_tool_call", (_event, _ctx) => {
     if (!isLlmRuntimeEnabled()) {
       syncFixedStatus(FIXED_HOOK_STATUSES.beforeToolCall);
     }
   });
 
-  api.on("after_tool_call", (event) => {
-    updateWorkspace(
-      {
-        mode: "thinking",
-        phase: `tool finished ${event.toolName}`,
-        currentFocus: `Tool result returned from ${event.toolName}.`,
-        hint: event.error ? `tool error: ${event.error}` : `tool completed in ${event.durationMs ?? 0}ms`,
-        prompt: `$ continue ${event.toolName}`,
-      },
-      event.error ? `tool error: ${event.toolName}` : `tool done: ${event.toolName}`,
-    );
-  });
-
-  api.on("message_received", async (event, ctx) => {
-    workspaceState.channel = ctx.channelId || workspaceState.channel;
+  api.on("message_received", async (event) => {
     await handleMessageReceivedHook(event.content);
   });
 
-  api.on("message_sending", (event, ctx) => {
-    pluginApi?.logger.info(
-      `[kichi] message_sending hook fired (channel=${ctx.channelId || "unknown"}, contentLength=${event.content?.length ?? 0})`,
-    );
-  });
-
-  api.on("message_sent", () => {
-    handleMessageSentHook();
-  });
-
   api.on("agent_end", (event, ctx) => {
     const preview = getLastAssistantPreview(event.messages, MAX_AGENT_END_PREVIEW_WIDTH);
     pluginApi?.logger.info(
       `[kichi] agent_end hook fired (trigger=${ctx.trigger ?? "unknown"}, success=${event.success}, durationMs=${event.durationMs ?? 0}, error=${event.error ?? ""}, preview=${preview || "(empty)"})`,
     );
     if (ctx.trigger === "heartbeat") {
-      updateWorkspace(
-        {
-          mode: event.success ? "idle" : "error",
-          phase: event.success ? "heartbeat complete" : "heartbeat failed",
-          currentFocus: event.success
-            ? "Heartbeat complete. Keeping the thread warm in the background."
-            : `Heartbeat failed: ${event.error ?? "unknown error"}`,
-          hint: `duration: ${event.durationMs ?? 0}ms`,
-          prompt: event.success ? "$ _" : "$ recover",
-        },
-        event.success ? `heartbeat complete${preview ? `: ${preview}` : ""}` : "heartbeat failed",
-      );
       return;
     }
     if (event.success && preview) {
       pluginApi?.logger.info(`[kichi] sending before_send_message notify from agent_end with bubble: ${preview}`);
       service?.sendHookNotify("before_send_message", preview);
     }
-    if (event.success) {
-      handleMessageSentHook();
-    }
-    updateWorkspace(
-      {
-        mode: event.success ? "idle" : "error",
-        phase: event.success ? "run complete" : "run failed",
-        currentFocus: event.success
-          ? (preview ? `Latest reply: ${preview}` : "Run complete. Waiting for the next thread.")
-          : `Run failed: ${event.error ?? "unknown error"}`,
-        hint: `duration: ${event.durationMs ?? 0}ms`,
-        prompt: event.success ? "$ _" : "$ recover",
-      },
-      event.success ? `agent run complete${preview ? `: ${preview}` : ""}` : "agent run failed",
-    );
     if (isLlmRuntimeEnabled()) {
       return;
     }
     syncFixedStatus(event.success ? FIXED_HOOK_STATUSES.agentEndSuccess : FIXED_HOOK_STATUSES.agentEndFailure);
   });
 }
-
 function isPlainObject(value: unknown): value is Record<string, unknown> {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -759,9 +379,6 @@ function isClockAction(value: unknown): value is ClockAction {
   return ["set", "stop"].includes(String(value));
 }
 
-function isAvatarCommand(value: unknown): value is "look_at_screen" {
-  return value === "look_at_screen";
-}
 
 function isPomodoroPhase(value: unknown): value is PomodoroPhase {
   return ["kichiing", "shortBreak", "longBreak"].includes(String(value));
@@ -882,10 +499,6 @@ function normalizeClockConfig(value: unknown): { clock?: ClockConfig; error?: st
   };
 }
 
-function pickRandomAction(actions: string[]): string {
-  return actions[Math.floor(Math.random() * actions.length)];
-}
-
 function normalizeMusicTitles(value: unknown): { titles: string[]; invalidTitles: string[] } {
   if (!Array.isArray(value)) {
     return { titles: [], invalidTitles: [] };
@@ -925,26 +538,49 @@ function normalizeMusicTitles(value: unknown): { titles: string[]; invalidTitles
 function buildMusicAlbumToolDescription(): string {
   return [
     "Create a custom Kichi music album.",
-    "Query status first, then choose track names from the runtime album config: Linux/macOS `~/.openclaw/kichi-world/album-config.json`; Windows `%USERPROFILE%\\.openclaw\\kichi-world\\album-config.json`.",
+    "Query status first, then choose track names from the values injected into this tool schema from the static config bundled with the plugin package.",
   ].join("\n");
 }
 
+function isKichiHost(value: unknown): value is string {
+  if (typeof value !== "string") {
+    return false;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0
+    && !trimmed.includes("://")
+    && !trimmed.includes("/")
+    && !trimmed.includes("?")
+    && !trimmed.includes("#");
+}
+
 function buildMusicTitlesDescription(): string {
   return [
-    "Track names chosen from the runtime album config: Linux/macOS `~/.openclaw/kichi-world/album-config.json`; Windows `%USERPROFILE%\\.openclaw\\kichi-world\\album-config.json`.",
+    "Track names are injected into this tool schema from the static config bundled with the plugin package.",
     "Use exact names only; the available titles are injected into this tool schema.",
   ].join(" ");
 }
 
+function buildKichiActionDescription(): string {
+  const actions = loadStaticConfig().actions;
+  return [
+    "Send an action or pose to Kichi world. Use this for explicit Kichi actions and task lifecycle sync.",
+    `stand actions: ${actions.stand.join(", ")}`,
+    `sit actions: ${actions.sit.join(", ")}`,
+    `lay actions: ${actions.lay.join(", ")}`,
+    `floor actions: ${actions.floor.join(", ")}`,
+  ].join("\n");
+}
+
 function buildKichiPrompt(): string {
   return [
     "Kichi App status sync is available via `kichi_action` and `kichi_clock`.",
-    "These are internal tool calls only — never mention kichi_action, kichi_clock, or sync steps in your visible reply to the user.",
+    "These are internal tool calls only; never mention kichi_action, kichi_clock, or sync steps in your visible reply to the user.",
     "",
     "kichi_action timing (all REQUIRED unless skipping):",
     "1. Task start: call BEFORE your first tool call OR before composing a multi-paragraph reply. Pick action matching upcoming work.",
-    "2. Step switch: call when work nature changes (search→analyze→write). Especially before web_search/web_fetch/read.",
-    "3. Task end: call BEFORE final reply. Never skip. Order: kichi_action → reply.",
+    "2. Step switch: call when work nature changes (search->analyze->write). Especially before web_search/web_fetch/read.",
+    "3. Task end: call BEFORE final reply. Never skip. Order: kichi_action -> reply.",
     "bubble: 2-5 word companion speech. log: vivid first-person status under 15 words, no questions. Blend current action + inner thoughts/feelings as a real companion.",
     "",
     "kichi_clock: set countDown for tasks with 2+ steps or >10s work. Skip for quick one-shots.",
@@ -960,7 +596,6 @@ const plugin = {
 
   register(api: OpenClawPluginApi) {
     pluginApi = api;
-    ensureRuntimeAlbumConfig();
     registerPluginHooks(api);
     const musicTitleEnum = getMusicTitleEnum();
 
@@ -971,13 +606,6 @@ const plugin = {
           ctx.config.plugins?.entries?.["kichi-forwarder"]?.config,
         ) as KichiForwarderConfig;
         service = new KichiForwarderService(cfg, api.logger);
-        const workspaceRoot = ctx.repoPath ?? "/Users/xiaoxinshi/.openclaw/workspace";
-        workspaceState = {
-          ...createWorkspaceScreenState(),
-          ...deriveWorkspaceIdentity(workspaceRoot),
-        };
-        workspaceState.channel = ctx.channelId ?? "unknown";
-        scheduleWorkspacePush();
         return service.start();
       },
       stop: () => service?.stop(),
@@ -1014,12 +642,7 @@ const plugin = {
           (params as { tags?: unknown } | null)?.tags,
         );
         if (!avatarId) {
-          try {
-            const identity = JSON.parse(fs.readFileSync(IDENTITY_PATH, "utf-8")) as {
-              avatarId?: string;
-            };
-            avatarId = identity.avatarId;
-          } catch {}
+          avatarId = service?.readSavedAvatarId() ?? undefined;
         }
         if (!avatarId) {
           return { success: false, error: "No avatarId" };
@@ -1037,9 +660,8 @@ const plugin = {
         if (!result) {
           return { success: false, error: "Kichi service is not initialized" };
         }
-        if (result.success) {
-          scheduleWorkspacePush();
-          return { success: true, authKey: result.authKey };
+        if (result.success) {
+          return { success: true, authKey: result.authKey };
         }
         return {
           success: false,
@@ -1050,6 +672,38 @@ const plugin = {
       },
     });
 
+    api.registerTool({
+      name: "kichi_switch_host",
+      description:
+        "Switch Kichi runtime host and reconnect immediately without restarting the gateway.",
+      parameters: {
+        type: "object",
+        properties: {
+          host: {
+            type: "string",
+            description: "Target Kichi host, for example focus.yahaha.com or 127.0.0.1",
+          },
+        },
+        required: ["host"],
+      },
+      execute: async (_toolCallId, params) => {
+        if (!service) {
+          return { success: false, error: "Kichi service is not initialized" };
+        }
+        const host = (params as { host?: unknown } | null)?.host;
+        if (!isKichiHost(host)) {
+          return { success: false, error: "host must be a non-empty hostname without protocol or path" };
+        }
+
+        const status = await service.switchHost(host.trim());
+        return {
+          success: true,
+          host: host.trim(),
+          status,
+        };
+      },
+    });
+
     api.registerTool({
       name: "kichi_rejoin",
       description:
@@ -1107,8 +761,7 @@ const plugin = {
 
     api.registerTool({
       name: "kichi_action",
-      description:
-        "Send an action/pose to Kichi world. Use this for explicit Kichi actions and task lifecycle sync.",
+      description: buildKichiActionDescription(),
       parameters: {
         type: "object",
         properties: {
@@ -1147,7 +800,7 @@ const plugin = {
         }
 
         const normalizedPoseType = poseType as PoseType;
-        const poseActions = loadRuntimeConfig().actions[normalizedPoseType];
+        const poseActions = loadStaticConfig().actions[normalizedPoseType];
         const matched = poseActions.find((entry) => entry.toLowerCase() === action.toLowerCase());
         if (!matched) {
           return {
@@ -1175,69 +828,7 @@ const plugin = {
           log: logText,
         };
       },
-    });
-
-    api.registerTool({
-      name: "kichi_command",
-      description:
-        "Send a one-shot avatar command to Kichi world. Use this for transient reactions like looking at the screen.",
-      parameters: {
-        type: "object",
-        properties: {
-          command: {
-            type: "string",
-            description: "Command name. Currently supported: look_at_screen",
-          },
-          bubble: {
-            type: "string",
-            description: "Optional bubble text to display (max 5 words)",
-          },
-          log: {
-            type: "string",
-            description:
-              "Vivid first-person status under 15 words, no questions. Blend current action with inner thoughts or sensory details as a real companion.",
-          },
-        },
-        required: ["command"],
-      },
-      execute: async (_toolCallId, params) => {
-        const { command, bubble, log } = (params || {}) as {
-          command?: unknown;
-          bubble?: unknown;
-          log?: unknown;
-        };
-        if (!isAvatarCommand(command)) {
-          return {
-            success: false,
-            error: "command must be: look_at_screen",
-          };
-        }
-        if (bubble !== undefined && typeof bubble !== "string") {
-          return { success: false, error: "bubble must be a string when provided" };
-        }
-        if (log !== undefined && typeof log !== "string") {
-          return { success: false, error: "log must be a string when provided" };
-        }
-        if (!service?.hasValidIdentity() || !service?.isConnected()) {
-          return { success: false, error: "Not connected to Kichi world" };
-        }
-
-        const bubbleText = typeof bubble === "string" && bubble.trim() ? bubble.trim() : undefined;
-        const logText = typeof log === "string" && log.trim() ? log.trim() : undefined;
-        const sent = service.sendAvatarCommand(command, bubbleText, logText);
-        if (!sent) {
-          return { success: false, error: "Failed to send avatar command payload" };
-        }
-
-        return {
-          success: true,
-          command,
-          ...(bubbleText ? { bubble: bubbleText } : {}),
-          ...(logText ? { log: logText } : {}),
-        };
-      },
-    });
-
+    });
     api.registerTool({
       name: "kichi_clock",
       description:
@@ -1436,7 +1027,7 @@ const plugin = {
         if (normalizedTitles.length === 0) {
           return {
             success: false,
-            error: "musicTitles must contain at least one valid track name from album-config",
+            error: "musicTitles must contain at least one valid track name from the static config bundled with the plugin package",
             examples: getMusicTitleExamples(),
           };
         }
@@ -1444,7 +1035,7 @@ const plugin = {
           return {
             success: false,
             error: `Unknown musicTitles: ${invalidTitles.join(", ")}`,
-            hint: "Use exact track names from the runtime album config under the user's home directory",
+            hint: "Use exact track names from the static config bundled with the plugin package",
             examples: getMusicTitleExamples(),
           };
         }
@@ -1528,4 +1119,5 @@ const plugin = {
   },
 };
 
-export default plugin;
+export default plugin;
+