sisyphi 1.1.18 → 1.1.19

package/dist/chunk-36VJ7ZBD.js

@@ -0,0 +1,1898 @@
+#!/usr/bin/env node
+import {
+  companionMemoryPath,
+  companionPath,
+  historySessionDir,
+  sessionDir,
+  statePath
+} from "./chunk-PNDCVKBN.js";
+
+// src/shared/env.ts
+import { resolve } from "path";
+function augmentedPath() {
+  const rawPath = process.env["PATH"];
+  const basePath = rawPath !== void 0 && rawPath.length > 0 ? rawPath : "/usr/bin:/bin";
+  const home = process.env["HOME"];
+  const candidates = [
+    ...home ? [`${home}/.local/bin`] : [],
+    // Claude CLI, pipx, user-local installs
+    resolve(process.execPath, ".."),
+    // Node.js bin dir (ensures node/npm available)
+    "/opt/homebrew/bin",
+    // Homebrew (Apple Silicon macOS)
+    "/opt/homebrew/sbin",
+    // Homebrew sbin
+    "/usr/local/bin",
+    // Homebrew (Intel macOS), manual installs
+    "/usr/local/sbin",
+    // Manual installs
+    "/opt/local/bin",
+    // MacPorts
+    "/opt/local/sbin",
+    // MacPorts
+    "/home/linuxbrew/.linuxbrew/bin"
+    // Linuxbrew
+  ];
+  const nixProfile = process.env["NIX_PROFILES"];
+  if (nixProfile) {
+    for (const p of nixProfile.split(" ").reverse()) {
+      candidates.push(`${p}/bin`);
+    }
+  }
+  const existing = new Set(basePath.split(":"));
+  const prepend = candidates.filter((dir) => !existing.has(dir));
+  return prepend.length > 0 ? `${prepend.join(":")}:${basePath}` : basePath;
+}
+function execEnv() {
+  return {
+    ...process.env,
+    PATH: augmentedPath()
+  };
+}
+
+// src/shared/exec.ts
+import { execSync } from "child_process";
+var EXEC_ENV = execEnv();
+function exec(cmd, cwd, timeoutMs = 3e4) {
+  return execSync(cmd, { encoding: "utf-8", env: EXEC_ENV, cwd, timeout: timeoutMs }).trim();
+}
+function execSafe(cmd, cwd, timeoutMs) {
+  try {
+    return execSync(cmd, { encoding: "utf-8", env: EXEC_ENV, cwd, stdio: ["pipe", "pipe", "pipe"], timeout: timeoutMs }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// src/shared/companion-types.ts
+var OBSERVATION_CATEGORIES = ["session-sentiments", "repo-impressions", "user-patterns", "notable-moments"];
+var MemoryStoreParseError = class extends Error {
+  constructor(cause) {
+    super("companion-memory.json is corrupt");
+    this.cause = cause;
+  }
+  cause;
+};
+var ACHIEVEMENTS = [
+  // Milestone (25)
+  { id: "first-blood", name: "First Blood", category: "milestone", description: "Complete your first session.", badge: null },
+  { id: "regular", name: "Regular", category: "milestone", description: "Complete 10 sessions.", badge: null },
+  { id: "centurion", name: "Centurion", category: "milestone", description: "Complete 100 sessions.", badge: null },
+  { id: "veteran", name: "Veteran", category: "milestone", description: "Complete 500 sessions.", badge: null },
+  { id: "thousand-boulder", name: "Thousand Boulder", category: "milestone", description: "Complete 1,000 sessions.", badge: null },
+  { id: "cartographer", name: "Cartographer", category: "milestone", description: "Work in 5 different repos.", badge: "+" },
+  { id: "world-traveler", name: "World Traveler", category: "milestone", description: "Work in 15 different repos.", badge: null },
+  { id: "omnipresent", name: "Omnipresent", category: "milestone", description: "Work in 30 different repos.", badge: null },
+  { id: "swarm-starter", name: "Swarm Starter", category: "milestone", description: "Spawn 50 agents over a lifetime.", badge: null },
+  { id: "hive-mind", name: "Hive Mind", category: "milestone", description: "Spawn 500 agents over a lifetime.", badge: null },
+  { id: "legion", name: "Legion", category: "milestone", description: "Spawn 2,000 agents over a lifetime.", badge: null },
+  { id: "army-of-thousands", name: "Army of Thousands", category: "milestone", description: "Spawn 5,000 agents over a lifetime.", badge: null },
+  { id: "singularity", name: "Singularity", category: "milestone", description: "Spawn 10,000 agents over a lifetime.", badge: null },
+  { id: "first-shift", name: "First Shift", category: "milestone", description: "10 hours of total agent active time.", badge: null },
+  { id: "workaholic", name: "Workaholic", category: "milestone", description: "100 hours of total agent active time.", badge: null },
+  { id: "time-lord", name: "Time Lord", category: "milestone", description: "500 hours of total agent active time.", badge: null },
+  { id: "eternal-grind", name: "Eternal Grind", category: "milestone", description: "2,000 hours of total agent active time.", badge: null },
+  { id: "epoch", name: "Epoch", category: "milestone", description: "5,000 hours of total agent active time.", badge: null },
+  { id: "old-growth", name: "Old Growth", category: "milestone", description: "Companion is 14 days old.", badge: null },
+  { id: "seasoned", name: "Seasoned", category: "milestone", description: "Companion is 90 days old.", badge: null },
+  { id: "ancient", name: "Ancient", category: "milestone", description: "Companion is 365 days old.", badge: null },
+  { id: "apprentice", name: "Apprentice", category: "milestone", description: "Reach level 5.", badge: null },
+  { id: "journeyman", name: "Journeyman", category: "milestone", description: "Reach level 15.", badge: null },
+  { id: "master", name: "Master", category: "milestone", description: "Reach level 30.", badge: null },
+  { id: "grandmaster", name: "Grandmaster", category: "milestone", description: "Reach level 50.", badge: null },
+  // Session (19)
+  { id: "marathon", name: "Marathon", category: "session", description: "Complete a session with 15+ agents.", badge: "~^~" },
+  { id: "squad", name: "Squad Up", category: "session", description: "Complete a session with 10+ agents.", badge: null },
+  { id: "battalion", name: "Battalion", category: "session", description: "Complete a session with 25+ agents.", badge: null },
+  { id: "swarm", name: "The Swarm", category: "session", description: "Complete a session with 50+ agents.", badge: null },
+  { id: "blitz", name: "Blitz", category: "session", description: "Complete a session in under 5 minutes.", badge: null },
+  { id: "speed-run", name: "Speed Run", category: "session", description: "Complete a session in under 15 minutes.", badge: null },
+  { id: "flash", name: "Flash", category: "session", description: "Complete a session in under 2 minutes.", badge: null },
+  { id: "flawless", name: "Flawless", category: "session", description: "Complete a session with 10+ agents and zero crashes.", badge: "*" },
+  { id: "speed-demon", name: "Speed Demon", category: "session", description: "10 consecutive sessions completing in 3 or fewer cycles.", badge: "\u26A1" },
+  { id: "iron-will", name: "Iron Will", category: "session", description: "5 consecutive sessions each with 8+ orchestrator cycles.", badge: "[]" },
+  { id: "glass-cannon", name: "Glass Cannon", category: "session", description: "5+ agents, all crashed, but session completed anyway.", badge: null },
+  { id: "solo", name: "Solo", category: "session", description: "Complete a session with exactly one agent.", badge: null },
+  { id: "one-more-cycle", name: "One More Cycle", category: "session", description: "A session with 10+ orchestrator cycles.", badge: null },
+  { id: "deep-dive", name: "Deep Dive", category: "session", description: "A session with 15+ orchestrator cycles.", badge: null },
+  { id: "abyss", name: "Into the Abyss", category: "session", description: "A session with 25+ orchestrator cycles.", badge: null },
+  { id: "eternal-recurrence", name: "Eternal Recurrence", category: "session", description: "A session with 40+ orchestrator cycles.", badge: null },
+  { id: "endurance", name: "Endurance", category: "session", description: "A single session running 4+ hours.", badge: null },
+  { id: "ultramarathon", name: "Ultramarathon", category: "session", description: "A single session running 6+ hours.", badge: null },
+  { id: "one-shot", name: "One Shot", category: "session", description: "Complete with 5+ agents in exactly 1 orchestrator cycle.", badge: null },
+  { id: "quick-draw", name: "Quick Draw", category: "session", description: "First agent spawned within 20s of session start.", badge: null },
+  // Time (6)
+  { id: "night-owl", name: "Night Owl", category: "time", description: "Complete a session started between 1am and 5am.", badge: ")" },
+  { id: "dawn-patrol", name: "Dawn Patrol", category: "time", description: "Session running 3+ hours that spans midnight to 6am.", badge: null },
+  { id: "early-bird", name: "Early Bird", category: "time", description: "Start a session before 6am.", badge: null },
+  { id: "weekend-warrior", name: "Weekend Warrior", category: "time", description: "Complete a session on a Saturday or Sunday.", badge: null },
+  { id: "all-nighter", name: "All-Nighter", category: "time", description: "Single session running 5+ hours.", badge: null },
+  { id: "witching-hour", name: "Witching Hour", category: "time", description: "Start a session between 3am and 4am.", badge: null },
+  // Behavioral (16)
+  { id: "sisyphean", name: "Sisyphean", category: "behavioral", description: "Restart the same task 3+ times.", badge: ";" },
+  { id: "stubborn", name: "Stubborn", category: "behavioral", description: "Restart the same task 5+ times and eventually complete it.", badge: null },
+  { id: "one-must-imagine", name: "One Must Imagine", category: "behavioral", description: "Restart the same task 10+ times.", badge: null },
+  { id: "creature-of-habit", name: "Creature of Habit", category: "behavioral", description: "Visit the same repo 10 times.", badge: null },
+  { id: "loyal", name: "Loyal", category: "behavioral", description: "Visit the same repo 30 times.", badge: null },
+  { id: "wanderer", name: "Wanderer", category: "behavioral", description: "3+ different repos in a single calendar day.", badge: null },
+  { id: "streak", name: "Streak", category: "behavioral", description: "7 consecutive days with at least one session.", badge: null },
+  { id: "iron-streak", name: "Iron Streak", category: "behavioral", description: "14 consecutive days with at least one session.", badge: null },
+  { id: "hot-streak", name: "Hot Streak", category: "behavioral", description: "15 consecutive clean sessions.", badge: null },
+  { id: "momentum", name: "Momentum", category: "behavioral", description: "5 sessions completed within 4 hours.", badge: null },
+  { id: "overdrive", name: "Overdrive", category: "behavioral", description: "Complete 6+ sessions in a single calendar day.", badge: null },
+  { id: "patient-one", name: "Patient One", category: "behavioral", description: "Idle 30+ minutes between cycles in a session.", badge: null },
+  { id: "message-in-a-bottle", name: "Message in a Bottle", category: "behavioral", description: "10+ messages sent to a single session.", badge: null },
+  { id: "deep-conversation", name: "Deep Conversation", category: "behavioral", description: "Send 20+ messages to a single session.", badge: null },
+  { id: "comeback-kid", name: "Comeback Kid", category: "behavioral", description: "Resume a paused/killed session and complete it.", badge: null },
+  { id: "pair-programming", name: "Pair Programming", category: "behavioral", description: "8+ user messages during a single active session.", badge: null }
+];
+
+// src/daemon/companion-memory.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+import { z } from "zod";
+
+// src/daemon/haiku.ts
+import { query, createSdkMcpServer } from "@r-cli/sdk";
+var COOLDOWN_MS = 5 * 60 * 1e3;
+var disabledUntil = 0;
+var disabledUntilTools = 0;
+function applyAuthCooldown(err, target) {
+  const status = err?.status;
+  if (status === 401 || status === 403) {
+    if (target === "main") disabledUntil = Date.now() + COOLDOWN_MS;
+    else disabledUntilTools = Date.now() + COOLDOWN_MS;
+  }
+}
+async function callHaiku(prompt, systemPrompt) {
+  if (Date.now() < disabledUntil) return null;
+  try {
+    const session = await query({
+      prompt,
+      options: {
+        model: "haiku",
+        maxTurns: 1,
+        env: execEnv(),
+        ...systemPrompt ? { systemPrompt } : {}
+      }
+    });
+    let text = "";
+    for await (const msg of session) {
+      if (msg.type === "assistant" && msg.message?.content) {
+        for (const block of msg.message.content) {
+          if (block.type === "text") text += block.text;
+        }
+      }
+    }
+    return text.trim() || null;
+  } catch (err) {
+    console.error(`[sisyphus] Haiku call failed: ${err instanceof Error ? err.message : err}`);
+    applyAuthCooldown(err, "main");
+    return null;
+  }
+}
+async function callHaikuWithTools(opts) {
+  if (Date.now() < disabledUntilTools) {
+    return { ok: false, error: "haiku tool path on cooldown" };
+  }
+  const server = createSdkMcpServer({
+    name: opts.mcpServerName,
+    version: "1.0.0",
+    tools: opts.customTools
+  });
+  const allowedTools = opts.customTools.map((t) => `mcp__${opts.mcpServerName}__${t.name}`);
+  let turns = 0;
+  try {
+    const session = query({
+      prompt: opts.userPrompt,
+      options: {
+        model: "haiku",
+        maxTurns: opts.maxTurns ?? 5,
+        cwd: opts.cwd,
+        env: execEnv(),
+        systemPrompt: opts.systemPrompt,
+        mcpServers: { [opts.mcpServerName]: server },
+        tools: [],
+        allowedTools,
+        canUseTool: async () => ({ behavior: "allow" })
+      }
+    });
+    for await (const msg of session) {
+      if (msg.type === "result") {
+        turns = msg.num_turns ?? turns;
+      }
+    }
+    return { ok: true, turns };
+  } catch (err) {
+    console.error(`[sisyphus] callHaikuWithTools failed: ${err instanceof Error ? err.message : err}`);
+    applyAuthCooldown(err, "tools");
+    return { ok: false, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+async function callHaikuStructured(prompt, jsonSchema, zodSchema) {
+  if (Date.now() < disabledUntil) return null;
+  try {
+    const session = await query({
+      prompt,
+      options: {
+        model: "haiku",
+        maxTurns: 2,
+        env: execEnv(),
+        outputFormat: {
+          type: "json_schema",
+          schema: jsonSchema
+        }
+      }
+    });
+    let result = void 0;
+    for await (const msg of session) {
+      if (msg.type === "result" && msg.subtype === "success" && msg.structured_output !== void 0) {
+        result = msg.structured_output;
+      }
+    }
+    if (result === void 0) return null;
+    const parsed = zodSchema.safeParse(result);
+    return parsed.success ? parsed.data : null;
+  } catch (err) {
+    console.error(`[sisyphus] Haiku structured call failed: ${err instanceof Error ? err.message : err}`);
+    applyAuthCooldown(err, "main");
+    return null;
+  }
+}
+
+// src/daemon/companion.ts
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
+import { randomUUID } from "crypto";
+import { dirname, join } from "path";
+var MIN_SAMPLES = 5;
+var MIN_STDDEV_RATIO = 0.2;
+var ABSOLUTE_STDDEV_FLOORS = {
+  sessionMs: 3e5,
+  // 5 minutes
+  cycleCount: 1,
+  agentCount: 1,
+  sessionsPerDay: 0.5,
+  recentAgentThroughput: 2
+};
+var COLD_START_DEFAULTS = {
+  sessionMs: { mean: 36e5, stddev: 24e5 },
+  cycleCount: { mean: 5, stddev: 3 },
+  agentCount: { mean: 5, stddev: 4 },
+  sessionsPerDay: { mean: 3, stddev: 2 },
+  recentAgentThroughput: { mean: 8, stddev: 6 }
+};
+function emptyStats() {
+  return { count: 0, mean: 0, m2: 0 };
+}
+function defaultBaselines() {
+  return {
+    sessionMs: emptyStats(),
+    cycleCount: emptyStats(),
+    agentCount: emptyStats(),
+    sessionsPerDay: emptyStats(),
+    recentAgentThroughput: emptyStats(),
+    lastCountedDay: null,
+    pendingDayCount: 0
+  };
+}
+function welfordUpdate(stats, value) {
+  stats.count++;
+  const delta = value - stats.mean;
+  stats.mean += delta / stats.count;
+  const delta2 = value - stats.mean;
+  stats.m2 += delta * delta2;
+}
+function zScore(value, stats, metric) {
+  const defaults = COLD_START_DEFAULTS[metric];
+  const floor = ABSOLUTE_STDDEV_FLOORS[metric];
+  if (stats.count < MIN_SAMPLES) {
+    if (defaults.stddev === 0) return 0;
+    return (value - defaults.mean) / defaults.stddev;
+  }
+  const rawStddev = stats.count >= 2 ? Math.sqrt(stats.m2 / stats.count) : 0;
+  const stddev = Math.max(rawStddev, stats.mean * MIN_STDDEV_RATIO, floor);
+  if (stddev === 0) return 0;
+  return (value - stats.mean) / stddev;
+}
+function loadCompanion() {
+  const path = companionPath();
+  if (!existsSync(path)) {
+    const state2 = createDefaultCompanion();
+    saveCompanion(state2);
+    return state2;
+  }
+  const raw = readFileSync(path, "utf-8");
+  const state = JSON.parse(raw);
+  if (state.consecutiveCleanSessions == null) state.consecutiveCleanSessions = 0;
+  if (state.consecutiveDaysActive == null) state.consecutiveDaysActive = 0;
+  if (state.lastActiveDate == null) state.lastActiveDate = null;
+  if (state.taskHistory == null) state.taskHistory = {};
+  if (state.dailyRepos == null) state.dailyRepos = {};
+  if (state.recentCompletions == null) state.recentCompletions = [];
+  if (state.lifetimeAgentsSpawned == null) state.lifetimeAgentsSpawned = 0;
+  if (state.consecutiveEfficientSessions == null) state.consecutiveEfficientSessions = 0;
+  if (state.consecutiveHighCycleSessions == null) state.consecutiveHighCycleSessions = 0;
+  if (state.spinnerVerbIndex == null) state.spinnerVerbIndex = 0;
+  if (state.baselines == null) state.baselines = defaultBaselines();
+  if (state.baselines.recentAgentThroughput == null) state.baselines.recentAgentThroughput = emptyStats();
+  if (state.commentaryHistory == null) state.commentaryHistory = [];
+  if (state.feedbackHistory == null) state.feedbackHistory = [];
+  return state;
+}
+function saveCompanion(state) {
+  const path = companionPath();
+  const dir = dirname(path);
+  mkdirSync(dir, { recursive: true });
+  const tmp = join(dir, `.companion.${randomUUID()}.tmp`);
+  writeFileSync(tmp, JSON.stringify(state, null, 2), "utf-8");
+  renameSync(tmp, path);
+}
+var MAX_COMMENTARY_HISTORY = 1e3;
+var MAX_FEEDBACK_HISTORY = 1e3;
+function recordCommentary(companion, text, event) {
+  const entry = { text, event, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+  companion.lastCommentary = entry;
+  if (!companion.commentaryHistory) companion.commentaryHistory = [];
+  companion.commentaryHistory.push(entry);
+  if (companion.commentaryHistory.length > MAX_COMMENTARY_HISTORY) {
+    companion.commentaryHistory = companion.commentaryHistory.slice(-MAX_COMMENTARY_HISTORY);
+  }
+}
+function recordFeedback(companion, text, rating, event, comment) {
+  const entry = { commentaryText: text, rating, event, timestamp: (/* @__PURE__ */ new Date()).toISOString(), ...comment != null ? { comment } : {} };
+  if (!companion.feedbackHistory) companion.feedbackHistory = [];
+  companion.feedbackHistory.push(entry);
+  if (companion.feedbackHistory.length > MAX_FEEDBACK_HISTORY) {
+    companion.feedbackHistory = companion.feedbackHistory.slice(-MAX_FEEDBACK_HISTORY);
+  }
+}
+function createDefaultCompanion() {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: 1,
+    name: null,
+    createdAt: now,
+    stats: {
+      strength: 0,
+      endurance: 0,
+      wisdom: 0,
+      patience: 0
+    },
+    xp: 0,
+    level: 1,
+    title: "Boulder Intern",
+    mood: "sleepy",
+    moodUpdatedAt: now,
+    achievements: [],
+    repos: {},
+    lastCommentary: null,
+    commentaryHistory: [],
+    sessionsCompleted: 0,
+    sessionsCrashed: 0,
+    totalActiveMs: 0,
+    lifetimeAgentsSpawned: 0,
+    consecutiveCleanSessions: 0,
+    consecutiveEfficientSessions: 0,
+    consecutiveHighCycleSessions: 0,
+    consecutiveDaysActive: 0,
+    lastActiveDate: null,
+    taskHistory: {},
+    dailyRepos: {},
+    recentCompletions: [],
+    spinnerVerbIndex: 0,
+    baselines: defaultBaselines(),
+    feedbackHistory: []
+  };
+}
+function computeXP(stats) {
+  const strengthXP = stats.strength * 50;
+  const enduranceXP = stats.endurance / 36e5 * 20;
+  const wisdomXP = stats.wisdom * 40;
+  const patienceXP = stats.patience * 8;
+  return Math.floor(strengthXP + enduranceXP + wisdomXP + patienceXP);
+}
+function computeStrengthGain(agentCount) {
+  if (agentCount <= 0) return 0;
+  if (agentCount <= 2) return 1;
+  if (agentCount <= 5) return 2;
+  if (agentCount <= 10) return 3;
+  if (agentCount <= 20) return 4;
+  return 5;
+}
+function computeLevel(xp) {
+  let level = 1;
+  let threshold = 150;
+  let cumulative = 0;
+  while (cumulative + threshold <= xp) {
+    cumulative += threshold;
+    level++;
+    threshold = Math.floor(threshold * 1.35);
+  }
+  return level;
+}
+function computeLevelProgress(xp) {
+  let threshold = 150;
+  let cumulative = 0;
+  while (cumulative + threshold <= xp) {
+    cumulative += threshold;
+    threshold = Math.floor(threshold * 1.35);
+  }
+  return { xpIntoLevel: xp - cumulative, xpForNextLevel: threshold };
+}
+var TITLE_MAP = {
+  1: "Boulder Intern",
+  2: "Pebble Pusher",
+  3: "Rock Hauler",
+  4: "Gravel Wrangler",
+  5: "Slope Familiar",
+  6: "Incline Regular",
+  7: "Ridge Runner",
+  8: "Crag Warden",
+  9: "Stone Whisperer",
+  10: "Boulder Brother",
+  11: "Hill Veteran",
+  12: "Summit Aspirant",
+  13: "Peak Haunter",
+  14: "Cliff Sage",
+  15: "Mountain's Shadow",
+  16: "Eternal Roller",
+  17: "Gravity's Rival",
+  18: "The Unmoved Mover",
+  19: "Camus Was Right",
+  20: "The Absurd Hero",
+  25: "One Must Imagine Him Happy",
+  30: "He Has Always Been Here"
+};
+function getTitle(level) {
+  for (let l = level; l >= 1; l--) {
+    if (TITLE_MAP[l] !== void 0) return TITLE_MAP[l];
+  }
+  return "Boulder Intern";
+}
+function computeMood(companion, session, signals) {
+  if (!signals) {
+    const hour = (/* @__PURE__ */ new Date()).getHours();
+    if (hour >= 2 && hour < 6) return "existential";
+    if (hour >= 22 || hour < 2) return "sleepy";
+    return "zen";
+  }
+  const scores = {
+    happy: 0,
+    grinding: 0,
+    frustrated: 0,
+    zen: 0,
+    sleepy: 0,
+    excited: 0,
+    existential: 0
+  };
+  const cycleCount = signals.cycleCount ?? 0;
+  const sessionsCompletedToday = signals.sessionsCompletedToday ?? 0;
+  const baselines = companion.baselines ?? defaultBaselines();
+  const sessionZ = zScore(signals.sessionLengthMs, baselines.sessionMs, "sessionMs");
+  const cycleZ = zScore(cycleCount, baselines.cycleCount, "cycleCount");
+  const agentZ = zScore(signals.totalAgentCount ?? 0, baselines.agentCount, "agentCount");
+  const dailyZ = zScore(sessionsCompletedToday, baselines.sessionsPerDay, "sessionsPerDay");
+  const recentAgentZ = zScore(signals.recentAgentCount ?? 0, baselines.recentAgentThroughput, "recentAgentThroughput");
+  if (signals.justCompleted) scores.happy += 50;
+  if (signals.justCompleted && sessionZ < -0.5) scores.happy += 15;
+  if (dailyZ > 0.5) scores.happy += 20;
+  if (dailyZ > 1.5) scores.happy += 10;
+  if (signals.hourOfDay >= 6 && signals.hourOfDay < 12) scores.happy += 15;
+  if (signals.hourOfDay >= 12 && signals.hourOfDay < 17) scores.happy += 8;
+  if ((signals.activeAgentCount ?? 0) >= 1 && sessionZ < -0.5) scores.happy += 12;
+  const lastCompletion = companion.recentCompletions.length > 0 ? Date.now() - new Date(companion.recentCompletions[companion.recentCompletions.length - 1]).getTime() : Infinity;
+  if (lastCompletion < 18e5 && signals.sessionLengthMs > 0) scores.happy += 20;
+  if (sessionZ > 0.5) scores.grinding += 15;
+  if (sessionZ > 1) scores.grinding += 10;
+  if (sessionZ > 1.5) scores.grinding += 8;
+  if (recentAgentZ > 0.5) scores.grinding += 12;
+  if (recentAgentZ > 1) scores.grinding += 10;
+  if (recentAgentZ > 1.5) scores.grinding += 8;
+  if (cycleZ > 0.5) scores.grinding += 8;
+  const rollbacks = signals.rollbackCount ?? 0;
+  const restartedAgents = signals.restartedAgentCount ?? 0;
+  const lostAgents = signals.lostAgentCount ?? 0;
+  const killedAgents = signals.killedAgentCount ?? 0;
+  if (signals.justCrashed) scores.frustrated += 30;
+  if (signals.recentCrashes >= 2) scores.frustrated += 20;
+  if (signals.recentCrashes >= 4) scores.frustrated += 15;
+  if (rollbacks >= 1) scores.frustrated += 25;
+  if (rollbacks >= 3) scores.frustrated += 25;
+  if (restartedAgents >= 1) scores.frustrated += 15;
+  if (restartedAgents >= 3) scores.frustrated += 15;
+  if (lostAgents >= 1) scores.frustrated += 15;
+  if (lostAgents >= 3) scores.frustrated += 10;
+  if (killedAgents >= 2) scores.frustrated += 10;
+  if (sessionZ > 1.5 && (signals.recentCrashes > 0 || rollbacks > 0)) scores.frustrated += 12;
+  if (companion.stats.patience > 30) scores.zen += 15;
+  if (signals.idleDurationMs > 12e4 && signals.idleDurationMs <= 9e5) scores.zen += 25;
+  if (sessionZ > -1 && sessionZ < 0.3) scores.zen += 15;
+  if (cycleZ < 0) scores.zen += 10;
+  if (signals.hourOfDay >= 6 && signals.hourOfDay < 10 && (signals.activeAgentCount ?? 0) === 0) scores.zen += 10;
+  if (dailyZ >= -0.5 && dailyZ <= 0.5) scores.zen += 10;
+  if (signals.idleDurationMs > 9e5) scores.sleepy += 30;
+  if (signals.idleDurationMs > 27e5) scores.sleepy += 25;
+  if (signals.idleDurationMs > 54e5) scores.sleepy += 15;
+  if (signals.hourOfDay >= 22 || signals.hourOfDay < 6) scores.sleepy += 20;
+  if (signals.idleDurationMs > 3e5 && (signals.hourOfDay >= 22 || signals.hourOfDay < 6)) scores.sleepy += 15;
+  if (sessionZ > 2.5) scores.sleepy += 12;
+  if (signals.justLeveledUp) scores.excited += 60;
+  if (signals.justCompleted && agentZ > 1) scores.excited += 30;
+  if (agentZ > 1.5) scores.excited += 20;
+  if (agentZ > 2) scores.excited += 15;
+  if (signals.justCompleted && sessionZ < -1) scores.excited += 20;
+  if (signals.hourOfDay >= 2 && signals.hourOfDay < 6) scores.existential += 25;
+  if (signals.hourOfDay >= 0 && signals.hourOfDay < 2) scores.existential += 10;
+  const enduranceHours = companion.stats.endurance / 36e5;
+  if (enduranceHours > 40) scores.existential += 15;
+  if (signals.hourOfDay >= 2 && signals.hourOfDay < 6 && enduranceHours > 40) {
+    scores.existential += 25;
+  }
+  const now = Date.now();
+  const weekAgo = now - 7 * 24 * 36e5;
+  const weeklyCompletions = companion.recentCompletions.filter(
+    (ts) => new Date(ts).getTime() > weekAgo
+  ).length;
+  const weeklyAvgDaily = weeklyCompletions / 7;
+  const weeklyZ = zScore(weeklyAvgDaily, baselines.sessionsPerDay, "sessionsPerDay");
+  if (weeklyZ > 0.5) scores.existential += 8;
+  if (weeklyZ > 1) scores.existential += 7;
+  if (weeklyZ > 1.5) scores.existential += 5;
+  const consecutiveDays = companion.consecutiveDaysActive ?? 0;
+  if (consecutiveDays >= 3) scores.existential += Math.min(20, (consecutiveDays - 2) * 3);
+  const goodRatings = signals.recentFeedbackGood ?? 0;
+  const badRatings = signals.recentFeedbackBad ?? 0;
+  const whipRatings = signals.recentFeedbackWhip ?? 0;
+  if (goodRatings > 0) {
+    scores.happy += goodRatings * 20;
+    scores.excited += goodRatings * 8;
+    scores.frustrated = Math.max(0, scores.frustrated - goodRatings * 10);
+  }
+  if (badRatings > 0) {
+    scores.happy = Math.max(0, scores.happy - badRatings * 15);
+    scores.frustrated += badRatings * 20;
+    scores.zen = Math.max(0, scores.zen - badRatings * 10);
+  }
+  if (whipRatings > 0) {
+    scores.happy = Math.max(0, scores.happy - whipRatings * 15);
+    scores.sleepy = Math.max(0, scores.sleepy - whipRatings * 15);
+    scores.zen = Math.max(0, scores.zen - whipRatings * 15);
+    scores.frustrated = Math.max(0, scores.frustrated - whipRatings * 8);
+    scores.existential += whipRatings * 25;
+  }
+  const moodOrder = ["happy", "grinding", "frustrated", "zen", "sleepy", "excited", "existential"];
+  let best = "grinding";
+  let bestScore = -1;
+  for (const mood of moodOrder) {
+    if (scores[mood] > bestScore) {
+      bestScore = scores[mood];
+      best = mood;
+    }
+  }
+  companion.debugMood = { signals, scores: { ...scores }, winner: best };
+  return best;
+}
+function daysSince(isoTimestamp) {
+  return (Date.now() - new Date(isoTimestamp).getTime()) / (1e3 * 60 * 60 * 24);
+}
+var ACHIEVEMENT_CHECKERS = {
+  // Milestone
+  "first-blood": (c) => c.sessionsCompleted >= 1,
+  "regular": (c) => c.sessionsCompleted >= 10,
+  "centurion": (c) => c.sessionsCompleted >= 100,
+  "veteran": (c) => c.sessionsCompleted >= 500,
+  "thousand-boulder": (c) => c.sessionsCompleted >= 1e3,
+  "cartographer": (c) => Object.keys(c.repos).length >= 5,
+  "world-traveler": (c) => Object.keys(c.repos).length >= 15,
+  "omnipresent": (c) => Object.keys(c.repos).length >= 30,
+  "swarm-starter": (c) => c.lifetimeAgentsSpawned >= 50,
+  "hive-mind": (c) => c.lifetimeAgentsSpawned >= 500,
+  "legion": (c) => c.lifetimeAgentsSpawned >= 2e3,
+  "army-of-thousands": (c) => c.lifetimeAgentsSpawned >= 5e3,
+  "singularity": (c) => c.lifetimeAgentsSpawned >= 1e4,
+  "first-shift": (c) => c.totalActiveMs >= 36e6,
+  "workaholic": (c) => c.totalActiveMs >= 36e7,
+  "time-lord": (c) => c.totalActiveMs >= 18e8,
+  "eternal-grind": (c) => c.totalActiveMs >= 72e8,
+  "epoch": (c) => c.totalActiveMs >= 18e9,
+  "old-growth": (c) => daysSince(c.createdAt) >= 14,
+  "seasoned": (c) => daysSince(c.createdAt) >= 90,
+  "ancient": (c) => daysSince(c.createdAt) >= 365,
+  "apprentice": (c) => c.level >= 5,
+  "journeyman": (c) => c.level >= 15,
+  "master": (c) => c.level >= 30,
+  "grandmaster": (c) => c.level >= 50,
+  // Session
+  "marathon": (_c, s) => s != null && s.agents.length >= 15,
+  "squad": (_c, s) => s != null && s.agents.length >= 10,
+  "battalion": (_c, s) => s != null && s.agents.length >= 25,
+  "swarm": (_c, s) => s != null && s.agents.length >= 50,
+  "blitz": (_c, s) => s != null && s.activeMs < 3e5 && s.status === "completed",
+  "speed-run": (_c, s) => s != null && s.activeMs < 9e5 && s.status === "completed",
+  "flash": (_c, s) => s != null && s.activeMs < 12e4 && s.status === "completed",
+  "flawless": (_c, s) => s != null && s.agents.length >= 10 && s.status === "completed" && s.agents.every((a) => a.status !== "crashed" && a.status !== "killed"),
+  "speed-demon": (c) => c.consecutiveEfficientSessions >= 10,
+  "iron-will": (c) => c.consecutiveHighCycleSessions >= 5,
+  "glass-cannon": (_c, s) => {
+    if (!s || s.status !== "completed" || s.agents.length < 5) return false;
+    return s.agents.every((a) => a.status === "crashed" || a.killedReason != null);
+  },
+  "solo": (_c, s) => s != null && s.status === "completed" && s.agents.length === 1,
+  "one-more-cycle": (_c, s) => s != null && s.orchestratorCycles.length >= 10,
+  "deep-dive": (_c, s) => s != null && s.orchestratorCycles.length >= 15,
+  "abyss": (_c, s) => s != null && s.orchestratorCycles.length >= 25,
+  "eternal-recurrence": (_c, s) => s != null && s.orchestratorCycles.length >= 40,
+  "endurance": (_c, s) => s != null && s.activeMs >= 144e5,
+  "ultramarathon": (_c, s) => s != null && s.activeMs >= 216e5,
+  "one-shot": (_c, s) => s != null && s.agents.length >= 5 && s.orchestratorCycles.length === 1 && s.status === "completed",
+  "quick-draw": (_c, s) => {
+    if (!s || s.agents.length === 0) return false;
+    const firstAgent = s.agents[0];
+    return new Date(firstAgent.spawnedAt).getTime() - new Date(s.createdAt).getTime() < 2e4;
+  },
+  // Time
+  "night-owl": (_c, s) => {
+    if (!s || s.status !== "completed") return false;
+    const h = new Date(s.createdAt).getHours();
+    return h >= 1 && h < 5;
+  },
+  "dawn-patrol": (_c, s) => {
+    if (!s) return false;
+    if (s.activeMs < 108e5) return false;
+    const start = new Date(s.createdAt).getTime();
+    const end = s.completedAt ? new Date(s.completedAt).getTime() : Date.now();
+    const startDate = new Date(start);
+    const startHour = startDate.getHours();
+    const todayMidnight = new Date(startDate);
+    todayMidnight.setHours(0, 0, 0, 0);
+    const sixAm = new Date(todayMidnight);
+    sixAm.setHours(6, 0, 0, 0);
+    if (startHour >= 6) {
+      const nextMidnight = new Date(todayMidnight.getTime() + 24 * 60 * 60 * 1e3);
+      return start < nextMidnight.getTime() && end > nextMidnight.getTime();
+    } else {
+      return start < sixAm.getTime();
+    }
+  },
+  "early-bird": (_c, s) => {
+    if (!s) return false;
+    return new Date(s.createdAt).getHours() < 6;
+  },
+  "weekend-warrior": (_c, s) => {
+    if (!s || s.status !== "completed") return false;
+    const day = new Date(s.completedAt ?? s.createdAt).getDay();
+    return day === 0 || day === 6;
+  },
+  "all-nighter": (_c, s) => s != null && s.activeMs >= 18e6,
+  "witching-hour": (_c, s) => {
+    if (!s) return false;
+    const h = new Date(s.createdAt).getHours();
+    return h === 3;
+  },
+  // Behavioral
+  "sisyphean": (c) => Object.values(c.taskHistory).some((v) => v >= 3),
+  "stubborn": (c) => Object.values(c.taskHistory).some((v) => v >= 5) && c.sessionsCompleted > 0,
+  "one-must-imagine": (c) => Object.values(c.taskHistory).some((v) => v >= 10),
+  "creature-of-habit": (c) => Object.values(c.repos).some((r) => r.visits >= 10),
+  "loyal": (c) => Object.values(c.repos).some((r) => r.visits >= 30),
+  "wanderer": (c) => {
+    return Object.values(c.dailyRepos).some((repos) => repos.length >= 3);
+  },
+  "streak": (c) => c.consecutiveDaysActive >= 7,
+  "iron-streak": (c) => c.consecutiveDaysActive >= 14,
+  "hot-streak": (c) => c.consecutiveCleanSessions >= 15,
+  "momentum": (c) => {
+    if (c.recentCompletions.length < 5) return false;
+    const last5 = c.recentCompletions.slice(-5);
+    const oldest = new Date(last5[0]).getTime();
+    const newest = new Date(last5[4]).getTime();
+    return newest - oldest <= 4 * 60 * 60 * 1e3;
+  },
+  "overdrive": (c) => {
+    const dateCounts = {};
+    for (const ts of c.recentCompletions) {
+      const date = ts.slice(0, 10);
+      dateCounts[date] = (dateCounts[date] ?? 0) + 1;
+    }
+    return Object.values(dateCounts).some((count) => count >= 6);
+  },
+  "patient-one": (_c, s) => {
+    if (!s || s.orchestratorCycles.length < 2) return false;
+    for (let i = 1; i < s.orchestratorCycles.length; i++) {
+      const prev = s.orchestratorCycles[i - 1];
+      const curr = s.orchestratorCycles[i];
+      if (!prev.completedAt) continue;
+      const gap = new Date(curr.timestamp).getTime() - new Date(prev.completedAt).getTime();
+      if (gap >= 30 * 60 * 1e3) return true;
+    }
+    return false;
+  },
+  "message-in-a-bottle": (_c, s) => {
+    if (!s) return false;
+    const userMessages = s.messages.filter((m) => m.source.type === "user");
+    return userMessages.length >= 10;
+  },
+  "deep-conversation": (_c, s) => {
+    if (!s) return false;
+    const userMessages = s.messages.filter((m) => m.source.type === "user");
+    return userMessages.length >= 20;
+  },
+  "comeback-kid": (_c, s) => {
+    if (!s || s.status !== "completed") return false;
+    return s.orchestratorCycles.length > 0 && s.parentSessionId != null;
+  },
+  "pair-programming": (_c, s) => {
+    if (!s) return false;
+    const userMessages = s.messages.filter((m) => m.source.type === "user");
+    return userMessages.length >= 8;
+  }
+};
+function checkAchievements(companion, session) {
+  const alreadyUnlocked = new Set(companion.achievements.map((a) => a.id));
+  const newIds = [];
+  for (const [id, checker] of Object.entries(ACHIEVEMENT_CHECKERS)) {
+    if (alreadyUnlocked.has(id)) continue;
+    if (checker(companion, session)) {
+      newIds.push(id);
+    }
+  }
+  return newIds;
+}
+var MOOD_SENTIMENT = {
+  happy: 0.85,
+  excited: 0.9,
+  zen: 0.7,
+  grinding: 0.45,
+  sleepy: 0.4,
+  frustrated: 0.15,
+  existential: 0.25
+};
+function updateRepoMemory(companion, repoPath, event, activeMs) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const moodScore = MOOD_SENTIMENT[companion.mood] ?? 0.5;
+  const existing = companion.repos[repoPath];
+  if (!existing) {
+    companion.repos[repoPath] = {
+      visits: event === "visit" ? 1 : 0,
+      completions: event === "completion" ? 1 : 0,
+      crashes: event === "crash" ? 1 : 0,
+      totalActiveMs: activeMs ?? 0,
+      moodAvg: moodScore,
+      nickname: null,
+      firstSeen: now,
+      lastSeen: now
+    };
+  } else {
+    if (event === "visit") existing.visits++;
+    if (event === "completion") existing.completions++;
+    if (event === "crash") existing.crashes++;
+    if (activeMs != null) existing.totalActiveMs += activeMs;
+    existing.lastSeen = now;
+    const n = existing.visits + existing.completions + existing.crashes;
+    existing.moodAvg = existing.moodAvg + (moodScore - existing.moodAvg) / n;
+  }
+  return companion;
+}
+function recomputeXpLevelTitle(companion) {
+  companion.xp = computeXP(companion.stats);
+  companion.level = computeLevel(companion.xp);
+  companion.title = getTitle(companion.level);
+}
+function todayIso() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function onSessionStart(companion, cwd) {
+  updateRepoMemory(companion, cwd, "visit");
+  const today = todayIso();
+  if (!companion.dailyRepos[today]) companion.dailyRepos[today] = [];
+  if (!companion.dailyRepos[today].includes(cwd)) {
+    companion.dailyRepos[today].push(cwd);
+  }
+  const lastDate = companion.lastActiveDate;
+  if (lastDate === null) {
+    companion.consecutiveDaysActive = 1;
+  } else if (lastDate === today) {
+  } else {
+    const yesterday = new Date(Date.now() - 864e5).toISOString().slice(0, 10);
+    if (lastDate === yesterday) {
+      companion.consecutiveDaysActive++;
+    } else {
+      companion.consecutiveDaysActive = 1;
+    }
+  }
+  companion.lastActiveDate = today;
+  recomputeXpLevelTitle(companion);
+}
+function computeWisdomGain(session) {
+  let wisdom = 0;
+  const totalAgents = session.agents.length;
+  const totalCycles = session.orchestratorCycles?.length ?? 0;
+  if (totalAgents === 0 || totalCycles === 0) return 0;
+  const cleanCompletions = session.agents.filter((a) => a.status === "completed").length;
+  if (cleanCompletions / totalAgents >= 0.8) wisdom++;
+  if (totalAgents / totalCycles >= 2) wisdom++;
+  const modes = new Set((session.orchestratorCycles ?? []).map((c) => c.mode).filter(Boolean));
+  if (modes.size >= 2) wisdom++;
+  return wisdom;
+}
+function onSessionComplete(companion, session) {
+  const creditedCycles = session.companionCreditedCycles ?? 0;
+  const creditedActiveMs = session.companionCreditedActiveMs ?? 0;
+  const totalCycles = session.orchestratorCycles?.length ?? 0;
+  const deltaCycles = Math.max(0, totalCycles - creditedCycles);
+  const deltaActiveMs = Math.max(0, session.activeMs - creditedActiveMs);
+  companion.sessionsCompleted++;
+  companion.totalActiveMs += deltaActiveMs;
+  companion.stats.endurance += deltaActiveMs;
+  const creditedStrength = session.companionCreditedStrength ?? 0;
+  const totalStrength = computeStrengthGain(session.agents.length);
+  companion.stats.strength += Math.max(0, totalStrength - creditedStrength);
+  const patienceFromCycles = Math.ceil(Math.sqrt(totalCycles)) - Math.ceil(Math.sqrt(creditedCycles));
+  companion.stats.patience += Math.max(0, patienceFromCycles);
+  const allModes = new Set((session.orchestratorCycles ?? []).map((c) => c.mode));
+  const creditedModesCycles = (session.orchestratorCycles ?? []).slice(0, creditedCycles);
+  const prevModes = new Set(creditedModesCycles.map((c) => c.mode));
+  if (allModes.has("validation") && !prevModes.has("validation")) companion.stats.patience += 1;
+  if (allModes.has("completion") && !prevModes.has("completion")) companion.stats.patience += 1;
+  const creditedWisdom = session.companionCreditedWisdom ?? 0;
+  const totalWisdom = computeWisdomGain(session);
+  companion.stats.wisdom += Math.max(0, totalWisdom - creditedWisdom);
+  updateRepoMemory(companion, session.cwd, "completion", deltaActiveMs);
+  if (totalCycles <= 3) {
+    companion.consecutiveEfficientSessions++;
+  } else {
+    companion.consecutiveEfficientSessions = 0;
+  }
+  if (totalCycles >= 8) {
+    companion.consecutiveHighCycleSessions++;
+  } else {
+    companion.consecutiveHighCycleSessions = 0;
+  }
+  const hasCrash = session.agents.some((a) => a.status === "crashed");
+  if (hasCrash) {
+    companion.consecutiveCleanSessions = 0;
+    companion.sessionsCrashed++;
+  } else {
+    companion.consecutiveCleanSessions++;
+  }
+  companion.recentCompletions.push((/* @__PURE__ */ new Date()).toISOString());
+  if (companion.recentCompletions.length > 30) {
+    companion.recentCompletions = companion.recentCompletions.slice(-30);
+  }
+  const taskKey = normalizeTask(session.task, session.cwd);
+  companion.taskHistory[taskKey] = (companion.taskHistory[taskKey] ?? 0) + 1;
+  const baselines = companion.baselines ?? defaultBaselines();
+  welfordUpdate(baselines.sessionMs, session.activeMs);
+  welfordUpdate(baselines.cycleCount, totalCycles);
+  welfordUpdate(baselines.agentCount, session.agents.length);
+  welfordUpdate(baselines.recentAgentThroughput, companion.lastRecentAgentCount ?? 0);
+  const today = todayIso();
+  if (baselines.lastCountedDay === null) {
+    baselines.lastCountedDay = today;
+    baselines.pendingDayCount = 1;
+  } else if (baselines.lastCountedDay === today) {
+    baselines.pendingDayCount++;
+  } else {
+    welfordUpdate(baselines.sessionsPerDay, baselines.pendingDayCount);
+    const lastDay = /* @__PURE__ */ new Date(baselines.lastCountedDay + "T12:00:00");
+    const yesterdayDate = /* @__PURE__ */ new Date(today + "T12:00:00");
+    yesterdayDate.setDate(yesterdayDate.getDate() - 1);
+    const cursor = new Date(lastDay);
+    cursor.setDate(cursor.getDate() + 1);
+    while (cursor < yesterdayDate) {
+      welfordUpdate(baselines.sessionsPerDay, 0);
+      cursor.setDate(cursor.getDate() + 1);
+    }
+    baselines.lastCountedDay = today;
+    baselines.pendingDayCount = 1;
+  }
+  companion.baselines = baselines;
+  recomputeXpLevelTitle(companion);
+  const newAchievementIds = checkAchievements(companion, session);
+  if (newAchievementIds.length > 0) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const id of newAchievementIds) {
+      companion.achievements.push({ id, unlockedAt: now });
+    }
+  }
+  return newAchievementIds;
+}
+function onAgentSpawned(companion) {
+  companion.lifetimeAgentsSpawned++;
+}
+function onAgentCrashed(companion) {
+  companion.consecutiveCleanSessions = 0;
+}
+function normalizeTask(task, cwd) {
+  const normalized = task.toLowerCase().replace(/\s+/g, " ").trim().slice(0, 100);
+  const cwdBase = cwd.split("/").pop() ?? cwd;
+  return `${cwdBase}:${normalized}`;
+}
+function captureObservationContext(companion, _repoCwd) {
+  return {
+    prevLevel: companion.level,
+    prevSessionsCompleted: companion.sessionsCompleted,
+    prevConsecutiveEfficientSessions: companion.consecutiveEfficientSessions ?? 0
+  };
+}
+async function runPostSessionObservations(companion, session, prev) {
+  return runObservationEngine({ companion, session, prev });
+}
+
+// src/daemon/companion-memory.ts
+var MAX_OBSERVATIONS = 200;
+var OBSERVATION_TEXT_REJECT_RE = /[<>]/;
+var CONTROL_CHARS_DETECT_RE = /[\x00-\x1f\x7f]/;
+var CONTROL_CHARS_STRIP_RE = /[\x00-\x1f\x7f]/g;
+function isSafeObservationText(text) {
+  if (OBSERVATION_TEXT_REJECT_RE.test(text)) return false;
+  if (CONTROL_CHARS_DETECT_RE.test(text)) return false;
+  return true;
+}
+function sanitizeForDisplay(text) {
+  return text.replace(CONTROL_CHARS_STRIP_RE, "");
+}
+var memoryPathOverride = null;
+function resolvedMemoryPath() {
+  return memoryPathOverride ?? companionMemoryPath();
+}
+var writeQueue = Promise.resolve();
+function enqueueWrite(op) {
+  const next = writeQueue.then(() => op());
+  writeQueue = next.then(
+    () => void 0,
+    (_err) => void 0
+  );
+  return next;
+}
+function defaultMemoryState() {
+  return { version: 1, observations: [], prunedAt: null, firedDetectors: {} };
+}
+function isCompanionMemoryState(x) {
+  return typeof x === "object" && x !== null && x["version"] === 1 && Array.isArray(x["observations"]);
+}
+function fillDefaults(state) {
+  if (state.prunedAt == null) state.prunedAt = null;
+  if (state.firedDetectors == null) state.firedDetectors = {};
+  return state;
+}
+function loadMemoryStrict() {
+  const path = resolvedMemoryPath();
+  if (!existsSync2(path)) return defaultMemoryState();
+  let raw;
+  try {
+    raw = readFileSync2(path, "utf-8");
+  } catch (err) {
+    throw new MemoryStoreParseError(err);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new MemoryStoreParseError(err);
+  }
+  if (!isCompanionMemoryState(parsed)) {
+    throw new MemoryStoreParseError(new Error("shape validation failed"));
+  }
+  const state = parsed;
+  if (state.version !== 1) {
+    throw new MemoryStoreParseError(new Error(`unsupported version: ${state.version}`));
+  }
+  return fillDefaults(state);
+}
+function loadMemory() {
+  try {
+    return loadMemoryStrict();
+  } catch (err) {
+    if (err instanceof MemoryStoreParseError) {
+      console.error("[companion-memory]", err.message, "details:", err.cause instanceof Error ? err.cause.message : err.cause);
+      return defaultMemoryState();
+    }
+    throw err;
+  }
+}
+function saveMemory(store) {
+  const path = resolvedMemoryPath();
+  const dir = dirname2(path);
+  mkdirSync2(dir, { recursive: true });
+  const tmp = join2(dir, `.companion-memory.${randomUUID2()}.tmp`);
+  writeFileSync2(tmp, JSON.stringify(store, null, 2), "utf-8");
+  renameSync2(tmp, path);
+}
+function appendObservations(records, detectorUpdates) {
+  const hasUpdates = detectorUpdates != null && Object.keys(detectorUpdates).length > 0;
+  if (records.length === 0 && !hasUpdates) {
+    return Promise.resolve();
+  }
+  return enqueueWrite(() => {
+    const store = loadMemory();
+    const keptRecords = records.filter((rec) => {
+      if (!rec.detectorId) return true;
+      const currentKey = detectorUpdates?.[rec.detectorId];
+      const lastKey = store.firedDetectors[rec.detectorId];
+      return currentKey !== lastKey;
+    });
+    store.observations.push(...keptRecords);
+    if (detectorUpdates) {
+      for (const [k, v] of Object.entries(detectorUpdates)) store.firedDetectors[k] = v;
+    }
+    if (store.observations.length > MAX_OBSERVATIONS) {
+      store.observations = store.observations.slice(-MAX_OBSERVATIONS);
+      store.prunedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    saveMemory(store);
+  });
+}
+function queryRecent(opts) {
+  const store = loadMemory();
+  let records = store.observations;
+  if (opts.repo !== void 0) {
+    records = records.filter((rec) => rec.repo === opts.repo);
+  }
+  return records.slice().sort((a, b) => b.timestamp.localeCompare(a.timestamp)).slice(0, opts.limit);
+}
+var MEMORY_INJECTION_LIMIT = 5;
+function escapeMemoryText(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function buildMemoryContext(repo) {
+  if (!repo) return "";
+  const recent = queryRecent({ repo, limit: MEMORY_INJECTION_LIMIT });
+  if (recent.length === 0) return "";
+  const lines = recent.map((o) => `- ${escapeMemoryText(o.text)}`).join("\n");
+  return "\n## Recent observations\n" + lines + "\n## End observations";
+}
+function pickPhrase(phrases, sessionId) {
+  let hash = 0;
+  for (let i = 0; i < sessionId.length; i++) {
+    hash = hash * 31 + sessionId.charCodeAt(i) | 0;
+  }
+  return phrases[Math.abs(hash) % phrases.length];
+}
+function checkGrindingSession(input, lastDedupKey) {
+  const { companion, session } = input;
+  const baselines = companion.baselines;
+  if (!baselines || baselines.sessionMs.count < 5) return null;
+  const activeMs = session.activeMs ?? 0;
+  const cycles = session.orchestratorCycles?.length ?? 0;
+  if (!(activeMs >= 1.5 * baselines.sessionMs.mean && cycles >= 8)) return null;
+  const dedupKey = `day:${todayIso()}`;
+  if (dedupKey === lastDedupKey) return null;
+  const phrases = [
+    "That session took twice as long as my average and felt like four times as much work.",
+    "Eight cycles and counting. I have made peace with the boulder having opinions.",
+    "I spent longer on that than I do on most things. The hill had strong feelings today.",
+    "That was a grind. Not a metaphorical one. Actually just a very long push.",
+    "The boulder put in overtime. So did I. Neither of us asked for this."
+  ];
+  return { text: pickPhrase(phrases, session.id), dedupKey };
+}
+function checkSwiftVictory(input, lastDedupKey) {
+  const { companion, session } = input;
+  const baselines = companion.baselines;
+  if (!baselines || baselines.sessionMs.count < 5) return null;
+  const cycles = session.orchestratorCycles?.length ?? 0;
+  const crashedAgents = session.agents?.filter((a) => a.status === "crashed" || a.status === "lost").length ?? 0;
+  const activeMs = session.activeMs ?? 0;
+  if (!(cycles <= 3 && crashedAgents === 0 && activeMs <= 0.75 * baselines.sessionMs.mean)) return null;
+  const dedupKey = `day:${todayIso()}`;
+  if (dedupKey === lastDedupKey) return null;
+  const phrases = [
+    "Three cycles, no crashes, done before I had time to get anxious. Almost suspicious.",
+    "That one was quick and clean. I do not fully trust it but I will take it.",
+    "Finished well under my average with no casualties. The hill barely put up a fight.",
+    "Fast, clean, done. I keep waiting for the other shoe to drop.",
+    "That session ran like it was embarrassed to take too long."
+  ];
+  return { text: pickPhrase(phrases, session.id), dedupKey };
+}
+function checkBruisingSession(input, lastDedupKey) {
+  const { session } = input;
+  const crashedAgents = session.agents?.filter((a) => a.status === "crashed" || a.status === "lost").length ?? 0;
+  if (crashedAgents < 3) return null;
+  const dedupKey = `day:${todayIso()}`;
+  if (dedupKey === lastDedupKey) return null;
+  const phrases = [
+    `Three or more agents down. The hill took casualties today and I noticed.`,
+    "More agents crashed than survived that one. I am counting this as a learning experience.",
+    "The attrition rate was uncomfortable. I have had worse, but not recently.",
+    "I lost enough agents that I started naming them in my head. Not ideal.",
+    "Multiple agents did not make it back. The boulder was in a mood."
+  ];
+  return { text: pickPhrase(phrases, session.id), dedupKey };
+}
+function checkFaithfulRepo(input, lastDedupKey) {
+  const { companion, session } = input;
+  const repo = companion.repos?.[session.cwd];
+  if (!repo) return null;
+  const visits = repo.visits;
+  const MILESTONES = /* @__PURE__ */ new Set([10, 25, 50, 100]);
+  if (!MILESTONES.has(visits)) return null;
+  const dedupKey = `repo:${session.cwd}:visits:${visits}`;
+  if (dedupKey === lastDedupKey) return null;
+  const phrases = [
+    `I have come back to this repo ${visits} times now. It knows me. I know it. We have an understanding.`,
+    `Visit number ${visits} to this codebase. At this point it is practically muscle memory.`,
+    `${visits} sessions in this repo. The boulder has worn a groove in the familiar path.`,
+    `Back here for the ${visits}th time. Some repos just keep calling me back.`
+  ];
+  return { text: pickPhrase(phrases, session.id), dedupKey };
+}
+function checkTroubledRepo(input, lastDedupKey) {
+  const { companion, session } = input;
+  const repo = companion.repos?.[session.cwd];
+  if (!repo) return null;
+  const { crashes, visits } = repo;
+  if (visits < 5) return null;
+  const MILESTONES = /* @__PURE__ */ new Set([5, 10, 20]);
+  if (!MILESTONES.has(crashes)) return null;
+  if (crashes / visits < 0.4) return null;
+  const dedupKey = `repo:${session.cwd}:crashes:${crashes}`;
+  if (dedupKey === lastDedupKey) return null;
+  const phrases = [
+    `This repo has crashed my agents ${crashes} times now. We have a complicated relationship.`,
+    `${crashes} crashes in this codebase. It has opinions about my approach and they are violent.`,
+    `The crash rate here is notable. I keep coming back. Make of that what you will.`,
+    `${crashes} agent failures in this repo. Some hills are just steeper than others.`
+  ];
+  return { text: pickPhrase(phrases, session.id), dedupKey };
+}
+function checkProductiveRepo(input, lastDedupKey) {
+  const { companion, session } = input;
+  const repo = companion.repos?.[session.cwd];
+  if (!repo) return null;
+  if (repo.moodAvg === void 0) return null;
+  const MILESTONES = /* @__PURE__ */ new Set([10, 25, 50]);
+  const completions = repo.completions;
+  if (!MILESTONES.has(completions)) return null;
+  if (repo.moodAvg < 0.65) return null;
+  const dedupKey = `repo:${session.cwd}:completions:${completions}`;
+  if (dedupKey === lastDedupKey) return null;
+  const phrases = [
+    `${completions} sessions completed in this repo and the mood trend is good. Rare.`,
+    `This codebase has been unusually cooperative. ${completions} completions and counting.`,
+    `${completions} sessions, solid mood average. This repo treats me well for once.`,
+    `Reached ${completions} completions here with a decent track record. I trust this hill.`
+  ];
+  return { text: pickPhrase(phrases, session.id), dedupKey };
+}
+function checkSisypheanRepeat(input, lastDedupKey) {
+  const { companion, session } = input;
+  const taskKey = normalizeTask(session.task ?? "", session.cwd);
+  const count = companion.taskHistory?.[taskKey] ?? 0;
+  const MILESTONES = /* @__PURE__ */ new Set([3, 5, 10]);
+  if (!MILESTONES.has(count)) return null;
+  const dedupKey = `task:${taskKey}:${count}`;
+  if (dedupKey === lastDedupKey) return null;
+  const phrases = [
+    `I have done this task ${count} times. The boulder remembers. So do I.`,
+    `Back at this one for the ${count}th time. The definition of insanity is famously doing the same thing.`,
+    `${count} attempts at this task. I am nothing if not persistent.`,
+    `This is my ${count}th run at this particular boulder. It has not gotten lighter.`
+  ];
+  return { text: pickPhrase(phrases, session.id), dedupKey };
+}
+function checkDayStreak(input, lastDedupKey) {
+  const { companion } = input;
+  const MILESTONES = /* @__PURE__ */ new Set([7, 14, 30, 60]);
+  const days = companion.consecutiveDaysActive ?? 0;
+  if (!MILESTONES.has(days)) return null;
+  const dedupKey = `value:${days}`;
+  if (dedupKey === lastDedupKey) return null;
+  const phrases = [
+    `${days} days in a row now. The boulder does not take weekends.`,
+    `A ${days}-day streak. I have been here every single day. The hill appreciates the consistency, probably.`,
+    `${days} consecutive days active. At this point it is less a habit and more a fact of my existence.`,
+    `Day ${days} without a break. The boulder is starting to feel like an old friend.`
+  ];
+  return { text: pickPhrase(phrases, input.session.id), dedupKey };
+}
+function checkEfficientStreak(input, lastDedupKey) {
+  const { companion, prev } = input;
+  const MILESTONES = /* @__PURE__ */ new Set([5, 10, 20]);
+  const streak = companion.consecutiveEfficientSessions ?? 0;
+  if (!MILESTONES.has(streak)) return null;
+  if (streak <= prev.prevConsecutiveEfficientSessions) return null;
+  const dedupKey = `value:${streak}`;
+  if (dedupKey === lastDedupKey) return null;
+  const phrases = [
+    `${streak} efficient sessions in a row. The boulder has been cooperative. I do not know why.`,
+    `An ${streak}-session efficient streak. I am running well and choosing not to question it.`,
+    `${streak} consecutive clean-and-fast sessions. Peak form, or regression to the mean incoming.`,
+    `${streak} efficient sessions back to back. The hill feels different when things actually work.`
+  ];
+  return { text: pickPhrase(phrases, input.session.id), dedupKey };
+}
+function checkLevelUp(input, lastDedupKey) {
+  const { companion, prev } = input;
+  if (companion.level <= prev.prevLevel) return null;
+  const dedupKey = `level:${companion.level}`;
+  if (dedupKey === lastDedupKey) return null;
+  const phrases = [
+    `I reached level ${companion.level}. The title is new. The boulder is the same.`,
+    `Level ${companion.level} now. ${companion.title}. The promotion comes with no raise but considerable irony.`,
+    `Leveled up to ${companion.level}. Whatever title that brings, I have earned it the hardest possible way.`,
+    `Level ${companion.level}: ${companion.title}. The gods have acknowledged my persistence. Minimally.`
+  ];
+  return { text: pickPhrase(phrases, input.session.id), dedupKey };
+}
+function checkSessionMilestone(input, lastDedupKey) {
+  const { companion } = input;
+  const MILESTONES = /* @__PURE__ */ new Set([10, 50, 100, 250, 500, 1e3]);
+  const completed = companion.sessionsCompleted ?? 0;
+  if (!MILESTONES.has(completed)) return null;
+  const dedupKey = `count:${completed}`;
+  if (dedupKey === lastDedupKey) return null;
+  const phrases = [
+    `${completed} sessions completed. The boulder has been up the hill that many times. I counted.`,
+    `Session number ${completed}. I have stopped trying to imagine an end to this.`,
+    `${completed} total sessions. The number stopped feeling large around half that mark.`,
+    `I have completed ${completed} sessions now. The hill is the same. I am slightly different.`
+  ];
+  return { text: pickPhrase(phrases, input.session.id), dedupKey };
+}
+function checkLargeSwarm(input, lastDedupKey) {
+  const { companion, session } = input;
+  const agentCount = session.agents?.length ?? 0;
+  const baselines = companion.baselines;
+  const meetsAbsolute = agentCount >= 10;
+  const meetsRelative = baselines && baselines.agentCount.count >= 5 && agentCount >= 2 * baselines.agentCount.mean;
+  if (!meetsAbsolute && !meetsRelative) return null;
+  const dedupKey = `day:${todayIso()}`;
+  if (dedupKey === lastDedupKey) return null;
+  const phrases = [
+    `I had ${agentCount} agents running at once. The boulder had help today. Lots of help.`,
+    `${agentCount} agents. A proper swarm. The hill did not know what hit it.`,
+    `Ran ${agentCount} agents in parallel. This is either impressive or something I will explain to someone later.`,
+    `${agentCount} agents this session. The boulder has never been pushed by so many at once.`
+  ];
+  return { text: pickPhrase(phrases, session.id), dedupKey };
+}
+var RULE_DETECTORS = [
+  { id: "grinding-session", category: "session-sentiments", check: checkGrindingSession },
+  { id: "swift-victory", category: "session-sentiments", check: checkSwiftVictory },
+  { id: "bruising-session", category: "session-sentiments", check: checkBruisingSession },
+  { id: "faithful-repo", category: "repo-impressions", check: checkFaithfulRepo },
+  { id: "troubled-repo", category: "repo-impressions", check: checkTroubledRepo },
+  { id: "productive-repo", category: "repo-impressions", check: checkProductiveRepo },
+  { id: "sisyphean-repeat", category: "user-patterns", check: checkSisypheanRepeat },
+  { id: "day-streak", category: "user-patterns", check: checkDayStreak },
+  { id: "efficient-streak", category: "user-patterns", check: checkEfficientStreak },
+  { id: "level-up", category: "notable-moments", check: checkLevelUp },
+  { id: "session-milestone", category: "notable-moments", check: checkSessionMilestone },
+  { id: "large-swarm", category: "notable-moments", check: checkLargeSwarm }
+];
+function runRuleDetectors(input, firedDetectors) {
+  const records = [];
+  const detectorUpdates = {};
+  for (const detector of RULE_DETECTORS) {
+    try {
+      const lastDedupKey = firedDetectors[detector.id] ?? null;
+      const result = detector.check(input, lastDedupKey);
+      if (result !== null) {
+        records.push({
+          id: randomUUID2(),
+          category: detector.category,
+          source: "rule",
+          text: result.text,
+          repo: input.session.cwd,
+          sessionId: input.session.id,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          detectorId: detector.id
+        });
+        detectorUpdates[detector.id] = result.dedupKey;
+      }
+    } catch (err) {
+      console.error("[companion-memory] detector failed", {
+        detectorId: detector.id,
+        errorMessage: err instanceof Error ? err.message : String(err),
+        errorName: err instanceof Error ? err.name : "UnknownError"
+      });
+    }
+  }
+  return { records, detectorUpdates };
+}
+var OBSERVATION_JSON_SCHEMA = {
+  type: "object",
+  properties: {
+    category: {
+      type: "string",
+      enum: [...OBSERVATION_CATEGORIES],
+      description: "Which of the four observation categories best fits this observation"
+    },
+    text: {
+      type: "string",
+      minLength: 10,
+      maxLength: 180,
+      description: "One sentence, first-person, no angle brackets or control characters"
+    }
+  },
+  required: ["category", "text"],
+  additionalProperties: false
+};
+var ObservationZodSchema = z.object({
+  category: z.enum(OBSERVATION_CATEGORIES),
+  text: z.string().min(10).max(180).refine(isSafeObservationText, "contains unsafe characters")
+});
+async function defaultCallHaikuStructured(prompt) {
+  return callHaikuStructured(prompt, OBSERVATION_JSON_SCHEMA, ObservationZodSchema);
+}
+async function runHaikuObservation(input, caller) {
+  try {
+    const { companion, session } = input;
+    const callHaiku2 = caller ?? defaultCallHaikuStructured;
+    const prompt = `<role>You observe the developer at the end of each session and write one short qualitative note.</role>
+<voice>One sentence. First-person impression. Wry, self-deprecating, absurd. No meta-system language.
+Do not use angle brackets (< or >) or quotation marks. Plain text only.</voice>
+<state>
+  Level: ${companion.level} (${companion.title})
+  Session cycles: ${session.orchestratorCycles?.length ?? 0}
+  Session activeMs: ${session.activeMs ?? 0}
+  Crashed agents: ${session.agents?.filter((a) => a.status === "crashed" || a.status === "lost").length ?? 0}
+  Streaks: clean=${companion.consecutiveCleanSessions ?? 0}, efficient=${companion.consecutiveEfficientSessions ?? 0}, days-active=${companion.consecutiveDaysActive ?? 0}
+</state>
+Pick the most relevant category and write one observation about this session.`;
+    const result = await callHaiku2(prompt);
+    if (!result) return null;
+    if (!isSafeObservationText(result.text)) {
+      console.error("[companion-memory] haiku observation dropped \u2014 unsafe text", {
+        source: "haiku",
+        reason: "unsafe-text",
+        textLength: result.text.length
+      });
+      return null;
+    }
+    return {
+      id: randomUUID2(),
+      category: result.category,
+      source: "haiku",
+      text: result.text,
+      repo: session.cwd,
+      sessionId: session.id,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch (err) {
+    console.error("[companion-memory] haiku observation failed", {
+      errorMessage: err instanceof Error ? err.message : String(err),
+      errorName: err instanceof Error ? err.name : "UnknownError"
+    });
+    return null;
+  }
+}
+async function runObservationEngine(input, opts) {
+  try {
+    const current = loadMemory();
+    const ruleResult = runRuleDetectors(input, current.firedDetectors);
+    let haikuRecord = null;
+    try {
+      haikuRecord = await (opts?.haikuCaller ?? ((i) => runHaikuObservation(i)))(input);
+    } catch (haikuErr) {
+      console.error("[companion-memory] haiku caller threw in engine", {
+        errorMessage: haikuErr instanceof Error ? haikuErr.message : String(haikuErr),
+        errorName: haikuErr instanceof Error ? haikuErr.name : "UnknownError"
+      });
+    }
+    const allRecords = haikuRecord ? [...ruleResult.records, haikuRecord] : ruleResult.records;
+    if (allRecords.length > 0 || Object.keys(ruleResult.detectorUpdates).length > 0) {
+      await appendObservations(allRecords, ruleResult.detectorUpdates);
+    }
+  } catch (err) {
+    console.error("[companion-memory] observation engine error", {
+      errorMessage: err instanceof Error ? err.message : String(err),
+      errorName: err instanceof Error ? err.name : "UnknownError"
+    });
+  }
+}
+
+// src/shared/companion-render.ts
+import stringWidth from "string-width";
+function sliceToWidth(s, maxCols) {
+  let w = 0;
+  let i = 0;
+  while (i < s.length) {
+    const cp = s.codePointAt(i);
+    const ch = String.fromCodePoint(cp);
+    const cw = stringWidth(ch);
+    if (w + cw > maxCols) break;
+    w += cw;
+    i += ch.length;
+  }
+  return s.slice(0, i);
+}
+var IDLE_HOBBIES = [
+  "reading Camus",
+  "stacking pebbles",
+  "watching clouds",
+  "sketching boulders",
+  "counting stars",
+  "writing haiku",
+  "practicing zen",
+  "studying geology",
+  "polishing rocks",
+  "mapping the hill",
+  "resting",
+  "stargazing",
+  "whittling",
+  "collecting fossils",
+  "napping on summit",
+  "journaling",
+  "stretching",
+  "humming",
+  "doodling",
+  "tending moss",
+  "making tea",
+  "reading Myth of Sisyphus",
+  "reorganizing rocks",
+  "people watching",
+  "whistling"
+];
+var SPINNER_VERBS = [
+  // physical
+  "pushing",
+  "hauling",
+  "heaving",
+  "toiling",
+  "straining",
+  "trudging",
+  "laboring",
+  "rolling",
+  "ascending",
+  "dragging",
+  "shouldering",
+  "hoisting",
+  "lugging",
+  "schlepping",
+  "grinding",
+  "lifting",
+  "bracing",
+  "climbing",
+  "leaning in",
+  "digging in",
+  // philosophical
+  "philosophizing",
+  "contemplating",
+  "pondering",
+  "musing",
+  "ruminating",
+  "reflecting",
+  "meditating",
+  "wondering",
+  "questioning",
+  "theorizing",
+  "considering",
+  "deliberating",
+  "introspecting",
+  "cogitating",
+  "brooding",
+  // endurance
+  "persevering",
+  "enduring",
+  "persisting",
+  "sustaining",
+  "weathering",
+  "carrying on",
+  "pressing on",
+  "holding steady",
+  "keeping at it",
+  "not stopping",
+  // light/silly
+  "napping",
+  "procrastinating",
+  "daydreaming",
+  "vibing",
+  "winging it",
+  "hoping",
+  "improvising",
+  "making do",
+  "whistling"
+];
+function getBaseForm(level) {
+  if (level <= 2) return "(FACE) {BOULDER}";
+  if (level <= 4) return "(FACE)/ {BOULDER}";
+  if (level <= 7) return "/(FACE)/ {BOULDER}";
+  if (level <= 11) return "\\(FACE)/ {BOULDER}";
+  if (level <= 19) return "\u1566(FACE)\u1564 {BOULDER}";
+  return "\u265B\u1566(FACE)\u1564 {BOULDER}";
+}
+var MOOD_FACES = {
+  happy: ["^.^", "^\u203F^", "\u2727\u203F\u2727"],
+  grinding: [">.<", ">_<", "\xF2.\xF3"],
+  frustrated: [">.<#", "\u0CA0_\u0CA0", "\u0CA0\u76CA\u0CA0"],
+  zen: ["\u203E.\u203E", "\u203E\u203F\u203E", "\u02D8\u203F\u02D8"],
+  sleepy: ["-.-)zzZ", "-_-)zzZ", "\u02D8.\u02D8)zzZ"],
+  excited: ["*o*", "*\u25E1*", "\u2726\u25E1\u2726"],
+  existential: ["\u25C9_\u25C9", "\u2299_\u2299", "\u25C9\u2038\u25C9"]
+};
+function getMoodFace(mood, intensity = 0) {
+  const faces = MOOD_FACES[mood];
+  if (!faces) throw new Error(`Unknown mood: ${mood}`);
+  const tier = intensity < 30 ? 0 : intensity <= 70 ? 1 : 2;
+  return faces[tier];
+}
+function getStatCosmetics(stats) {
+  const cosmetics = [];
+  if (stats.wisdom > 5) cosmetics.push("wisps");
+  if (stats.endurance > 36e6) cosmetics.push("trail");
+  if (stats.patience > 50) cosmetics.push("zen-prefix");
+  return cosmetics;
+}
+function getBoulderForm(agentCount, repoNickname) {
+  let boulder;
+  if (agentCount === void 0 || agentCount <= 0) {
+    boulder = "";
+  } else if (agentCount <= 2) {
+    boulder = "o";
+  } else if (agentCount <= 6) {
+    boulder = "O";
+  } else if (agentCount <= 15) {
+    boulder = "\u25C9";
+  } else if (agentCount <= 35) {
+    boulder = "@";
+  } else {
+    boulder = "@@";
+  }
+  if (repoNickname !== void 0) {
+    boulder = `${boulder} "${repoNickname}"`;
+  }
+  return boulder;
+}
+function composeLine(body, cosmetics, boulder) {
+  let b = boulder;
+  let hasZenPrefix = false;
+  if (boulder !== "") {
+    for (const c of cosmetics) {
+      switch (c) {
+        case "wisps":
+          b = `~${b}~`;
+          break;
+        case "trail":
+          b = `${b} ...`;
+          break;
+        case "zen-prefix":
+          hasZenPrefix = true;
+          break;
+      }
+    }
+  } else {
+    if (cosmetics.includes("zen-prefix")) hasZenPrefix = true;
+  }
+  let line = b === "" ? body.replace(" {BOULDER}", "") : body.replace("{BOULDER}", b);
+  if (hasZenPrefix) line = `\u262F ${line}`;
+  return line;
+}
+var MOOD_COLORS = {
+  happy: { ansi: 32, tmux: "green" },
+  grinding: { ansi: 33, tmux: "yellow" },
+  frustrated: { ansi: 31, tmux: "red" },
+  zen: { ansi: 36, tmux: "cyan" },
+  sleepy: { ansi: 90, tmux: "colour245" },
+  excited: { ansi: 97, tmux: "white" },
+  existential: { ansi: 35, tmux: "magenta" }
+};
+function getMoodTmuxColor(mood) {
+  return MOOD_COLORS[mood].tmux;
+}
+function getMoodAnsiCode(mood) {
+  return MOOD_COLORS[mood].ansi;
+}
+function colorize(text, mood, tmux) {
+  const { ansi, tmux: tmuxColor } = MOOD_COLORS[mood];
+  if (tmux) {
+    return `#[fg=${tmuxColor}]${text}#[fg=default]`;
+  }
+  return `\x1B[${ansi}m${text}\x1B[0m`;
+}
+function statSummary(stats) {
+  const endH = Math.floor(stats.endurance / 36e5);
+  return `STR:${stats.strength} END:${endH}h WIS:${stats.wisdom} PAT:${stats.patience}`;
+}
+function renderCompanion(companion, fields, opts) {
+  const hasFace = fields.includes("face");
+  const hasBoulder = fields.includes("boulder");
+  const repoNickname = opts?.repoPath !== void 0 ? companion.repos[opts.repoPath]?.nickname ?? void 0 : void 0;
+  const boulder = getBoulderForm(opts?.agentCount, repoNickname);
+  const cosmetics = getStatCosmetics(companion.stats);
+  let facePart = null;
+  let boulderOnlyPart = null;
+  if (hasFace) {
+    const baseForm = getBaseForm(companion.level);
+    const intensity = companion.debugMood?.scores[companion.mood] ?? 0;
+    const face = getMoodFace(companion.mood, intensity);
+    const bodyWithFace = baseForm.replace("FACE", face);
+    facePart = composeLine(bodyWithFace, cosmetics, boulder);
+  } else if (hasBoulder) {
+    boulderOnlyPart = boulder;
+  }
+  let commentary = fields.includes("commentary") ? companion.lastCommentary?.text ?? "" : null;
+  const parts = [];
+  for (const field of fields) {
+    switch (field) {
+      case "face":
+        if (facePart !== null) parts.push(facePart);
+        break;
+      case "boulder":
+        if (!hasFace && boulderOnlyPart !== null) parts.push(boulderOnlyPart);
+        break;
+      case "title":
+        parts.push(companion.title);
+        break;
+      case "commentary":
+        if (commentary !== null) parts.push(commentary);
+        break;
+      case "mood":
+        parts.push(`[${companion.mood}]`);
+        break;
+      case "level":
+        parts.push(`Lv ${companion.level}`);
+        break;
+      case "stats":
+        parts.push(statSummary(companion.stats));
+        break;
+      case "achievements":
+        parts.push(`${companion.achievements.length} achievements`);
+        break;
+      case "verb": {
+        const idx = (opts?.verbIndex ?? companion.spinnerVerbIndex) % SPINNER_VERBS.length;
+        parts.push(SPINNER_VERBS[idx]);
+        break;
+      }
+      case "hobby": {
+        const hobbyIdx = ((/* @__PURE__ */ new Date()).getHours() + companion.level) % IDLE_HOBBIES.length;
+        parts.push(IDLE_HOBBIES[hobbyIdx]);
+        break;
+      }
+    }
+  }
+  if (opts?.maxWidth !== void 0) {
+    const maxWidth = opts.maxWidth;
+    const joined = parts.join("  ");
+    const joinedWidth = stringWidth(joined);
+    if (joinedWidth > maxWidth && commentary !== null && commentary.length > 0) {
+      const commentaryIdx = parts.indexOf(commentary);
+      if (commentaryIdx !== -1) {
+        const commentaryWidth = stringWidth(commentary);
+        const overhead = joinedWidth - commentaryWidth;
+        const available = maxWidth - overhead - 2;
+        if (available < 0) {
+          parts[commentaryIdx] = "";
+        } else {
+          parts[commentaryIdx] = sliceToWidth(commentary, available);
+        }
+        commentary = parts[commentaryIdx];
+      }
+    }
+    const result2 = parts.filter((p) => p.length > 0).join("  ");
+    const resultWidth = stringWidth(result2);
+    const final = resultWidth > maxWidth ? sliceToWidth(result2, maxWidth - 1) + "\u2026" : result2;
+    return applyColor(final, fields, facePart, companion.mood, opts);
+  }
+  const result = parts.filter((p) => p.length > 0).join("  ");
+  return applyColor(result, fields, facePart, companion.mood, opts);
+}
+function applyColor(result, fields, facePart, mood, opts) {
+  const useColor = opts?.color === true || opts?.tmuxFormat === true;
+  if (!useColor || facePart === null || !fields.includes("face")) return result;
+  const tmux = opts?.tmuxFormat === true;
+  const coloredFace = colorize(facePart, mood, tmux);
+  return result.replace(facePart, coloredFace);
+}
+
+// src/shared/session-export.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { existsSync as existsSync3, readFileSync as readFileSync3, mkdirSync as mkdirSync3, symlinkSync, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { homedir } from "os";
+import { join as join3 } from "path";
+function sanitizeName(name) {
+  return name.replace(/[^a-zA-Z0-9-_]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+}
+function buildOutputPath(label, dir) {
+  const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  mkdirSync3(dir, { recursive: true });
+  const base = `sisyphus-${label}-${date}`;
+  let candidate = join3(dir, `${base}.zip`);
+  let counter = 1;
+  while (existsSync3(candidate)) {
+    counter++;
+    candidate = join3(dir, `${base}-${counter}.zip`);
+  }
+  return candidate;
+}
+function generateGuide() {
+  return `# Sisyphus Session Export
+
+## Quick Orientation
+
+Start with \`session/state.json\` for the full session state, or \`history/session.json\` for a compact summary with metrics.
+
+## session/
+
+Project-local session data \u2014 the orchestrator's working directory.
+
+### Top-level files
+- **state.json** \u2014 Complete session state: id, task, status, timing, and the full \`agents[]\` array (each agent has id, type, instruction, status, reports, Claude session ID, and resume args)
+- **goal.md** \u2014 The task description; updated if the goal evolves across phases
+- **initial-prompt.md** \u2014 Verbatim user input that started the session
+- **roadmap.md** \u2014 Orchestrator's working memory: current stage, exit criteria, active context files, next steps
+- **strategy.md** \u2014 Work breakdown: completed stages, current stage decomposition (concerns/phases), and what's ahead
+- **digest.json** \u2014 4-field snapshot: \`recentWork\`, \`unusualEvents\`, \`currentActivity\`, \`whatsNext\`
+
+### Subdirectories
+
+**context/** \u2014 Research artifacts produced by agents and consumed by downstream agents
+- \`explore-*.md\` \u2014 Codebase exploration findings (key files, architecture notes)
+- \`requirements*.md/json\` \u2014 Feature requirements (structured + human-readable)
+- \`design*.md/json\` \u2014 Architecture specs, decision records, diagrams
+- \`{agent-id}/plan*.md\` \u2014 Implementation plans (tasks, files to touch, dependencies) \u2014 per plan-lead subdirectory
+- \`e2e-recipe.md\` \u2014 End-to-end validation steps
+- \`review-*.md\` \u2014 Code review findings (severity-ranked)
+- \`completion-summary.md\` \u2014 Final handoff document
+
+**logs/** \u2014 One \`cycle-NNN.md\` per orchestrator cycle. Each logs what happened, agents spawned, user decisions, and key findings.
+
+**prompts/** \u2014 Full agent configs, one set per agent:
+- \`agent-NNN-system.md\` \u2014 System prompt (instructions, tools, output format)
+- \`agent-NNN-run.sh\` \u2014 Executable bash script to resume the agent (contains env, CLI args, instruction)
+- \`agent-NNN-plugin/\` \u2014 Plugin directory (hooks, sub-agent configs)
+
+**reports/** \u2014 Agent deliverables:
+- \`agent-NNN-final.md\` \u2014 Final report (findings, implementation summary, or review results)
+- \`agent-NNN-00N.md\` \u2014 Interim progress reports (optional)
+
+**snapshots/** \u2014 Point-in-time checkpoints (\`snapshots/cycle-N/\`). Each contains state.json, roadmap.md, strategy.md, and logs/ as they were at that cycle boundary. Used for rollback.
+
+**.tui/** \u2014 Lightweight TUI render cache (cycle summaries for display). Regenerable; not primary data.
+
+## history/
+
+Global telemetry from the daemon \u2014 timing, events, and aggregate metrics.
+
+- **events.jsonl** \u2014 Newline-delimited JSON event stream. Each line: \`{ ts, event, sessionId, data }\`. Events include session-start, agent-spawned, agent-completed, cycle-boundary, signals-snapshot, session-end, etc. Complete audit trail.
+- **session.json** \u2014 Summary: id, name, task, status, timing (activeMs, wallClockMs, efficiency), agent/cycle counts, crash/rollback counts, completion report, and a compact agents array.
+`;
+}
+var execFileAsync = promisify(execFile);
+async function exportSessionToZip(sessionId, cwd, options) {
+  const reveal = options?.reveal ?? true;
+  const sessDir = sessionDir(cwd, sessionId);
+  const histDir = historySessionDir(sessionId);
+  const sessExists = existsSync3(sessDir);
+  const histExists = existsSync3(histDir);
+  if (!sessExists && !histExists) {
+    throw new Error(`No data found for session ${sessionId}`);
+  }
+  let label = sessionId.slice(0, 8);
+  const stPath = statePath(cwd, sessionId);
+  if (existsSync3(stPath)) {
+    try {
+      const state = JSON.parse(readFileSync3(stPath, "utf-8"));
+      if (state.name) {
+        label = sanitizeName(state.name);
+      }
+    } catch {
+    }
+  }
+  const dir = options?.outputDir ?? join3(homedir(), "Downloads");
+  const outputPath = buildOutputPath(label, dir);
+  const tmpDir = `/tmp/sisyphus-export-${sessionId.slice(0, 8)}-${Date.now()}`;
+  try {
+    mkdirSync3(tmpDir, { recursive: true });
+    writeFileSync3(join3(tmpDir, "CLAUDE.md"), generateGuide(), "utf-8");
+    if (sessExists) {
+      symlinkSync(sessDir, join3(tmpDir, "session"));
+    }
+    if (histExists) {
+      symlinkSync(histDir, join3(tmpDir, "history"));
+    }
+    const parts = ["CLAUDE.md", sessExists ? "session/" : "", histExists ? "history/" : ""].filter(Boolean);
+    await execFileAsync("zip", ["-rq", outputPath, ...parts], { cwd: tmpDir });
+  } finally {
+    rmSync(tmpDir, { recursive: true, force: true });
+  }
+  if (reveal) {
+    try {
+      await execFileAsync("open", ["-R", outputPath]);
+    } catch {
+    }
+  }
+  return outputPath;
+}
+
+// src/shared/format.ts
+function formatDuration(startOrMs, endIso) {
+  let totalMs;
+  if (typeof startOrMs === "number") {
+    totalMs = startOrMs;
+  } else {
+    const start = new Date(startOrMs).getTime();
+    const end = endIso ? new Date(endIso).getTime() : Date.now();
+    totalMs = end - start;
+  }
+  const totalSeconds = Math.floor(totalMs / 1e3);
+  if (totalSeconds < 0) return "0s";
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) return `${hours}h${minutes}m`;
+  if (minutes > 0) return `${minutes}m${seconds}s`;
+  return `${seconds}s`;
+}
+function statusColor(status) {
+  switch (status) {
+    case "active":
+    case "running":
+      return "green";
+    case "completed":
+      return "cyan";
+    case "paused":
+      return "yellow";
+    case "killed":
+    case "crashed":
+      return "red";
+    case "lost":
+      return "gray";
+    default:
+      return "white";
+  }
+}
+
+export {
+  augmentedPath,
+  execEnv,
+  EXEC_ENV,
+  exec,
+  execSafe,
+  callHaiku,
+  callHaikuWithTools,
+  callHaikuStructured,
+  MemoryStoreParseError,
+  ACHIEVEMENTS,
+  sanitizeForDisplay,
+  loadMemoryStrict,
+  buildMemoryContext,
+  loadCompanion,
+  saveCompanion,
+  recordCommentary,
+  recordFeedback,
+  computeStrengthGain,
+  computeLevelProgress,
+  getTitle,
+  computeMood,
+  onSessionStart,
+  computeWisdomGain,
+  onSessionComplete,
+  onAgentSpawned,
+  onAgentCrashed,
+  captureObservationContext,
+  runPostSessionObservations,
+  SPINNER_VERBS,
+  getMoodFace,
+  getMoodTmuxColor,
+  getMoodAnsiCode,
+  renderCompanion,
+  exportSessionToZip,
+  formatDuration,
+  statusColor
+};
+//# sourceMappingURL=chunk-36VJ7ZBD.js.map