@ramarivera/coding-buddy 0.8.0 → 0.9.0

package/adapters/omp/ui.ts

@@ -3,9 +3,17 @@ import type { Achievement } from "../../core/achievements.ts";
 import type { Companion, ReactionState } from "../../core/model.ts";
 import { renderAchievementsSummary, renderBuddyWidget } from "./renderers.ts";
 import { OmpBuddyStorage } from "./storage.ts";
+import { getWidgetWidth, subscribeToWidgetResize } from "../shared/widget-layout.ts";
 
 export class OmpBuddyUI {
   private readonly timers: Array<{ timer: Timer; clear: (timer: Timer) => void }> = [];
+  private resizeUnsubscribe: (() => void) | null = null;
+  private rendered: {
+    ctx: OmpBuddyUiContext;
+    companion: Companion;
+    reaction: ReactionState | null;
+    achievements: Achievement[];
+  } | null = null;
 
   constructor(private readonly storage: OmpBuddyStorage) {}
 
@@ -19,6 +27,13 @@ export class OmpBuddyUI {
     }
   }
 
+  dispose(): void {
+    this.cancelTimers();
+    this.resizeUnsubscribe?.();
+    this.resizeUnsubscribe = null;
+    this.rendered = null;
+  }
+
   refresh(
     ctx: OmpBuddyUiContext,
     companion: Companion,
@@ -27,10 +42,12 @@ export class OmpBuddyUI {
   ): void {
     const currentReaction = reaction ?? null;
     const muted = this.storage.isMuted();
+    this.rendered = { ctx, companion, reaction: currentReaction, achievements: [...achievements] };
+    this.subscribeToResize();
     ctx.ui.setStatus("buddy", undefined);
     ctx.ui.setWidget(
       "buddy",
-      renderBuddyWidget(companion, muted ? null : currentReaction, achievements),
+      renderBuddyWidget(companion, muted ? null : currentReaction, achievements, getWidgetWidth()),
     );
 
     this.cancelTimers();
@@ -66,9 +83,21 @@ export class OmpBuddyUI {
     unlocked: Array<{ achievement: Achievement; unlockedAt: number; slot?: string }>,
     remaining: Achievement[],
   ): void {
+    this.rendered = null;
     ctx.ui.setWidget("buddy", renderAchievementsSummary(unlocked, remaining));
     ctx.ui.notify(`Achievements: ${unlocked.length} unlocked`, "info");
   }
+
+  private subscribeToResize(): void {
+    if (this.resizeUnsubscribe) return;
+    const resizeHandler = () => {
+      if (!this.rendered) return;
+      const { ctx, companion, reaction, achievements } = this.rendered;
+      const muted = this.storage.isMuted();
+      ctx.ui.setWidget("buddy", renderBuddyWidget(companion, muted ? null : reaction, achievements, getWidgetWidth()));
+    };
+    this.resizeUnsubscribe = subscribeToWidgetResize(resizeHandler);
+  }
 }
 
 function getScheduler(

package/adapters/pi/events.ts

@@ -13,7 +13,7 @@ import { complete, type AssistantMessage, type TextContent, type UserMessage } f
 import { BuddyCommandService, type ReactionResult } from "../../core/command-service.ts";
 import type { Achievement } from "../../core/achievements.ts";
 import type { BuddyTurnCommentModelConfig, Companion } from "../../core/model.ts";
-import { getNameReaction, getSuccessReaction, isNameMentioned } from "../../core/reactions.ts";
+import { extractGeneratedPersonality, generatePersonalityPrompt, getNameReaction, getSuccessReaction, isNameMentioned } from "../../core/reactions.ts";
 import { PiBuddyStorage } from "./storage.ts";
 import { buildBuddyReactionPrompt, buildBuddyReactionSystemPrompt, normalizeBuddyComment, stripBuddyComments } from "./prompt.ts";
 import { PiBuddyUI } from "./ui.ts";
@@ -29,19 +29,32 @@ interface RegisterBuddyEventsDeps {
   storage: PiBuddyStorage;
   ui: PiBuddyUI;
   logger: PiBuddyLog;
+  completeTurnComment?: TurnCommentCompleter;
+  completePersonality?: PersonalityCompleter;
 }
 
 export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsDeps): void {
   pi.on("session_start", async (_event: SessionStartEvent, ctx: ExtensionContext) => {
     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.loadPiConfig().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);
   });
@@ -152,14 +165,17 @@ export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsD
       deps.ui.refresh(ctx, progress.companion, null, progress.achievements);
       return;
     }
