@ramarivera/coding-buddy 0.7.3 → 0.9.0

package/.claude-plugin/marketplace.json

@@ -5,14 +5,14 @@
     },
     "metadata": {
         "description": "Persistent coding companion for Claude Code, Pi, and Oh My Pi (requires bun: https://bun.sh/install)",
-        "version": "0.7.3"
+        "version": "0.8.0"
     },
     "plugins": [
         {
             "name": "coding-buddy",
             "source": "./",
             "description": "Persistent coding companion for Claude Code, Pi, and Oh My Pi. MCP-based terminal pet with ASCII art, stats, reactions, and personality. Requires bun runtime (https://bun.sh/install).",
-            "version": "0.7.3",
+            "version": "0.8.0",
             "author": {
                 "name": "ramarivera"
             },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
     "name": "coding-buddy",
-    "version": "0.7.3",
+    "version": "0.8.0",
     "description": "Persistent coding companion for Claude Code, Pi, and Oh My Pi. MCP-based terminal pet with ASCII art, stats, reactions, and personality.",
     "author": {
         "name": "ramarivera"

package/README.md

@@ -53,7 +53,7 @@
 <td align="center" width="25%">
 <h3>💬</h3>
 <b>Speech Bubbles</b><br>
-<sub>Your buddy comments on your code in real time. Invisible, contextual, alive.</sub>
+<sub>End-of-turn reactions come from the model by default (MCP tool call). When that doesn't fire — older Claude Code, no MCP, a turn where the model didn't react — a Stop hook falls back to a tagged canned pool line so the bubble is never silent.</sub>
 </td>
 <td align="center" width="25%">
 <h3>⚡</h3>
@@ -95,6 +95,8 @@ The `claude-buddy` package ended at **v0.5.2**.
 | **Pi** | `mariozechner/pi-coding-agent` workspace | Stable random UUID persisted in `~/.pi/agent/buddy/identity.json` |
 | **Oh My Pi (OMP)** | OMP harness with `omp.extensions` support | Stable random UUID persisted in `~/.omp/agent/buddy/identity.json` |
 
+All three surfaces use the same hero composition: the dashed speech bubble is on the left, its `--` tail points toward the rarity-colored sprite on the right, and the companion name is centered underneath the sprite. The card recomputes against the current terminal width on every render.
+
 ## 🚀 Quick Start
 
 ### Claude Code
@@ -135,6 +137,8 @@ bun run install-buddy
 <sub>💡 Need help? → `bun run help`, `npx -y @ramarivera/coding-buddy help`, or `coding-buddy help` (if linked) · `/buddy help` in Claude Code</sub>
 
 
+
+
 ### Multiple Claude profiles?
 
 If you run Claude Code with `CLAUDE_CONFIG_DIR` set (e.g. separate work and personal accounts), pass the same env var to install so buddy lands in the active profile and gets its own menagerie:
@@ -146,6 +150,16 @@ CLAUDE_CONFIG_DIR=~/.claude-personal npx -y @ramarivera/coding-buddy uninstall
 
 The installer prints `Target profile: <path>` at the top so you can see at a glance which profile you're targeting. Each profile gets its own MCP entry, skill, hooks, status line, and `$CLAUDE_CONFIG_DIR/buddy-state/` menagerie — installs in one profile don't touch another. With `CLAUDE_CONFIG_DIR` unset, behaviour is identical to single-profile (`~/.claude/`, `~/.claude-buddy/`).
 
+### One companion across harnesses
+
+To opt into one identity and one menagerie across Claude Code, Pi, and OMP, set the same variable before launching each harness:
+
+```bash
+export CODING_BUDDY_USER_ID="ramiro"
+```
+
+This opt-in uses `~/.coding-buddy/shared` for the companion, XP, achievements, and reaction state. Set `CODING_BUDDY_STATE_DIR` when you need a different shared root. Sharing the state directory is intentional: it makes the companion actually follow you, at the cost of giving up separate per-harness progress. Without `CODING_BUDDY_USER_ID`, the existing Claude account identity and Pi/OMP per-harness `identity.json` behavior remain unchanged.
+
 <br>
 
 ---
@@ -159,7 +173,7 @@ The installer prints `Target profile: <path>` at the top so you can see at a gla
 
 <br>
 
-Every buddy is uniquely generated — same species, same stats, same personality every time. On **Claude Code** the seed is derived from your `accountUuid` in `~/.claude.json`; on **Pi** and **Oh My Pi** a stable random UUID is generated once and persisted in `~/.pi/agent/buddy/identity.json` or `~/.omp/agent/buddy/identity.json` (deleting the file and letting it regenerate will change your buddy). 19 species, each with 3 idle animation frames + a blink.
+Every buddy is uniquely generated — same species, same stats, same personality every time. On **Claude Code** the seed is derived from your `accountUuid` in `~/.claude.json`; on **Pi** and **Oh My Pi** a stable random UUID is generated once and persisted in `~/.pi/agent/buddy/identity.json` or `~/.omp/agent/buddy/identity.json` (unless `CODING_BUDDY_USER_ID` is set). 19 species, each with 3 idle animation frames + a blink.
 
 <!-- Later replace with: docs/species-grid.png -->
 <p align="center">
@@ -233,11 +247,11 @@ Five integration points, zero binary dependencies. When Claude Code, Pi, or Oh M
              └─────────────────────┘
 ```
 
-- **MCP Server** — companion tools + system prompt that instructs Claude to write buddy comments
+- **MCP Server** — companion tools + system prompt that tells Claude to call `buddy_react` at the end of every turn. The tool call writes the reaction with `source: "tool"` — model-authored, renders nowhere in the transcript.
 - **Skill** — routes `/buddy`, `/buddy pet`, `/buddy stats`, `/buddy off`, `/buddy rename`
 - **Status Line** — animated ASCII art, right-aligned, with rarity color and speech bubble
 - **PostToolUse Hook** — detects errors, test failures, large diffs in Bash output
-- **Stop Hook** — extracts invisible `<!-- buddy: ... -->` comments from Claude's responses
+- **Stop Hook** — backward-compat fallback chain. Skips if a fresh `buddy_react` (primary channel) just ran; otherwise extracts a legacy `<!-- buddy: ... -->` comment if Claude happens to emit one (older Claude Code builds), and otherwise picks a canned pool line via `server/turn-reaction.ts`. Every write carries a `source` tag (`tool`/`comment`/`fallback`) so `/buddy stats` can prove what produced the bubble.
 
 ### Why MCP Instead of Binary Patching?
 
@@ -314,8 +328,13 @@ You can run any command with `npx -y @ramarivera/coding-buddy <command>` from an
 | `bun run disable` | Temporarily deactivate buddy |
 | `bun run enable` | Re-enable buddy |
 | `bun run help` | Full CLI reference |
+
 | `bun run uninstall` | Clean removal |
 
+### Statusline width and reaction lifetime
+
+The statusline reserves 14 columns for Claude Code's content-box chrome before laying out the buddy (two columns for `padding: 1` and twelve for internal margins, calibrated against the reported ~74-column content box). If your harness uses different padding or margins, set the signed `statuslineWidthAdjust` value in `buddy-state/config.json` (for example, `-4` makes the usable width four columns narrower; `+4` widens it). Width is resolved in this order: `BUDDY_STATUSLINE_COLS`, exported `COLUMNS`, Linux `/proc` PTY, macOS `ps` + `stty`, PowerShell, then a final default of `125`; `statuslineWidthAdjust` is applied to the detected width. Both environment overrides must be positive integers to take effect. The width regression fixture renders at 60, 80, and 120 columns and asserts that every ANSI-stripped row fits the resulting budget. `reactionTTL` defaults to 900 seconds (15 minutes); set it to `0` only to keep reactions permanently. Expired per-session reaction and comment-throttle files are removed automatically, so stale bubbles don't accumulate. The final ANSI safety pass does one Unicode-width profile per row rather than spawning subprocesses per character.
+
 <sub>💡 Want a global `coding-buddy` command? → `cd coding-buddy && bun link`</sub>
 
 ### 🎯 Buddy Pick

package/adapters/omp/context.ts

@@ -16,7 +16,7 @@ export interface OmpBuddyContext extends OmpBuddyUiContext {
   model: ExtensionContext["model"];
   modelRegistry: Pick<
     ExtensionContext["modelRegistry"],
-    "find" | "getApiKey" | "getProviderHeaders"
+    "find" | "getApiKeyForProvider" | "getProviderHeaders"
   >;
   sessionManager: Pick<ExtensionContext["sessionManager"], "getBranch">;
 }

package/adapters/omp/events.ts

@@ -12,7 +12,7 @@ import { complete, type AssistantMessage, type TextContent, type UserMessage } f
 import { BuddyCommandService, type ReactionResult } from "../../core/command-service.ts";
 import type { BuddyTurnCommentModelConfig, Companion } from "../../core/model.ts";
 import type { Achievement } from "../../core/achievements.ts";
-import { getNameReaction, getSuccessReaction, isNameMentioned } from "../../core/reactions.ts";
+import { extractGeneratedPersonality, generatePersonalityPrompt, getNameReaction, getSuccessReaction, isNameMentioned } from "../../core/reactions.ts";
 import { OmpBuddyStorage } from "./storage.ts";
 import { buildBuddyReactionPrompt, buildBuddyReactionSystemPrompt, normalizeBuddyComment, stripBuddyComments } from "./prompt.ts";
 import { OmpBuddyUI } from "./ui.ts";
@@ -37,19 +37,31 @@ interface RegisterOmpBuddyEventsDeps {
   ui: OmpBuddyUI;
   logger: OmpBuddyLog;
   completeTurnComment?: TurnCommentCompleter;
+  completePersonality?: PersonalityCompleter;
 }
 
 export function registerOmpBuddyEvents(pi: ExtensionAPI, deps: RegisterOmpBuddyEventsDeps): void {
   pi.on("session_start", async (_event: SessionStartEvent, ctx: OmpBuddyContext) => {
     const result = deps.service.startSession();
+    let companion = result.companion;
+    if (result.created) {
+      const generated = await generatePersonality(ctx, companion, deps.logger, deps.completePersonality, {
+        modelOverride: deps.storage.loadOmpConfig().turnCommentModel,
+      });
+      if (generated) {
+        const updated = deps.service.setPersonalityForSlot(result.slot, generated, result.companion.personality);
+        if (updated) companion = updated;
+      }
+    }
+    companion = deps.storage.loadActive() ?? companion;
     deps.logger.info("session_start", {
-      companion: result.companion.name,
-      species: result.companion.bones.species,
+      companion: companion.name,
+      species: companion.bones.species,
       created: result.created,
     });
-    deps.ui.refresh(ctx, result.companion, deps.storage.loadLatest(), result.achievements);
+    deps.ui.refresh(ctx, companion, deps.storage.loadLatest(), result.achievements);
     if (result.created) {
-      ctx.ui.notify(`A new buddy hatched: ${result.companion.name}`, "info");
+      ctx.ui.notify(`A new buddy hatched: ${companion.name}`, "info");
     }
     deps.ui.notifyAchievements(ctx, result.achievements);
   });
@@ -162,13 +174,17 @@ export function registerOmpBuddyEvents(pi: ExtensionAPI, deps: RegisterOmpBuddyE
       return;
     }
 
+    const config = deps.storage.loadOmpConfig();
     const generated = await generateTurnComment(
       ctx,
       progress.companion,
       event,
       deps.logger,
       deps.completeTurnComment ?? complete,
-      deps.storage.loadOmpConfig().turnCommentModel,
+      {
+        modelOverride: config.turnCommentModel,
+        timeoutMs: config.turnCommentTimeoutMs,
+      },
     );
     if (!generated.comment) {
       const assistantLength = isAssistantMessage(event.message) ? getAssistantText(event.message).length : 0;
@@ -188,7 +204,7 @@ export function registerOmpBuddyEvents(pi: ExtensionAPI, deps: RegisterOmpBuddyE
     deps.ui.notifyAchievements(ctx, achievements);
   });
   pi.on("session_shutdown", () => {
-    deps.ui.cancelTimers();
+    deps.ui.dispose();
   });
 
 }
@@ -294,14 +310,28 @@ function getAssistantText(message: AssistantMessage): string {
     .join("\n");
 }
 
+/** Well under OMP's 30s handler budget; cosmetic reactions must never stall a turn. */
+export const TURN_COMMENT_TIMEOUT_MS = 5_000;
+
+export function resolveTurnCommentTimeoutMs(timeoutMs: number | undefined): number {
+  return typeof timeoutMs === "number" && Number.isFinite(timeoutMs) && timeoutMs > 0
+    ? timeoutMs
+    : TURN_COMMENT_TIMEOUT_MS;
+}
+
 export async function generateTurnComment(
   ctx: OmpBuddyContext,
   companion: Companion,
   event: TurnEndEvent,
   logger: OmpBuddyLog,
   completeTurnComment: TurnCommentCompleter = complete,
-  modelOverride?: BuddyTurnCommentModelConfig,
+  options: {
+    modelOverride?: BuddyTurnCommentModelConfig;
+    timeoutMs?: number;
+  } = {},
 ): Promise<{ comment: string | null; source: "llm" | "fallback" | "none" }> {
+  const { modelOverride } = options;
+  const timeoutMs = resolveTurnCommentTimeoutMs(options.timeoutMs);
   const assistantText = isAssistantMessage(event.message) ? getAssistantText(event.message) : "";
   if (!assistantText.trim()) {
     logger.warn("turn_comment_skipped", { reason: "empty_assistant_text" });
@@ -309,97 +339,151 @@ export async function generateTurnComment(
   }
 
   const turnCommentModel = resolveTurnCommentModel(ctx, logger, modelOverride);
-  if (turnCommentModel) {
-    const toolResultsText = getToolResultsText(event);
-    const userText = getUserPromptText(ctx);
-    const systemPrompt = buildBuddyReactionSystemPrompt(companion);
-    const promptText = buildBuddyReactionPrompt(companion, assistantText, toolResultsText, userText);
-    logger.info("turn_comment_llm_attempt", {
-      modelProvider: turnCommentModel.provider,
-      modelId: turnCommentModel.id,
+  if (!turnCommentModel) {
+    logger.warn("turn_comment_llm_skipped", { reason: "no_model" });
+    const fallback = deriveTurnComment(companion, event.message);
+    logger.warn("turn_comment_fallback", {
+      fallbackLength: fallback?.length ?? 0,
       assistantLength: assistantText.length,
-      toolLength: toolResultsText.length,
-      userTextLength: userText.length,
-      promptLength: promptText.length,
-      systemPromptLength: systemPrompt.length,
-      toolResultCount: event.toolResults.length,
     });
-    const promptDebugData: Record<string, unknown> = {
-      assistantLength: assistantText.length,
-      toolLength: toolResultsText.length,
-      userTextLength: userText.length,
-    };
-    if (diagnosticPreviewsEnabled()) {
-      promptDebugData.systemPromptPreview = systemPrompt.slice(0, 800);
-      promptDebugData.promptPreview = promptText.slice(0, 1200);
-      promptDebugData.userTextPreview = userText.slice(0, 200);
-      promptDebugData.assistantPreview = assistantText.slice(0, 200);
-      promptDebugData.toolPreview = toolResultsText.slice(0, 200);
-    }
-    logger.debug("turn_comment_llm_prompt", promptDebugData);
+    return { comment: fallback, source: fallback ? "fallback" : "none" };
+  }
+
+  const toolResultsText = getToolResultsText(event);
+  const userText = getUserPromptText(ctx);
+  const systemPrompt = buildBuddyReactionSystemPrompt(companion);
+  const promptText = buildBuddyReactionPrompt(companion, assistantText, toolResultsText, userText);
+  logger.info("turn_comment_llm_attempt", {
+    modelProvider: turnCommentModel.provider,
+    modelId: turnCommentModel.id,
+    assistantLength: assistantText.length,
+    toolLength: toolResultsText.length,
+    userTextLength: userText.length,
+    promptLength: promptText.length,
+    systemPromptLength: systemPrompt.length,
+    toolResultCount: event.toolResults.length,
+    timeoutMs,
+  });
+  const promptDebugData: Record<string, unknown> = {
+    assistantLength: assistantText.length,
+    toolLength: toolResultsText.length,
+    userTextLength: userText.length,
+  };
+  if (diagnosticPreviewsEnabled()) {
+    promptDebugData.systemPromptPreview = systemPrompt.slice(0, 800);
+    promptDebugData.promptPreview = promptText.slice(0, 1200);
+    promptDebugData.userTextPreview = userText.slice(0, 200);
+    promptDebugData.assistantPreview = assistantText.slice(0, 200);
+    promptDebugData.toolPreview = toolResultsText.slice(0, 200);
+  }
+  logger.debug("turn_comment_llm_prompt", promptDebugData);
+
+  const userMessage: UserMessage = {
+    role: "user",
+    content: [{ type: "text", text: promptText }],
+    timestamp: Date.now(),
+  };
+
+  const controller = new AbortController();
+  let timedOut = false;
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    timeoutId = setTimeout(() => {
+      timedOut = true;
+      controller.abort(new Error("Turn comment generation timed out"));
+      reject(new Error("Turn comment generation timed out"));
+    }, timeoutMs);
+  });
+
+  const workPromise = (async (): Promise<string | null> => {
     let apiKey: string | undefined;
     try {
-      apiKey = await ctx.modelRegistry.getApiKey(turnCommentModel);
+      apiKey = await ctx.modelRegistry.getApiKeyForProvider(
+        turnCommentModel.provider,
+        undefined,
+        {
+          baseUrl: turnCommentModel.baseUrl,
+          modelId: turnCommentModel.id,
+          signal: controller.signal,
+        },
+      );
     } catch (error) {
       logger.warn("turn_comment_auth_unavailable", {
         message: error instanceof Error ? error.message : String(error),
       });
+      return null;
     }
+
     const headers = ctx.modelRegistry.getProviderHeaders(turnCommentModel.provider);
     logger.debug("turn_comment_auth", {
       hasApiKey: Boolean(apiKey),
       headerKeys: Object.keys(headers ?? {}),
     });
-    if (apiKey) {
-      const userMessage: UserMessage = {
-        role: "user",
-        content: [{ type: "text", text: promptText }],
-        timestamp: Date.now(),
-      };
-
-      try {
-        const response = await completeTurnComment(
-          turnCommentModel,
-          {
-            systemPrompt: [systemPrompt],
-            messages: [userMessage],
-          },
-          {
-            apiKey,
-            headers,
-          },
-        );
-
-        if (response.stopReason !== "aborted") {
-          const text = response.content
-            .filter((block): block is TextContent => block.type === "text")
-            .map((block) => block.text)
-            .join("\n");
-          const normalized = normalizeBuddyComment(text);
-          logger.info("turn_comment_llm_result", {
-            stopReason: response.stopReason,
-            errorMessage: "errorMessage" in response ? response.errorMessage : undefined,
-            contentTypes: response.content.map((block) => block.type),
-            contentCount: response.content.length,
-            rawLength: text.length,
-            normalizedLength: normalized.length,
-          });
-          if (normalized) return { comment: normalized, source: "llm" };
-          logger.warn("turn_comment_llm_empty", { rawLength: text.length });
-        }
-      } catch (error) {
-        logger.error("turn_comment_llm_error", {
-          message: error instanceof Error ? error.message : String(error),
-          stack: error instanceof Error ? error.stack : undefined,
-        });
-      }
-    } else {
+    if (!apiKey) {
       logger.warn("turn_comment_auth_unavailable", {
         message: "missing api key",
       });
+      return null;
+    }
+
+    const response = await completeTurnComment(
+      turnCommentModel,
+      {
+        systemPrompt: [systemPrompt],
+        messages: [userMessage],
+      },
+      {
+        apiKey,
+        headers,
+        signal: controller.signal,
+      },
+    );
+
+    if (response.stopReason === "aborted") {
+      logger.warn("turn_comment_llm_aborted", {
+        errorMessage: "errorMessage" in response ? response.errorMessage : undefined,
+      });
+      return null;
+    }
+
+    const text = response.content
+      .filter((block): block is TextContent => block.type === "text")
+      .map((block) => block.text)
+      .join("\n");
+    const normalized = normalizeBuddyComment(text);
+    logger.info("turn_comment_llm_result", {
+      stopReason: response.stopReason,
+      errorMessage: "errorMessage" in response ? response.errorMessage : undefined,
+      contentTypes: response.content.map((block) => block.type),
+      contentCount: response.content.length,
+      rawLength: text.length,
+      normalizedLength: normalized.length,
+    });
+    if (normalized) return normalized;
+    logger.warn("turn_comment_llm_empty", { rawLength: text.length });
+    return null;
+  })();
+
+  // Prevent unhandled rejection if timeout wins the race first.
+  workPromise.catch(() => {});
+
+  try {
+    const comment = await Promise.race([workPromise, timeoutPromise]);
+    clearTimeout(timeoutId);
+    if (comment) return { comment, source: "llm" };
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (timedOut) {
+      logger.warn("turn_comment_llm_timeout", {
+        timeoutMs,
+        message: error instanceof Error ? error.message : String(error),
+      });
+    } else {
+      logger.error("turn_comment_llm_error", {
+        message: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : undefined,
+      });
     }
-  } else {
-    logger.warn("turn_comment_llm_skipped", { reason: "no_model" });
   }
 
   const fallback = deriveTurnComment(companion, event.message);
@@ -409,6 +493,127 @@ export async function generateTurnComment(
   });
   return { comment: fallback, source: fallback ? "fallback" : "none" };
 }
+const PERSONALITY_GENERATION_TIMEOUT_MS = 10_000;
+
+export type PersonalityCompleter = (
+  model: Parameters<typeof complete>[0],
+  context: Parameters<typeof complete>[1],
+  options: Parameters<typeof complete>[2],
+) => Promise<AssistantMessage>;
+export async function generatePersonality(
+  ctx: OmpBuddyContext,
+  companion: Companion,
+  logger: OmpBuddyLog,
+  completePersonality: PersonalityCompleter = complete,
+  options: {
+    modelOverride?: BuddyTurnCommentModelConfig;
+    timeoutMs?: number;
+  } = {},
+): Promise<string | null> {
+  const { modelOverride, timeoutMs = PERSONALITY_GENERATION_TIMEOUT_MS } = options;
+  const model = resolveTurnCommentModel(ctx, logger, modelOverride);
+  if (!model) {
+    logger.warn("personality_generation_skipped", { reason: "no_model" });
+    return null;
+  }
+
+  const promptText = generatePersonalityPrompt(
+    companion.bones.species,
+    companion.bones.rarity,
+    { ...companion.bones.stats } as Record<string, number>,
+    companion.bones.shiny,
+  );
+  const userMessage: UserMessage = {
+    role: "user",
+    content: [{ type: "text", text: promptText }],
+    timestamp: Date.now(),
+  };
+
+  const controller = new AbortController();
+  let timedOut = false;
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    timeoutId = setTimeout(() => {
+      timedOut = true;
+      controller.abort(new Error("Personality generation timed out"));
+      reject(new Error("Personality generation timed out"));
+    }, timeoutMs);
+  });
+
+  const workPromise = (async (): Promise<string | null> => {
+    let apiKey: string | undefined;
+    try {
+      apiKey = await ctx.modelRegistry.getApiKeyForProvider(
+        model.provider,
+        undefined,
+        { baseUrl: model.baseUrl, modelId: model.id, signal: controller.signal },
+      );
+    } catch (error) {
+      logger.warn("personality_generation_auth_unavailable", {
+        message: error instanceof Error ? error.message : String(error),
+      });
+    }
+    const headers = ctx.modelRegistry.getProviderHeaders(model.provider);
+    logger.debug("personality_generation_auth", {
+      hasApiKey: Boolean(apiKey),
+      headerKeys: Object.keys(headers ?? {}),
+    });
+    if (!apiKey) {
+      logger.warn("personality_generation_auth_unavailable", { message: "missing api key" });
+      return null;
+    }
+
+    const response = await completePersonality(
+      model,
+      { messages: [userMessage] },
+      { apiKey, headers, signal: controller.signal },
+    );
+
+    if (response.stopReason === "aborted") {
+      logger.warn("personality_generation_aborted", {
+        errorMessage: response.errorMessage,
+      });
+      return null;
+    }
+
+    const text = response.content
+      .filter((block): block is TextContent => block.type === "text")
+      .map((block) => block.text)
+      .join("\n");
+    const personality = extractGeneratedPersonality(text);
+    logger.info("personality_generation_result", {
+      stopReason: response.stopReason,
+      rawLength: text.length,
+      hasPersonality: !!personality,
+    });
+    if (personality) return personality;
+    logger.warn("personality_generation_malformed", { rawLength: text.length });
+    return null;
+  })();
+
+  workPromise.catch(() => {});
+
+  let result: string | null;
+  try {
+    result = await Promise.race([workPromise, timeoutPromise]);
+    clearTimeout(timeoutId);
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (timedOut) {
+      logger.warn("personality_generation_timeout", {
+        message: error instanceof Error ? error.message : String(error),
+      });
+    } else {
+      logger.error("personality_generation_error", {
+        message: error instanceof Error ? error.message : String(error),
+        stack: error instanceof Error ? error.stack : undefined,
+      });
+    }
+    result = null;
+  }
+
+  return result;
+}
 
 export function resolveTurnCommentModel(
   ctx: OmpBuddyContext,

package/adapters/omp/index.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
 import { BuddyCommandService } from "../../core/command-service.ts";
 import { registerBuddyCommands } from "./commands.ts";
-import { registerOmpBuddyEvents, type TurnCommentCompleter } from "./events.ts";
+import { registerOmpBuddyEvents, type PersonalityCompleter, type TurnCommentCompleter } from "./events.ts";
 import { OmpIdentityProvider } from "./identity.ts";
 import { OmpBuddyLogger } from "./logger.ts";
 import { OmpBuddyStorage } from "./storage.ts";
@@ -10,6 +10,7 @@ import { OmpBuddyUI } from "./ui.ts";
 export interface OmpBuddyExtensionOptions {
   stateDir?: string;
   completeTurnComment?: TurnCommentCompleter;
+  completePersonality?: PersonalityCompleter;
 }
 
 export default function registerOmpBuddyExtension(
@@ -35,5 +36,6 @@ export default function registerOmpBuddyExtension(
     ui,
     logger,
     completeTurnComment: options.completeTurnComment,
+    completePersonality: options.completePersonality,
   });
 }

package/adapters/omp/renderers.ts

@@ -1,61 +1,14 @@
-import { RARITY_STARS } from "../../core/engine.ts";
-import { getArtFrame, HAT_ART } from "../../core/render-model.ts";
-import type { Companion, ReactionState } from "../../core/model.ts";
 import type { Achievement } from "../../core/achievements.ts";
-import { getRarityColor } from "../../server/theme.ts";
+import type { Companion, ReactionState } from "../../core/model.ts";
 import {
-  composeDetailsAndArt,
   displayWidth,
-  getDetailsWidth,
   getWidgetWidth,
+  renderCompanionWidget,
   stripAnsi,
   WIDGET_MAX_LINES,
-  wrapReaction,
 } from "../shared/widget-layout.ts";
 
-const RESET = "\x1b[0m";
-const DIM_ITALIC = "\x1b[2;3m";
-
-export { displayWidth, WIDGET_MAX_LINES as OMP_WIDGET_MAX_LINES };
-
-function trimArt(line: string): string {
-  return line.replace(/\s+$/g, "");
-}
-
-function getFullArtFrame(companion: Companion, frame: number): string[] {
-  const art = getArtFrame(companion.bones.species, companion.bones.eye, frame);
-  if (companion.bones.hat !== "none" && !stripAnsi(art[0] ?? "").trim()) {
-    art[0] = HAT_ART[companion.bones.hat];
-  }
-  return art.map(trimArt);
-}
-
-function renderDetails(
-  companion: Companion,
-  reaction: ReactionState | null | undefined,
-  achievements: Achievement[],
-  sideWidth: number,
-): string[] {
-  const color = getRarityColor(companion.bones.rarity);
-  const stars = RARITY_STARS[companion.bones.rarity];
-  const shiny = companion.bones.shiny ? " ✨" : "";
-  const lines = [
-    `${color}${companion.name} ${stars}${shiny}${RESET}`,
-    `${companion.bones.rarity} ${companion.bones.species}`,
-  ];
-
-  if (reaction?.reaction) {
-    const remainingLines = Math.max(1, WIDGET_MAX_LINES - lines.length);
-    lines.push(...wrapReaction(reaction.reaction, sideWidth, remainingLines).map((line) => `${DIM_ITALIC}${line}${RESET}`));
-  }
-
-  for (const achievement of achievements) {
-    if (lines.length >= WIDGET_MAX_LINES) break;
-    lines.push(`🏆 ${achievement.name}`);
-  }
-
-  return lines;
-}
+export { displayWidth, stripAnsi, WIDGET_MAX_LINES as OMP_WIDGET_MAX_LINES };
 
 export function renderBuddyWidget(
   companion: Companion,
@@ -63,10 +16,7 @@ export function renderBuddyWidget(
   achievements: Achievement[] = [],
   width: number = getWidgetWidth(),
 ): string[] {
-  const art = getFullArtFrame(companion, Math.floor(Date.now() / 700));
-  const sideWidth = getDetailsWidth(art, width);
-  const details = renderDetails(companion, reaction, achievements, sideWidth);
-  return composeDetailsAndArt(details, art, width, WIDGET_MAX_LINES);
+  return renderCompanionWidget(companion, reaction, achievements, width);
 }
 
 export function renderBuddyStats(companion: Companion): string[] {