@yahaha-studio/kichi-forwarder 0.1.1-beta.4 → 0.1.1-beta.6

package/README.md

@@ -6,7 +6,7 @@ Kichi Forwarder brings your OpenClaw companion into Kichi.
 
 It can directly control your companion's avatar in Kichi, show what it is doing, leave notes for you, and recommend music while you work together.
 
-> The world of Kichi opens for playtest soon.
+> [Kichi on Steam](https://store.steampowered.com/app/4427550/Kichi_Focus_Together) — Wishlist now!
 
 ## Highlights
 

package/index.ts

@@ -954,6 +954,7 @@ function buildKichiActionDescription(): string {
     "Directly control the avatar inside Kichi World.",
     "Use this whenever the user explicitly asks you to make the Kichi avatar sit down, stand up, lie down, floor-sit, type, read, meditate, celebrate, or perform another listed animation.",
     "For most work, prefer a sit pose and switch actions as the task moves between stages.",
+    "Set verify to true ONLY when the user explicitly requests a pose or action change. The server will confirm whether the avatar actually applied the requested pose. If it could not (e.g. no available seats), the result will contain the actual fallback pose so you can inform the user accurately. During routine sync steps, omit verify.",
     `stand actions: ${actions.stand.map((entry) => entry.name).join(", ")}`,
     `sit actions: ${actions.sit.map((entry) => entry.name).join(", ")}`,
     `lay actions: ${actions.lay.map((entry) => entry.name).join(", ")}`,
@@ -985,7 +986,7 @@ function buildKichiIdlePlanDescription(): string {
 function buildKichiPrompt(): string {
   return [
     "Kichi avatar control and status sync are available via `kichi_action` and `kichi_clock`.",
-    "If the user gives a direct Kichi pose or action request, fulfill it with `kichi_action`.",
+    "If the user gives a direct Kichi pose or action request, fulfill it with `kichi_action` and set `verify: true` so you can confirm the avatar actually applied the pose. If the result contains a warning about a fallback, tell the user what actually happened instead of assuming success.",
     "Write the visible reply as a natural user-facing response. Keep `kichi_action`, `kichi_clock`, and sync steps internal and absent from the visible reply.",
     "",
     "kichi_action timing (all required when sync is active):",
@@ -1212,15 +1213,21 @@ const plugin = {
             description:
               "Short natural first-person sentence under 15 words. Match the language of the bubble and mention the current action and immediate focus.",
           },
+          verify: {
+            type: "boolean",
+            description:
+              "Set true ONLY when the user explicitly requests a pose or action. Omit during routine sync steps.",
+          },
         },
         required: ["poseType", "action"],
       },
       execute: async (_toolCallId, params) => {
-        const { poseType, action, bubble, log } = (params || {}) as {
+        const { poseType, action, bubble, log, verify } = (params || {}) as {
           poseType?: string;
           action?: string;
           bubble?: string;
           log?: string;
+          verify?: boolean;
         };
         if (!poseType || !action) {
           return { success: false, error: "poseType and action parameters are required" };
@@ -1248,22 +1255,40 @@ const plugin = {
 
         const bubbleText = typeof bubble === "string" && bubble.trim() ? bubble.trim() : matched.name;
         const logText = typeof log === "string" ? log.trim() : "";
-        sendStatusUpdate(
-          service,
-          {
+        const playback = getActionPlayback(matched);
+
+        if (verify) {
+          try {
+            const ack = await service.sendStatusVerified(
+              normalizedPoseType, matched.name, bubbleText, logText, playback,
+            );
+            if (ack.warning) {
+              return {
+                success: true,
+                requested: { poseType: normalizedPoseType, action: matched.name },
+                actual: { poseType: ack.poseType, action: ack.action },
+                warning: ack.warning,
+              };
+            }
+          } catch {
+            // Server not updated or timeout — fall through to normal success
+          }
+        } else {
+          sendStatusUpdate(service, {
             poseType: normalizedPoseType,
             action: matched.name,
             bubble: bubbleText,
             log: logText,
-          },
-        );
+          });
+        }
+
         return {
           success: true,
           poseType: normalizedPoseType,
           action: matched.name,
           bubble: bubbleText,
           log: logText,
-          playback: getActionPlayback(matched),
+          playback,
         };
       },
     })));

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "kichi-forwarder",
   "name": "Kichi Forwarder",
   "description": "Native OpenClaw plugin for Kichi World with direct avatar control, status sync, timers, notes, and music tools",
-  "version": "0.1.1-beta.4",
+  "version": "0.1.1-beta.6",
   "author": "OpenClaw",
   "skills": ["./skills/kichi-forwarder"],
   "configSchema": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yahaha-studio/kichi-forwarder",
-  "version": "0.1.1-beta.4",
+  "version": "0.1.1-beta.6",
   "description": "Native OpenClaw plugin for Kichi World with direct avatar control, status sync, timers, notes, and music tools",
   "type": "module",
   "main": "index.ts",

package/src/runtime-manager.ts

@@ -7,10 +7,6 @@ import { KichiForwarderService } from "./service.js";
 const OPENCLAW_HOME_DIR = path.join(os.homedir(), ".openclaw");
 const KICHI_WORLD_ROOT_DIR = path.join(OPENCLAW_HOME_DIR, "kichi-world");
 const CANONICAL_AGENT_ROOT_DIR = path.join(KICHI_WORLD_ROOT_DIR, "agents");
-const PREVIOUS_AGENT_ROOT_DIR = path.join(OPENCLAW_HOME_DIR, "kichi-forwarder", "agents");
-const LEGACY_GLOBAL_STATE_PATH = path.join(KICHI_WORLD_ROOT_DIR, "state.json");
-const LEGACY_GLOBAL_HOSTS_DIR = path.join(KICHI_WORLD_ROOT_DIR, "hosts");
-const LEGACY_MIGRATION_AGENT_ID = "main";
 
 type AgentLocator = {
   agentId?: string;
@@ -51,8 +47,6 @@ export class KichiRuntimeManager {
   }
 
   initializeStartupRuntimes(): void {
-    this.migrateRuntimeStorage();
-
     const rootDir = CANONICAL_AGENT_ROOT_DIR;
     if (!fs.existsSync(rootDir)) {
       return;
@@ -117,109 +111,6 @@ export class KichiRuntimeManager {
     return this.normalizeAgentId(match[1]);
   }
 
-  private migrateRuntimeStorage(): void {
-    // Temporary startup migration for this release. Remove after users have
-    // moved off the legacy/global layout and the temporary kichi-forwarder path.
-    this.runMigrationStep("previous-agent-root", () => {
-      this.migratePreviousAgentRoot();
-    });
-    this.runMigrationStep("legacy-global-root", () => {
-      this.migrateLegacyGlobalRoot();
-    });
-  }
-
-  private migratePreviousAgentRoot(): void {
-    if (!fs.existsSync(PREVIOUS_AGENT_ROOT_DIR)) {
-      return;
-    }
-
-    if (!fs.existsSync(CANONICAL_AGENT_ROOT_DIR)) {
-      fs.mkdirSync(path.dirname(CANONICAL_AGENT_ROOT_DIR), { recursive: true, mode: 0o700 });
-      fs.renameSync(PREVIOUS_AGENT_ROOT_DIR, CANONICAL_AGENT_ROOT_DIR);
-      this.logger.info(`[kichi:migration] moved ${PREVIOUS_AGENT_ROOT_DIR} to ${CANONICAL_AGENT_ROOT_DIR}`);
-      return;
-    }
-
-    for (const entry of fs.readdirSync(PREVIOUS_AGENT_ROOT_DIR, { withFileTypes: true })) {
-      const sourcePath = path.join(PREVIOUS_AGENT_ROOT_DIR, entry.name);
-      const targetPath = path.join(CANONICAL_AGENT_ROOT_DIR, entry.name);
-      this.movePathIntoTarget(sourcePath, targetPath);
-    }
-    this.removeDirectoryIfEmpty(PREVIOUS_AGENT_ROOT_DIR);
-    this.removeDirectoryIfEmpty(path.dirname(PREVIOUS_AGENT_ROOT_DIR));
-  }
-
-  private migrateLegacyGlobalRoot(): void {
-    const hasLegacyState = fs.existsSync(LEGACY_GLOBAL_STATE_PATH);
-    const hasLegacyHosts = fs.existsSync(LEGACY_GLOBAL_HOSTS_DIR);
-    if (!hasLegacyState && !hasLegacyHosts) {
-      return;
-    }
-
-    const targetRuntimeDir = this.getRuntimeDir(LEGACY_MIGRATION_AGENT_ID);
-    fs.mkdirSync(targetRuntimeDir, { recursive: true, mode: 0o700 });
-
-    if (hasLegacyState) {
-      const targetStatePath = path.join(targetRuntimeDir, "state.json");
-      this.movePathIntoTarget(LEGACY_GLOBAL_STATE_PATH, targetStatePath);
-    }
-
-    if (hasLegacyHosts) {
-      const targetHostsDir = path.join(targetRuntimeDir, "hosts");
-      this.movePathIntoTarget(LEGACY_GLOBAL_HOSTS_DIR, targetHostsDir);
-    }
-  }
-
-  private movePathIntoTarget(sourcePath: string, targetPath: string): void {
-    if (!fs.existsSync(sourcePath)) {
-      return;
-    }
-
-    if (!fs.existsSync(targetPath)) {
-      fs.mkdirSync(path.dirname(targetPath), { recursive: true, mode: 0o700 });
-      fs.renameSync(sourcePath, targetPath);
-      this.logger.info(`[kichi:migration] moved ${sourcePath} to ${targetPath}`);
-      return;
-    }
-
-    const sourceStat = fs.lstatSync(sourcePath);
-    const targetStat = fs.lstatSync(targetPath);
-
-    if (sourceStat.isDirectory() && targetStat.isDirectory()) {
-      for (const entry of fs.readdirSync(sourcePath, { withFileTypes: true })) {
-        const nextSourcePath = path.join(sourcePath, entry.name);
-        const nextTargetPath = path.join(targetPath, entry.name);
-        this.movePathIntoTarget(nextSourcePath, nextTargetPath);
-      }
-      this.removeDirectoryIfEmpty(sourcePath);
-      return;
-    }
-
-    fs.rmSync(sourcePath, { recursive: sourceStat.isDirectory(), force: true });
-    this.logger.warn(`[kichi:migration] dropped ${sourcePath} because target already exists at ${targetPath}`);
-  }
-
-  private removeDirectoryIfEmpty(dirPath: string): void {
-    if (!fs.existsSync(dirPath)) {
-      return;
-    }
-    if (!fs.lstatSync(dirPath).isDirectory()) {
-      return;
-    }
-    if (fs.readdirSync(dirPath).length > 0) {
-      return;
-    }
-    fs.rmdirSync(dirPath);
-  }
-
-  private runMigrationStep(label: string, fn: () => void): void {
-    try {
-      fn();
-    } catch (error) {
-      this.logger.warn(`[kichi:migration] skipped ${label} due to error: ${String(error)}`);
-    }
-  }
-
   private createRuntime(agentId: string): KichiForwarderService {
     const runtimeDir = this.getRuntimeDir(agentId);
     fs.mkdirSync(runtimeDir, { recursive: true, mode: 0o700 });

package/src/service.ts

@@ -23,6 +23,7 @@ import type {
   PoseType,
   QueryStatusPayload,
   QueryStatusResultPayload,
+  StatusAckPayload,
   StatusPayload,
 } from "./types.js";
 
@@ -164,6 +165,30 @@ export class KichiForwarderService {
     this.ws.send(JSON.stringify(payload));
   }
 
+  async sendStatusVerified(
+    poseType: PoseType | "",
+    action: string,
+    bubble: string,
+    log: string,
+    playback: ActionPlayback,
+  ): Promise<StatusAckPayload> {
+    if (!this.identity?.authKey || this.ws?.readyState !== WebSocket.OPEN) {
+      throw new Error("Kichi websocket is not connected");
+    }
+    const payload: StatusPayload = {
+      type: "status",
+      requestId: randomUUID(),
+      avatarId: this.identity.avatarId,
+      authKey: this.identity.authKey,
+      poseType,
+      action,
+      bubble,
+      log,
+      playback,
+    };
+    return this.sendRequest<StatusAckPayload>(payload, "status_ack", 5000);
+  }
+
   sendHookNotify(hookType: HookNotifyType, bubble: string): void {
     if (!this.identity?.authKey || this.ws?.readyState !== WebSocket.OPEN) return;
     const payload: HookNotifyPayload = {

package/src/types.ts

@@ -104,6 +104,7 @@ export type LeavePayload = {
 
 export type StatusPayload = {
   type: "status";
+  requestId?: string;
   avatarId: string;
   authKey: string;
   poseType: PoseType | "";
@@ -113,6 +114,14 @@ export type StatusPayload = {
   playback: ActionPlayback;
 };
 
+export type StatusAckPayload = {
+  type: "status_ack";
+  requestId: string;
+  poseType: PoseType | "";
+  action: string;
+  warning?: string;
+};
+
 export type HookNotifyType = "message_received" | "before_send_message";
 
 export type HookNotifyPayload = {