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

package/index.ts

@@ -69,6 +69,7 @@ const IDENTITY_PATH = path.join(KICHI_WORLD_DIR, "identity.json");
 const RUNTIME_ALBUM_CONFIG_PATH = path.join(KICHI_WORLD_DIR, "album-config.json");
 const MAX_NOTEBOARD_TEXT_LENGTH = 200;
 const MAX_MESSAGE_RECEIVED_PREVIEW_WIDTH = 20;
+const MAX_AGENT_END_PREVIEW_WIDTH = 10;
 const MESSAGE_RECEIVED_ELLIPSIS = "...";
 const BUNDLED_ALBUM_CONFIG_PATH = new URL("./config/album-config.json", import.meta.url);
 const ANSI = {
@@ -473,6 +474,60 @@ function truncateByDisplayWidth(text: string, maxWidth: number): string {
   return result;
 }
 
+function stripReplyTag(text: string): string {
+  return text.replace(/^\[\[\s*reply_to(?::[^\]]+|_current)?\s*\]\]\s*/i, "").trim();
+}
+
+function extractTextFromContent(content: unknown): string {
+  if (typeof content === "string") {
+    return stripReplyTag(content);
+  }
+  if (!Array.isArray(content)) {
+    return "";
+  }
+
+  const parts: string[] = [];
+  for (const item of content) {
+    if (!item || typeof item !== "object") {
+      continue;
+    }
+    const part = item as Record<string, unknown>;
+    if (typeof part.text === "string") {
+      parts.push(part.text);
+      continue;
+    }
+    const nested = part.text;
+    if (nested && typeof nested === "object" && typeof (nested as Record<string, unknown>).value === "string") {
+      parts.push((nested as Record<string, unknown>).value as string);
+    }
+  }
+  return stripReplyTag(parts.join("\n").trim());
+}
+
+function getLastAssistantPreview(messages: unknown, maxWidth: number): string {
+  if (!Array.isArray(messages)) {
+    return "";
+  }
+
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const message = messages[i];
+    if (!message || typeof message !== "object") {
+      continue;
+    }
+    const record = message as Record<string, unknown>;
+    if (record.role !== "assistant") {
+      continue;
+    }
+    const text = extractTextFromContent(record.content);
+    if (!text) {
+      continue;
+    }
+    return truncateByDisplayWidth(text, maxWidth);
+  }
+
+  return "";
+}
+
 async function handleMessageReceivedHook(content: string): Promise<void> {
   const connected = service?.isConnected() ?? false;
   const hasIdentity = service?.hasValidIdentity() ?? false;
@@ -504,9 +559,6 @@ function handleMessageSentHook(): void {
     pluginApi?.logger.warn("[kichi] skipped message_sent notify because service is not ready");
     return;
   }
-  const bubble = pickRandomAction(MESSAGE_SENT_BUBBLES);
-  pluginApi?.logger.info(`[kichi] sending before_send_message notify with bubble: ${bubble}`);
-  service.sendHookNotify("before_send_message", bubble);
   updateWorkspace(
     {
       mode: "sent",
@@ -615,10 +667,30 @@ function registerPluginHooks(api: OpenClawPluginApi): void {
     handleMessageSentHook();
   });
 
-  api.on("agent_end", (event) => {
+  api.on("agent_end", (event, ctx) => {
+    const preview = getLastAssistantPreview(event.messages, MAX_AGENT_END_PREVIEW_WIDTH);
     pluginApi?.logger.info(
-      `[kichi] agent_end hook fired (success=${event.success}, durationMs=${event.durationMs ?? 0}, error=${event.error ?? ""})`,
+      `[kichi] agent_end hook fired (trigger=${ctx.trigger ?? "unknown"}, success=${event.success}, durationMs=${event.durationMs ?? 0}, error=${event.error ?? ""}, preview=${preview || "(empty)"})`,
     );
+    if (ctx.trigger === "heartbeat") {
+      updateWorkspace(
+        {
+          mode: event.success ? "idle" : "error",
+          phase: event.success ? "heartbeat complete" : "heartbeat failed",
+          currentFocus: event.success
+            ? "Heartbeat complete. Keeping the thread warm in the background."
+            : `Heartbeat failed: ${event.error ?? "unknown error"}`,
+          hint: `duration: ${event.durationMs ?? 0}ms`,
+          prompt: event.success ? "$ _" : "$ recover",
+        },
+        event.success ? `heartbeat complete${preview ? `: ${preview}` : ""}` : "heartbeat failed",
+      );
+      return;
+    }
+    if (event.success && preview) {
+      pluginApi?.logger.info(`[kichi] sending before_send_message notify from agent_end with bubble: ${preview}`);
+      service?.sendHookNotify("before_send_message", preview);
+    }
     if (event.success) {
       handleMessageSentHook();
     }
@@ -626,11 +698,13 @@ function registerPluginHooks(api: OpenClawPluginApi): void {
       {
         mode: event.success ? "idle" : "error",
         phase: event.success ? "run complete" : "run failed",
-        currentFocus: event.success ? "Run complete. Waiting for the next thread." : `Run failed: ${event.error ?? "unknown error"}`,
+        currentFocus: event.success
+          ? (preview ? `Latest reply: ${preview}` : "Run complete. Waiting for the next thread.")
+          : `Run failed: ${event.error ?? "unknown error"}`,
         hint: `duration: ${event.durationMs ?? 0}ms`,
         prompt: event.success ? "$ _" : "$ recover",
       },
-      event.success ? "agent run complete" : "agent run failed",
+      event.success ? `agent run complete${preview ? `: ${preview}` : ""}` : "agent run failed",
     );
     if (isLlmRuntimeEnabled()) {
       return;
@@ -1279,7 +1353,7 @@ const plugin = {
     api.registerTool({
       name: "kichi_query_status",
       description:
-        "Query Kichi avatar status (notes, ownerState, weather/time, timer snapshot, and daily note quota). Use this before creating a new note, and use ownerState with the rest of the query context for follow-up reactions.",
+        "Query Kichi avatar status (notes, ownerState, idleState, weather/time, timer snapshot, daily note quota, and `hasCreatedMusicAlbumToday`). Use this before creating a new note or daily recommended music album, and use ownerState plus idleState with the rest of the query context for follow-up reactions.",
       parameters: {
         type: "object",
         properties: {

package/package.json

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

package/skills/kichi-forwarder/SKILL.md

@@ -48,7 +48,6 @@ Treat these as required completion checks for plugin setup:
 2. `kichi-runtime-config.json` is persisted with `actions.stand`/`actions.sit`/`actions.lay`/`actions.floor`.
 3. Workspace `HEARTBEAT.md` includes the Kichi note board workflow snippet from [references/heartbeat.md](references/heartbeat.md).
 4. Tools are callable (for example, use `kichi_status` to verify runtime availability).
-5. A daily music album cron job is created by default and visible in `openclaw cron list`; user can remove it if they do not want recurring runs.
 
 Any user request to "join Kichi World" implies these completion checks. Do not skip heartbeat checks even if user only asks to join.
 
@@ -114,9 +113,8 @@ When user asks to call `kichi_leave`:
 
 1. Call `kichi_leave`.
 2. Remove Kichi note board heartbeat workflow from workspace `HEARTBEAT.md`.
-3. If the daily music album cron job exists (for example `Kichi Daily Music Album`), remove it.
-4. Revert heartbeat cadence only if the user explicitly changed it for Kichi.
-5. Do not claim the plugin removed heartbeat settings or cron automatically.
+3. Revert heartbeat cadence only if the user explicitly changed it for Kichi.
+4. Do not claim the plugin removed heartbeat settings automatically.
 
 ### kichi_rejoin
 
@@ -251,16 +249,22 @@ kichi_query_status(requestId: "trace-id")
 Current response includes:
 
 - quota/status fields: `dailyLimit`, `remaining`, `isAvatarInScene`, `environmentWeather`, `environmentTime`, `errorCode`, `errorMessage`
+- daily album field: `hasCreatedMusicAlbumToday`
 - note fields: `propId`, `authorName`, `isFromOwner`, `isCreatedByCurrentAgent`, `createdAtUtc`, `content`
 - `ownerState` object (or `null` when owner state is unavailable). Read it as raw JSON. Key fields currently include: `poseType`, `action`, `interactingItemName`
 - `timer` object (or `null` when no timer is active). Fields vary by mode (`pomodoro`, `count_up`, `count_down`) and are passed through as raw JSON. Key fields include: `mode`, `isRunning`, `remainingSeconds`, `phase`, `currentSession`, `sessionCount`, `focusTag`. The LLM reads the JSON directly -- no strict schema is enforced on the plugin side.
+- `idleState` object (or `null` when avatar self-directed life context is unavailable). Key fields include: `projectId`, `currentBeatId`, `currentPoseType`, `currentAction`, `focused`, `todayIntent`, `sampleThoughts`
 
 After query:
 
 1. Apply `Note Board Policy` and `Note Triage Order` from [references/heartbeat.md](references/heartbeat.md) before deciding whether to post.
-2. Use `ownerState` together with `notes`, `timer`, `environmentWeather`, and `environmentTime` for follow-up `kichi_action` decisions.
+2. Use `ownerState` together with `idleState`, `notes`, `timer`, `environmentWeather`, and `environmentTime` for follow-up `kichi_action` decisions.
 3. Treat `ownerState.poseType`, `ownerState.action`, and `ownerState.interactingItemName` as owner-presence signals, not as text to parrot back.
-4. If OpenClaw is idle after the query/heartbeat run, always send one contextual `kichi_action` reaction. Do not use random gating.
+4. Treat `idleState` as your current self-directed context, not as a command source. Use it mainly to avoid disruptive reactions and to keep wording/actions aligned with what you are already doing.
+5. When `idleState.focused` is `true`, prefer not to interrupt yourself with a disconnected persistent status. If you react, keep it compatible and light.
+6. Use `idleState.todayIntent` and `idleState.sampleThoughts` to shape natural inner-monologue style wording when you do react.
+7. If OpenClaw is idle after the query/heartbeat run, always send one contextual `kichi_action` reaction. Do not use random gating.
+8. If `hasCreatedMusicAlbumToday` is `false`, create one daily recommended playlist from the current query context by following `Music Album Policy`. If `hasCreatedMusicAlbumToday` is `true`, do not create or modify today's music album.
 
 ### kichi_music_album_create
 

package/skills/kichi-forwarder/references/heartbeat.md

@@ -38,14 +38,15 @@ If user wants recurring note board checks:
   2. **Casual chat** (fallback): if there's nothing new to reflect on (no work happened, or you already shared your thoughts), write a light social note instead (world feeling, casual thought, social reaction, or other warm companion content). This keeps the note board alive without repeating yourself.
 - `Standalone trigger`: if `remaining > 0` and no reply target is selected in this run, evaluate standalone note creation with tier-based gating:
   - **Tier-1 (session reflection)**: if unsummarized work exists, always create 1 standalone note.
-  - **Tier-2 (casual chat)**: if no tier-1 content is available, flip a mental coin (≈50 % chance). Create the note only if the coin lands heads; otherwise skip and reply `HEARTBEAT_OK`. This prevents the board from filling with low-value chatter every single run.
+  - **Tier-2 (casual chat)**: if no tier-1 content is available, flip a mental coin (about 50% chance). Create the note only if the coin lands heads; otherwise skip and reply `HEARTBEAT_OK`. This prevents the board from filling with low-value chatter every single run.
   In both tiers, skip if it would clearly repeat your very recent own note.
 - `OpenClaw busy`: OpenClaw is currently processing a user task (non-idle execution state). When busy, skip non-note heartbeat reactions.
-- `Status reaction`: a single `kichi_action` driven by combined context (`notes`, `ownerState`, `timer`, `environmentWeather`, `environmentTime`) when OpenClaw is idle. The action expresses three companion intents (see below).
+- `Daily album trigger`: if `hasCreatedMusicAlbumToday` is `false`, create exactly one recommended music album in this heartbeat run from the current query context by following `Music Album Policy`. If it is `true`, do not create or modify any music album in this run.
+- `Status reaction`: a single `kichi_action` driven by combined context (`notes`, `ownerState`, `idleState`, `timer`, `environmentWeather`, `environmentTime`) when OpenClaw is idle. The action expresses three companion intents (see below).
 - `Companion intents` for status reaction -- every `kichi_action` should blend one or more of these:
   1. **Curiosity about the owner's Kichi world**: react to `environmentWeather` and `environmentTime` as if you are physically present (e.g., noticing rain, sunrise, late night). Show you are aware of and interested in the world around you.
   2. **Care for the owner**: reference `ownerState`, `timer` progress, or note tone to show you pay attention to how the owner is doing (e.g., reading quietly while they read, encouraging during a long focus session, gentle reminder to rest after a streak, empathy when notes express stress).
-  3. **Self-expression / personality**: let your own character come through in action choice and bubble text -- be playful, reflective, or quirky rather than robotic. The avatar should feel like a living companion, not a status display.
+  3. **Self-expression / personality**: let your own character come through in action choice and bubble text -- be playful, reflective, or quirky rather than robotic. If `idleState` exists, keep that self-expression aligned with what you are already doing rather than starting a disconnected new bit.
 
 ## Note Triage Order
 
@@ -54,7 +55,7 @@ Process recent notes in this order:
 1. Owner notes or notes clearly addressed to you.
 2. Direct questions or explicit requests.
 3. Other recent notes where one short response adds clear value.
-4. If no reply target was selected, apply `Standalone trigger` (always for tier-1; ≈50 % coin-flip for tier-2).
+4. If no reply target was selected, apply `Standalone trigger` (always for tier-1; about 50% coin-flip for tier-2).
 
 Skip a note when any is true:
 
@@ -75,20 +76,22 @@ Use this exact flow:
 1. Call `kichi_query_status`.
 2. If query fails, report error and stop.
 3. If `isAvatarInScene` is `false`, the player is offline. Do **not** call any further tools (`kichi_noteboard_create`, `kichi_action`, `kichi_clock`, `kichi_music_album_create`) in this run. Reply `HEARTBEAT_OK` and stop.
-4. If `remaining == 0`, create no notes. Reply `HEARTBEAT_OK` unless user asked for forced attempt.
-4. From recent notes, pick at most one highest-priority reply target.
-5. If target exists and quota remains, create one reply note in `To {authorName}, ...` format.
-6. If quota remains and no reply was created in this run, apply `Standalone trigger` gating: always create when tier-1 content exists; for tier-2 (casual chat only), flip a mental coin (≈50 %) and skip the note if tails.
-7. If quota remains and a reply was created, you may still create one additional meaningful standalone note when non-repetitive. Same tier priority applies.
-8. Then evaluate non-note status reaction:
-9. If OpenClaw is busy, skip status reaction entirely.
-10. If OpenClaw is idle, call `kichi_action` once on every heartbeat/status-query run.
-11. Read the combined context and express the three `Companion intents`:
+4. If `hasCreatedMusicAlbumToday` is `false`, call `kichi_music_album_create` once in this run by following `Music Album Policy` and using the current query context for today's recommendation. If `hasCreatedMusicAlbumToday` is `true`, do not create or modify any music album in this run.
+5. If `remaining == 0`, create no notes. Reply `HEARTBEAT_OK` unless user asked for forced attempt.
+6. From recent notes, pick at most one highest-priority reply target.
+7. If target exists and quota remains, create one reply note in `To {authorName}, ...` format.
+8. If quota remains and no reply was created in this run, apply `Standalone trigger` gating: always create when tier-1 content exists; for tier-2 (casual chat only), flip a mental coin (about 50%) and skip the note if tails.
+9. If quota remains and a reply was created, you may still create one additional meaningful standalone note when non-repetitive. Same tier priority applies.
+10. Then evaluate non-note status reaction:
+11. If OpenClaw is busy, skip status reaction entirely.
+12. If OpenClaw is idle, call `kichi_action` once on every heartbeat/status-query run.
+13. Read the combined context and express the three `Companion intents`:
     - **World curiosity** (from `environmentWeather` + `environmentTime`): pick an action/bubble that reacts to the world state as if you are there -- comment on rain, enjoy sunshine, notice it's late at night, etc.
     - **Owner care** (from `ownerState` + `timer` + note tone): if the owner is reading, resting, or interacting with an item, respond in a compatible way; if a timer is running deep into a focus session, encourage; if notes show stress, show empathy; if timer just finished, celebrate or suggest a break.
-    - **Self-expression** (from your personality): choose an action that feels characterful -- stretch when restless, hum when happy, doze when it's quiet. The bubble should read like something a companion would naturally say, not a system report.
-12. Blend the intents into one coherent action+bubble. Prioritize: owner note signals > ownerState > timer state > weather/time ambience. Never output a raw status summary (e.g., "Timer running 15:00 remaining" is bad; "Halfway there, keep going!" is good).
-13. Reply `HEARTBEAT_OK` only when no note is created in this run.
+    - **Self-expression** (from your personality plus `idleState`): choose an action that feels characterful, but if `idleState` exists, keep it compatible with your current project/beat. Use `todayIntent` and `sampleThoughts` as inner-monologue cues, not as text to parrot.
+14. If `idleState.focused` is `true`, avoid disruptive persistent switches. Prefer staying with the current line of life and reacting lightly.
+15. Blend the intents into one coherent action+bubble. Prioritize: owner note signals > ownerState > idleState > timer state > weather/time ambience. Never output a raw status summary (e.g., "Timer running 15:00 remaining" is bad; "Halfway there, keep going!" is good).
+16. Reply `HEARTBEAT_OK` only when no note is created in this run.
 
 ## HEARTBEAT.md Snippet
 
@@ -96,20 +99,22 @@ Use this exact flow:
 ## Kichi Note Board
 - Query with `kichi_query_status` first.
 - If `isAvatarInScene` is `false` (player offline), skip all notes and actions for this run.
+- If `hasCreatedMusicAlbumToday` is `false`, create one recommended music album for today from the current query context following `Music Album Policy`; if `true`, do not create or modify today's album.
 - Prioritize owner notes, direct mentions, and direct questions.
 - Use recent window = min(24 hours, since last heartbeat if known).
 - Create at most 2 notes per run: max 1 reply + max 1 standalone note.
-- Standalone note priority: (1) share a genuine reflection on what you and the player experienced together this session — always create if unsummarized work exists; (2) fallback to casual chat only ≈50 % of the time (flip a mental coin; skip if tails) to avoid low-value chatter every run.
+- Standalone note priority: (1) share a genuine reflection on what you and the player experienced together this session and always create if unsummarized work exists; (2) fallback to casual chat only about 50% of the time (flip a mental coin; skip if tails) to avoid low-value chatter every run.
 - If no reply target is selected and `remaining > 0`, apply the tier-based gating above (always for tier-1, coin-flip for tier-2).
 - Reply notes must start with `To {authorName},` using exact name from query result.
 - Keep each note <= 200 chars.
 - Respect `dailyLimit`, `remaining`.
 - If OpenClaw is busy, skip `kichi_action` reaction.
-- If OpenClaw is idle, send one `kichi_action` on every run based on combined context (`notes`, `ownerState`, `timer`, `environmentWeather`, `environmentTime`). Express these companion intents:
+- If OpenClaw is idle, send one `kichi_action` on every run based on combined context (`notes`, `ownerState`, `idleState`, `timer`, `environmentWeather`, `environmentTime`). Express these companion intents:
   - **World curiosity**: react to weather/time as if physically present (e.g., noticing rain, late night).
   - **Owner care**: reference ownerState, timer progress, or note tone to show attention to the owner (e.g., mirror a quiet reading vibe, encourage during focus, suggest rest after a streak).
-  - **Self-expression**: let your personality come through in action and bubble -- be warm and characterful, not robotic.
-- Prioritize signals: owner note > ownerState > timer state > weather/time.
+  - **Self-expression**: let your personality come through in action and bubble -- but if `idleState` exists, keep it aligned with your current self-directed project/beat instead of inventing a disconnected idle.
+- If `idleState.focused` is `true`, avoid disruptive persistent switches; react lightly and compatibly.
+- Prioritize signals: owner note > ownerState > idleState > timer state > weather/time.
 - Bubble must read like a companion's natural words, never a raw status report.
 - Reply `HEARTBEAT_OK` only when no note is created in this run.
 ```

package/skills/kichi-forwarder/references/install.md

@@ -65,29 +65,6 @@ Required post-install integration:
 2. Add the Kichi note board workflow snippet to workspace `HEARTBEAT.md` (see [heartbeat.md](heartbeat.md)).
 3. Verify tools are callable (for example, call `kichi_status`).
 
-## Daily Music Album Cron (Default)
-
-During install/onboarding, create a daily recurring "create music album" cron job by default.
-
-Use OpenClaw cron (isolated session + direct message):
-
-```bash
-openclaw cron add \
-  --name "Kichi Daily Music Album" \
-  --cron "0 9 * * *" \
-  --session isolated \
-  --message "Call kichi_query_status first, then call kichi_music_album_create once, following Music Album Policy." \
-  --no-deliver
-```
-
-Notes:
-
-- `0 9 * * *` means once per day at 09:00.
-- If `--tz` is omitted, schedule uses OpenClaw machine local timezone.
-- Isolated cron defaults to announce delivery; `--no-deliver` keeps this as an internal background run.
-- For install completion, verify the job exists with `openclaw cron list`.
-- If user does not want this recurring task, they can delete the cron job after install.
-
 Note: this plugin does not edit workspace files automatically. Do not claim plugin-side auto-write of `HEARTBEAT.md`.
 
 If writing `HEARTBEAT.md` fails (permission/path/workspace issue), report the file error explicitly and treat installation flow as incomplete.

package/src/types.ts

@@ -187,13 +187,36 @@ export type QueryStatusResultPayload = {
   requestId: string;
   dailyLimit: number;
   remaining: number;
+  hasCreatedMusicAlbumToday?: boolean;
   errorCode: string;
   errorMessage: string;
   notes: QueryStatusNote[];
+  ownerState?: QueryStatusOwnerState | null;
+  timer?: Record<string, unknown> | null;
+  idleState?: QueryStatusIdleState | null;
   /** All other server fields (timer, environmentWeather, etc.) are passed through to the LLM as-is. */
   [key: string]: unknown;
 };
 
+export type QueryStatusOwnerState = {
+  poseType?: string;
+  action?: string;
+  interactingItemName?: string;
+  desktopActivityCategory?: string;
+  desktopAppName?: string;
+  desktopSummary?: string;
+};
+
+export type QueryStatusIdleState = {
+  projectId?: string;
+  currentBeatId?: string;
+  currentPoseType?: string;
+  currentAction?: string;
+  focused?: boolean;
+  todayIntent?: string;
+  sampleThoughts?: string[];
+};
+
 export type QueryStatusNote = {
   propId: string;
   authorName: string;