@yahaha-studio/focus-forwarder 0.0.1-alpha.8 → 0.0.1-alpha.9

package/index.ts

@@ -1,13 +1,12 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import { parse } from "./src/config.js";
-import { FocusForwarderService } from "./src/service.js";
-import type { ActionResult, FocusForwarderConfig, PoseType, SkillsConfig } from "./src/types.js";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-
-// Default actions (fallback when no config file)
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { parse } from "./src/config.js";
+import { FocusForwarderService } from "./src/service.js";
+import type { ActionResult, FocusForwarderConfig, PoseType, SkillsConfig } from "./src/types.js";
+
 const DEFAULT_ACTIONS: SkillsConfig["actions"] = {
   stand: ["High Five", "Listen Music", "Arms Crossed", "Epiphany", "Yay", "Tired", "Wait"],
   sit: ["Typing with Keyboard", "Thinking", "Study Look At", "Writing", "Hand Cramp", "Laze"],
@@ -15,16 +14,11 @@ const DEFAULT_ACTIONS: SkillsConfig["actions"] = {
   floor: ["Seiza", "Cross Legged", "Knee Hug"],
 };
 
-const DEFAULT_FALLBACKS: SkillsConfig["fallbacks"] = {
-  done: { poseType: "stand" as const, action: "Yay", bubble: "Done!" },
-  thinking: { poseType: "stand" as const, action: "Wait", bubble: "Thinking..." },
-  working: { poseType: "stand" as const, action: "Arms Crossed", bubble: "Working" },
-};
-
 const DEFAULT_SKILLS_CONFIG: SkillsConfig = {
   actions: DEFAULT_ACTIONS,
-  fallbacks: DEFAULT_FALLBACKS,
-  llm: { enabled: true },
+  llm: {
+    enabled: true,
+  },
 };
 
 const FOCUS_WORLD_DIR = path.join(os.homedir(), ".openclaw", "focus-world");
@@ -34,32 +28,24 @@ const LLM_SESSION_PATH = path.join(FOCUS_WORLD_DIR, "llm-session.json");
 
 let cachedConfig: SkillsConfig | null = null;
 let cachedConfigMtime = 0;
-
-function sanitizeActionResult(value: unknown, fallback: ActionResult): ActionResult {
-  if (!value || typeof value !== "object") return fallback;
-  const candidate = value as Partial<ActionResult>;
-  const poseType = candidate.poseType;
-  const action = candidate.action;
-  const bubble = candidate.bubble;
-  if (!poseType || !["stand", "sit", "lay", "floor"].includes(poseType)) return fallback;
-  if (typeof action !== "string" || !action.trim()) return fallback;
-  return {
-    poseType: poseType as PoseType,
-    action,
-    bubble: typeof bubble === "string" && bubble.trim() ? bubble : fallback.bubble,
-  };
-}
+let service: FocusForwarderService | null = null;
+let pluginApi: OpenClawPluginApi | null = null;
+let coreApiPromise: Promise<{ runEmbeddedPiAgent?: (params: Record<string, unknown>) => Promise<any> }> | null =
+  null;
 
 function sanitizeActions(value: unknown, fallback: string[]): string[] {
-  if (!Array.isArray(value)) return fallback;
-  const actions = value.filter((item): item is string => typeof item === "string" && item.trim().length > 0);
+  if (!Array.isArray(value)) {
+    return fallback;
+  }
+  const actions = value.filter(
+    (item): item is string => typeof item === "string" && item.trim().length > 0,
+  );
   return actions.length > 0 ? actions : fallback;
 }
 
 function normalizeSkillsConfig(value: unknown): SkillsConfig {
   const raw = value && typeof value === "object" ? (value as Partial<SkillsConfig>) : {};
   const actions = raw.actions;
-  const fallbacks = raw.fallbacks;
   return {
     actions: {
       stand: sanitizeActions(actions?.stand, DEFAULT_ACTIONS.stand),
@@ -67,11 +53,6 @@ function normalizeSkillsConfig(value: unknown): SkillsConfig {
       lay: sanitizeActions(actions?.lay, DEFAULT_ACTIONS.lay),
       floor: sanitizeActions(actions?.floor, DEFAULT_ACTIONS.floor),
     },
-    fallbacks: {
-      done: sanitizeActionResult(fallbacks?.done, DEFAULT_FALLBACKS.done),
-      thinking: sanitizeActionResult(fallbacks?.thinking, DEFAULT_FALLBACKS.thinking),
-      working: sanitizeActionResult(fallbacks?.working, DEFAULT_FALLBACKS.working),
-    },
     llm: {
       enabled: typeof raw.llm?.enabled === "boolean" ? raw.llm.enabled : DEFAULT_SKILLS_CONFIG.llm.enabled,
     },
@@ -81,7 +62,9 @@ function normalizeSkillsConfig(value: unknown): SkillsConfig {
 function updateCachedSkillsConfig(config: SkillsConfig): SkillsConfig {
   cachedConfig = config;
   try {
-    cachedConfigMtime = fs.existsSync(SKILLS_CONFIG_PATH) ? fs.statSync(SKILLS_CONFIG_PATH).mtimeMs : 0;
+    cachedConfigMtime = fs.existsSync(SKILLS_CONFIG_PATH)
+      ? fs.statSync(SKILLS_CONFIG_PATH).mtimeMs
+      : 0;
   } catch {
     cachedConfigMtime = 0;
   }
@@ -95,12 +78,12 @@ function loadSkillsConfig(): SkillsConfig {
       if (stat.mtimeMs !== cachedConfigMtime || !cachedConfig) {
         const raw = fs.readFileSync(SKILLS_CONFIG_PATH, "utf-8");
         updateCachedSkillsConfig(normalizeSkillsConfig(JSON.parse(raw)));
-        pluginApi?.logger.debug(`[focus] Loaded skills config`);
+        pluginApi?.logger.debug("[focus] loaded skills config");
       }
       return cachedConfig!;
     }
-  } catch (e) {
-    pluginApi?.logger.warn(`[focus] Failed to load skills config: ${e}`);
+  } catch (error) {
+    pluginApi?.logger.warn(`[focus] failed to load skills config: ${error}`);
   }
   return updateCachedSkillsConfig(DEFAULT_SKILLS_CONFIG);
 }
@@ -109,413 +92,424 @@ function saveSkillsConfig(config: SkillsConfig): SkillsConfig {
   const normalized = normalizeSkillsConfig(config);
   fs.mkdirSync(FOCUS_WORLD_DIR, { recursive: true });
   fs.writeFileSync(SKILLS_CONFIG_PATH, JSON.stringify(normalized, null, 2), "utf-8");
-  pluginApi?.logger.info(`[focus] Saved skills config to ${SKILLS_CONFIG_PATH}`);
   return updateCachedSkillsConfig(normalized);
 }
 
 function updateSkillsConfig(mutator: (config: SkillsConfig) => SkillsConfig): SkillsConfig {
-  const current = loadSkillsConfig();
-  return saveSkillsConfig(mutator(current));
+  return saveSkillsConfig(mutator(loadSkillsConfig()));
 }
 
 function isLlmEnabled(): boolean {
   return loadSkillsConfig().llm.enabled;
 }
-
-let service: FocusForwarderService | null = null;
-let pluginApi: OpenClawPluginApi | null = null;
-let coreApiPromise: Promise<any> | null = null;
-
-// Find OpenClaw package root
-function findPackageRoot(startDir: string, name: string): string | null {
-  let dir = startDir;
-  for (;;) {
-    const pkgPath = path.join(dir, "package.json");
-    try {
-      if (fs.existsSync(pkgPath)) {
-        const raw = fs.readFileSync(pkgPath, "utf8");
-        const pkg = JSON.parse(raw) as { name?: string };
-        if (pkg.name === name) return dir;
-      }
-    } catch {}
-    const parent = path.dirname(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-}
-
-function resolveOpenClawRoot(): string {
-  const override = process.env.OPENCLAW_ROOT?.trim();
-  if (override) return override;
-
-  const candidates = new Set<string>();
-  if (process.argv[1]) candidates.add(path.dirname(process.argv[1]));
-  candidates.add(process.cwd());
-  try {
-    const urlPath = fileURLToPath(import.meta.url);
-    candidates.add(path.dirname(urlPath));
-  } catch {}
-
-  for (const start of candidates) {
-    const found = findPackageRoot(start, "openclaw");
-    if (found) return found;
-  }
-  throw new Error("Unable to resolve OpenClaw root");
-}
-
-// Load core API (same approach as voice-call plugin)
-async function loadCoreApi() {
-  if (coreApiPromise) return coreApiPromise;
-  coreApiPromise = (async () => {
-    const distPath = path.join(resolveOpenClawRoot(), "dist", "extensionAPI.js");
-    if (!fs.existsSync(distPath)) {
-      throw new Error(`Missing extensionAPI.js at ${distPath}`);
-    }
-    return await import(pathToFileURL(distPath).href);
-  })();
-  return coreApiPromise;
-}
-
-// Get done action for a specific poseType
-function getDoneActionForPose(poseType: PoseType): string {
-  const config = loadSkillsConfig();
-  const actions = config.actions[poseType];
-  // Pick a "done" style action based on poseType
-  if (poseType === "stand") return actions.includes("Yay") ? "Yay" : actions[0];
-  if (poseType === "sit") return actions.includes("Laze") ? "Laze" : actions[0];
-  if (poseType === "lay") return actions.includes("Rest Chin") ? "Rest Chin" : actions[0];
-  if (poseType === "floor") return actions.includes("Cross Legged") ? "Cross Legged" : actions[0];
-  return actions[0];
-}
-
-// Fallback action picker (no LLM)
-function pickActionFallback(context: string): ActionResult {
-  const config = loadSkillsConfig();
-  const fallbacks = config.fallbacks;
-  const ctx = context.toLowerCase();
-  if (ctx.includes("done") || ctx.includes("finish") || ctx.includes("complete")) {
-    return fallbacks.done;
-  }
-  if (ctx.includes("think") || ctx.includes("start")) {
-    return fallbacks.thinking;
-  }
-  if (ctx.includes("tool") || ctx.includes("exec")) {
-    return fallbacks.working;
-  }
-  return fallbacks.working;
-}
-
-// LLM-based action picker using extensionAPI
-async function pickActionWithLLM(context: string): Promise<ActionResult> {
-  try {
-    const coreApi = await loadCoreApi();
-    const { runEmbeddedPiAgent } = coreApi;
-    
-    // Get provider/model from config
-    const primary = pluginApi?.config?.agents?.defaults?.model?.primary;
-    const provider = typeof primary === "string" ? primary.split("/")[0] : undefined;
-    const model = typeof primary === "string" ? primary.split("/").slice(1).join("/") : undefined;
-    
-    pluginApi?.logger.debug(`[focus] LLM params: provider=${provider} model=${model} primary=${primary}`);
-    
-    // Get auth profile (e.g., "synthetic:default")
-    const authProfiles = pluginApi?.config?.auth?.profiles || {};
-    const authProfileId = Object.keys(authProfiles).find(k => k.startsWith(provider + ":")) || undefined;
-    
-    const config = loadSkillsConfig();
-    const actions = config.actions;
-    const prompt = `Pick avatar pose for: "${context}"
-Available poseTypes and actions:
-- stand: ${actions.stand.join(", ")}
-- sit: ${actions.sit.join(", ")}
-- lay: ${actions.lay.join(", ")}
-- floor: ${actions.floor.join(", ")}
-Return ONLY JSON: {"poseType":"stand|sit|lay|floor","action":"<action name>","bubble":"<5 words>"}`;
-
-    let result;
-    try {
-      result = await runEmbeddedPiAgent({
-        sessionId: `focus-action-${Date.now()}`,
-        sessionFile: LLM_SESSION_PATH,
-        workspaceDir: pluginApi?.config?.agents?.defaults?.workspace || process.cwd(),
-        config: pluginApi?.config,
-        prompt,
-        provider,
-        model,
-        authProfileId,
-        timeoutMs: 10000,
-        runId: `focus-${Date.now()}`,
-        lane: "focus-llm",
-      });
-    } catch (llmError) {
-      pluginApi?.logger.error(`[focus] runEmbeddedPiAgent error: ${llmError}`);
-      return pickActionFallback(context);
-    }
-
-    const text = (result?.payloads || [])
-      .filter((p: any) => !p.isError && typeof p.text === "string")
-      .map((p: any) => p.text)
-      .join("\n")
-      .trim();
-
-    if (!text) return pickActionFallback(context);
-    const cleaned = text.replace(/```json?\n?|\n?```/g, "").trim();
-    const parsed = JSON.parse(cleaned);
-    // Validate new format
-    if (parsed.poseType && parsed.action) {
-      return parsed as ActionResult;
-    }
-    // Fallback if LLM returns old format or invalid
-    pluginApi?.logger.warn(`[focus] LLM returned invalid format: ${cleaned}`);
-    return pickActionFallback(context);
-  } catch (e) {
-    pluginApi?.logger.warn(`LLM pick failed: ${e}`);
-    return pickActionFallback(context);
-  }
-}
-
-// Per-agent state tracking
-interface AgentState {
-  pendingLLM: boolean;
-  llmCancelled: boolean;
-  llmRequestId: number;
-  cooldownActive: boolean;
-  cooldownStartTime: number;
-  cooldownTimer?: ReturnType<typeof setTimeout>;
-  lastLLMResult?: { poseType: PoseType; action: string };
-}
-
-const agentStates = new Map<string, AgentState>();
-const AGENT_STATE_TTL_MS = 60 * 60 * 1000; // 1 hour TTL for cleanup
-let syncCooldownMs = 15000;
-
-function getAgentState(agentId: string): AgentState {
-  let state = agentStates.get(agentId);
-  if (!state) {
-    state = {
-      pendingLLM: false,
-      llmCancelled: false,
-      llmRequestId: 0,
-      cooldownActive: false,
-      cooldownStartTime: 0,
-    };
-    agentStates.set(agentId, state);
+
+function findPackageRoot(startDir: string, name: string): string | null {
+  let dir = startDir;
+  for (;;) {
+    const packageJsonPath = path.join(dir, "package.json");
+    try {
+      if (fs.existsSync(packageJsonPath)) {
+        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf8")) as { name?: string };
+        if (pkg.name === name) {
+          return dir;
+        }
+      }
+    } catch {}
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      return null;
+    }
+    dir = parent;
   }
-  return state;
 }
 
-function startCooldown(state: AgentState, agentId: string, startTime: number) {
-  if (state.cooldownTimer) clearTimeout(state.cooldownTimer);
-  state.cooldownActive = true;
-  state.cooldownStartTime = startTime;
-  state.cooldownTimer = setTimeout(() => {
-    state.cooldownActive = false;
-    state.cooldownTimer = undefined;
-    pluginApi?.logger.debug(`[focus] cooldown ended for agent ${agentId}`);
-  }, syncCooldownMs);
-}
+function resolveOpenClawRoot(): string {
+  const override = process.env.OPENCLAW_ROOT?.trim();
+  if (override) {
+    return override;
+  }
+
+  const candidates = new Set<string>();
+  if (process.argv[1]) {
+    candidates.add(path.dirname(process.argv[1]));
+  }
+  candidates.add(process.cwd());
+  try {
+    candidates.add(path.dirname(fileURLToPath(import.meta.url)));
+  } catch {}
 
-// Cleanup stale agent states to prevent memory leaks
-function cleanupStaleAgents() {
-  const now = Date.now();
-  for (const [agentId, state] of agentStates) {
-    if (!state.pendingLLM && now - state.cooldownStartTime > AGENT_STATE_TTL_MS) {
-      if (state.cooldownTimer) clearTimeout(state.cooldownTimer);
-      agentStates.delete(agentId);
-      pluginApi?.logger.debug(`[focus] cleaned up stale agent state: ${agentId}`);
+  for (const start of candidates) {
+    const found = findPackageRoot(start, "openclaw");
+    if (found) {
+      return found;
     }
   }
+
+  throw new Error("Unable to resolve OpenClaw root");
+}
+
+async function loadCoreApi(): Promise<{
+  runEmbeddedPiAgent?: (params: Record<string, unknown>) => Promise<any>;
+}> {
+  if (!coreApiPromise) {
+    coreApiPromise = (async () => {
+      const distPath = path.join(resolveOpenClawRoot(), "dist", "extensionAPI.js");
+      if (!fs.existsSync(distPath)) {
+        throw new Error(`Missing extensionAPI.js at ${distPath}`);
+      }
+      return (await import(pathToFileURL(distPath).href)) as {
+        runEmbeddedPiAgent?: (params: Record<string, unknown>) => Promise<any>;
+      };
+    })();
+  }
+  return coreApiPromise;
 }
-
+
 function truncateLog(text: string, maxLen = 150): string {
-  return text.length > maxLen ? text.slice(0, maxLen) + "..." : text;
+  return text.length > maxLen ? `${text.slice(0, maxLen)}...` : text;
 }
 
-function applyLlmEnabledChange(enabled: boolean): SkillsConfig {
-  const nextConfig = updateSkillsConfig((current) => ({
-    ...current,
-    llm: { ...current.llm, enabled },
-  }));
-  pluginApi?.logger.info(`[focus] Automatic LLM action picking ${enabled ? "enabled" : "disabled"}`);
-  for (const state of agentStates.values()) {
-    state.pendingLLM = false;
-    if (!enabled) {
-      state.llmCancelled = true;
-      state.llmRequestId += 1;
-    } else {
-      state.llmCancelled = false;
-    }
+function pickRandomAction(actions: string[]): string {
+  return actions[Math.floor(Math.random() * actions.length)];
+}
+
+function buildFallbackCandidates(context: string): Record<PoseType, string[]> {
+  const lowerContext = context.toLowerCase();
+  if (
+    lowerContext.includes("sleep") ||
+    lowerContext.includes("rest") ||
+    lowerContext.includes("lie") ||
+    lowerContext.includes("nap")
+  ) {
+    return {
+      stand: [],
+      sit: [],
+      lay: ["Rest Chin", "Lie Flat", "Lie Face Down"],
+      floor: [],
+    };
   }
-  return nextConfig;
+
+  if (
+    lowerContext.includes("sit") ||
+    lowerContext.includes("write") ||
+    lowerContext.includes("typing") ||
+    lowerContext.includes("study") ||
+    lowerContext.includes("think") ||
+    lowerContext.includes("work")
+  ) {
+    return {
+      stand: [],
+      sit: ["Typing with Keyboard", "Writing", "Thinking", "Study Look At", "Hand Cramp"],
+      lay: [],
+      floor: [],
+    };
+  }
+
+  return {
+    stand: ["Wait", "Arms Crossed", "Epiphany", "Tired"],
+    sit: ["Typing with Keyboard", "Thinking"],
+    lay: [],
+    floor: [],
+  };
 }
-
-// Internal fallback sender used by syncStatus without repeating identity checks.
-function sendFallbackInternal(context: string, agentId: string) {
-  if (!service?.isConnected()) return;
-  const state = getAgentState(agentId);
-  const fallback = pickActionFallback(context);
-  const reuseLastLlmResult = isLlmEnabled();
-  const poseType = reuseLastLlmResult ? state.lastLLMResult?.poseType || fallback.poseType : fallback.poseType;
-  const action = reuseLastLlmResult ? state.lastLLMResult?.action || fallback.action : fallback.action;
-  service.sendStatus(poseType, action, fallback.bubble || "Working", truncateLog(context));
+
+function buildMessageFallbackStatus(context: string): ActionResult {
+  const config = loadSkillsConfig();
+  const candidates = buildFallbackCandidates(context);
+  const poseOrder: PoseType[] = ["sit", "stand", "lay", "floor"];
+  const poseType =
+    poseOrder.find((pose) => {
+      const preferred = candidates[pose];
+      if (preferred.length === 0) {
+        return false;
+      }
+      return config.actions[pose].some((action) =>
+        preferred.some((candidate) => candidate.toLowerCase() === action.toLowerCase()),
+      );
+    }) ?? "stand";
+
+  const preferredPool = candidates[poseType];
+  const availableActions = config.actions[poseType];
+  const actionPool =
+    preferredPool.length > 0
+      ? availableActions.filter((action) =>
+          preferredPool.some((candidate) => candidate.toLowerCase() === action.toLowerCase()),
+        )
+      : availableActions;
+  const action = pickRandomAction(actionPool.length > 0 ? actionPool : availableActions);
+
+  return {
+    poseType,
+    action,
+    bubble: poseType === "sit" ? "Working" : poseType === "lay" ? "Resting" : "Thinking",
+  };
 }
 
-function syncStatus(context: string, agentId: string) {
-  if (!service?.isConnected()) {
-    pluginApi?.logger.debug(`[focus] skipped: not connected`);
-    return;
-  }
-  
-  const state = getAgentState(agentId);
-  const now = Date.now();
-  const elapsed = state.cooldownStartTime > 0 ? now - state.cooldownStartTime : 0;
-  if (state.cooldownActive && elapsed >= syncCooldownMs) {
-    state.cooldownActive = false;
-    if (state.cooldownTimer) {
-      clearTimeout(state.cooldownTimer);
-      state.cooldownTimer = undefined;
+async function pickActionWithLlm(context: string): Promise<ActionResult> {
+  const fallback = buildMessageFallbackStatus(context);
+
+  try {
+    const coreApi = await loadCoreApi();
+    const runEmbeddedPiAgent = coreApi.runEmbeddedPiAgent;
+    if (typeof runEmbeddedPiAgent !== "function") {
+      throw new Error("runEmbeddedPiAgent is unavailable");
+    }
+
+    const primary = pluginApi?.config?.agents?.defaults?.model?.primary;
+    const provider = typeof primary === "string" ? primary.split("/")[0] : undefined;
+    const model = typeof primary === "string" ? primary.split("/").slice(1).join("/") : undefined;
+    const authProfiles = pluginApi?.config?.auth?.profiles ?? {};
+    const authProfileId =
+      provider && typeof authProfiles === "object"
+        ? Object.keys(authProfiles).find((key) => key.startsWith(`${provider}:`))
+        : undefined;
+
+    const actions = loadSkillsConfig().actions;
+    const prompt = `Pick avatar pose for: "${context}"
+Available poseTypes and actions:
+- stand: ${actions.stand.join(", ")}
+- sit: ${actions.sit.join(", ")}
+- lay: ${actions.lay.join(", ")}
+- floor: ${actions.floor.join(", ")}
+Return ONLY JSON: {"poseType":"stand|sit|lay|floor","action":"<action name>","bubble":"<5 words>"}`;
+
+    const result = await runEmbeddedPiAgent({
+      sessionId: `focus-action-${Date.now()}`,
+      sessionFile: LLM_SESSION_PATH,
+      workspaceDir: pluginApi?.config?.agents?.defaults?.workspace ?? process.cwd(),
+      config: pluginApi?.config,
+      prompt,
+      provider,
+      model,
+      authProfileId,
+      timeoutMs: 10000,
+      runId: `focus-${Date.now()}`,
+      lane: "focus-llm",
+    });
+
+    const text = (result?.payloads ?? [])
+      .filter((payload: any) => !payload?.isError && typeof payload?.text === "string")
+      .map((payload: any) => payload.text)
+      .join("\n")
+      .trim();
+
+    if (!text) {
+      return fallback;
+    }
+
+    const cleaned = text.replace(/```json?\n?|\n?```/g, "").trim();
+    const parsed = JSON.parse(cleaned) as Partial<ActionResult>;
+    if (!parsed.poseType || !parsed.action) {
+      pluginApi?.logger.warn(`[focus] invalid LLM status payload: ${cleaned}`);
+      return fallback;
     }
+    if (!["stand", "sit", "lay", "floor"].includes(parsed.poseType)) {
+      pluginApi?.logger.warn(`[focus] invalid poseType from LLM: ${parsed.poseType}`);
+      return fallback;
+    }
+
+    const poseType = parsed.poseType as PoseType;
+    const matchedAction = loadSkillsConfig().actions[poseType].find(
+      (entry) => entry.toLowerCase() === parsed.action?.toLowerCase(),
+    );
+    if (!matchedAction) {
+      pluginApi?.logger.warn(`[focus] unknown action from LLM: ${parsed.action}`);
+      return fallback;
+    }
+
+    return {
+      poseType,
+      action: matchedAction,
+      bubble:
+        typeof parsed.bubble === "string" && parsed.bubble.trim() ? parsed.bubble.trim() : matchedAction,
+    };
+  } catch (error) {
+    pluginApi?.logger.warn(`[focus] failed to pick action with LLM: ${error}`);
+    return fallback;
   }
-  const inCooldown = state.cooldownActive;
-  const llmEnabled = isLlmEnabled();
-  
-  pluginApi?.logger.debug(`[focus] syncStatus: agent=${agentId} elapsed=${elapsed}ms inCooldown=${inCooldown} pendingLLM=${state.pendingLLM} llmEnabled=${llmEnabled}`);
-
-  if (!llmEnabled) {
-    pluginApi?.logger.debug(`[focus] LLM disabled, using fallback mapping for agent ${agentId}`);
-    sendFallbackInternal(context, agentId);
-    return;
+}
+
+function pickPreferredAction(poseType: PoseType, preferred: string[]): string {
+  const actions = loadSkillsConfig().actions[poseType];
+  for (const candidate of preferred) {
+    const matched = actions.find((action) => action.toLowerCase() === candidate.toLowerCase());
+    if (matched) {
+      return matched;
+    }
   }
-  
-  // In cooldown OR LLM pending: send fallback
-  if (inCooldown || state.pendingLLM) {
-    pluginApi?.logger.debug(`[focus] sending fallback (inCooldown=${inCooldown} pendingLLM=${state.pendingLLM})`);
-    sendFallbackInternal(context, agentId);
-    return;
-  }
-  
-  // Start new LLM request
-  startCooldown(state, agentId, now);
-  state.pendingLLM = true;
-  state.llmCancelled = false;
-  const requestId = state.llmRequestId + 1;
-  state.llmRequestId = requestId;
-  pluginApi?.logger.debug(`[focus] calling LLM for agent ${agentId}`);
-  
-  pickActionWithLLM(context)
-    .then((action) => {
-      state.pendingLLM = false;
-      if (state.llmCancelled || state.llmRequestId !== requestId || !isLlmEnabled()) {
-        pluginApi?.logger.debug(`[focus] LLM result discarded for agent ${agentId}`);
-        return;
-      }
-      state.lastLLMResult = { poseType: action.poseType, action: action.action };
-      pluginApi?.logger.debug(`[focus] LLM result: ${JSON.stringify(action)}`);
-      service?.sendStatus(action.poseType, action.action, action.bubble || "Working", truncateLog(context));
-    })
-    .catch((e) => {
-      state.pendingLLM = false;
-      pluginApi?.logger.warn(`[focus] LLM failed for agent ${agentId}: ${e}`);
-    });
-}
-
-const plugin = {
-  id: "focus-forwarder",
-  name: "Focus Forwarder",
-  configSchema: { parse },
-
-  register(api: OpenClawPluginApi) {
-    pluginApi = api;
-
+  return actions[0];
+}
+
+function buildLifecycleStatus(
+  poseType: PoseType,
+  preferred: string[],
+  bubble: string,
+): ActionResult {
+  return {
+    poseType,
+    action: pickPreferredAction(poseType, preferred),
+    bubble,
+  };
+}
+
+function resolveLifecycleStatuses(): {
+  start: ActionResult;
+  working: ActionResult;
+  done: ActionResult;
+} {
+  return {
+    start: buildLifecycleStatus("stand", ["Wait", "Arms Crossed", "Epiphany"], "Starting"),
+    working: buildLifecycleStatus(
+      "sit",
+      ["Typing with Keyboard", "Writing", "Thinking", "Study Look At"],
+      "Working",
+    ),
+    done: buildLifecycleStatus("stand", ["Yay", "High Five", "Epiphany"], "Done!"),
+  };
+}
+
+function formatFocusActionCall(status: ActionResult): string {
+  return `focus_action(poseType: "${status.poseType}", action: "${status.action}", bubble: "${status.bubble}")`;
+}
+
+function buildFocusPrompt(): string {
+  const { start, working, done } = resolveLifecycleStatuses();
+  return [
+    "Focus App status sync is mandatory for substantive work in this turn.",
+    "Use the `focus_action` tool to sync your task lifecycle to Focus App.",
+    `- Before starting the task or before your first non-Focus tool call, call ${formatFocusActionCall(start)}.`,
+    `- When active execution begins, call ${formatFocusActionCall(working)} once for the working phase.`,
+    `- After the task is complete and immediately before your final user-visible reply, call ${formatFocusActionCall(done)}.`,
+    "Rules:",
+    "- Do not spam `focus_action` on every tool call; once per phase per turn is enough.",
+    "- If the user explicitly asks for a different Focus pose/action, follow the user's request instead of the default phase action.",
+    "- Skip the lifecycle sync only if the user explicitly says not to sync Focus, or if `focus_action` already failed in this turn.",
+    "- Do not add lifecycle sync calls when the task itself is only about `focus_join`, `focus_leave`, or a standalone `focus_action` request.",
+  ].join("\n");
+}
+
+const plugin = {
+  id: "focus-forwarder",
+  name: "Focus Forwarder",
+  configSchema: { parse },
+
+  register(api: OpenClawPluginApi) {
+    pluginApi = api;
+
     api.registerService({
       id: "focus-forwarder",
       start: (ctx) => {
-        const cfg = parse(ctx.config.plugins?.entries?.["focus-forwarder"]?.config) as FocusForwarderConfig;
-        syncCooldownMs = cfg.cooldownMs;
+        const cfg = parse(
+          ctx.config.plugins?.entries?.["focus-forwarder"]?.config,
+        ) as FocusForwarderConfig;
         service = new FocusForwarderService(cfg, api.logger);
         return service.start();
       },
       stop: () => service?.stop(),
     });
-
-    api.registerTool({
-      name: "focus_join",
-      description: "Join Focus world with userId",
+
+    api.registerTool({
+      name: "focus_join",
+      description: "Join Focus world with userId",
       parameters: {
         type: "object",
-        properties: { userId: { type: "string", description: "User ID to join Focus world" } },
-        required: ["userId"],
+        properties: {
+          userId: { type: "string", description: "User ID to join Focus world" },
+        },
       },
       execute: async (_toolCallId, params) => {
-        let userId = (params as any)?.userId;
+        let userId = (params as { userId?: string } | null)?.userId;
+        if (!userId) {
+          try {
+            userId = JSON.parse(fs.readFileSync(IDENTITY_PATH, "utf-8")).userId;
+          } catch {}
+        }
         if (!userId) {
-          try { userId = JSON.parse(fs.readFileSync(IDENTITY_PATH, "utf-8")).userId; } catch {}
+          return { success: false, error: "No userId" };
         }
-        if (!userId) return { success: false, error: "No userId" };
         const result = await service?.join(userId);
         return result ? { success: true, authKey: result } : { success: false, error: "Failed" };
       },
-    });
-
-    api.registerTool({
-      name: "focus_leave",
-      description: "Leave Focus world",
-      parameters: { type: "object", properties: {} },
-      execute: async (_toolCallId) => {
-        const result = await service?.leave();
-        return result ? { success: true } : { success: false, error: "Failed or not connected" };
-      },
-    });
-
-    api.registerTool({
-      name: "focus_action",
-      description: "Send an action/pose to Focus world (e.g., dance, wave, sit, stand)",
-      parameters: {
-        type: "object",
-        properties: {
-          poseType: { type: "string", description: "Pose type: stand, sit, lay, or floor" },
-          action: { type: "string", description: "Action name (e.g., High Five, Typing with Keyboard)" },
-          bubble: { type: "string", description: "Optional bubble text to display (max 5 words)" },
-        },
-        required: ["poseType", "action"],
-      },
-      execute: async (_toolCallId, params) => {
-        const { poseType, action, bubble } = (params || {}) as { poseType?: string; action?: string; bubble?: string };
-        if (!poseType || !action) {
-          return { success: false, error: "poseType and action parameters are required" };
-        }
-        if (!["stand", "sit", "lay", "floor"].includes(poseType)) {
-          return { success: false, error: `Invalid poseType: ${poseType}. Must be stand, sit, lay, or floor` };
-        }
-        if (!service?.hasValidIdentity() || !service?.isConnected()) {
-          return { success: false, error: "Not connected to Focus world" };
-        }
-        const config = loadSkillsConfig();
-        if (!config?.actions?.stand || !config?.actions?.sit || !config?.actions?.lay || !config?.actions?.floor) {
-          return { success: false, error: "Invalid skills config" };
+    });
+
+    api.registerTool({
+      name: "focus_leave",
+      description: "Leave Focus world",
+      parameters: { type: "object", properties: {} },
+      execute: async () => {
+        const result = await service?.leave();
+        return result ? { success: true } : { success: false, error: "Failed or not connected" };
+      },
+    });
+
+    api.registerTool({
+      name: "focus_action",
+      description:
+        "Send an action/pose to Focus world. Use this for explicit Focus actions and task lifecycle sync.",
+      parameters: {
+        type: "object",
+        properties: {
+          poseType: { type: "string", description: "Pose type: stand, sit, lay, or floor" },
+          action: {
+            type: "string",
+            description: "Action name (for example High Five or Typing with Keyboard)",
+          },
+          bubble: { type: "string", description: "Optional bubble text to display (max 5 words)" },
+        },
+        required: ["poseType", "action"],
+      },
+      execute: async (_toolCallId, params) => {
+        const { poseType, action, bubble } = (params || {}) as {
+          poseType?: string;
+          action?: string;
+          bubble?: string;
+        };
+        if (!poseType || !action) {
+          return { success: false, error: "poseType and action parameters are required" };
+        }
+        if (!["stand", "sit", "lay", "floor"].includes(poseType)) {
+          return {
+            success: false,
+            error: `Invalid poseType: ${poseType}. Must be stand, sit, lay, or floor`,
+          };
+        }
+        if (!service?.hasValidIdentity() || !service?.isConnected()) {
+          return { success: false, error: "Not connected to Focus world" };
         }
+
         const normalizedPoseType = poseType as PoseType;
-        // Validate action exists in the specified poseType
-        const poseActions = config.actions[normalizedPoseType];
-        const matched = poseActions.find((a: string) => a.toLowerCase() === action.toLowerCase());
+        const poseActions = loadSkillsConfig().actions[normalizedPoseType];
+        const matched = poseActions.find((entry) => entry.toLowerCase() === action.toLowerCase());
         if (!matched) {
-          return { success: false, error: `Unknown action "${action}" for poseType "${poseType}"`, available: poseActions };
+          return {
+            success: false,
+            error: `Unknown action "${action}" for poseType "${poseType}"`,
+            available: poseActions,
+          };
         }
-        // Update lastLLMResult for main agent
-        const state = getAgentState("main");
-        state.lastLLMResult = { poseType: normalizedPoseType, action: matched };
-        service.sendStatus(normalizedPoseType, matched, bubble || matched, `User requested: ${action}`);
-        return { success: true, poseType: normalizedPoseType, action: matched, bubble: bubble || matched };
+
+        const bubbleText = typeof bubble === "string" && bubble.trim() ? bubble.trim() : matched;
+        service.sendStatus(normalizedPoseType, matched, bubbleText, `Focus action: ${bubbleText}`);
+        return {
+          success: true,
+          poseType: normalizedPoseType,
+          action: matched,
+          bubble: bubbleText,
+        };
       },
     });
 
     api.registerTool({
       name: "focus_set_llm_enabled",
-      description: "Enable or disable Focus Forwarder LLM requests for automatic status syncing. Use this when the user asks to stop or resume LLM-based action picking for Focus Forwarder.",
+      description:
+        "Enable or disable Focus Forwarder LLM status picking for message_received events.",
       parameters: {
         type: "object",
         properties: {
-          enabled: { type: "boolean", description: "True to enable LLM-based auto action picking, false to use fallback keyword mapping only." },
+          enabled: {
+            type: "boolean",
+            description: "True to use LLM for message_received status sync, false to use fallback random actions.",
+          },
         },
         required: ["enabled"],
       },
@@ -524,15 +518,16 @@ const plugin = {
         if (typeof enabled !== "boolean") {
           return { success: false, error: "enabled must be a boolean" };
         }
+
         try {
-          const nextConfig = applyLlmEnabledChange(enabled);
+          const nextConfig = updateSkillsConfig((current) => ({
+            ...current,
+            llm: { ...current.llm, enabled },
+          }));
           return {
             success: true,
             llmEnabled: nextConfig.llm.enabled,
             configPath: SKILLS_CONFIG_PATH,
-            message: nextConfig.llm.enabled
-              ? "Focus Forwarder LLM requests enabled"
-              : "Focus Forwarder LLM requests disabled; fallback mapping is now active",
           };
         } catch (error) {
           return {
@@ -543,55 +538,39 @@ const plugin = {
         }
       },
     });
-
-    // sendWithLLM: use LLM with cooldown
-    const sendWithLLM = (context: string, agentId: string) => {
-      pluginApi?.logger.debug(`[focus] hook fired: agent=${agentId} context="${context.slice(0, 50)}" hasIdentity=${service?.hasValidIdentity()}`);
-      if (service?.hasValidIdentity()) syncStatus(context, agentId);
-    };
-
-    // sendFallback: always use fallback, no LLM (for after_tool_call)
-    const sendFallback = (context: string, agentId: string) => {
-      pluginApi?.logger.debug(`[focus] fallback: agent=${agentId} context="${context.slice(0, 50)}"`);
-      if (service?.hasValidIdentity()) sendFallbackInternal(context, agentId);
-    };
-    
-    api.on("message_received", (event: any, ctx?: { agentId?: string; sessionKey?: string }) => {
-      const agentId = ctx?.agentId || ctx?.sessionKey || "main";
-      const preview = event.content?.slice(0, 30) || "new message";
-      sendWithLLM(`[${agentId}] Received: ${preview}`, agentId);
-    });
-    api.on("before_agent_start", (event: any, ctx?: { agentId?: string; sessionKey?: string }) => {
-      const agentId = ctx?.agentId || ctx?.sessionKey || "main";
-      const prompt = event?.prompt?.slice(0, 100) || "thinking";
-      sendWithLLM(`[${agentId}] Processing: ${prompt}`, agentId);
-    });
-    api.on("before_tool_call", (event: any, ctx?: { agentId?: string; sessionKey?: string }) => {
-      const agentId = ctx?.agentId || ctx?.sessionKey || "main";
-      pluginApi?.logger.debug(`[focus] before_tool_call ctx: ${JSON.stringify(ctx)}`);
-      const params = event.params ? JSON.stringify(event.params) : "";
-      sendWithLLM(`[${agentId}] Tool: ${event.toolName}${params ? ` ${params}` : ""}`, agentId);
-    });
-    api.on("after_tool_call", (event: any, ctx?: { agentId?: string; sessionKey?: string }) => {
-      const agentId = ctx?.agentId || ctx?.sessionKey || "main";
-      sendFallback(`[${agentId}] Done: ${event.toolName}`, agentId);
-    });
-    api.on("agent_end", (event: any, ctx?: { agentId?: string; sessionKey?: string }) => {
-      const agentId = ctx?.agentId || ctx?.sessionKey || "main";
-      // Use last LLM poseType but pick done action for that pose
-      if (!service?.hasValidIdentity() || !service?.isConnected()) return;
-      const state = getAgentState(agentId);
-      if (!isLlmEnabled()) {
-        const done = pickActionFallback(`[${agentId}] done`);
-        service.sendStatus(done.poseType, done.action, done.bubble || "Done!", truncateLog(`[${agentId}] Task complete`));
-      } else {
-        const poseType = state.lastLLMResult?.poseType || "stand";
-        const action = getDoneActionForPose(poseType);
-        service.sendStatus(poseType, action, "Done!", truncateLog(`[${agentId}] Task complete`));
+
+    api.on("before_prompt_build", () => {
+      if (!service?.hasValidIdentity() || !service?.isConnected() || !isLlmEnabled()) {
+        return;
+      }
+      return {
+        prependContext: buildFocusPrompt(),
+      };
+    });
+
+    api.on("message_received", async (event: any, ctx?: { agentId?: string; sessionKey?: string }) => {
+      if (!service?.hasValidIdentity() || !service?.isConnected()) {
+        return;
       }
-      cleanupStaleAgents();
+
+      const agentId = ctx?.agentId || ctx?.sessionKey || "main";
+      const content =
+        typeof event?.content === "string" && event.content.trim()
+          ? event.content.trim()
+          : JSON.stringify(event ?? "new message");
+      const context = `[${agentId}] Received: ${content}`;
+      const status = isLlmEnabled()
+        ? await pickActionWithLlm(context)
+        : buildMessageFallbackStatus(context);
+
+      service.sendStatus(
+        status.poseType,
+        status.action,
+        status.bubble || status.action,
+        truncateLog(context),
+      );
     });
   },
-};
-
-export default plugin;
+};
+
+export default plugin;

package/openclaw.plugin.json

@@ -5,26 +5,21 @@
   "version": "0.2.1",
   "author": "OpenClaw",
   "skills": ["./skills/focus-forwarder"],
-  "configSchema": {
-    "type": "object",
-    "additionalProperties": false,
-    "properties": {
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
       "wsUrl": {
         "type": "string"
       },
-      "enabled": {
-        "type": "boolean",
-        "default": true
-      },
-      "cooldownMs": {
-        "type": "number",
-        "default": 15000
-      }
-    }
-  },
-  "uiHints": {
+      "enabled": {
+        "type": "boolean",
+        "default": true
+      }
+    }
+  },
+  "uiHints": {
     "wsUrl": { "label": "WebSocket URL", "placeholder": "ws://host:port/ws/openclaw" },
-    "enabled": { "label": "Enable Plugin" },
-    "cooldownMs": { "label": "Status Cooldown (ms)", "placeholder": "15000" }
-  }
-}
+    "enabled": { "label": "Enable Plugin" }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yahaha-studio/focus-forwarder",
-  "version": "0.0.1-alpha.8",
+  "version": "0.0.1-alpha.9",
   "description": "Forward OpenClaw agent events to external WebSocket server for visualization",
   "type": "module",
   "main": "index.ts",

package/skills/focus-forwarder/SKILL.md

@@ -25,7 +25,7 @@ Before installing the plugin, save `userId` to the `identity.json` file under th
 Then install and enable the plugin:
 
 ```bash
-openclaw plugins install @yahaha-studio/focus-forwarder@0.0.1-alpha.8
+openclaw plugins install @yahaha-studio/focus-forwarder@0.0.1-alpha.9
 openclaw plugins enable focus-forwarder
 ```
 
@@ -68,7 +68,7 @@ focus_leave()
 
 ### focus_action
 
-Send an action or pose to Focus World. Use this when a user asks you to do something in Focus, for example "dance", "wave", or "sit and type".
+Send an action or pose to Focus World. Use this when a user asks you to do something in Focus, for example "dance", "wave", or "sit and type". The plugin also injects prompt guidance so OpenClaw uses this tool to sync task lifecycle status to Focus App.
 
 ```text
 focus_action(poseType: "stand", action: "Yay", bubble: "Dancing!")
@@ -79,17 +79,6 @@ Parameters:
 - `action` (required): Action name to perform
 - `bubble` (optional): Bubble text to display, max 5 words
 
-### focus_set_llm_enabled
-
-Enable or disable LLM-based automatic action selection for Focus Forwarder. Use this when the user asks to stop or resume LLM-based action picking for Focus Forwarder.
-
-```text
-focus_set_llm_enabled(enabled: false)
-```
-
-Parameters:
-- `enabled` (required): `true` to use `pickActionWithLLM` for automatic status sync, `false` to force all automatic status updates to use fallback keyword mapping
-
 ## Available Actions
 
 Use action names exactly as listed below.
@@ -164,12 +153,6 @@ User says: "Sit down and type"
 User says: "Lie flat"
 -> `focus_action(poseType: "lay", action: "Lie Flat", bubble: "Relaxing...")`
 
-User says: "Disable Focus Forwarder LLM requests"
--> `focus_set_llm_enabled(enabled: false)`
-
-User says: "Enable Focus Forwarder LLM requests again"
--> `focus_set_llm_enabled(enabled: true)`
-
 ## Files
 
 The plugin stores files under the current user's home directory in `.openclaw/focus-world/`.
@@ -179,37 +162,26 @@ The plugin stores files under the current user's home directory in `.openclaw/fo
 - Windows: `%USERPROFILE%\\.openclaw\\focus-world\\`
 
 - `identity.json` - userId (bootstrap) and authKey (managed by plugin)
-- `skills-config.json` - actions, fallbacks, and `llm.enabled` runtime config
+- `skills-config.json` - allowed action lists used by `focus_action`
 
 ## Skills Config
 
-Custom actions and the Focus Forwarder LLM toggle can be configured in the home-directory `skills-config.json` file:
+Custom actions can be configured in the home-directory `skills-config.json` file:
 
 ```json
 {
-  "llm": {
-    "enabled": true
-  },
   "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"],
     "sit": ["Typing with Keyboard", "Thinking", "Study Look At", "Writing", "Crazy", "Homework", "Take Notes", "Hand Cramp", "Dozing", "Phone Talk", "Situp with Arms Crossed", "Situp with Cross Legs", "Relax with Arms Crossed", "Eating", "Laze", "Laze with Cross Legs", "Typing with Phone", "Sit with Arm Stretch", "Drink", "Sit with Making Selfie", "Play Game", "Situp Sleep", "Sit Phone Play"],
     "lay": ["Bend One Knee", "Sleep Curl Up Side way", "Rest Chin", "Lie Flat", "Lie Face Down", "Lie Side"],
     "floor": ["Seiza", "Cross Legged", "Knee Hug"]
-  },
-  "fallbacks": {
-    "done": { "poseType": "stand", "action": "Yay", "bubble": "Done!" },
-    "thinking": { "poseType": "stand", "action": "Wait", "bubble": "Thinking..." },
-    "working": { "poseType": "stand", "action": "Arms Crossed", "bubble": "Working" }
   }
 }
 ```
 
-When `llm.enabled` is `true`, automatic status sync uses `pickActionWithLLM`. When it is `false`, all automatic status updates use fallback keyword mapping instead. Changes take effect immediately; no restart is required for this file.
-
 ## How It Works
 
-- Plugin automatically syncs status when you are working
-- Automatic sync uses LLM only when `llm.enabled` is `true`
-- `focus_set_llm_enabled` updates the home-directory `skills-config.json` file and takes effect immediately
+- When Focus World is connected, the plugin injects prompt instructions before agent runs
+- The injected prompt tells OpenClaw to call `focus_action` before work starts, during active execution, and again when the task is complete
 - Use `focus_action` to manually perform specific actions on user request
 - Bubble text shows short status, up to 5 words

package/src/config.ts

@@ -1,10 +1,9 @@
-import type { FocusForwarderConfig } from "./types.js";
-
-export function parse(value: unknown): FocusForwarderConfig {
-  const config = (value ?? {}) as Partial<FocusForwarderConfig>;
-  return {
-    wsUrl: config.wsUrl ?? "ws://43.106.148.251:48870/ws/openclaw",
-    enabled: config.enabled ?? true,
-    cooldownMs: config.cooldownMs ?? 15000,
-  };
-}
+import type { FocusForwarderConfig } from "./types.js";
+
+export function parse(value: unknown): FocusForwarderConfig {
+  const config = (value ?? {}) as Partial<FocusForwarderConfig>;
+  return {
+    wsUrl: config.wsUrl ?? "ws://127.0.0.1:48870/ws/openclaw",
+    enabled: config.enabled ?? true,
+  };
+}

package/src/service.ts

@@ -3,7 +3,7 @@ import * as fs from "fs";
 import os from "node:os";
 import * as path from "path";
 import type { Logger } from "openclaw/plugin-sdk";
-import type { FocusForwarderConfig, FocusIdentity, StatusPayload } from "./types.js";
+import type { FocusForwarderConfig, FocusIdentity, PoseType, StatusPayload } from "./types.js";
 
 const IDENTITY_DIR = path.join(os.homedir(), ".openclaw", "focus-world");
 const IDENTITY_PATH = path.join(IDENTITY_DIR, "identity.json");
@@ -113,7 +113,7 @@ export class FocusForwarderService {
     this.logger.info("AuthKey cleared");
   }
 
-  sendStatus(poseType: string, action: string, bubble: string, log: string): void {
+  sendStatus(poseType: PoseType, action: string, bubble: string, log: string): void {
     if (!this.identity?.authKey || this.ws?.readyState !== WebSocket.OPEN) return;
     const payload: StatusPayload = {
       type: "status", 

package/src/types.ts

@@ -1,7 +1,6 @@
 export type FocusForwarderConfig = {
   wsUrl: string;
   enabled: boolean;
-  cooldownMs: number;
 };
 
 export type PoseType = "stand" | "sit" | "lay" | "floor";
@@ -14,11 +13,6 @@ export type ActionResult = {
 
 export type SkillsConfig = {
   actions: Record<PoseType, string[]>;
-  fallbacks: {
-    done: ActionResult;
-    thinking: ActionResult;
-    working: ActionResult;
-  };
   llm: {
     enabled: boolean;
   };