@ramarivera/coding-buddy 0.9.0 → 0.9.2

package/scripts/ci/vhs-run-statusline.sh

@@ -1,15 +1,27 @@
 #!/usr/bin/env bash
 # Invoked from VHS tapes. Args: <cols> <fixture-relpath-from-repo-root>
+# BUDDY_STATUSLINE_ROWS defaults to 50 (full density) so golden renders are not
+# sensitive to the VHS terminal's actual row count.
 set -euo pipefail
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
 cols="${1:?cols}"
 fixture_rel="${2:?fixture}"
 payload='{"session_id":"ci","model":{"display_name":"CI"},"workspace":{"current_dir":"."}}'
+
+if [[ "$fixture_rel" = /* ]]; then
+  cfg_dir="$fixture_rel"
+else
+  cfg_dir="$ROOT/$fixture_rel"
+fi
+
+rows="${BUDDY_STATUSLINE_ROWS:-50}"
+
 cd "$ROOT"
 printf '%s' "$payload" \
   | COLUMNS="$cols" \
     BUDDY_FAKE_NOW=0 \
-    CLAUDE_CONFIG_DIR="$ROOT/$fixture_rel" \
+    BUDDY_STATUSLINE_ROWS="$rows" \
+    CLAUDE_CONFIG_DIR="$cfg_dir" \
     CLAUDE_CODE_SESSION_ID= \
     TMUX_PANE= \
     BUDDY_SHELL= \

package/scripts/ci/write-density-status.ts

@@ -0,0 +1,86 @@
+#!/usr/bin/env bun
+/**
+ * Derives a status.json fixture with full/compact/minimal frame arrays.
+ *
+ * Reads a base status object from stdin, computes frames from species/eye/hat,
+ * and writes the augmented object to the file named by the first argument.
+ *
+ * Usage:
+ *   cat base-status.json | bun scripts/ci/write-density-status.ts dest.json
+ *   bun scripts/ci/write-density-status.ts dest.json < base-status.json
+ */
+import { writeFileSync } from "fs";
+import { getStatusFrames } from "../../server/art.ts";
+import { renderFace, resolveEyeGlyph, type Species } from "../../core/engine.ts";
+
+function deriveCompactFrames(fullFrames: string[]): string[] {
+  return fullFrames.map((body) => {
+    const lines = body.split("\n");
+    const selected: string[] = [];
+    for (const line of lines) {
+      if (selected.length >= 3) break;
+      if (line.trim() !== "") selected.push(line);
+    }
+    while (selected.length < 3) selected.push("");
+    return selected.join("\n");
+  });
+}
+
+function deriveMinimalFrames(species: Species, eye: string): string[] {
+  const face = renderFace(species, resolveEyeGlyph(eye));
+  return Array.from({ length: 4 }, () => face);
+}
+
+async function main() {
+  const dest = process.argv[2];
+  if (!dest) {
+    console.error("usage: write-density-status.ts <dest.json>");
+    process.exit(2);
+  }
+
+  let input = "";
+  for await (const chunk of process.stdin) {
+    input += chunk;
+  }
+  const base = input ? JSON.parse(input) : {};
+
+  const bones = {
+    species: base.species ?? "pikachu",
+    rarity: base.rarity ?? "common",
+    eye: base.eye ?? "o",
+    hat: base.hat ?? "none",
+    shiny: base.shiny ?? false,
+    stats: base.stats ?? { DEBUGGING: 50, PATIENCE: 50, CHAOS: 50, WISDOM: 50, SNARK: 50 },
+    peak: base.peak ?? "DEBUGGING",
+    dump: base.dump ?? "PATIENCE",
+  };
+
+  const result = getStatusFrames(bones) as {
+    frames: string[];
+    frameSequence: number[];
+    compactFrames?: string[];
+    minimalFrames?: string[];
+  };
+
+  const compactFrames =
+    result.compactFrames && result.compactFrames.length > 0
+      ? result.compactFrames
+      : deriveCompactFrames(result.frames);
+
+  const minimalFrames =
+    result.minimalFrames && result.minimalFrames.length > 0
+      ? result.minimalFrames
+      : deriveMinimalFrames(bones.species as Species, bones.eye);
+
+  const out = {
+    ...base,
+    frames: result.frames,
+    compactFrames,
+    minimalFrames,
+    frameSequence: result.frameSequence,
+  };
+
+  writeFileSync(dest, JSON.stringify(out));
+}
+
+main();

package/server/art.ts

@@ -6,11 +6,12 @@
  * {E} is replaced with the eye character at render time.
  */
 
-import { resolveEyeGlyph, type Species, type Hat, type Rarity, type StatName, type BuddyBones } from "../core/engine.ts"
+import { renderFace, resolveEyeGlyph, type Species, type Hat, type Rarity, type StatName, type BuddyBones } from "../core/engine.ts"
 export { resolveEyeGlyph };
 import { HAT_ART } from "../core/art-data.ts";
-import { getRarityColor } from "./theme.ts";
+
 export { HAT_ART };
+import { getRarityColor } from "./theme.ts";
 
 // ─── Species art: 3 frames × 5 lines each ──────────────────────────────────
 
@@ -265,6 +266,8 @@ export const STATUS_FRAME_SEQUENCE: readonly number[] = [
 // \n-joined 5-line string (one jq call + mapfile in bash).
 export function getStatusFrames(bones: BuddyBones): {
   frames: string[];
+  compactFrames: string[];
+  minimalFrames: string[];
   frameSequence: number[];
 } {
   const resolveFrame = (frameIdx: number, eyeGlyph: string): string => {
@@ -277,16 +280,34 @@ export function getStatusFrames(bones: BuddyBones): {
     return art.join("\n");
   };
 
+  // Compact: keep the first three non-empty rows of each full frame. This
+  // preserves a hat if it occupies the top row, otherwise it drops the blank
+  // placeholder and shows the face/body.
+  const deriveCompactFrames = (fullFrames: string[]): string[] =>
+    fullFrames.map((body) => {
+      const lines = body.split("\n");
+      const selected: string[] = [];
+      for (const line of lines) {
+        if (selected.length >= 3) break;
+        if (line.trim() !== "") selected.push(line);
+      }
+      while (selected.length < 3) selected.push("");
+      return selected.join("\n");
+    });
+
   // Sanitize once at the boundary. Blink uses a literal "-" eye, which is
   // intentionally outside EYES and must not pass through resolveEyeGlyph.
   const eye = resolveEyeGlyph(bones.eye);
+  const frames = [
+    resolveFrame(0, eye),
+    resolveFrame(1, eye),
+    resolveFrame(2, eye),
+    resolveFrame(0, "-"),
+  ];
   return {
-    frames: [
-      resolveFrame(0, eye),
-      resolveFrame(1, eye),
-      resolveFrame(2, eye),
-      resolveFrame(0, "-"),
-    ],
+    frames,
+    compactFrames: deriveCompactFrames(frames),
+    minimalFrames: Array.from({ length: frames.length }, () => renderFace(bones.species, eye)),
     frameSequence: [...STATUS_FRAME_SEQUENCE],
   };
 }

package/server/hooks/buddy-comment.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 
-import { mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync } from "fs";
 import { join } from "path";
 import { reactionPool } from "./reaction-data.ts";
 import {
@@ -44,7 +44,9 @@ const BUDDY_COMMENT_PATTERN = /<!--\s*buddy:\s*([\s\S]*?)\s*-->/g;
  * Provenance of the reaction the hook wrote. Mirrors server/state.ts
  * `ReactionSource`; loaded as `none` on legacy files without the field.
  */
-export type ReactionSource = "comment" | "fallback" | "none";
+// "tool" is returned when a buddy_react reaction was adopted rather than
+// written by this hook; it mirrors server/state.ts's ReactionSource.
+export type ReactionSource = "tool" | "comment" | "fallback" | "none";
 
 export interface BuddyCommentResult {
   comment?: string;
@@ -131,19 +133,83 @@ function readTimestampSeconds(path: string): number {
  * is clamped to `now` so a skewed clock on a prior run does not poison
  * the comparison.
  */
-function toolFiredThisTurn(
-  reactionPath: string,
+/**
+ * How long after a stop marker a tool reaction still counts as "this turn".
+ *
+ * The Stop hook can legitimately fire more than once per turn — duplicate
+ * registrations accumulate in settings.json, and one dogfooding machine was
+ * observed with EIGHT Stop entries. Without this grace window the first
+ * invocation adopts the buddy_react reaction and stamps the marker, and every
+ * subsequent invocation then judges that same reaction stale and overwrites
+ * the bubble with a canned pool line. The user only ever sees the last write.
+ */
+const SAME_TURN_GRACE_MS = 10_000;
+
+/**
+ * Hard ceiling on how old an adopted tool reaction may be.
+ *
+ * A brand-new session has no stop marker, so `readTimestampSeconds` returns 0
+ * and every positive timestamp would otherwise look "fresh" — letting a
+ * leftover reaction from an unrelated session surface on the first turn.
+ * Bounded to the statusline's default reactionTTL: never adopt something the
+ * statusline would already treat as expired.
+ */
+const MAX_ADOPTION_AGE_MS = 900_000;
+
+function isFreshToolReaction(
+  candidate: ReactionFile | null,
   stopMarkerPath: string,
   nowMs: number,
 ): boolean {
-  const existing = readJsonFile<ReactionFile>(reactionPath);
-  if (!existing || existing.source !== "tool") return false;
-  const ts = typeof existing.timestamp === "number" ? existing.timestamp : 0;
+  if (!candidate || candidate.source !== "tool") return false;
+  const ts = typeof candidate.timestamp === "number" ? candidate.timestamp : 0;
   if (ts <= 0) return false;
   if (ts > nowMs + FUTURE_TIMESTAMP_TOLERANCE_MS) return false;
+  if (nowMs - ts > MAX_ADOPTION_AGE_MS) return false;
   const lastStopSec = readTimestampSeconds(stopMarkerPath);
   const effectiveLastStopMs = Math.min(lastStopSec * 1000, nowMs);
-  return ts > effectiveLastStopMs;
+  return ts > effectiveLastStopMs - SAME_TURN_GRACE_MS;
+}
+
+/**
+ * The MCP server and this hook do not always agree on the session id: the
+ * server is long-lived and resolves BUDDY_SID once at launch, while the hook
+ * and the statusline resolve it per invocation. When they diverge,
+ * `buddy_react` writes a real model-authored reaction into a file nothing
+ * renders, this hook sees an empty file for *its* session, and overwrites the
+ * bubble with a canned pool line — which looks exactly like the reactions
+ * being fake.
+ *
+ * So look for a fresh tool reaction across every session file, not just ours,
+ * and adopt it. Ours still wins when both are fresh.
+ */
+function findFreshToolReaction(
+  stateDir: string,
+  ownReactionPath: string,
+  stopMarkerPath: string,
+  nowMs: number,
+): ReactionFile | null {
+  const own = readJsonFile<ReactionFile>(ownReactionPath);
+  if (isFreshToolReaction(own, stopMarkerPath, nowMs)) return own;
+
+  let best: ReactionFile | null = null;
+  let entries: string[] = [];
+  try {
+    entries = readdirSync(stateDir);
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    if (!entry.startsWith("reaction.") || !entry.endsWith(".json")) continue;
+    const path = join(stateDir, entry);
+    if (path === ownReactionPath) continue;
+    const candidate = readJsonFile<ReactionFile>(path);
+    if (!isFreshToolReaction(candidate, stopMarkerPath, nowMs)) continue;
+    const bestTs = typeof best?.timestamp === "number" ? best.timestamp : 0;
+    const candidateTs = typeof candidate?.timestamp === "number" ? candidate.timestamp : 0;
+    if (!best || candidateTs > bestTs) best = candidate;
+  }
+  return best;
 }
 
 export function handleBuddyComment(
@@ -170,9 +236,22 @@ export function handleBuddyComment(
   const cooldown = nonNegativeInteger(config.commentCooldown, 30);
 
   // ─── Don't clobber a buddy_react tool reaction from this turn ───────────
-  if (toolFiredThisTurn(reactionPath, stopMarkerFile, now)) {
+  // Checked across all session files: see findFreshToolReaction for why.
+  const freshTool = findFreshToolReaction(stateDir, reactionPath, stopMarkerFile, now);
+  if (freshTool) {
+    // Adopt it into this session's file so the statusline — which reads only
+    // its own session — actually renders the model-authored line.
+    const own = readJsonFile<ReactionFile>(reactionPath);
+    let wrote = false;
+    if (own?.reaction !== freshTool.reaction || own?.source !== "tool") {
+      mkdirSync(stateDir, { recursive: true });
+      atomicWriteJson(reactionPath, freshTool);
+      wrote = true;
+    }
     atomicWriteTimestamp(stopMarkerFile, now);
-    return { source: "none", updated: false };
+    // `updated` reports whether this invocation wrote the bubble, so adoption
+    // counts — a consumer using it to trigger a re-render must see the write.
+    return { source: "tool", updated: wrote };
   }
 
   // ─── Cooldown: rate-limit the reaction write AND bookkeeping ──────────

package/server/state.ts

@@ -30,10 +30,12 @@ import {
   rmSync,
 } from "fs";
 import { join } from "path";
-import type { Companion } from "../core/engine.ts"
+import { configuredSharedUserId } from "../core/identity.ts";
+import type { BuddyBones, Companion } from "../core/engine.ts"
 import type * as CoreEngine from "../core/engine.ts";
 import type * as Art from "./art.ts";
-import { configuredSharedUserId } from "../core/identity.ts";
+import type * as MoodModule from "./mood.ts";
+import type * as XpModule from "./xp.ts";
 import {
   buddyStateDir,
   claudeSettingsPath,
@@ -41,9 +43,17 @@ import {
   toUnixPath,
 } from "./path.ts";
 
-export const STATE_DIR = buddyStateDir();
-const MANIFEST_FILE = join(STATE_DIR, "menagerie.json");
-const CONFIG_FILE = join(STATE_DIR, "config.json");
+// Resolved per call, never captured at import. ES modules are cached, so a
+// module-level `buddyStateDir()` pinned these paths to whatever
+// CLAUDE_CONFIG_DIR happened to be at *first* import. Once any file in a test
+// process had imported this module, every later redirect was silently ignored —
+// which is how `bun test` came to overwrite a user's live companion with a test
+// fixture. Individually the test files were clean; only running them together
+// leaked. A lazy lookup makes that class of bug impossible.
+const stateDir = () => buddyStateDir();
+const MANIFEST_FILE = () => join(stateDir(), "menagerie.json");
+const CONFIG_FILE = () => join(stateDir(), "config.json");
+const STATUS_FILE = () => join(stateDir(), "status.json");
 
 // ─── Session ID (Claude Code session isolation, tmux pane fallback) ─────────
 //
@@ -65,7 +75,7 @@ function sessionId(): string {
 }
 
 function reactionFile(): string {
-  return join(STATE_DIR, `reaction.${sessionId()}.json`);
+  return join(stateDir(), `reaction.${sessionId()}.json`);
 }
 
 // ─── Manifest schema ─────────────────────────────────────────────────────────
@@ -83,7 +93,7 @@ function emptyManifest(): Manifest {
 
 function loadManifest(): Manifest {
   try {
-    const raw = readFileSync(MANIFEST_FILE, "utf8");
+    const raw = readFileSync(MANIFEST_FILE(), "utf8");
     const m = JSON.parse(raw) as Manifest;
     if (!m.companions) m.companions = {};
     return m;
@@ -93,10 +103,10 @@ function loadManifest(): Manifest {
 }
 
 function saveManifest(m: Manifest): void {
-  mkdirSync(STATE_DIR, { recursive: true });
-  const tmp = MANIFEST_FILE + ".tmp";
+  mkdirSync(stateDir(), { recursive: true });
+  const tmp = MANIFEST_FILE() + ".tmp";
   writeFileSync(tmp, JSON.stringify(m, null, 2));
-  renameSync(tmp, MANIFEST_FILE); // atomic on same filesystem
+  renameSync(tmp, MANIFEST_FILE()); // atomic on same filesystem
 }
 
 // ─── Slot helpers ────────────────────────────────────────────────────────────
@@ -222,13 +232,13 @@ export function saveCompanion(companion: Companion): void {
 // ─── Migration: legacy companion.json -> single manifest ────────────────────
 
 function migrateIfNeeded(): void {
-  if (existsSync(MANIFEST_FILE)) return;
+  if (existsSync(MANIFEST_FILE())) return;
 
   const companions: Record<string, Companion> = {};
   let active = "buddy";
 
   // Absorb menagerie/<slot>.json files
-  const menagerieDir = join(STATE_DIR, "menagerie");
+  const menagerieDir = join(stateDir(), "menagerie");
   if (existsSync(menagerieDir)) {
     try {
       for (const f of readdirSync(menagerieDir).filter((f) =>
@@ -249,7 +259,7 @@ function migrateIfNeeded(): void {
   }
 
   // Absorb legacy companion.json
-  const legacyFile = join(STATE_DIR, "companion.json");
+  const legacyFile = join(stateDir(), "companion.json");
   if (existsSync(legacyFile) && Object.keys(companions).length === 0) {
     try {
       const c: Companion = JSON.parse(readFileSync(legacyFile, "utf8"));
@@ -262,7 +272,7 @@ function migrateIfNeeded(): void {
   }
 
   // Read active pointer if it exists
-  const activeFile = join(STATE_DIR, "active");
+  const activeFile = join(stateDir(), "active");
   if (existsSync(activeFile)) {
     try {
       const a = readFileSync(activeFile, "utf8").trim();
@@ -322,7 +332,7 @@ export function saveReaction(
   reason: string,
   source: ReactionSource = "fallback",
 ): void {
-  mkdirSync(STATE_DIR, { recursive: true });
+  mkdirSync(stateDir(), { recursive: true });
   const state: ReactionState = { reaction, timestamp: Date.now(), reason, source };
   // Atomic via tmp + rename — torn reads on the reaction file would
   // make the Stop hook's freshness check see an absent file, pinning
@@ -353,6 +363,7 @@ export interface BuddyConfig {
   bubblePosition: "top" | "left";
   showRarity: boolean;
   statusLineEnabled: boolean;
+  statuslineDensity: "auto" | "full" | "compact" | "minimal";
   statuslineWidthAdjust: number;
   bubbleWidth: number;
   bubbleMargin: number;
@@ -366,7 +377,6 @@ export interface BuddyConfig {
   suggestionsEnabled: boolean;
   suggestionCooldown: number;
 }
-
 const DEFAULT_CONFIG: BuddyConfig = {
   commentCooldown: 30,
   // Long enough that a reaction survives the turn you were reading when it was
@@ -377,6 +387,7 @@ const DEFAULT_CONFIG: BuddyConfig = {
   bubblePosition: "top",
   showRarity: true,
   statusLineEnabled: false,
+  statuslineDensity: "auto",
   statuslineWidthAdjust: 0,
   bubbleWidth: 28,
   bubbleMargin: 8,
@@ -406,22 +417,26 @@ export function normalizeConfig(data: unknown): BuddyConfig {
   if (!Number.isInteger(config.statuslineWidthAdjust)) {
     config.statuslineWidthAdjust = DEFAULT_CONFIG.statuslineWidthAdjust;
   }
+  const allowedDensities: BuddyConfig["statuslineDensity"][] = ["auto", "full", "compact", "minimal"];
+  if (!allowedDensities.includes(config.statuslineDensity)) {
+    config.statuslineDensity = DEFAULT_CONFIG.statuslineDensity;
+  }
   return config;
 }
 
 export function loadConfig(): BuddyConfig {
   try {
-    return normalizeConfig(JSON.parse(readFileSync(CONFIG_FILE, "utf8")));
+    return normalizeConfig(JSON.parse(readFileSync(CONFIG_FILE(), "utf8")));
   } catch {
     return normalizeConfig({});
   }
 }
 
 export function saveConfig(config: Partial<BuddyConfig>): BuddyConfig {
-  mkdirSync(STATE_DIR, { recursive: true });
+  mkdirSync(stateDir(), { recursive: true });
   const current = loadConfig();
   const merged = { ...current, ...config };
-  writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2));
+  writeFileSync(CONFIG_FILE(), JSON.stringify(merged, null, 2));
   return merged;
 }
 
@@ -440,12 +455,36 @@ export interface StatusState {
   muted: boolean;
   achievement: string;
   frames: string[];
+  compactFrames: string[];
+  minimalFrames: string[];
   frameSequence: number[];
   level: number;
   xp: number;
   mood: string;
 }
 
+// Density frame fallbacks used when server/art.ts has not yet been updated
+// to emit compactFrames/minimalFrames. The art worker owns the pre-rendered
+// density frames; state.ts only derives a degraded fallback from the full
+// frames so old/new status.json remains renderable.
+function deriveCompactFrames(fullFrames: string[]): string[] {
+  return fullFrames.map((body) => {
+    const lines = body.split("\n");
+    const selected: string[] = [];
+    for (const line of lines) {
+      if (selected.length >= 3) break;
+      if (line.trim() !== "") selected.push(line);
+    }
+    while (selected.length < 3) selected.push("");
+    return selected.join("\n");
+  });
+}
+
+function deriveMinimalFrames(bones: BuddyBones, eye: string): string[] {
+  const { renderFace } = require("../core/engine.ts") as typeof CoreEngine;
+  const face = renderFace(bones.species, eye);
+  return Array.from({ length: 4 }, () => face);
+}
 export function writeStatusState(
   companion: Companion,
   reaction?: string,
@@ -454,18 +493,32 @@ export function writeStatusState(
   level?: number,
   xp?: number,
 ): void {
-  mkdirSync(STATE_DIR, { recursive: true });
+  mkdirSync(stateDir(), { recursive: true });
   const { renderFace, RARITY_STARS, resolveEyeGlyph } =
     require("../core/engine.ts") as typeof CoreEngine;
   const { getStatusFrames } =
     require("./art.ts") as typeof Art;
   const safeEye = resolveEyeGlyph(companion.bones.eye);
-  const { frames, frameSequence } = getStatusFrames(companion.bones);
+  const artResult = getStatusFrames(companion.bones) as {
+    frames: string[];
+    frameSequence: number[];
+    compactFrames?: string[];
+    minimalFrames?: string[];
+  };
+  const { frames, frameSequence } = artResult;
+  const compactFrames =
+    artResult.compactFrames && artResult.compactFrames.length > 0
+      ? artResult.compactFrames
+      : deriveCompactFrames(frames);
+  const minimalFrames =
+    artResult.minimalFrames && artResult.minimalFrames.length > 0
+      ? artResult.minimalFrames
+      : deriveMinimalFrames(companion.bones, safeEye);
   let xpLevel = level ?? 1;
   let xpTotal = xp ?? 0;
   let moodStr = "focused";
   try {
-    const { getXpState } = require("./xp.ts") as typeof import("./xp.ts");
+    const { getXpState } = require("./xp.ts") as typeof XpModule;
     const xpState = getXpState();
     xpLevel = xpState.level;
     xpTotal = xpState.totalXp;
@@ -473,7 +526,7 @@ export function writeStatusState(
     // XP state is optional during first install / version skew.
   }
   try {
-    const { getMood } = require("./mood.ts") as typeof import("./mood.ts");
+    const { getMood } = require("./mood.ts") as typeof MoodModule;
     moodStr = getMood().current;
   } catch {
     // Mood state is optional during first install / version skew.
@@ -491,11 +544,18 @@ export function writeStatusState(
     muted: muted ?? false,
     achievement: achievement ?? "",
     frames,
+    compactFrames,
+    minimalFrames,
     frameSequence,
     level: xpLevel,
     xp: xpTotal,
     mood: moodStr,
   };
+  // Atomic: the statusline reads this file on a timer, so a plain write can
+  // be observed half-flushed and blank the companion for a tick.
+  const statusTmp = `${STATUS_FILE()}.tmp`;
+  writeFileSync(statusTmp, JSON.stringify(state));
+  renameSync(statusTmp, STATUS_FILE());
   // writeStatusState no longer calls saveReaction implicitly. Callers
   // that need a reaction file do so explicitly with the correct
   // `source` tag — the old implicit save had no source argument and
@@ -580,11 +640,11 @@ const TRANSIENT_PREFIXES = [
  *
  * Companion data (menagerie.json, status.json, config.json) is intentionally
  * kept — users reinstalling get their buddy back. Call-sites that want a full
- * wipe should delete STATE_DIR themselves after calling this.
+ * wipe should delete stateDir() themselves after calling this.
  */
 export function cleanupPluginState(
   settingsPath: string = CLAUDE_SETTINGS_PATH,
-  stateDir: string = STATE_DIR,
+  stateDir: string = buddyStateDir(),
 ): CleanupResult {
   const statusLineRemoved = unsetBuddyStatusLine(settingsPath);