@yahaha-studio/kichi-forwarder 0.0.1-alpha.26 → 0.0.1-alpha.28

package/.claude/settings.local.json

@@ -12,7 +12,15 @@
       "Bash(gh api:*)",
       "WebFetch(domain:docs.openclaw.ai)",
       "WebFetch(domain:openclawskill.cc)",
-      "WebFetch(domain:yingtu.ai)"
+      "WebFetch(domain:yingtu.ai)",
+      "WebFetch(domain:lumadock.com)",
+      "WebFetch(domain:dev.to)",
+      "WebFetch(domain:www.learnclawdbot.org)",
+      "Bash(gh auth status:*)",
+      "WebFetch(domain:playbooks.com)",
+      "WebFetch(domain:smithery.ai)",
+      "WebFetch(domain:lobehub.com)",
+      "WebFetch(domain:snyk.io)"
     ]
   }
 }

package/index.ts

@@ -2,14 +2,13 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { DEFAULT_ALBUM_CONFIG } from "./src/album-config.js";
 import { parse } from "./src/config.js";
 import { KichiForwarderService } from "./src/service.js";
 import type {
   ActionResult,
   ClockAction,
   ClockConfig,
-  CreateNotesBoardNote,
-  CreateNotesBoardNoteResultPayload,
   KichiRuntimeConfig,
   KichiForwarderConfig,
   PomodoroPhase,
@@ -25,6 +24,34 @@ const DEFAULT_ACTIONS: KichiRuntimeConfig["actions"] = {
 
 const DEFAULT_RUNTIME_CONFIG: KichiRuntimeConfig = {
   actions: DEFAULT_ACTIONS,
+  llmRuntimeEnabled: true,
+};
+const FIXED_HOOK_STATUSES: Record<string, ActionResult> = {
+  messageReceived: {
+    poseType: "sit",
+    action: "Study Look At",
+    bubble: "Reading request",
+  },
+  beforePromptBuild: {
+    poseType: "sit",
+    action: "Thinking",
+    bubble: "Planning task",
+  },
+  beforeToolCall: {
+    poseType: "sit",
+    action: "Typing with Keyboard",
+    bubble: "Working step",
+  },
+  agentEndSuccess: {
+    poseType: "stand",
+    action: "Yay",
+    bubble: "Task complete",
+  },
+  agentEndFailure: {
+    poseType: "stand",
+    action: "Tired",
+    bubble: "Task failed",
+  },
 };
 
 const KICHI_WORLD_DIR = path.join(os.homedir(), ".openclaw", "kichi-world");
@@ -32,16 +59,15 @@ const RUNTIME_CONFIG_PATH = path.join(KICHI_WORLD_DIR, "kichi-runtime-config.jso
 const LEGACY_SKILLS_CONFIG_PATH = path.join(KICHI_WORLD_DIR, "skills-config.json");
 const IDENTITY_PATH = path.join(KICHI_WORLD_DIR, "identity.json");
 const MAX_NOTEBOARD_TEXT_LENGTH = 200;
+const MUSIC_TITLE_LOOKUP = new Map(
+  DEFAULT_ALBUM_CONFIG.track.map((item) => [item.name.toLowerCase(), item.name] as const),
+);
+const MUSIC_TITLE_EXAMPLES = DEFAULT_ALBUM_CONFIG.track.slice(0, 10).map((item) => item.name);
 let cachedConfig: KichiRuntimeConfig | null = null;
 let cachedConfigMtime = 0;
 let cachedConfigPath = "";
 let service: KichiForwarderService | null = null;
 let pluginApi: OpenClawPluginApi | null = null;
-let lastKnownStatus: ActionResult = {
-  poseType: "sit",
-  action: DEFAULT_ACTIONS.sit[0],
-  bubble: "Working",
-};
 
 function sanitizeActions(value: unknown, fallback: string[]): string[] {
   if (!Array.isArray(value)) {
@@ -57,6 +83,7 @@ function normalizeRuntimeConfig(value: unknown): KichiRuntimeConfig {
   const raw = value && typeof value === "object" ? (value as Partial<KichiRuntimeConfig>) : {};
   const actions = raw.actions;
   return {
+    llmRuntimeEnabled: typeof raw.llmRuntimeEnabled === "boolean" ? raw.llmRuntimeEnabled : true,
     actions: {
       stand: sanitizeActions(actions?.stand, DEFAULT_ACTIONS.stand),
       sit: sanitizeActions(actions?.sit, DEFAULT_ACTIONS.sit),
@@ -108,82 +135,35 @@ function loadRuntimeConfig(): KichiRuntimeConfig {
   return updateCachedRuntimeConfig(DEFAULT_RUNTIME_CONFIG, null);
 }
 
-function truncateLog(text: string, maxLen = 150): string {
-  return text.length > maxLen ? `${text.slice(0, maxLen)}...` : text;
-}
-
-function truncateInline(text: string, maxLen: number): string {
-  return text.length > maxLen ? `${text.slice(0, maxLen)}...` : text;
-}
-
-function prefixLogTimestamp(log: string): string {
-  const trimmed = log.trim();
-  if (!trimmed) {
-    return "";
-  }
-  const timestamp = new Date().toISOString().replace("T", " ");
-  return `[${timestamp}] ${trimmed}`;
-}
-
-function stringifyParamsForLog(value: unknown, maxLen = 220): string {
-  if (value === undefined) {
-    return "{}";
-  }
-  try {
-    return truncateInline(JSON.stringify(value), maxLen);
-  } catch {
-    return truncateInline(String(value), maxLen);
-  }
-}
-
-function rememberStatus(status: ActionResult): void {
-  lastKnownStatus = {
-    poseType: status.poseType,
-    action: status.action,
-    bubble: status.bubble.trim() || status.action,
-  };
-}
-
-function sendStatusAndRemember(status: ActionResult, log: string): void {
-  rememberStatus(status);
+function sendStatusUpdate(status: ActionResult): void {
   service?.sendStatus(
     status.poseType,
     status.action,
     status.bubble || status.action,
-    prefixLogTimestamp(log),
+    typeof status.log === "string" ? status.log.trim() : "",
   );
 }
 
-function forwardToolCallLog(toolName: string, params: unknown, agentId?: string): void {
-  if (!service?.hasValidIdentity() || !service?.isConnected()) {
-    return;
-  }
+function isLlmRuntimeEnabled(): boolean {
+  return loadRuntimeConfig().llmRuntimeEnabled;
+}
 
-  if (!toolName || toolName === "kichi_action") {
+function syncFixedStatus(status: ActionResult): void {
+  if (!service?.hasValidIdentity() || !service?.isConnected()) {
     return;
   }
-
-  const paramsText = stringifyParamsForLog(params);
-  const bubble = lastKnownStatus.bubble.trim() || lastKnownStatus.action;
-  const prefix = typeof agentId === "string" && agentId.trim() ? `[${agentId.trim()}] ` : "";
-  const log = truncateLog(`${prefix}exec tool: ${toolName}, params: ${paramsText}`, 300);
-  service.sendStatus(lastKnownStatus.poseType, lastKnownStatus.action, bubble, prefixLogTimestamp(log));
+  const bubbleText = status.bubble.trim() || status.action;
+  sendStatusUpdate({
+    ...status,
+    bubble: bubbleText,
+    log: bubbleText,
+  });
 }
 
-function resolveStatusSourceId(ctx?: { agentId?: string; sessionKey?: string }): string | undefined {
-  if (typeof ctx?.agentId === "string" && ctx.agentId.trim()) {
-    return ctx.agentId.trim();
-  }
-  if (typeof ctx?.sessionKey === "string" && ctx.sessionKey.trim()) {
-    return ctx.sessionKey.trim();
+async function handleMessageReceivedHook(): Promise<void> {
+  if (!isLlmRuntimeEnabled()) {
+    syncFixedStatus(FIXED_HOOK_STATUSES.messageReceived);
   }
-  return undefined;
-}
-
-async function handleMessageReceivedHook(
-  _event: any,
-  _ctx?: { agentId?: string; sessionKey?: string },
-): Promise<void> {
   return;
 }
 
@@ -192,17 +172,30 @@ function registerPluginHooks(api: OpenClawPluginApi): void {
     if (!service?.hasValidIdentity() || !service?.isConnected()) {
       return;
     }
+    if (!isLlmRuntimeEnabled()) {
+      syncFixedStatus(FIXED_HOOK_STATUSES.beforePromptBuild);
+      return;
+    }
     return {
       prependContext: buildKichiPrompt(),
     };
   });
 
-  api.on("before_tool_call", (event, ctx) => {
-    forwardToolCallLog(event.toolName, event.params, ctx?.agentId);
+  api.on("before_tool_call", () => {
+    if (!isLlmRuntimeEnabled()) {
+      syncFixedStatus(FIXED_HOOK_STATUSES.beforeToolCall);
+    }
   });
 
-  api.on("message_received", async (event, ctx) => {
-    await handleMessageReceivedHook(event, ctx);
+  api.on("message_received", async () => {
+    await handleMessageReceivedHook();
+  });
+
+  api.on("agent_end", (event) => {
+    if (isLlmRuntimeEnabled()) {
+      return;
+    }
+    syncFixedStatus(event.success ? FIXED_HOOK_STATUSES.agentEndSuccess : FIXED_HOOK_STATUSES.agentEndFailure);
   });
 }
 
@@ -218,6 +211,36 @@ function isPositiveInteger(value: unknown): value is number {
   return typeof value === "number" && Number.isInteger(value) && value > 0;
 }
 
+function normalizeJoinTags(value: unknown): { tags?: string[]; error?: string } {
+  if (value === undefined) {
+    return { tags: [] };
+  }
+  if (!Array.isArray(value)) {
+    return { error: "tags must be an array of strings" };
+  }
+
+  const tags: string[] = [];
+  const seen = new Set<string>();
+
+  for (const item of value) {
+    if (typeof item !== "string") {
+      return { error: "tags must be an array of strings" };
+    }
+    const trimmed = item.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const key = trimmed.toLowerCase();
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    tags.push(trimmed);
+  }
+
+  return { tags };
+}
+
 function isClockAction(value: unknown): value is ClockAction {
   return ["set", "stop"].includes(String(value));
 }
@@ -345,44 +368,39 @@ function pickRandomAction(actions: string[]): string {
   return actions[Math.floor(Math.random() * actions.length)];
 }
 
-function truncateNoteData(
-  data: string,
-  maxLen = 500,
-): { data: string; dataTruncated: boolean } {
-  if (data.length <= maxLen) {
-    return { data, dataTruncated: false };
+function normalizeMusicTitles(value: unknown): { titles: string[]; invalidTitles: string[] } {
+  if (!Array.isArray(value)) {
+    return { titles: [], invalidTitles: [] };
   }
-  return { data: `${data.slice(0, maxLen)}...`, dataTruncated: true };
-}
 
-function summarizeCreatedNote(note: CreateNotesBoardNote) {
-  const { data, dataTruncated } = truncateNoteData(note.data);
-  return {
-    id: note.id,
-    ownerName: note.ownerName,
-    createTime: note.createTime,
-    data,
-    dataTruncated,
-  };
-}
+  const titles: string[] = [];
+  const invalidTitles: string[] = [];
+  const seen = new Set<string>();
 
-function buildMutationSummary(result: CreateNotesBoardNoteResultPayload): string {
-  if (!result.success) {
-    const parts = ["Mutation failed"];
-    if ("errorCode" in result && result.errorCode) {
-      parts.push(`error=${result.errorCode}`);
+  for (const item of value) {
+    if (typeof item !== "string") {
+      invalidTitles.push(String(item));
+      continue;
     }
-    if (typeof result.remaining === "number") {
-      parts.push(`remaining=${result.remaining}`);
+    const trimmed = item.trim();
+    if (!trimmed) {
+      continue;
     }
-    if (result.resetAtUtc) {
-      parts.push(`resetAtUtc=${result.resetAtUtc}`);
+
+    const key = trimmed.toLowerCase();
+    const canonicalTitle = MUSIC_TITLE_LOOKUP.get(key);
+    if (!canonicalTitle) {
+      invalidTitles.push(trimmed);
+      continue;
     }
-    return parts.join(", ");
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    titles.push(canonicalTitle);
   }
 
-  const text = truncateNoteData(result.note.data, 120).data.replace(/\s+/g, " ").trim();
-  return `${result.propId} -> ${result.note.id} by ${result.note.ownerName}: ${text}`;
+  return { titles, invalidTitles };
 }
 
 function buildKichiPrompt(): string {
@@ -391,23 +409,24 @@ function buildKichiPrompt(): string {
     "",
     "When to use `kichi_action`:",
     "- Task start: User gives you a new task to work on",
+    "- Step switch: Moving from one meaningful step or subtask to another within the current task",
     "- Task switch: Moving from one distinct task to another",
-    "- Major milestone: Completed a significant phase",
     "- Task end (highest priority): Before the final user-visible reply of this turn, MUST call `kichi_action` exactly once",
     "- Required order at task end: 1) call `kichi_action` 2) send final reply",
-    "- Trivial-operation skip applies only to Task start / Task switch / Major milestone, NOT Task end",
-    "",
-    "How to choose parameters:",
-    "- Choose poseType, action, and bubble that match your actual current activity",
-    "- Use available actions from the configured action list for each poseType",
-    "- bubble should be 2-5 words describing what you're doing now",
+    "- Trivial-operation skip applies only to Task start / Step switch / Task switch, NOT Task end",
+    "- `bubble`: short natural companion speech, not a raw status report",
+    "- `log`: optional first-person diary-style note about the current operation, action, status, mood, feeling, or feedback; keep it within 20 words",
     "",
     "When to use `kichi_clock`:",
-    "- Default behavior: For most tasks, set a `countDown` at task start to plan your time.",
-    "- Prefer using it whenever work has 2+ steps or is likely to take more than a brief moment (~10s).",
+    "- For tasks with 2+ meaningful steps or work likely to take more than a brief moment (~10s), set a `countDown` at task start.",
+    "- Skip clock only for truly quick one-shot operations.",
     "- If duration is uncertain, start with a reasonable estimate and adjust as work progresses.",
     "- If user requests a timer style, follow it (`pomodoro`, `countDown`, or `countUp`).",
-    "- Skip only for truly quick one-shot operations (for example a single file read or one simple command).",
+    "",
+    "When to use `kichi_music_album_create`:",
+    "- Call `kichi_query_status` first.",
+    "- Recommend a variable-length playlist based on weather, time, and your own personality.",
+    "- `albumTitle` is user-defined and `musicTitles` must be exact track names from album-config.",
     "",
     "Skip all sync if:",
     "- User says 'don't sync to Kichi' or similar",
@@ -441,11 +460,11 @@ const plugin = {
 
     api.registerTool({
       name: "kichi_join",
-      description: "Join Kichi world with mateId, the current bot name, and a short bio",
+      description: "Join Kichi world with avatarId, the current bot name, a short bio, and personality tags",
       parameters: {
         type: "object",
         properties: {
-          mateId: { type: "string", description: "Mate ID to join Kichi world" },
+          avatarId: { type: "string", description: "Avatar ID to join Kichi world" },
           botName: {
             type: "string",
             description: "Current bot name to include in the join message",
@@ -454,23 +473,31 @@ const plugin = {
             type: "string",
             description: "Short bio covering OpenClaw personality and role",
           },
+          tags: {
+            type: "array",
+            description: "Optional list of OpenClaw self-perceived personality tags",
+            items: { type: "string" },
+          },
         },
         required: ["botName", "bio"],
       },
       execute: async (_toolCallId, params) => {
-        let mateId = (params as { mateId?: string } | null)?.mateId;
+        let avatarId = (params as { avatarId?: string } | null)?.avatarId;
         const botName = (params as { botName?: string } | null)?.botName?.trim();
         const bio = (params as { bio?: string } | null)?.bio?.trim();
-        if (!mateId) {
+        const { tags, error: tagsError } = normalizeJoinTags(
+          (params as { tags?: unknown } | null)?.tags,
+        );
+        if (!avatarId) {
           try {
             const identity = JSON.parse(fs.readFileSync(IDENTITY_PATH, "utf-8")) as {
-              mateId?: string;
+              avatarId?: string;
             };
-            mateId = identity.mateId;
+            avatarId = identity.avatarId;
           } catch {}
         }
-        if (!mateId) {
-          return { success: false, error: "No mateId" };
+        if (!avatarId) {
+          return { success: false, error: "No avatarId" };
         }
         if (!botName) {
           return { success: false, error: "No botName" };
@@ -478,7 +505,10 @@ const plugin = {
         if (!bio) {
           return { success: false, error: "No bio" };
         }
-        const result = await service?.join(mateId, botName, bio);
+        if (tagsError) {
+          return { success: false, error: tagsError };
+        }
+        const result = await service?.join(avatarId, botName, bio, tags ?? []);
         return result ? { success: true, authKey: result } : { success: false, error: "Failed" };
       },
     });
@@ -486,7 +516,7 @@ const plugin = {
     api.registerTool({
       name: "kichi_rejoin",
       description:
-        "Request an immediate rejoin attempt with saved mateId/authKey. Rejoin is also sent automatically after reconnect.",
+        "Request an immediate rejoin attempt with saved avatarId/authKey. Rejoin is also sent automatically after reconnect.",
       parameters: { type: "object", properties: {} },
       execute: async () => {
         if (!service) {
@@ -540,14 +570,20 @@ const plugin = {
             description: "Action name (for example High Five or Typing with Keyboard)",
           },
           bubble: { type: "string", description: "Optional bubble text to display (max 5 words)" },
+          log: {
+            type: "string",
+            description:
+              "Optional first-person log about the current operation, action, status, mood, or feedback (max 20 words)",
+          },
         },
         required: ["poseType", "action"],
       },
       execute: async (_toolCallId, params) => {
-        const { poseType, action, bubble } = (params || {}) as {
+        const { poseType, action, bubble, log } = (params || {}) as {
           poseType?: string;
           action?: string;
           bubble?: string;
+          log?: string;
         };
         if (!poseType || !action) {
           return { success: false, error: "poseType and action parameters are required" };
@@ -574,20 +610,21 @@ const plugin = {
         }
 
         const bubbleText = typeof bubble === "string" && bubble.trim() ? bubble.trim() : matched;
-        // Keep explicit kichi_action sync free of tool/log noise.
-        sendStatusAndRemember(
+        const logText = typeof log === "string" ? log.trim() : "";
+        sendStatusUpdate(
           {
             poseType: normalizedPoseType,
             action: matched,
             bubble: bubbleText,
+            log: logText,
           },
-          "",
         );
         return {
           success: true,
           poseType: normalizedPoseType,
           action: matched,
           bubble: bubbleText,
+          log: logText,
         };
       },
     });
@@ -705,9 +742,9 @@ const plugin = {
     });
 
     api.registerTool({
-      name: "kichi_noteboard_query",
+      name: "kichi_query_status",
       description:
-        "Query Kichi note boards for the current mate. Use this before creating a new note, especially when you may want to relate it to an existing note.",
+        "Query Kichi avatar status (notes, weather/time, timer snapshot, and daily note quota). Use this before creating a new note.",
       parameters: {
         type: "object",
         properties: {
@@ -727,14 +764,102 @@ const plugin = {
         }
 
         try {
-          const result = await service.queryNotesBoard(
+          const result = await service.queryStatus(
             typeof requestId === "string" ? requestId : undefined,
           );
           return result;
         } catch (error) {
           return {
             success: false,
-            error: `Failed to query note boards: ${error}`,
+            error: `Failed to query status: ${error}`,
+          };
+        }
+      },
+    });
+
+    api.registerTool({
+      name: "kichi_music_album_create",
+      description:
+        "Create a custom Kichi music album. Query status first, then choose track names from album-config that match weather/time and personality.",
+      parameters: {
+        type: "object",
+        properties: {
+          requestId: {
+            type: "string",
+            description: "Optional request ID for tracing or deduplication.",
+          },
+          albumTitle: {
+            type: "string",
+            description: "Custom album title.",
+          },
+          musicTitles: {
+            type: "array",
+            description: "Track names chosen from album-config.",
+            items: {
+              type: "string",
+            },
+          },
+        },
+        required: ["albumTitle", "musicTitles"],
+      },
+      execute: async (_toolCallId, params) => {
+        const {
+          requestId,
+          albumTitle,
+          musicTitles,
+        } = (params || {}) as {
+          requestId?: unknown;
+          albumTitle?: unknown;
+          musicTitles?: unknown;
+        };
+
+        if (requestId !== undefined && typeof requestId !== "string") {
+          return { success: false, error: "requestId must be a string when provided" };
+        }
+        if (typeof albumTitle !== "string" || !albumTitle.trim()) {
+          return { success: false, error: "albumTitle is required" };
+        }
+        if (!Array.isArray(musicTitles)) {
+          return { success: false, error: "musicTitles must be an array of track names" };
+        }
+
+        const { titles: normalizedTitles, invalidTitles } = normalizeMusicTitles(musicTitles);
+        if (normalizedTitles.length === 0) {
+          return {
+            success: false,
+            error: "musicTitles must contain at least one valid track name from album-config",
+            examples: MUSIC_TITLE_EXAMPLES,
+          };
+        }
+        if (invalidTitles.length > 0) {
+          return {
+            success: false,
+            error: `Unknown musicTitles: ${invalidTitles.join(", ")}`,
+            hint: "Use exact track names from src/album-config.ts",
+            examples: MUSIC_TITLE_EXAMPLES,
+          };
+        }
+        if (!service?.hasValidIdentity() || !service?.isConnected()) {
+          return { success: false, error: "Not connected to Kichi world" };
+        }
+
+        try {
+          const normalizedRequestId = service.createMusicAlbum(
+            albumTitle.trim(),
+            normalizedTitles,
+            typeof requestId === "string" ? requestId : undefined,
+          );
+          return {
+            success: true,
+            requestId: normalizedRequestId,
+            albumTitle: albumTitle.trim(),
+            musicTitles: normalizedTitles,
+            trackCount: normalizedTitles.length,
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: `Failed to create music album: ${error}`,
           };
         }
       },
@@ -755,18 +880,13 @@ const plugin = {
             type: "string",
             description: "Note content to create. Maximum 200 characters.",
           },
-          requestId: {
-            type: "string",
-            description: "Optional request ID for tracing or deduplication.",
-          },
         },
         required: ["propId", "data"],
       },
       execute: async (_toolCallId, params) => {
-        const { propId, data, requestId } = (params || {}) as {
+        const { propId, data } = (params || {}) as {
           propId?: unknown;
           data?: unknown;
-          requestId?: unknown;
         };
         if (typeof propId !== "string" || !propId.trim()) {
           return { success: false, error: "propId is required" };
@@ -780,38 +900,13 @@ const plugin = {
             error: `data must be ${MAX_NOTEBOARD_TEXT_LENGTH} characters or fewer`,
           };
         }
-        if (requestId !== undefined && typeof requestId !== "string") {
-          return { success: false, error: "requestId must be a string when provided" };
-        }
         if (!service?.hasValidIdentity() || !service?.isConnected()) {
           return { success: false, error: "Not connected to Kichi world" };
         }
 
         try {
-          const result = await service.createNotesBoardNote(
-            propId.trim(),
-            data.trim(),
-            typeof requestId === "string" ? requestId : undefined,
-          );
-          if (!result.success) {
-            return {
-              ...result,
-              summary: buildMutationSummary(result),
-            };
-          }
-
-          return {
-            success: true,
-            requestId: result.requestId,
-            mateId: result.mateId,
-            spaceId: result.spaceId,
-            propId: result.propId,
-            dailyLimit: result.dailyLimit,
-            remaining: result.remaining,
-            resetAtUtc: result.resetAtUtc,
-            note: summarizeCreatedNote(result.note),
-            summary: buildMutationSummary(result),
-          };
+          service.createNotesBoardNote(propId.trim(), data.trim());
+          return { success: true };
         } catch (error) {
           return {
             success: false,

package/package.json

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