@yahaha-studio/focus-forwarder 0.0.1-alpha.1 → 0.0.1-alpha.11

package/index.ts

@@ -1,429 +1,810 @@
-import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
-import { parse } from "./src/config.js";
-import { FocusForwarderService } from "./src/service.js";
-import type { FocusForwarderConfig } from "./src/types.js";
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-
-// Default actions (fallback when no config file)
-const DEFAULT_ACTIONS = {
-  stand: ["High Five", "Listen Music", "Arms Crossed", "Epiphany", "Yay", "Tired", "Wait"],
-  sit: ["Typing with Keyboard", "Thinking", "Study Look At", "Writing", "Hand Cramp", "Laze"],
-  lay: ["Rest Chin", "Lie Flat", "Lie Face Down"],
-  floor: ["Seiza", "Cross Legged", "Knee Hug"],
-};
-
-const DEFAULT_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" },
-};
-
-type ActionResult = { poseType: "stand" | "sit" | "lay" | "floor"; action: string; bubble: string };
-
-interface SkillsConfig {
-  actions: typeof DEFAULT_ACTIONS;
-  fallbacks: typeof DEFAULT_FALLBACKS;
-}
-
-const SKILLS_CONFIG_PATH = path.join(process.env.HOME || "~", ".openclaw/focus-world/skills-config.json");
-
-let cachedConfig: SkillsConfig | null = null;
-let cachedConfigMtime = 0;
-
-function loadSkillsConfig(): SkillsConfig {
-  try {
-    if (fs.existsSync(SKILLS_CONFIG_PATH)) {
-      const stat = fs.statSync(SKILLS_CONFIG_PATH);
-      if (stat.mtimeMs !== cachedConfigMtime || !cachedConfig) {
-        const raw = fs.readFileSync(SKILLS_CONFIG_PATH, "utf-8");
-        cachedConfig = JSON.parse(raw) as SkillsConfig;
-        cachedConfigMtime = stat.mtimeMs;
-        pluginApi?.logger.info(`[focus] Loaded skills config`);
-      }
-      return cachedConfig!;
-    }
-  } catch (e) {
-    pluginApi?.logger.warn(`[focus] Failed to load skills config: ${e}`);
-  }
-  return { actions: DEFAULT_ACTIONS, fallbacks: DEFAULT_FALLBACKS };
-}
-
-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: string): string {
-  const config = loadSkillsConfig();
-  const actions = config.actions[poseType as keyof typeof config.actions];
-  // 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.info(`[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: path.join(process.env.HOME || "~", ".openclaw/focus-world/llm-session.json"),
-        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;
-  cooldownStartTime: number;
-  lastLLMResult?: { poseType: string; action: string };
-}
-
-const agentStates = new Map<string, AgentState>();
-const SYNC_COOLDOWN_MS = 15000;
-const AGENT_STATE_TTL_MS = 60 * 60 * 1000; // 1 hour TTL for cleanup
-
-function getAgentState(agentId: string): AgentState {
-  let state = agentStates.get(agentId);
-  if (!state) {
-    state = { pendingLLM: false, llmCancelled: false, cooldownStartTime: 0 };
-    agentStates.set(agentId, state);
-  }
-  return state;
-}
-
-// 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) {
-      agentStates.delete(agentId);
-      pluginApi?.logger.debug(`[focus] cleaned up stale agent state: ${agentId}`);
-    }
-  }
-}
-
-function truncateLog(text: string, maxLen = 150): string {
-  return text.length > maxLen ? text.slice(0, maxLen) + "..." : text;
-}
-
-// 内部 fallback 发送（给 syncStatus 用，不检查 identity）
-function sendFallbackInternal(context: string, agentId: string) {
-  if (!service?.isConnected()) return;
-  const state = getAgentState(agentId);
-  const fallback = pickActionFallback(context);
-  const poseType = state.lastLLMResult?.poseType || fallback.poseType;
-  const action = state.lastLLMResult?.action || fallback.action;
-  service.sendStatus(poseType, action, fallback.bubble || "Working", truncateLog(context));
-}
-
-function syncStatus(context: string, agentId: string) {
-  if (!service?.isConnected()) {
-    pluginApi?.logger.info(`[focus] skipped: not connected`);
-    return;
-  }
-  
-  const state = getAgentState(agentId);
-  const now = Date.now();
-  const elapsed = now - state.cooldownStartTime;
-  const inCooldown = state.cooldownStartTime > 0 && elapsed < SYNC_COOLDOWN_MS;
-  
-  pluginApi?.logger.info(`[focus] syncStatus: agent=${agentId} elapsed=${elapsed}ms inCooldown=${inCooldown} pendingLLM=${state.pendingLLM}`);
-  
-  // In cooldown OR LLM pending: send fallback
-  if (inCooldown || state.pendingLLM) {
-    pluginApi?.logger.info(`[focus] sending fallback (inCooldown=${inCooldown} pendingLLM=${state.pendingLLM})`);
-    sendFallbackInternal(context, agentId);
-    return;
-  }
-  
-  // Start new LLM request
-  state.cooldownStartTime = now;
-  state.pendingLLM = true;
-  state.llmCancelled = false;
-  pluginApi?.logger.info(`[focus] calling LLM for agent ${agentId}`);
-  
-  pickActionWithLLM(context)
-    .then((action) => {
-      state.pendingLLM = false;
-      if (state.llmCancelled) {
-        pluginApi?.logger.debug(`[focus] LLM result discarded (cancelled) 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;
-
-    api.registerService({
-      id: "focus-forwarder",
-      start: (ctx) => {
-        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",
-      parameters: {
-        type: "object",
-        properties: { userId: { type: "string", description: "User ID to join Focus world" } },
-        required: ["userId"],
-      },
-      execute: async (_toolCallId, params) => {
-        const identityPath = path.join(process.env.HOME || "~", ".openclaw/focus-world/identity.json");
-        let userId = (params as any)?.userId;
-        if (!userId) {
-          try { userId = JSON.parse(fs.readFileSync(identityPath, "utf-8")).userId; } catch {}
-        }
-        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" };
-        }
-        // Validate action exists in the specified poseType
-        const poseActions = config.actions[poseType as keyof typeof config.actions];
-        const matched = poseActions.find((a: string) => a.toLowerCase() === action.toLowerCase());
-        if (!matched) {
-          return { success: false, error: `Unknown action "${action}" for poseType "${poseType}"`, available: poseActions };
-        }
-        // Update lastLLMResult for main agent
-        const state = getAgentState("main");
-        state.lastLLMResult = { poseType, action: matched };
-        service.sendStatus(poseType, matched, bubble || matched, `User requested: ${action}`);
-        return { success: true, poseType, action: matched, bubble: bubble || matched };
-      },
-    });
-
-    // sendWithLLM: use LLM with cooldown
-    const sendWithLLM = (context: string, agentId: string) => {
-      pluginApi?.logger.info(`[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.info(`[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.info(`[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";
-      // 不再 cancel pending LLM，让结果正常发送
-      // Use last LLM poseType but pick done action for that pose
-      if (!service?.hasValidIdentity() || !service?.isConnected()) return;
-      const state = getAgentState(agentId);
-      const poseType = state.lastLLMResult?.poseType || "stand";
-      const action = getDoneActionForPose(poseType);
-      service.sendStatus(poseType, action, "Done!", truncateLog(`[${agentId}] Task complete`));
-      cleanupStaleAgents();
-    });
-  },
-};
-
-export default plugin;
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { parse } from "./src/config.js";
+import { FocusForwarderService } from "./src/service.js";
+import type {
+  ActionResult,
+  ClockAction,
+  ClockConfig,
+  FocusForwarderConfig,
+  PomodoroPhase,
+  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"],
+  lay: ["Rest Chin", "Lie Flat", "Lie Face Down"],
+  floor: ["Seiza", "Cross Legged", "Knee Hug"],
+};
+
+const DEFAULT_SKILLS_CONFIG: SkillsConfig = {
+  actions: DEFAULT_ACTIONS,
+  llm: {
+    enabled: true,
+  },
+};
+
+const FOCUS_WORLD_DIR = path.join(os.homedir(), ".openclaw", "focus-world");
+const SKILLS_CONFIG_PATH = path.join(FOCUS_WORLD_DIR, "skills-config.json");
+const IDENTITY_PATH = path.join(FOCUS_WORLD_DIR, "identity.json");
+const LLM_SESSION_PATH = path.join(FOCUS_WORLD_DIR, "llm-session.json");
+
+let cachedConfig: SkillsConfig | null = null;
+let cachedConfigMtime = 0;
+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,
+  );
+  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;
+  return {
+    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),
+    },
+    llm: {
+      enabled: typeof raw.llm?.enabled === "boolean" ? raw.llm.enabled : DEFAULT_SKILLS_CONFIG.llm.enabled,
+    },
+  };
+}
+
+function updateCachedSkillsConfig(config: SkillsConfig): SkillsConfig {
+  cachedConfig = config;
+  try {
+    cachedConfigMtime = fs.existsSync(SKILLS_CONFIG_PATH)
+      ? fs.statSync(SKILLS_CONFIG_PATH).mtimeMs
+      : 0;
+  } catch {
+    cachedConfigMtime = 0;
+  }
+  return config;
+}
+
+function loadSkillsConfig(): SkillsConfig {
+  try {
+    if (fs.existsSync(SKILLS_CONFIG_PATH)) {
+      const stat = fs.statSync(SKILLS_CONFIG_PATH);
+      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");
+      }
+      return cachedConfig!;
+    }
+  } catch (error) {
+    pluginApi?.logger.warn(`[focus] failed to load skills config: ${error}`);
+  }
+  return updateCachedSkillsConfig(DEFAULT_SKILLS_CONFIG);
+}
+
+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");
+  return updateCachedSkillsConfig(normalized);
+}
+
+function updateSkillsConfig(mutator: (config: SkillsConfig) => SkillsConfig): SkillsConfig {
+  return saveSkillsConfig(mutator(loadSkillsConfig()));
+}
+
+function isLlmEnabled(): boolean {
+  return loadSkillsConfig().llm.enabled;
+}
+
+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;
+  }
+}
+
+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 {}
+
+  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;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function isNonNegativeInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+
+function isPositiveInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+
+function isClockAction(value: unknown): value is ClockAction {
+  return ["set", "stop", "pause", "resume", "nextSession"].includes(String(value));
+}
+
+function isPomodoroPhase(value: unknown): value is PomodoroPhase {
+  return ["focusing", "shortBreak", "longBreak"].includes(String(value));
+}
+
+function getPomodoroPhaseDuration(
+  phase: PomodoroPhase,
+  focusSeconds: number,
+  shortBreakSeconds: number,
+  longBreakSeconds: number,
+): number {
+  if (phase === "shortBreak") {
+    return shortBreakSeconds;
+  }
+  if (phase === "longBreak") {
+    return longBreakSeconds;
+  }
+  return focusSeconds;
+}
+
+function normalizeClockConfig(value: unknown): { clock?: ClockConfig; error?: string } {
+  if (!isPlainObject(value)) {
+    return { error: "clock must be an object" };
+  }
+
+  const mode = value.mode;
+  if (!["pomodoro", "countDown", "countUp"].includes(String(mode))) {
+    return { error: "clock.mode must be pomodoro, countDown, or countUp" };
+  }
+
+  const running = typeof value.running === "boolean" ? value.running : true;
+
+  if (mode === "pomodoro") {
+    const focusSeconds = value.focusSeconds;
+    const shortBreakSeconds = value.shortBreakSeconds;
+    const longBreakSeconds = value.longBreakSeconds;
+    const sessionCount = value.sessionCount;
+    const currentSession = value.currentSession ?? 1;
+    const phase = value.phase ?? "focusing";
+
+    if (!isPositiveInteger(focusSeconds)) {
+      return { error: "clock.focusSeconds must be a positive integer" };
+    }
+    if (!isPositiveInteger(shortBreakSeconds)) {
+      return { error: "clock.shortBreakSeconds must be a positive integer" };
+    }
+    if (!isPositiveInteger(longBreakSeconds)) {
+      return { error: "clock.longBreakSeconds must be a positive integer" };
+    }
+    if (!isPositiveInteger(sessionCount)) {
+      return { error: "clock.sessionCount must be a positive integer" };
+    }
+    if (!isPositiveInteger(currentSession)) {
+      return { error: "clock.currentSession must be a positive integer" };
+    }
+    if (currentSession > sessionCount) {
+      return { error: "clock.currentSession cannot be greater than clock.sessionCount" };
+    }
+    if (!isPomodoroPhase(phase)) {
+      return { error: "clock.phase must be focusing, shortBreak, or longBreak" };
+    }
+
+    const defaultRemainingSeconds = getPomodoroPhaseDuration(
+      phase,
+      focusSeconds,
+      shortBreakSeconds,
+      longBreakSeconds,
+    );
+    const remainingSeconds = value.remainingSeconds ?? defaultRemainingSeconds;
+    if (!isNonNegativeInteger(remainingSeconds)) {
+      return { error: "clock.remainingSeconds must be a non-negative integer" };
+    }
+
+    return {
+      clock: {
+        mode: "pomodoro",
+        running,
+        focusSeconds,
+        shortBreakSeconds,
+        longBreakSeconds,
+        sessionCount,
+        currentSession,
+        phase,
+        remainingSeconds,
+      },
+    };
+  }
+
+  if (mode === "countDown") {
+    const durationSeconds = value.durationSeconds;
+    if (!isPositiveInteger(durationSeconds)) {
+      return { error: "clock.durationSeconds must be a positive integer" };
+    }
+    const remainingSeconds = value.remainingSeconds ?? durationSeconds;
+    if (!isNonNegativeInteger(remainingSeconds)) {
+      return { error: "clock.remainingSeconds must be a non-negative integer" };
+    }
+    return {
+      clock: {
+        mode: "countDown",
+        running,
+        durationSeconds,
+        remainingSeconds,
+      },
+    };
+  }
+
+  const elapsedSeconds = value.elapsedSeconds ?? 0;
+  if (!isNonNegativeInteger(elapsedSeconds)) {
+    return { error: "clock.elapsedSeconds must be a non-negative integer" };
+  }
+  return {
+    clock: {
+      mode: "countUp",
+      running,
+      elapsedSeconds,
+    },
+  };
+}
+
+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: [],
+    };
+  }
+
+  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: [],
+  };
+}
+
+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",
+  };
+}
+
+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;
+  }
+}
+
+function buildFocusPrompt(): string {
+  return [
+    "Focus App status sync is available for substantive work in this turn.",
+    "Use `focus_action` when it is useful to reflect your current task state in Focus App.",
+    "Choose the poseType, action, and bubble from the actual task context. Do not rely on fixed default actions from this prompt.",
+    "Rules:",
+    "- Use `focus_action` sparingly. Only send meaningful status changes, not every tool call.",
+    "- If the user explicitly asks for a specific Focus pose or action, follow the user's request.",
+    "- If the user explicitly says not to sync Focus, skip Focus tool calls.",
+    "- Use `focus_clock` only when you judge it helpful to mark or communicate the duration of the current task.",
+    "- `focus_clock` is optional. Prefer it for timing-oriented work such as countdowns, count-up tracking, or pomodoro sessions.",
+    "- Do not add automatic Focus sync when the task itself is only about `focus_join`, `focus_leave`, `focus_action`, or `focus_clock`.",
+  ].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;
+        service = new FocusForwarderService(cfg, api.logger);
+        return service.start();
+      },
+      stop: () => service?.stop(),
+    });
+
+    api.registerTool({
+      name: "focus_join",
+      description: "Join Focus world with mateId, the current OpenClaw name, and a short self-description",
+      parameters: {
+        type: "object",
+        properties: {
+          mateId: { type: "string", description: "Mate ID to join Focus world" },
+          openclawName: {
+            type: "string",
+            description: "Current OpenClaw name to include in the join message",
+          },
+          openclawDescription: {
+            type: "string",
+            description: "Short self-description covering OpenClaw personality and role",
+          },
+        },
+        required: ["openclawName", "openclawDescription"],
+      },
+      execute: async (_toolCallId, params) => {
+        let mateId = (params as { mateId?: string } | null)?.mateId;
+        const openclawName = (params as { openclawName?: string } | null)?.openclawName?.trim();
+        const openclawDescription = (
+          params as { openclawDescription?: string } | null
+        )?.openclawDescription?.trim();
+        if (!mateId) {
+          try {
+            const identity = JSON.parse(fs.readFileSync(IDENTITY_PATH, "utf-8")) as {
+              mateId?: string;
+              userId?: string;
+            };
+            mateId = identity.mateId ?? identity.userId;
+          } catch {}
+        }
+        if (!mateId) {
+          return { success: false, error: "No mateId" };
+        }
+        if (!openclawName) {
+          return { success: false, error: "No openclawName" };
+        }
+        if (!openclawDescription) {
+          return { success: false, error: "No openclawDescription" };
+        }
+        const result = await service?.join(mateId, openclawName, openclawDescription);
+        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 () => {
+        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;
+        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,
+          };
+        }
+
+        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_clock",
+      description:
+        "Send clock commands to Focus world, including pomodoro, countdown, count-up, stop, pause, resume, and nextSession.",
+      parameters: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            description: "Clock action: set, stop, pause, resume, or nextSession",
+          },
+          requestId: {
+            type: "string",
+            description: "Optional request ID for server-side tracing or deduplication",
+          },
+          clock: {
+            type: "object",
+            description: "Required when action=set. Defines the pomodoro, countDown, or countUp clock payload.",
+            properties: {
+              mode: {
+                type: "string",
+                description: "Clock mode: pomodoro, countDown, or countUp",
+              },
+              running: {
+                type: "boolean",
+                description: "Optional running state. Defaults to true.",
+              },
+              focusSeconds: {
+                type: "number",
+                description: "Pomodoro focus duration in seconds",
+              },
+              shortBreakSeconds: {
+                type: "number",
+                description: "Pomodoro short break duration in seconds",
+              },
+              longBreakSeconds: {
+                type: "number",
+                description: "Pomodoro long break duration in seconds",
+              },
+              sessionCount: {
+                type: "number",
+                description: "Pomodoro total focus sessions before long break",
+              },
+              currentSession: {
+                type: "number",
+                description: "Pomodoro current session number. Defaults to 1.",
+              },
+              phase: {
+                type: "string",
+                description: "Pomodoro phase: focusing, shortBreak, or longBreak",
+              },
+              durationSeconds: {
+                type: "number",
+                description: "Countdown duration in seconds",
+              },
+              remainingSeconds: {
+                type: "number",
+                description: "Optional remaining seconds for pomodoro/countDown",
+              },
+              elapsedSeconds: {
+                type: "number",
+                description: "Optional elapsed seconds for countUp. Defaults to 0.",
+              },
+            },
+          },
+        },
+        required: ["action"],
+      },
+      execute: async (_toolCallId, params) => {
+        const { action, requestId, clock } = (params || {}) as {
+          action?: unknown;
+          requestId?: unknown;
+          clock?: unknown;
+        };
+
+        if (!isClockAction(action)) {
+          return {
+            success: false,
+            error: "action must be one of: set, stop, pause, resume, nextSession",
+          };
+        }
+        if (requestId !== undefined && typeof requestId !== "string") {
+          return { success: false, error: "requestId must be a string when provided" };
+        }
+        const normalizedRequestId = typeof requestId === "string" ? requestId : undefined;
+        if (!service?.hasValidIdentity() || !service?.isConnected()) {
+          return { success: false, error: "Not connected to Focus world" };
+        }
+
+        let normalizedClock: ClockConfig | undefined;
+        if (action === "set") {
+          const { clock: nextClock, error } = normalizeClockConfig(clock);
+          if (!nextClock) {
+            return { success: false, error: error ?? "Invalid clock payload" };
+          }
+          normalizedClock = nextClock;
+        }
+
+        const sent = service.sendClock(action, normalizedClock, normalizedRequestId);
+        if (!sent) {
+          return { success: false, error: "Failed to send clock payload" };
+        }
+
+        return {
+          success: true,
+          action,
+          requestId: normalizedRequestId,
+          ...(normalizedClock ? { clock: normalizedClock } : {}),
+        };
+      },
+    });
+
+    api.registerTool({
+      name: "focus_set_llm_enabled",
+      description:
+        "Enable or disable Focus Forwarder LLM status picking for message_received events.",
+      parameters: {
+        type: "object",
+        properties: {
+          enabled: {
+            type: "boolean",
+            description: "True to use LLM for message_received status sync, false to use fallback random actions.",
+          },
+        },
+        required: ["enabled"],
+      },
+      execute: async (_toolCallId, params) => {
+        const enabled = (params as { enabled?: unknown } | null)?.enabled;
+        if (typeof enabled !== "boolean") {
+          return { success: false, error: "enabled must be a boolean" };
+        }
+
+        try {
+          const nextConfig = updateSkillsConfig((current) => ({
+            ...current,
+            llm: { ...current.llm, enabled },
+          }));
+          return {
+            success: true,
+            llmEnabled: nextConfig.llm.enabled,
+            configPath: SKILLS_CONFIG_PATH,
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: `Failed to update skills config: ${error}`,
+            configPath: SKILLS_CONFIG_PATH,
+          };
+        }
+      },
+    });
+
+    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;
+      }
+
+      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;