-
+    const config = deps.storage.loadPiConfig();
     const generated = await generateTurnComment(
       ctx,
       progress.companion,
       event,
       deps.logger,
-      complete,
-      deps.storage.loadPiConfig().turnCommentModel,
+      deps.completeTurnComment ?? complete,
+      {
+        modelOverride: config.turnCommentModel,
+        timeoutMs: config.turnCommentTimeoutMs,
+      },
     );
     if (!generated.comment) {
       const assistantLength = isAssistantMessage(event.message) ? getAssistantText(event.message).length : 0;
@@ -179,7 +195,7 @@ export function registerBuddyEvents(pi: ExtensionAPI, deps: RegisterBuddyEventsD
     deps.ui.notifyAchievements(ctx, achievements);
   });
   pi.on("session_shutdown", () => {
-    deps.ui.cancelTimers();
+    deps.ui.dispose();
   });
 }
 function diagnosticPreviewsEnabled(): boolean {
@@ -283,19 +299,34 @@ function getAssistantText(message: AssistantMessage): string {
     .join("\n");
 }
 
-type TurnCommentCompleter = (
+export type TurnCommentCompleter = (
   model: Parameters<typeof complete>[0],
   context: Parameters<typeof complete>[1],
   options: Parameters<typeof complete>[2],
 ) => Promise<AssistantMessage>;
+
+/** Well under typical harness handler budgets; 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: ExtensionContext,
   companion: Companion,
   event: TurnEndEvent,
   logger: PiBuddyLog,
   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" });
@@ -303,91 +334,144 @@ 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);
+    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 auth: Awaited<ReturnType<ExtensionContext["modelRegistry"]["getApiKeyAndHeaders"]>>;
+    try {
+      auth = await ctx.modelRegistry.getApiKeyAndHeaders(turnCommentModel);
+    } catch (error) {
+      logger.warn("turn_comment_auth_unavailable", {
+        message: error instanceof Error ? error.message : String(error),
+      });
+      return null;
     }
-    logger.debug("turn_comment_llm_prompt", promptDebugData);
-    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(turnCommentModel);
+
     logger.debug("turn_comment_auth", {
       ok: auth.ok,
       hasApiKey: auth.ok ? !!auth.apiKey : false,
       headerKeys: auth.ok ? Object.keys(auth.headers ?? {}) : [],
     });
-    if (auth.ok && auth.apiKey) {
-      const userMessage: UserMessage = {
-        role: "user",
-        content: [{ type: "text", text: promptText }],
-        timestamp: Date.now(),
-      };
-
-      try {
-        const response = await completeTurnComment(
-          turnCommentModel,
-          {
-            systemPrompt,
-            messages: [userMessage],
-          },
-          {
-            apiKey: auth.apiKey,
-            headers: auth.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 as { errorMessage?: string }).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 (!auth.ok || !auth.apiKey) {
       logger.warn("turn_comment_auth_unavailable", {
         ok: auth.ok,
         message: auth.ok ? "missing api key" : auth.error,
       });
+      return null;
+    }
+
+    const response = await completeTurnComment(
+      turnCommentModel,
+      {
+        systemPrompt,
+        messages: [userMessage],
+      },
+      {
+        apiKey: auth.apiKey,
+        headers: auth.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);
@@ -397,6 +481,119 @@ export async function generateTurnComment(
   });
   return { comment: fallback, source: fallback ? "fallback" : "none" };
 }
+export type PersonalityCompleter = (
+  model: Parameters<typeof complete>[0],
+  context: Parameters<typeof complete>[1],
+  options: Parameters<typeof complete>[2],
+) => Promise<AssistantMessage>;
+const PERSONALITY_GENERATION_TIMEOUT_MS = 10_000;
+
+export async function generatePersonality(
+  ctx: ExtensionContext,
+  companion: Companion,
+  logger: PiBuddyLog,
+  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> => {
+    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+    logger.debug("personality_generation_auth", {
+      ok: auth.ok,
+      hasApiKey: auth.ok ? !!auth.apiKey : false,
+      headerKeys: auth.ok ? Object.keys(auth.headers ?? {}) : [],
+    });
+    if (!auth.ok || !auth.apiKey) {
+      logger.warn("personality_generation_auth_unavailable", {
+        ok: auth.ok,
+        message: auth.ok ? "missing api key" : auth.error,
+      });
+      return null;
+    }
+
+    const response = await completePersonality(
+      model,
+      { messages: [userMessage] },
+      { apiKey: auth.apiKey, headers: auth.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 interface PiTurnCommentModelContext {
   model: ExtensionContext["model"];

package/adapters/pi/index.ts

@@ -3,12 +3,14 @@ import { BuddyCommandService } from "../../core/command-service.ts";
 import { PiIdentityProvider } from "./identity.ts";
 import { PiBuddyLogger } from "./logger.ts";
 import { registerBuddyCommands } from "./commands.ts";
-import { registerBuddyEvents } from "./events.ts";
+import { registerBuddyEvents, type TurnCommentCompleter, type PersonalityCompleter } from "./events.ts";
 import { PiBuddyStorage } from "./storage.ts";
 import { PiBuddyUI } from "./ui.ts";
 
 export interface PiBuddyExtensionOptions {
   stateDir?: string;
+  completeTurnComment?: TurnCommentCompleter;
+  completePersonality?: PersonalityCompleter;
 }
 
 export default function registerPiBuddyExtension(
@@ -28,5 +30,12 @@ export default function registerPiBuddyExtension(
   const ui = new PiBuddyUI(storage);
 
   registerBuddyCommands(pi, { service, storage, ui });
-  registerBuddyEvents(pi, { service, storage, ui, logger });
+  registerBuddyEvents(pi, {
+    service,
+    storage,
+    ui,
+    logger,
+    completeTurnComment: options.completeTurnComment,
+    completePersonality: options.completePersonality,
+  });
 }

package/adapters/pi/renderers.ts

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

package/adapters/pi/storage.ts

@@ -1,5 +1,6 @@
 import { getAgentDir } from "@mariozechner/pi-coding-agent";
 import { join } from "node:path";
+import { sharedStateDir } from "../../core/identity.ts";
 import {
   FileBuddyStorage,
   slugifySlot,
@@ -8,8 +9,12 @@ import {
 
 export const DEFAULT_PI_BUDDY_STATE_DIR = join(getAgentDir(), "buddy");
 
+function defaultPiBuddyStateDir(): string {
+  return sharedStateDir() ?? DEFAULT_PI_BUDDY_STATE_DIR;
+}
+
 export class PiBuddyStorage extends FileBuddyStorage {
-  constructor(stateDir = DEFAULT_PI_BUDDY_STATE_DIR) {
+  constructor(stateDir = defaultPiBuddyStateDir()) {
     super(stateDir);
   }