sisyphi 1.1.16 → 1.1.18

package/dist/daemon.js

@@ -1,18 +1,21 @@
 #!/usr/bin/env node
 import {
   resolveRequiredPluginDirs
-} from "./chunk-UIVQXCWB.js";
+} from "./chunk-6PJVJEYQ.js";
 import {
   EXEC_ENV,
   exec,
   execEnv,
   execSafe
-} from "./chunk-6TIO23U3.js";
+} from "./chunk-22ZGZTGY.js";
 import {
+  ACHIEVEMENTS,
   loadConfig,
+  renderCompanion,
   shellQuote
-} from "./chunk-IF55HPWX.js";
+} from "./chunk-V36NXMHP.js";
 import {
+  companionPath,
   contextDir,
   cycleLogPath,
   daemonPidPath,
@@ -33,22 +36,23 @@ import {
   snapshotsDir,
   socketPath,
   statePath,
-  strategyPath
-} from "./chunk-GSXF3TCZ.js";
+  strategyPath,
+  tmuxSessionName
+} from "./chunk-TMBAVPHH.js";
 
 // src/daemon/index.ts
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, existsSync as existsSync8 } from "fs";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync9, unlinkSync as unlinkSync3, existsSync as existsSync11 } from "fs";
 import { execSync as execSync4 } from "child_process";
 import { setTimeout as sleep } from "timers/promises";
 
 // src/daemon/server.ts
 import { createServer } from "net";
-import { unlinkSync, existsSync as existsSync7, writeFileSync as writeFileSync5, readFileSync as readFileSync5, mkdirSync as mkdirSync3, rmSync as rmSync3 } from "fs";
-import { join as join5 } from "path";
+import { unlinkSync, existsSync as existsSync10, writeFileSync as writeFileSync7, readFileSync as readFileSync8, mkdirSync as mkdirSync5, rmSync as rmSync3 } from "fs";
+import { join as join8 } from "path";
 
 // src/daemon/session-manager.ts
 import { v4 as uuidv4 } from "uuid";
-import { existsSync as existsSync6, readdirSync as readdirSync5, rmSync as rmSync2 } from "fs";
+import { existsSync as existsSync9, readdirSync as readdirSync5, rmSync as rmSync2 } from "fs";
 
 // src/daemon/state.ts
 import { randomUUID } from "crypto";
@@ -96,6 +100,8 @@ function createSession(id, task, cwd, context, name) {
   if (context) {
     writeFileSync(join(contextDir(cwd, id), "initial-context.md"), context, "utf-8");
   }
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  const created = new Date(createdAt);
   const session = {
     id,
     ...name ? { name } : {},
@@ -103,11 +109,13 @@ function createSession(id, task, cwd, context, name) {
     ...context ? { context } : {},
     cwd,
     status: "active",
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    createdAt,
     activeMs: 0,
     agents: [],
     orchestratorCycles: [],
-    messages: []
+    messages: [],
+    startHour: created.getHours(),
+    startDayOfWeek: created.getDay()
   };
   atomicWrite(statePath(cwd, id), JSON.stringify(session, null, 2));
   return session;
@@ -224,14 +232,21 @@ async function updateSessionName(cwd, sessionId, name) {
     saveSession(session);
   });
 }
-async function updateSessionTmux(cwd, sessionId, tmuxSessionName, tmuxWindowId) {
+async function updateSessionTmux(cwd, sessionId, tmuxSessionName2, tmuxWindowId) {
   return withSessionLock(sessionId, () => {
     const session = getSession(cwd, sessionId);
-    session.tmuxSessionName = tmuxSessionName;
+    session.tmuxSessionName = tmuxSessionName2;
     session.tmuxWindowId = tmuxWindowId;
     saveSession(session);
   });
 }
+async function updateSession(cwd, sessionId, updates) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    Object.assign(session, updates);
+    saveSession(session);
+  });
+}
 async function drainMessages(cwd, sessionId, count) {
   return withSessionLock(sessionId, () => {
     const session = getSession(cwd, sessionId);
@@ -339,10 +354,10 @@ function deleteSnapshotsAfter(cwd, sessionId, afterCycle) {
 }
 
 // src/daemon/orchestrator.ts
-import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
 import { execSync as execSync2 } from "child_process";
-import { randomUUID as randomUUID3 } from "crypto";
-import { resolve as resolve3, join as join4, relative } from "path";
+import { randomUUID as randomUUID4 } from "crypto";
+import { resolve as resolve3, join as join6, relative } from "path";
 
 // src/daemon/spawn-helpers.ts
 import { writeFileSync as writeFileSync2, existsSync as existsSync2 } from "fs";
@@ -547,10 +562,10 @@ function killPane(paneTarget) {
 function killWindow(windowTarget) {
   execSafe(`tmux kill-window -t "${windowTarget}"`);
 }
-function createSession2(sessionName, windowName, cwd) {
-  exec(`tmux new-session -d -s "${sessionName}" -n "${windowName}" -c ${shellQuote(cwd)}`);
-  const windowId = exec(`tmux display-message -t "${sessionName}:${windowName}" -p "#{window_id}"`);
-  const initialPaneId = exec(`tmux display-message -t "${sessionName}:${windowName}" -p "#{pane_id}"`);
+function createSession2(sessionName, cwd) {
+  exec(`tmux new-session -d -s "${sessionName}" -n main -c ${shellQuote(cwd)}`);
+  const windowId = exec(`tmux display-message -t "${sessionName}:main" -p "#{window_id}"`);
+  const initialPaneId = exec(`tmux display-message -t "${sessionName}:main" -p "#{pane_id}"`);
   configureSessionDefaults(sessionName, windowId);
   return { windowId, initialPaneId };
 }
@@ -574,7 +589,7 @@ function findHomeSession(cwd) {
   if (!output) return null;
   const normalizedCwd = cwd.replace(/\/+$/, "");
   for (const name of output.split("\n").filter(Boolean)) {
-    if (name.startsWith("sisyphus-")) continue;
+    if (name.startsWith("ssyph_")) continue;
     const val = execSafe(`tmux show-options -t "${name}" -v @sisyphus_cwd`);
     if (val?.trim() === normalizedCwd) return name;
   }
@@ -632,6 +647,35 @@ function updatePaneMeta(paneTarget, updates) {
 function selectLayout(windowTarget, layout = "even-horizontal") {
   execSafe(`tmux select-layout -t "${windowTarget}" ${layout}`);
 }
+function setWindowOption(windowTarget, option, value) {
+  execSafe(`tmux set-option -w -t "${windowTarget}" ${option} ${shellQuote(value)}`);
+}
+function getSessionOption(sessionName, option) {
+  return execSafe(`tmux show-options -t "${sessionName}" -v ${option}`);
+}
+function getGlobalOption(option) {
+  try {
+    return execSafe(`tmux show-option -gv ${option}`)?.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function setGlobalOption(option, value) {
+  execSafe(`tmux set-option -g ${option} ${shellQuote(value)}`);
+}
+function listAllSessions() {
+  const output = execSafe('tmux list-sessions -F "#{session_name}"');
+  if (!output) return [];
+  return output.split("\n").filter(Boolean);
+}
+function listAllPanes() {
+  const output = execSafe('tmux list-panes -a -F "#{session_name} #{pane_id}"');
+  if (!output) return [];
+  return output.split("\n").filter(Boolean).map((line) => {
+    const spaceIdx = line.indexOf(" ");
+    return { sessionName: line.slice(0, spaceIdx), paneId: line.slice(spaceIdx + 1) };
+  });
+}
 function configureSessionDefaults(sessionName, windowId) {
   execSafe(`tmux set -w -t "${windowId}" pane-border-status top`);
   execSafe(`tmux set -w -t "${windowId}" allow-rename off`);
@@ -682,17 +726,15 @@ import { execSync } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
 import { resolve as resolve2, dirname as dirname2, join as join3 } from "path";
 
-// src/daemon/summarize.ts
+// src/daemon/haiku.ts
 import { query } from "@r-cli/sdk";
 var COOLDOWN_MS = 5 * 60 * 1e3;
 var disabledUntil = 0;
-async function generateSessionName(task) {
+async function callHaiku(prompt) {
   if (Date.now() < disabledUntil) return null;
   try {
     const session = await query({
-      prompt: `Generate a 2-4 word kebab-case name for this task. Output ONLY the name.
-
-${task.slice(0, 500)}`,
+      prompt,
       options: {
         model: "haiku",
         maxTurns: 1,
@@ -707,11 +749,9 @@ ${task.slice(0, 500)}`,
         }
       }
     }
-    const name = text.trim().toLowerCase();
-    if (!name || !/^[a-zA-Z0-9_-]+$/.test(name)) return null;
-    return name.slice(0, 30);
+    return text.trim() || null;
   } catch (err) {
-    console.error(`[sisyphus] Haiku name generation failed: ${err instanceof Error ? err.message : err}`);
+    console.error(`[sisyphus] Haiku call failed: ${err instanceof Error ? err.message : err}`);
     const status = err.status;
     if (status === 401 || status === 403) {
       disabledUntil = Date.now() + COOLDOWN_MS;
@@ -719,37 +759,27 @@ ${task.slice(0, 500)}`,
     return null;
   }
 }
+
+// src/daemon/summarize.ts
+async function generateSessionName(task) {
+  const text = await callHaiku(
+    `Generate a 2-4 word kebab-case name for this task. Output ONLY the name.
+
+${task.slice(0, 500)}`
+  );
+  if (!text) return null;
+  const name = text.toLowerCase();
+  if (!/^[a-zA-Z0-9_-]+$/.test(name)) return null;
+  return name.slice(0, 30);
+}
 async function summarizeReport(reportText) {
-  if (Date.now() < disabledUntil) return null;
-  try {
-    const session = await query({
-      prompt: `Summarize this agent work report in one concise sentence (max 120 chars). Focus on what was accomplished and the outcome. Output ONLY the summary sentence, nothing else.
+  const text = await callHaiku(
+    `Summarize this agent work report in one concise sentence (max 120 chars). Focus on what was accomplished and the outcome. Output ONLY the summary sentence, nothing else.
 
-${reportText.slice(0, 3e3)}`,
-      options: {
-        model: "haiku",
-        maxTurns: 1,
-        env: execEnv()
-      }
-    });
-    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;
-        }
-      }
-    }
-    const summary = text.trim();
-    return summary.length > 0 ? summary : null;
-  } catch (err) {
-    console.error(`[sisyphus] Haiku summarization failed: ${err instanceof Error ? err.message : err}`);
-    const status = err.status;
-    if (status === 401 || status === 403) {
-      disabledUntil = Date.now() + COOLDOWN_MS;
-    }
-    return null;
-  }
+${reportText.slice(0, 3e3)}`
+  );
+  if (!text) return null;
+  return text.length > 0 ? text : null;
 }
 
 // src/daemon/agent.ts
@@ -860,6 +890,7 @@ function setupAgentPane(opts) {
   ]);
   const notifyCmd = buildNotifyCmd(paneId);
   let mainCmd;
+  let resumeArgs;
   if (provider === "openai") {
     const codexPromptPath = `${promptsDir(cwd, sessionId)}/${agentId}-codex-prompt.md`;
     const parts = [];
@@ -880,6 +911,7 @@ ${instruction}`);
     const extraPluginFlags = requiredPluginDirs.map((p) => `--plugin-dir "${p}"`).join(" ");
     const sessionIdFlag = claudeSessionId ? ` --session-id "${claudeSessionId}"` : "";
     mainCmd = `claude --dangerously-skip-permissions --effort ${effort} --plugin-dir "${pluginPath}"${agentFlag}${sessionIdFlag}${extraPluginFlags ? ` ${extraPluginFlags}` : ""} --name ${shellQuote(agentTitle)} --append-system-prompt "$(cat '${suffixFilePath}')" ${shellQuote(instruction)}`;
+    resumeArgs = `--dangerously-skip-permissions --effort ${effort} --plugin-dir "${pluginPath}"${agentFlag}${extraPluginFlags ? ` ${extraPluginFlags}` : ""}`;
   }
   const scriptPath = writeRunScript(promptsDir(cwd, sessionId), `${agentId}-run`, [
     "#!/usr/bin/env bash",
@@ -889,7 +921,7 @@ ${instruction}`);
     notifyCmd
   ]);
   const fullCmd = `bash '${scriptPath}'`;
-  return { paneId, fullCmd };
+  return { paneId, fullCmd, resumeEnv: envExports, resumeArgs };
 }
 async function spawnAgent(opts) {
   const { sessionId, cwd, agentType, name, instruction, windowId } = opts;
@@ -910,7 +942,7 @@ async function spawnAgent(opts) {
   const repoRoot = repo === "." ? cwd : join3(cwd, repo);
   const paneCwd = repoRoot;
   const claudeSessionId = provider !== "openai" ? randomUUID2() : void 0;
-  const { paneId, fullCmd } = setupAgentPane({
+  const { paneId, fullCmd, resumeEnv, resumeArgs } = setupAgentPane({
     sessionId,
     sessionName: opts.sessionName,
     cycleNum: opts.cycleNum,
@@ -940,7 +972,9 @@ async function spawnAgent(opts) {
     activeMs: 0,
     reports: [],
     paneId,
-    repo
+    repo,
+    resumeEnv,
+    resumeArgs
   };
   await addAgent(cwd, sessionId, agent);
   sendKeys(paneId, fullCmd);
@@ -1091,11 +1125,973 @@ function allAgentsDone(session) {
 // src/daemon/respawn-guard.ts
 var respawningSessions = /* @__PURE__ */ new Set();
 
+// src/daemon/companion.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync4 } from "fs";
+import { randomUUID as randomUUID3 } from "crypto";
+import { dirname as dirname3, join as join4 } from "path";
+function loadCompanion() {
+  const path = companionPath();
+  if (!existsSync5(path)) {
+    const state2 = createDefaultCompanion();
+    saveCompanion(state2);
+    return state2;
+  }
+  const raw = readFileSync4(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;
+  return state;
+}
+function saveCompanion(state) {
+  const path = companionPath();
+  const dir = dirname3(path);
+  mkdirSync3(dir, { recursive: true });
+  const tmp = join4(dir, `.companion.${randomUUID3()}.tmp`);
+  writeFileSync4(tmp, JSON.stringify(state, null, 2), "utf-8");
+  renameSync2(tmp, path);
+}
+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,
+    sessionsCompleted: 0,
+    sessionsCrashed: 0,
+    totalActiveMs: 0,
+    lifetimeAgentsSpawned: 0,
+    consecutiveCleanSessions: 0,
+    consecutiveEfficientSessions: 0,
+    consecutiveDaysActive: 0,
+    lastActiveDate: null,
+    taskHistory: {},
+    dailyRepos: {},
+    recentCompletions: []
+  };
+}
+function computeXP(stats) {
+  const strengthXP = stats.strength * 80;
+  const enduranceXP = stats.endurance / 36e5 * 15;
+  const wisdomXP = stats.wisdom * 40;
+  const patienceXP = stats.patience * 5;
+  return Math.floor(strengthXP + enduranceXP + wisdomXP + patienceXP);
+}
+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;
+}
+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;
+  if (signals.justCompleted) scores.happy += 50;
+  scores.happy += signals.cleanStreak * 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 && signals.sessionLengthMs < 9e5) scores.happy += 12;
+  if (signals.sessionLengthMs > 12e5) scores.grinding += 12;
+  if (signals.sessionLengthMs > 36e5) scores.grinding += 15;
+  if (signals.sessionLengthMs > 72e5) scores.grinding += 8;
+  if ((signals.activeAgentCount ?? 0) >= 3) scores.grinding += 10;
+  if (cycleCount >= 3) scores.grinding += 8;
+  scores.frustrated += signals.recentCrashes * 30;
+  if (signals.justCrashed) scores.frustrated += 45;
+  if (signals.sessionLengthMs > 108e5) scores.frustrated += 15;
+  if (cycleCount >= 8) scores.frustrated += 10;
+  if (signals.idleDurationMs >= 18e4 && signals.idleDurationMs < 6e5) scores.frustrated += 8;
+  if (companion.stats.patience > 30) scores.zen += 15;
+  if (signals.idleDurationMs > 12e4 && signals.idleDurationMs <= 9e5) scores.zen += 25;
+  if (signals.cleanStreak > 1) scores.zen += 12;
+  if (signals.sessionLengthMs > 0 && signals.sessionLengthMs < 12e5 && signals.recentCrashes === 0) scores.zen += 15;
+  if (signals.hourOfDay >= 6 && signals.hourOfDay < 10 && (signals.activeAgentCount ?? 0) === 0) 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 (signals.justLeveledUp) scores.excited += 60;
+  if (signals.justCompleted && (session?.agents.length ?? 0) >= 5) scores.excited += 30;
+  if ((signals.activeAgentCount ?? 0) >= 4) scores.excited += 20;
+  if (signals.sessionLengthMs > 0 && signals.sessionLengthMs < 6e5) scores.excited += 15;
+  if ((signals.activeAgentCount ?? 0) >= 6) scores.excited += 15;
+  if (signals.justCompleted && signals.sessionLengthMs < 12e5) 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;
+  }
+  if (companion.sessionsCompleted > 15) scores.existential += 8;
+  if (sessionsCompletedToday >= 4) scores.existential += 5;
+  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"),
+  "iron-will": (c) => c.consecutiveEfficientSessions >= 10,
+  "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 ts2 of c.recentCompletions) {
+      const date = ts2.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;
+}
+function updateRepoMemory(companion, repoPath, event) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  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: 0,
+      moodAvg: 0,
+      nickname: null,
+      firstSeen: now,
+      lastSeen: now
+    };
+  } else {
+    if (event === "visit") existing.visits++;
+    if (event === "completion") existing.completions++;
+    if (event === "crash") existing.crashes++;
+    existing.lastSeen = now;
+  }
+  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 isEfficientSession(session) {
+  const completed = session.agents.filter((a) => a.status === "completed" && a.activeMs > 0);
+  if (completed.length < 2) return false;
+  const times = completed.map((a) => a.activeMs);
+  const mean = times.reduce((a, b) => a + b, 0) / times.length;
+  const variance = times.reduce((acc, t) => acc + Math.pow(t - mean, 2), 0) / times.length;
+  const stddev = Math.sqrt(variance);
+  return stddev < mean * 0.3;
+}
+function onSessionComplete(companion, session) {
+  companion.sessionsCompleted++;
+  companion.totalActiveMs += session.activeMs;
+  companion.stats.endurance += session.activeMs;
+  companion.stats.strength++;
+  const cycleCount = session.orchestratorCycles?.length ?? 0;
+  companion.stats.patience += cycleCount;
+  const modes = new Set((session.orchestratorCycles ?? []).map((c) => c.mode));
+  if (modes.has("validation")) companion.stats.patience += 3;
+  if (modes.has("completion")) companion.stats.patience += 2;
+  if (isEfficientSession(session)) {
+    companion.stats.wisdom++;
+  }
+  updateRepoMemory(companion, session.cwd, "completion");
+  if (cycleCount <= 3) {
+    companion.consecutiveEfficientSessions++;
+  } else {
+    companion.consecutiveEfficientSessions = 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 > 10) {
+    companion.recentCompletions = companion.recentCompletions.slice(-10);
+  }
+  const taskKey = normalizeTask(session.task, session.cwd);
+  companion.taskHistory[taskKey] = (companion.taskHistory[taskKey] ?? 0) + 1;
+  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}`;
+}
+
+// src/daemon/companion-commentary.ts
+import { basename as basename2 } from "path";
+function timeOfDayModifier() {
+  const hour = (/* @__PURE__ */ new Date()).getHours();
+  if (hour >= 6 && hour < 10) return "Chipper, energetic, brief";
+  if (hour >= 10 && hour < 17) return "Professional, focused";
+  if (hour >= 17 && hour < 22) return "Reflective, slightly philosophical";
+  if (hour >= 22 || hour < 2) return "Dry humor, existential asides";
+  return "Delirious, absurdist, dramatic";
+}
+function shouldGenerateCommentary(event) {
+  switch (event) {
+    case "session-start":
+    case "session-complete":
+    case "level-up":
+    case "achievement":
+    case "late-night":
+      return true;
+    case "cycle-boundary":
+    case "idle-wake":
+      return Math.random() < 0.5;
+    case "agent-crash":
+      return Math.random() < 0.3;
+  }
+}
+function nicknameStyleGuide(companion) {
+  const { mood, stats, level } = companion;
+  if (level >= 15) return "legendary names (Prometheus, Orpheus, Icarus)";
+  if (mood === "happy" && stats.wisdom > 7) return "mythological names (Atlas, Hermes, Arachne)";
+  if (mood === "frustrated" && stats.patience < 4) return "blunt functional names (Fix-It, Patch, Leftovers)";
+  if (mood === "zen" && stats.patience > 7) return "nature names (River, Stone, Cedar, Moss)";
+  if (mood === "excited" && stats.strength > 7) return "heroic names (Vanguard, Striker, Apex)";
+  if (mood === "existential") return "abstract names (Echo, Void, Loop, Why)";
+  if (mood === "grinding" && stats.endurance > 7) return "workhorse names (Steady, Grind, Anvil, Ox)";
+  if (mood === "sleepy") return "drowsy names (Mumble, Blink, Yawn, Doze)";
+  return "short punchy names fitting the creature's current state";
+}
+async function generateCommentary(event, companion, context) {
+  if (!shouldGenerateCommentary(event)) return null;
+  const { mood, level, title, stats } = companion;
+  const timeModifier = timeOfDayModifier();
+  const prompt = `You are a small ASCII creature who pushes boulders for a living. You are self-aware about your Sisyphean condition but mostly at peace with it. You speak in 1-2 short sentences. Your voice is shaped by your mood and stats. High wisdom: insightful. Low patience: impatient and blunt. Existential mood: philosophical non-sequiturs. Never break character. Never use emojis.
+
+Current state:
+- Mood: ${mood}
+- Level: ${level} (${title})
+- Strength: ${stats.strength}, Endurance: ${stats.endurance}, Wisdom: ${stats.wisdom}, Patience: ${stats.patience}
+
+Tone for this time of day: ${timeModifier}
+
+Event: ${event}${context ? `
+Context: ${context}` : ""}
+
+Respond with 1-2 sentences only. No quotes around the text.`;
+  const raw = await callHaiku(prompt);
+  if (!raw) return null;
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  return trimmed;
+}
+async function generateNickname(companion) {
+  const { mood, stats, level } = companion;
+  const styleGuide = nicknameStyleGuide(companion);
+  const prompt = `An ASCII creature needs a nickname. Here is its current profile:
+- Mood: ${mood}
+- Level: ${level}
+- Strength: ${stats.strength}, Endurance: ${stats.endurance}, Wisdom: ${stats.wisdom}, Patience: ${stats.patience}
+
+Naming style: ${styleGuide}
+
+Generate a single agent nickname. One word only. No quotes, no explanation.`;
+  const raw = await callHaiku(prompt);
+  if (!raw) return null;
+  const word = raw.trim().split(/\s+/)[0];
+  if (!word) return null;
+  return word.length > 20 ? word.slice(0, 20) : word;
+}
+
+// src/daemon/status-bar.ts
+import { readFileSync as readFileSync6, existsSync as existsSync6 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join5 } from "path";
+
+// src/daemon/status-dots.ts
+import { readFileSync as readFileSync5 } from "fs";
+var CLAUDE_STATE_DIR = "/tmp/claude-tmux-state";
+var DOT_MAP = {
+  "orchestrator:processing": { icon: "\u25CF", color: "#d4ad6a" },
+  // yellow — orchestrator thinking
+  "orchestrator:idle": { icon: "\u25CF", color: "#d47766" },
+  // red — needs your input
+  "agents:running": { icon: "\u25C6", color: "#d4ad6a" },
+  // yellow diamond — agents working
+  "between-cycles": { icon: "\u25C6", color: "#5e584e" },
+  // dim diamond — respawning
+  "paused": { icon: "\u25CB", color: "#d47766" },
+  // red hollow — stuck
+  "completed": { icon: "\u25CF", color: "#a9b16e" }
+  // green — done
+};
+function renderDots(dots) {
+  const sorted = [...dots].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  return sorted.map((d) => {
+    const { icon, color } = DOT_MAP[d.phase];
+    return `#[fg=${color}]${icon}`;
+  }).join("");
+}
+function readClaudeState(paneId) {
+  const numericId = paneId.replace("%", "");
+  try {
+    const content = readFileSync5(`${CLAUDE_STATE_DIR}/${numericId}`, "utf-8").trim();
+    if (content === "idle" || content === "processing" || content === "stopped") {
+      return content;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function detectPhase(session, orchPaneId, livePaneIds) {
+  if (session.status === "completed") return "completed";
+  if (session.status === "paused") return "paused";
+  if (respawningSessions.has(session.id)) return "between-cycles";
+  const orchAlive = orchPaneId != null && livePaneIds.has(orchPaneId);
+  const hasRunningAgents = session.agents.some((a) => a.status === "running");
+  if (orchAlive) {
+    const claudeState = readClaudeState(orchPaneId);
+    if (claudeState === "idle" || claudeState === "stopped") {
+      return "orchestrator:idle";
+    }
+    return "orchestrator:processing";
+  }
+  if (hasRunningAgents) return "agents:running";
+  return "between-cycles";
+}
+var sisyphusPhases = /* @__PURE__ */ new Map();
+function getSisyphusPhases() {
+  return sisyphusPhases;
+}
+var totalRunningAgents = 0;
+function getTotalRunningAgents() {
+  return totalRunningAgents;
+}
+var getTrackedEntries = null;
+function setTrackedEntriesProvider(provider) {
+  getTrackedEntries = provider;
+}
+var COMPLETED_TTL_MS = 5 * 60 * 1e3;
+var completedSessions = /* @__PURE__ */ new Map();
+function markSessionCompleted(sessionId, createdAt, cwd) {
+  completedSessions.set(sessionId, {
+    createdAt,
+    cwd,
+    expireAt: Date.now() + COMPLETED_TTL_MS
+  });
+}
+function pruneCompleted() {
+  const now = Date.now();
+  for (const [id, entry] of completedSessions) {
+    if (entry.expireAt < now) completedSessions.delete(id);
+  }
+}
+var dashboardWindowCache = /* @__PURE__ */ new Map();
+var CACHE_TTL_MS = 3e4;
+function getDashboardWindowId(cwd) {
+  const now = Date.now();
+  const cached = dashboardWindowCache.get(cwd);
+  if (cached && now - cached.checkedAt < CACHE_TTL_MS) {
+    return cached.windowId;
+  }
+  const homeSession = findHomeSession(cwd);
+  if (!homeSession) return null;
+  const windowId = getSessionOption(homeSession, "@sisyphus_dashboard");
+  if (!windowId) return null;
+  dashboardWindowCache.set(cwd, { windowId, checkedAt: now });
+  return windowId;
+}
+function recomputeDots() {
+  if (!getTrackedEntries) return;
+  pruneCompleted();
+  sisyphusPhases.clear();
+  totalRunningAgents = 0;
+  const byCwd = /* @__PURE__ */ new Map();
+  for (const entry of getTrackedEntries()) {
+    if (!entry.windowId) continue;
+    let group = byCwd.get(entry.cwd);
+    if (!group) {
+      group = [];
+      byCwd.set(entry.cwd, group);
+    }
+    group.push({ sessionId: entry.id, windowId: entry.windowId });
+  }
+  for (const [sessionId, entry] of completedSessions) {
+    if (!byCwd.has(entry.cwd)) {
+      byCwd.set(entry.cwd, []);
+    }
+  }
+  const tmuxSessionMap = /* @__PURE__ */ new Map();
+  for (const entry of getTrackedEntries()) {
+    tmuxSessionMap.set(entry.id, entry.tmuxSession);
+  }
+  for (const [cwd, tracked] of byCwd) {
+    const dots = [];
+    const seenIds = /* @__PURE__ */ new Set();
+    for (const { sessionId, windowId } of tracked) {
+      seenIds.add(sessionId);
+      try {
+        const session = getSession(cwd, sessionId);
+        totalRunningAgents += session.agents.filter((a) => a.status === "running").length;
+        const orchPaneId = getOrchestratorPaneId(sessionId);
+        const livePanes = listPanes(windowId);
+        const livePaneIds = new Set(livePanes.map((p) => p.paneId));
+        const phase = detectPhase(session, orchPaneId, livePaneIds);
+        dots.push({ phase, createdAt: session.createdAt });
+        const tmuxSessionName2 = tmuxSessionMap.get(sessionId);
+        if (tmuxSessionName2) {
+          setSessionOption(tmuxSessionName2, "@sisyphus_phase", phase);
+          sisyphusPhases.set(sessionId, { phase, tmuxSession: tmuxSessionName2 });
+        }
+      } catch {
+      }
+    }
+    for (const [sessionId, entry] of completedSessions) {
+      if (entry.cwd !== cwd || seenIds.has(sessionId)) continue;
+      dots.push({ phase: "completed", createdAt: entry.createdAt });
+    }
+    const dashboardWindowId = getDashboardWindowId(cwd);
+    if (dashboardWindowId) {
+      const rendered = dots.length > 0 ? " " + renderDots(dots) : "";
+      setWindowOption(dashboardWindowId, "@sisyphus_dots", rendered);
+    }
+  }
+}
+
+// src/daemon/status-bar.ts
+var flashUntil = 0;
+var flashText = "";
+var cachedCompanion = null;
+var companionCacheTime = 0;
+var COMPANION_CACHE_TTL = 1e4;
+function getCachedCompanion() {
+  const now = Date.now();
+  if (!cachedCompanion || now - companionCacheTime > COMPANION_CACHE_TTL) {
+    cachedCompanion = loadCompanion();
+    companionCacheTime = now;
+  }
+  return cachedCompanion;
+}
+function flashCompanion(text, durationMs = 1e4) {
+  flashText = text;
+  flashUntil = Date.now() + durationMs;
+}
+var SESSION_ORDER_PATH = join5(homedir2(), ".config", "tmux", "session-order");
+var STATE_PRIORITY = {
+  processing: 3,
+  stopped: 2,
+  idle: 1
+};
+var STATE_COLORS = {
+  processing: "#d4ad6a",
+  stopped: "#d47766",
+  idle: "#5e584e",
+  none: "#5e584e"
+};
+var sessionOrderCache = null;
+var sessionOrderCacheTime = 0;
+var SESSION_ORDER_CACHE_TTL = 3e4;
+function getSessionOrder() {
+  const now = Date.now();
+  if (sessionOrderCache && now - sessionOrderCacheTime < SESSION_ORDER_CACHE_TTL) {
+    return sessionOrderCache;
+  }
+  try {
+    if (existsSync6(SESSION_ORDER_PATH)) {
+      sessionOrderCache = readFileSync6(SESSION_ORDER_PATH, "utf-8").split("\n").filter(Boolean);
+    } else {
+      sessionOrderCache = [];
+    }
+  } catch {
+    sessionOrderCache = [];
+  }
+  sessionOrderCacheTime = now;
+  return sessionOrderCache;
+}
+function orderSessions(sessions, order) {
+  if (order.length === 0) return sessions.sort();
+  const orderMap = new Map(order.map((name, idx) => [name, idx]));
+  return [...sessions].sort((a, b) => {
+    const aIdx = orderMap.get(a) ?? Infinity;
+    const bIdx = orderMap.get(b) ?? Infinity;
+    if (aIdx !== bIdx) return aIdx - bIdx;
+    return a.localeCompare(b);
+  });
+}
+var SESSIONS_BG = "#252629";
+var SISYPHUS_BG = "#36383e";
+var COMPANION_BG = "#4a4d55";
+var ACTIVE_SESSION_BG = "#3d3225";
+var ACTIVE_TEXT = "#e2d9c6";
+var INACTIVE_TEXT = "#b0a898";
+var WINDOW_TAB_BG = "#2d2f33";
+var WINDOW_TAB_ACTIVE_BG = "#4a4d55";
+var STATUS_LEFT_BG = "#1d1e21";
+function windowTabFormat(bg, text, active = false) {
+  const nextWindowIsActive = "#{e|==:#{active_window_index},#{e|+|:#{window_index},1}}";
+  const rightArrow = active ? `#[fg=${bg}]#[bg=#{?window_end_flag,${STATUS_LEFT_BG},${WINDOW_TAB_BG}}]\uE0B0` : `#{?window_end_flag,#[fg=${bg}]#[bg=${STATUS_LEFT_BG}]\uE0B0,#{?${nextWindowIsActive},#[fg=${bg}]#[bg=${WINDOW_TAB_ACTIVE_BG}]\uE0B0,#[fg=${bg}]#[bg=${bg}]\uE0B0}}`;
+  const name = active ? `#[fg=${text}]#[bg=${bg}]#[bold] #W#(~/.tmux/claude-status.sh '#{window_id}')#{@sisyphus_dots} #[nobold]` : `#[fg=${text}]#[bg=${bg}] #W#(~/.tmux/claude-status.sh '#{window_id}')#{@sisyphus_dots} `;
+  return `${name}${rightArrow}`;
+}
+function renderNormalSession(name, state, sectionBg) {
+  const color = STATE_COLORS[state];
+  const active = `#[bg=${ACTIVE_SESSION_BG}]#[fg=${color}] \u25CF #[fg=${ACTIVE_TEXT}]#[bold]${name}#[nobold] #[bg=${sectionBg}]`;
+  const inactive = `#[fg=${color}] \u25CF #[fg=${INACTIVE_TEXT}]${name} `;
+  return `#{?#{==:#{session_name},${name}},${active},${inactive}}`;
+}
+function renderSisyphusSession(tmuxName, phase, sectionBg) {
+  const { icon, color } = DOT_MAP[phase];
+  const active = `#[bg=${ACTIVE_SESSION_BG}]#[fg=${color}] ${icon} #[fg=${ACTIVE_TEXT}]#[bold]S#[nobold] #[bg=${sectionBg}]`;
+  const inactive = `#[fg=${color}] ${icon} #[fg=${INACTIVE_TEXT}]S `;
+  return `#{?#{==:#{session_name},${tmuxName}},${active},${inactive}}`;
+}
+function renderSessionArrow(name, leftNeighborName, leftBg, sectionBg) {
+  const active = `#[fg=${ACTIVE_SESSION_BG}]#[bg=${leftBg}]\uE0B2#[bg=${sectionBg}]`;
+  const afterActive = leftNeighborName ? `#[fg=${sectionBg}]#[bg=${ACTIVE_SESSION_BG}]\uE0B2#[bg=${sectionBg}]` : `#[fg=${sectionBg}]#[bg=${leftBg}]\uE0B2#[bg=${sectionBg}]`;
+  if (!leftNeighborName) {
+    return `#{?#{==:#{session_name},${name}},${active},${afterActive}}`;
+  }
+  return `#{?#{==:#{session_name},${name}},${active},#{?#{==:#{session_name},${leftNeighborName}},${afterActive},#[fg=${sectionBg}]#[bg=${leftBg}]\uE0B2#[bg=${sectionBg}]}}`;
+}
+function renderSessionBand(parts, sectionBg, prevBg) {
+  if (parts.length === 0) return { content: "", trailingName: null };
+  let band = "";
+  for (let i = 0; i < parts.length; i += 1) {
+    const part = parts[i];
+    const leftNeighbor = i > 0 ? parts[i - 1].name : null;
+    const leftBg = i > 0 ? sectionBg : prevBg;
+    band += renderSessionArrow(part.name, leftNeighbor, leftBg, sectionBg);
+    band += part.rendered;
+  }
+  return { content: band, trailingName: parts[parts.length - 1].name };
+}
+function renderSectionBoundary(targetBg, prevBg, trailingName) {
+  const inactive = `#[fg=${targetBg}]#[bg=${prevBg}]\uE0B2#[bg=${targetBg}]`;
+  if (!trailingName) return inactive;
+  const active = `#[fg=${targetBg}]#[bg=${ACTIVE_SESSION_BG}]\uE0B2#[bg=${targetBg}]`;
+  return `#{?#{==:#{session_name},${trailingName}},${active},${inactive}}`;
+}
+var SISYPHUS_STATUS_REF = "#{E:@sisyphus_status}";
+var statusIntegrated = false;
+function ensureStatusRightIntegration() {
+  if (statusIntegrated) return;
+  statusIntegrated = true;
+  try {
+    setGlobalOption("window-status-separator", "");
+    setGlobalOption("window-status-format", windowTabFormat(WINDOW_TAB_BG, INACTIVE_TEXT));
+    setGlobalOption("window-status-current-format", windowTabFormat(WINDOW_TAB_ACTIVE_BG, ACTIVE_TEXT, true));
+  } catch {
+  }
+  try {
+    const left = getGlobalOption("status-left");
+    if (left?.includes("@sisyphus_status")) {
+      setGlobalOption("status-left", left.replace(/\s*#\{E:@sisyphus_status\}/g, "").trim());
+    }
+  } catch {
+  }
+  try {
+    const current = getGlobalOption("status-right");
+    if (!current) return;
+    let updated = current.replace(/#\{E:@sisyphus_status\}\s+#\[fg=/, `${SISYPHUS_STATUS_REF}#[fg=`).replace(/#\{E:@sisyphus_status\}\s+$/, SISYPHUS_STATUS_REF);
+    if (!updated.includes("@sisyphus_status")) {
+      updated = updated.replace(/#\[fg=/, `${SISYPHUS_STATUS_REF}#[fg=`);
+      if (updated === current) updated = SISYPHUS_STATUS_REF + current;
+    }
+    if (updated === current) return;
+    setGlobalOption("status-right", updated);
+    try {
+      const lengthStr = getGlobalOption("status-right-length");
+      const length = parseInt(lengthStr ?? "120", 10);
+      if (length < 250) {
+        setGlobalOption("status-right-length", "250");
+      }
+    } catch {
+    }
+  } catch {
+  }
+}
+function writeStatusBar() {
+  ensureStatusRightIntegration();
+  const now = Date.now();
+  if (now < flashUntil) {
+    let rendered2 = "";
+    try {
+      const companion = getCachedCompanion();
+      const facePart = renderCompanion(companion, ["face", "boulder"], {
+        tmuxFormat: true,
+        agentCount: getTotalRunningAgents()
+      });
+      const commentary = flashText || companion.lastCommentary?.text || "";
+      rendered2 = `#[fg=${COMPANION_BG}]#[bg=default]\uE0B2#[bg=${COMPANION_BG}] ${facePart} #[fg=${INACTIVE_TEXT}] ${commentary}#[default]`;
+    } catch {
+    }
+    setGlobalOption("@sisyphus_status", rendered2);
+    return;
+  }
+  if (flashUntil !== 0) {
+    flashText = "";
+    flashUntil = 0;
+  }
+  const allPanes = listAllPanes();
+  const allSessions = listAllSessions();
+  if (allSessions.length === 0) return;
+  const sessionStates = /* @__PURE__ */ new Map();
+  for (const { sessionName, paneId } of allPanes) {
+    const state = readClaudeState(paneId);
+    if (!state) continue;
+    const current = sessionStates.get(sessionName);
+    if (!current || STATE_PRIORITY[state] > STATE_PRIORITY[current]) {
+      sessionStates.set(sessionName, state);
+    }
+  }
+  const phases = getSisyphusPhases();
+  const tmuxToPhase = /* @__PURE__ */ new Map();
+  for (const { tmuxSession, phase } of phases.values()) {
+    tmuxToPhase.set(tmuxSession, phase);
+  }
+  const normalSessions = [];
+  const sisyphusSessions = [];
+  for (const session of allSessions) {
+    const phase = tmuxToPhase.get(session);
+    if (phase) {
+      sisyphusSessions.push({ tmuxName: session, phase });
+    } else if (!session.startsWith("ssyph_")) {
+      normalSessions.push(session);
+    }
+  }
+  const orderedNormal = orderSessions(normalSessions, getSessionOrder());
+  const normalParts = orderedNormal.map((name) => ({
+    name,
+    rendered: renderNormalSession(name, sessionStates.get(name) ?? "none", SESSIONS_BG)
+  }));
+  const sisyphusParts = sisyphusSessions.map(({ tmuxName, phase }) => ({
+    name: tmuxName,
+    rendered: renderSisyphusSession(tmuxName, phase, SISYPHUS_BG)
+  }));
+  let companionStr = "";
+  try {
+    companionStr = renderCompanion(getCachedCompanion(), ["face", "boulder"], {
+      maxWidth: 20,
+      tmuxFormat: true,
+      agentCount: getTotalRunningAgents()
+    });
+  } catch {
+  }
+  let rendered = "";
+  let prevBg = "default";
+  let trailingSessionName = null;
+  if (normalParts.length > 0) {
+    const band = renderSessionBand(normalParts, SESSIONS_BG, prevBg);
+    rendered += band.content;
+    prevBg = SESSIONS_BG;
+    trailingSessionName = band.trailingName;
+  }
+  if (sisyphusParts.length > 0) {
+    rendered += renderSectionBoundary(SISYPHUS_BG, prevBg, trailingSessionName);
+    const band = renderSessionBand(sisyphusParts, SISYPHUS_BG, SISYPHUS_BG);
+    rendered += band.content;
+    prevBg = SISYPHUS_BG;
+    trailingSessionName = band.trailingName;
+  }
+  if (companionStr) {
+    rendered += renderSectionBoundary(COMPANION_BG, prevBg, trailingSessionName);
+    rendered += ` ${companionStr} `;
+    prevBg = COMPANION_BG;
+  }
+  if (prevBg !== "default") {
+    rendered += "#[default]";
+  }
+  setGlobalOption("@sisyphus_status", rendered);
+}
+
 // src/daemon/pane-monitor.ts
 var monitorInterval = null;
 var onAllAgentsDone = null;
+var onDotsUpdate = null;
 var lastPollTime = 0;
 var storedPollIntervalMs = 5e3;
+var idleStartTime = 0;
+var lastMoodCompute = 0;
+var lastCompletionTime = 0;
+var lastCrashTime = 0;
+var lastLevelUpTime = 0;
+var currentMaxCycleCount = 0;
+var lastLateNightCommentary = 0;
+function markEventCompletion() {
+  lastCompletionTime = Date.now();
+}
+function markEventCrash() {
+  lastCrashTime = Date.now();
+}
+function markEventLevelUp() {
+  lastLevelUpTime = Date.now();
+}
+function updateCycleCount(count) {
+  if (count > currentMaxCycleCount) currentMaxCycleCount = count;
+}
 var activeTimers = /* @__PURE__ */ new Map();
 function initTimers(sessionId, session) {
   const entry = {
@@ -1160,6 +2156,12 @@ function getTrackedSessionIds() {
 function setRespawnCallback(cb) {
   onAllAgentsDone = cb;
 }
+function setDotsCallback(cb) {
+  onDotsUpdate = cb;
+}
+function getTrackedSessionEntries() {
+  return trackedSessions.values();
+}
 function startMonitor(pollIntervalMs = 5e3) {
   if (monitorInterval) return;
   storedPollIntervalMs = pollIntervalMs;
@@ -1195,16 +2197,111 @@ async function pollAllSessions() {
   const threshold = storedPollIntervalMs * 3;
   const increment = elapsed > threshold ? storedPollIntervalMs : elapsed;
   lastPollTime = now;
+  const pollSessionCache = /* @__PURE__ */ new Map();
   for (const { id: sessionId, cwd, windowId } of trackedSessions.values()) {
     if (windowId) {
-      await pollSession(sessionId, cwd, windowId, increment);
+      await pollSession(sessionId, cwd, windowId, increment, pollSessionCache);
     }
   }
+  try {
+    onDotsUpdate?.();
+  } catch {
+  }
+  try {
+    const nowMs = Date.now();
+    const isIdle = trackedSessions.size === 0;
+    if (isIdle && nowMs - lastMoodCompute < 6e4) return;
+    const companion = loadCompanion();
+    let recentCrashes = 0;
+    let sessionLengthMs = 0;
+    let idleDurationMs = 0;
+    let activeAgentCount = 0;
+    const cutoff = nowMs - 30 * 60 * 1e3;
+    for (const { id: sessionId, cwd } of trackedSessions.values()) {
+      try {
+        const s = pollSessionCache.get(sessionId) ?? getSession(cwd, sessionId);
+        if (s.status === "active") {
+          sessionLengthMs = Math.max(sessionLengthMs, s.activeMs);
+          for (const agent of s.agents) {
+            if (agent.status === "crashed" && agent.completedAt && new Date(agent.completedAt).getTime() > cutoff) {
+              recentCrashes++;
+            }
+            if (agent.status === "running") {
+              activeAgentCount++;
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    const timerKeys = [...activeTimers.keys()];
+    if (timerKeys.length === 0) {
+      if (idleStartTime === 0) idleStartTime = nowMs;
+      idleDurationMs = nowMs - idleStartTime;
+    } else {
+      if (idleStartTime > 0) {
+        const idledMs = nowMs - idleStartTime;
+        if (idledMs > 6e4) {
+          generateCommentary("idle-wake", companion, `Idle for ${Math.round(idledMs / 6e4)} minutes`).then((text) => {
+            if (text) {
+              try {
+                const c = loadCompanion();
+                c.lastCommentary = { text, event: "idle-wake", timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+                saveCompanion(c);
+              } catch {
+              }
+            }
+          }).catch(() => {
+          });
+        }
+      }
+      idleStartTime = 0;
+    }
+    const DECAY_WINDOW = 12e4;
+    const signals = {
+      recentCrashes,
+      idleDurationMs,
+      sessionLengthMs,
+      cleanStreak: companion.consecutiveCleanSessions,
+      justCompleted: nowMs - lastCompletionTime < DECAY_WINDOW,
+      justCrashed: nowMs - lastCrashTime < DECAY_WINDOW,
+      justLeveledUp: nowMs - lastLevelUpTime < DECAY_WINDOW,
+      hourOfDay: (/* @__PURE__ */ new Date()).getHours(),
+      activeAgentCount,
+      cycleCount: currentMaxCycleCount,
+      sessionsCompletedToday: companion.recentCompletions.filter((t) => t.startsWith((/* @__PURE__ */ new Date()).toISOString().slice(0, 10))).length
+    };
+    const newMood = computeMood(companion, void 0, signals);
+    if (newMood !== companion.mood) {
+      companion.mood = newMood;
+      companion.moodUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      saveCompanion(companion);
+    }
+    const hour = (/* @__PURE__ */ new Date()).getHours();
+    if (hour >= 2 && hour < 6 && !isIdle && nowMs - lastLateNightCommentary > 30 * 60 * 1e3) {
+      lastLateNightCommentary = nowMs;
+      generateCommentary("late-night", companion).then((text) => {
+        if (text) {
+          try {
+            const c = loadCompanion();
+            c.lastCommentary = { text, event: "late-night", timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+            saveCompanion(c);
+            flashCompanion(text);
+          } catch {
+          }
+        }
+      }).catch(() => {
+      });
+    }
+    lastMoodCompute = nowMs;
+  } catch {
+  }
 }
-async function pollSession(sessionId, cwd, windowId, increment) {
+async function pollSession(sessionId, cwd, windowId, increment, sessionCache) {
   let session;
   try {
     session = getSession(cwd, sessionId);
+    sessionCache?.set(sessionId, session);
   } catch (err) {
     console.error(`[sisyphus] Failed to read state for session ${sessionId}:`, err);
     return;
@@ -1295,7 +2392,7 @@ async function pollSession(sessionId, cwd, windowId, increment) {
 function detectRepos(cwd) {
   const config = loadConfig(cwd);
   const repos = [];
-  if (existsSync5(join4(cwd, ".git"))) {
+  if (existsSync7(join6(cwd, ".git"))) {
     try {
       repos.push(getRepoInfo(cwd, "."));
     } catch {
@@ -1306,8 +2403,8 @@ function detectRepos(cwd) {
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       if (entry.name.startsWith(".")) continue;
-      const childPath = join4(cwd, entry.name);
-      if (existsSync5(join4(childPath, ".git"))) {
+      const childPath = join6(cwd, entry.name);
+      if (existsSync7(join6(childPath, ".git"))) {
         try {
           repos.push(getRepoInfo(childPath, entry.name));
         } catch {
@@ -1349,25 +2446,25 @@ function discoverOrchestratorModes() {
     (f) => f.startsWith("orchestrator-") && f.endsWith(".md") && f !== "orchestrator-base.md"
   );
   return files.map((file) => {
-    const content = readFileSync4(join4(templatesDir, file), "utf-8");
+    const content = readFileSync7(join6(templatesDir, file), "utf-8");
     const fm = parseAgentFrontmatter(content);
     const name = fm.name ?? file.replace(/^orchestrator-/, "").replace(/\.md$/, "");
-    return { name, description: fm.description, filePath: join4(templatesDir, file) };
+    return { name, description: fm.description, filePath: join6(templatesDir, file) };
   });
 }
 function loadOrchestratorPrompt(cwd, sessionId, mode) {
   const projectPath = projectOrchestratorPromptPath(cwd);
-  if (existsSync5(projectPath)) {
-    return readFileSync4(projectPath, "utf-8");
+  if (existsSync7(projectPath)) {
+    return readFileSync7(projectPath, "utf-8");
   }
   const basePath = resolve3(import.meta.dirname, "../templates/orchestrator-base.md");
-  const base = readFileSync4(basePath, "utf-8");
+  const base = readFileSync7(basePath, "utf-8");
   const modes = discoverOrchestratorModes();
   const selected = modes.find((m) => m.name === mode) ?? modes.find((m) => m.name === "strategy");
   if (!selected) {
     throw new Error(`Unknown orchestrator mode '${mode}' and no fallback found. Available: ${modes.map((m) => m.name).join(", ")}`);
   }
-  const modeContent = readFileSync4(selected.filePath, "utf-8");
+  const modeContent = readFileSync7(selected.filePath, "utf-8");
   const modeBody = extractAgentBody(modeContent);
   return base + "\n\n" + modeBody;
 }
@@ -1387,7 +2484,7 @@ ${session.context}
     }
   } else {
     let ctxFiles = [];
-    if (existsSync5(ctxDir)) {
+    if (existsSync7(ctxDir)) {
       ctxFiles = readdirSync4(ctxDir).filter((f) => f !== "CLAUDE.md");
     }
     if (ctxFiles.length > 0) {
@@ -1423,8 +2520,8 @@ ${agentLines}
 `;
   }
   const strategyFile = strategyPath(session.cwd, session.id);
-  const strategyRef = existsSync5(strategyFile) ? `@${relative(session.cwd, strategyFile)}` : "(empty)";
-  const roadmapRef = existsSync5(roadmapFile) ? `@${relative(session.cwd, roadmapFile)}` : "(empty)";
+  const strategyRef = existsSync7(strategyFile) ? `@${relative(session.cwd, strategyFile)}` : "(empty)";
+  const roadmapRef = existsSync7(roadmapFile) ? `@${relative(session.cwd, roadmapFile)}` : "(empty)";
   const repos = detectRepos(session.cwd);
   let repositoriesSection = "\n\n## Repositories\n";
   if (repos.length === 0) {
@@ -1451,7 +2548,7 @@ ${agentLines}
     }
   }
   const goalFile = goalPath(session.cwd, session.id);
-  const goalContent = existsSync5(goalFile) ? readFileSync4(goalFile, "utf-8").trim() : session.task;
+  const goalContent = existsSync7(goalFile) ? readFileSync7(goalFile, "utf-8").trim() : session.task;
   return `## Goal
 
 ${goalContent}
@@ -1499,7 +2596,7 @@ async function spawnOrchestrator(sessionId, cwd, windowId, message) {
   );
   const cycleNum = session.orchestratorCycles.length + 1;
   const promptFilePath = `${promptsDir(cwd, sessionId)}/orchestrator-system-${cycleNum}.md`;
-  writeFileSync4(promptFilePath, systemPrompt, "utf-8");
+  writeFileSync5(promptFilePath, systemPrompt, "utf-8");
   sessionWindowMap.set(sessionId, windowId);
   const npmBinDir = resolveNpmBinDir();
   const envExports = buildEnvExports([
@@ -1526,7 +2623,7 @@ The user resumed this session with new instructions: ${message}`;
 ${continuationText}`;
   }
   const userPromptFilePath = `${promptsDir(cwd, sessionId)}/orchestrator-user-${cycleNum}.md`;
-  writeFileSync4(userPromptFilePath, substituteEnvVars(userPrompt), "utf-8");
+  writeFileSync5(userPromptFilePath, substituteEnvVars(userPrompt), "utf-8");
   if (session.messages && session.messages.length > 0) {
     await drainMessages(cwd, sessionId, session.messages.length);
   }
@@ -1536,7 +2633,7 @@ ${continuationText}`;
   const effort = config.orchestratorEffort ?? "high";
   const requiredPluginDirs = resolveRequiredPluginDirs(cwd);
   const extraPluginFlags = requiredPluginDirs.map((p) => `--plugin-dir "${p}"`).join(" ");
-  const claudeSessionId = randomUUID3();
+  const claudeSessionId = randomUUID4();
   const claudeCmd = `claude --dangerously-skip-permissions --disallowed-tools "Task,Agent" --effort ${effort} --session-id "${claudeSessionId}" --settings "${settingsPath}" --plugin-dir "${pluginPath}"${extraPluginFlags ? ` ${extraPluginFlags}` : ""} --name "ssph:orch ${session.name ?? sessionId.slice(0, 8)} c${cycleNum}" --system-prompt "$(cat '${promptFilePath}')" "$(cat '${userPromptFilePath}')"`;
   const paneId = createPane(windowId, cwd, "left");
   sessionOrchestratorPane.set(sessionId, paneId);
@@ -1562,6 +2659,8 @@ ${continuationText}`;
     notifyCmd
   ]);
   sendKeys(paneId, `bash '${scriptPath}'`);
+  const resumeArgs = `--dangerously-skip-permissions --disallowed-tools "Task,Agent" --effort ${effort} --settings "${settingsPath}" --plugin-dir "${pluginPath}"${extraPluginFlags ? ` ${extraPluginFlags}` : ""}`;
+  const resumeEnv = `${envExports} && ${notifyEnvExports}`;
   await addOrchestratorCycle(cwd, sessionId, {
     cycle: cycleNum,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1569,7 +2668,9 @@ ${continuationText}`;
     agentsSpawned: [],
     paneId,
     claudeSessionId,
-    mode
+    mode,
+    resumeEnv,
+    resumeArgs
   });
 }
 function resolveOrchestratorPane(sessionId, cwd) {
@@ -1611,20 +2712,124 @@ function cleanupSessionMaps(sessionId) {
 }
 
 // src/daemon/notify.ts
-import { execFile } from "child_process";
-function sendTerminalNotification(title, message) {
-  execFile("osascript", [
-    "-e",
-    `display notification "${message.replace(/"/g, '\\"')}" with title "${title.replace(/"/g, '\\"')}"`
-  ], (err) => {
+import { spawn, execFile } from "child_process";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync4, existsSync as existsSync8 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir3 } from "os";
+var TMUX_SOCKET = `/tmp/tmux-${process.getuid()}/default`;
+var SWITCH_SCRIPT = [
+  "#!/bin/bash",
+  'SESSION="$1"',
+  `TMUX_SOCKET="${TMUX_SOCKET}"`,
+  `TTY=$(/opt/homebrew/bin/tmux -S "$TMUX_SOCKET" list-clients -F '#{client_tty} #{client_session}' 2>/dev/null | grep " \${SESSION}$" | awk '{print $1}' | sed 's|/dev/||' | head -1)`,
+  'if [ -n "$TTY" ]; then',
+  '  osascript -e "',
+  '    tell application \\"iTerm2\\"',
+  "      activate",
+  "      repeat with w in windows",
+  "        tell w",
+  "          repeat with t in tabs",
+  "            tell t",
+  "              repeat with s in sessions",
+  "                tell s",
+  '                  if tty contains \\"$TTY\\" then',
+  "                    select t",
+  "                    return",
+  "                  end if",
+  "                end tell",
+  "              end repeat",
+  "            end tell",
+  "          end repeat",
+  "        end tell",
+  "      end repeat",
+  "    end tell",
+  '  "',
+  "else",
+  `  osascript -e 'tell application "iTerm2" to activate'`,
+  "fi",
+  ""
+].join("\n");
+function ensureSwitchScript() {
+  const dir = join7(homedir3(), ".sisyphus");
+  const scriptPath = join7(dir, "notify-switch.sh");
+  try {
+    mkdirSync4(dir, { recursive: true });
+    writeFileSync6(scriptPath, SWITCH_SCRIPT, { mode: 493 });
+  } catch {
+  }
+}
+var notifyProcess = null;
+function getNotifyBinary() {
+  return join7(homedir3(), ".sisyphus", "SisyphusNotify.app", "Contents", "MacOS", "sisyphus-notify");
+}
+function ensureNotifyProcess() {
+  if (notifyProcess && !notifyProcess.killed && notifyProcess.stdin?.writable) {
+    return notifyProcess;
+  }
+  const binary = getNotifyBinary();
+  if (!existsSync8(binary)) {
+    return null;
+  }
+  notifyProcess = spawn(binary, [], {
+    stdio: ["pipe", "ignore", "pipe"]
+  });
+  notifyProcess.stderr?.on("data", (data) => {
+    const msg = data.toString().trim();
+    if (msg) console.error(`[sisyphus-notify] ${msg}`);
+  });
+  notifyProcess.on("close", () => {
+    notifyProcess = null;
+  });
+  return notifyProcess;
+}
+function sendTerminalNotification(titleOrOpts, message, tmuxSession) {
+  let title;
+  let msg;
+  let tmuxSess;
+  if (typeof titleOrOpts === "object") {
+    title = titleOrOpts.title;
+    msg = titleOrOpts.message;
+    tmuxSess = titleOrOpts.tmuxSession;
+  } else {
+    title = titleOrOpts;
+    msg = message;
+    tmuxSess = tmuxSession;
+  }
+  if (tmuxSess) ensureSwitchScript();
+  const proc = ensureNotifyProcess();
+  if (proc?.stdin?.writable) {
+    const payload = { title, message: msg };
+    if (tmuxSess) payload.tmuxSession = tmuxSess;
+    proc.stdin.write(JSON.stringify(payload) + "\n");
+    return;
+  }
+  execFile("terminal-notifier", ["-title", title, "-message", msg], (err) => {
     if (err) {
-      console.error("[sisyphus] Failed to send notification:", err.message);
+      execFile("osascript", [
+        "-e",
+        `display notification "${msg.replace(/"/g, '\\"')}" with title "${title.replace(/"/g, '\\"')}"`
+      ], () => {
+      });
     }
   });
 }
 
 // src/daemon/session-manager.ts
 var NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+function fireCommentary(event, companion, context, flash = false) {
+  generateCommentary(event, companion, context).then((text) => {
+    if (text) {
+      try {
+        const c = loadCompanion();
+        c.lastCommentary = { text, event, timestamp: (/* @__PURE__ */ new Date()).toISOString() };
+        saveCompanion(c);
+        if (flash) flashCompanion(text);
+      } catch {
+      }
+    }
+  }).catch(() => {
+  });
+}
 function switchToHomeSession(session) {
   if (!session.tmuxSessionName) return;
   const home = findHomeSession(session.cwd);
@@ -1635,12 +2840,22 @@ async function startSession(task, cwd, context, name) {
   if (name && !NAME_PATTERN.test(name)) {
     throw new Error(`Invalid session name "${name}": only alphanumeric, hyphens, and underscores allowed`);
   }
-  const tmuxName = `sisyphus-${name ?? sessionId.slice(0, 8)}`;
+  const tmuxName = tmuxSessionName(cwd, name ?? sessionId.slice(0, 8));
   if (sessionExists(tmuxName)) {
     throw new Error(`Tmux session "${tmuxName}" already exists. Choose a different name.`);
   }
   const session = createSession(sessionId, task, cwd, context, name);
-  const { windowId, initialPaneId } = createSession2(tmuxName, "main", cwd);
+  const config = loadConfig(cwd);
+  const model = config.model;
+  await updateSession(cwd, sessionId, {
+    model,
+    launchConfig: {
+      model,
+      context,
+      orchestratorPrompt: config.orchestratorPrompt
+    }
+  });
+  const { windowId, initialPaneId } = createSession2(tmuxName, cwd);
   setSessionOption(tmuxName, "@sisyphus_cwd", cwd.replace(/\/+$/, ""));
   await updateSessionTmux(cwd, sessionId, tmuxName, windowId);
   trackSession(sessionId, cwd, tmuxName);
@@ -1655,12 +2870,12 @@ async function startSession(task, cwd, context, name) {
         return;
       }
       let finalName = generatedName;
-      let candidate = `sisyphus-${finalName}`;
+      let candidate = tmuxSessionName(cwd, finalName);
       let attempt = 0;
       while (sessionExists(candidate) && attempt < 5) {
         attempt++;
         finalName = `${generatedName}-${attempt}`;
-        candidate = `sisyphus-${finalName}`;
+        candidate = tmuxSessionName(cwd, finalName);
       }
       if (sessionExists(candidate)) return;
       try {
@@ -1691,6 +2906,17 @@ async function startSession(task, cwd, context, name) {
       console.error(`[sisyphus] Name generation failed for session ${sessionId}:`, err);
     });
   }
+  try {
+    recomputeDots();
+  } catch {
+  }
+  try {
+    const companion = loadCompanion();
+    onSessionStart(companion, cwd);
+    saveCompanion(companion);
+    fireCommentary("session-start", companion, task);
+  } catch {
+  }
   return { ...getSession(cwd, sessionId), tmuxSessionName: tmuxName };
 }
 var PRUNE_KEEP_COUNT = 10;
@@ -1698,7 +2924,7 @@ var PRUNE_KEEP_DAYS = 7;
 function pruneOldSessions(cwd) {
   try {
     const dir = sessionsDir(cwd);
-    if (!existsSync6(dir)) return;
+    if (!existsSync9(dir)) return;
     const entries = readdirSync5(dir, { withFileTypes: true });
     const candidates = [];
     for (const entry of entries) {
@@ -1730,23 +2956,23 @@ function pruneOldSessions(cwd) {
 }
 async function reopenWindow(sessionId, cwd) {
   const session = getSession(cwd, sessionId);
-  const tmuxName = session.tmuxSessionName ?? `sisyphus-${session.name ?? sessionId.slice(0, 8)}`;
+  const tmuxName = session.tmuxSessionName ?? tmuxSessionName(cwd, session.name ?? sessionId.slice(0, 8));
   if (sessionExists(tmuxName) && session.tmuxWindowId) {
     return { tmuxSessionName: tmuxName, tmuxWindowId: session.tmuxWindowId };
   }
-  const created = createSession2(tmuxName, "main", cwd);
+  const created = createSession2(tmuxName, cwd);
   setSessionOption(tmuxName, "@sisyphus_cwd", cwd.replace(/\/+$/, ""));
   await updateSessionTmux(cwd, sessionId, tmuxName, created.windowId);
   return { tmuxSessionName: tmuxName, tmuxWindowId: created.windowId };
 }
 async function resumeSession(sessionId, cwd, message) {
   const session = getSession(cwd, sessionId);
-  const tmuxName = session.tmuxSessionName ?? `sisyphus-${sessionId.slice(0, 8)}`;
+  const tmuxName = session.tmuxSessionName ?? tmuxSessionName(cwd, session.name ?? sessionId.slice(0, 8));
   let windowId;
   if (sessionExists(tmuxName) && session.tmuxWindowId) {
     windowId = session.tmuxWindowId;
   } else {
-    const created = createSession2(tmuxName, "main", cwd);
+    const created = createSession2(tmuxName, cwd);
     setSessionOption(tmuxName, "@sisyphus_cwd", cwd.replace(/\/+$/, ""));
     windowId = created.windowId;
     await updateSessionTmux(cwd, sessionId, tmuxName, windowId);
@@ -1784,6 +3010,10 @@ async function resumeSession(sessionId, cwd, message) {
   if (initialPaneId) {
     killPane(initialPaneId);
   }
+  try {
+    recomputeDots();
+  } catch {
+  }
   return getSession(cwd, sessionId);
 }
 function getSessionStatus(cwd, sessionId) {
@@ -1791,7 +3021,7 @@ function getSessionStatus(cwd, sessionId) {
 }
 function listSessions(cwd) {
   const dir = sessionsDir(cwd);
-  if (!existsSync6(dir)) return [];
+  if (!existsSync9(dir)) return [];
   const entries = readdirSync5(dir, { withFileTypes: true });
   const sessions = [];
   for (const entry of entries) {
@@ -1839,6 +3069,11 @@ function onAllAgentsDone2(sessionId, cwd, windowId) {
   if (cycleNumber > 0) {
     createSnapshot(cwd, sessionId, cycleNumber);
   }
+  try {
+    const companion = loadCompanion();
+    fireCommentary("cycle-boundary", companion, `Cycle ${cycleNumber} complete, respawning orchestrator`);
+  } catch {
+  }
   setImmediate(async () => {
     pendingRespawns.delete(sessionId);
     try {
@@ -1857,7 +3092,7 @@ function onAllAgentsDone2(sessionId, cwd, windowId) {
         if (sessionExists(tmuxName)) {
           killSession(tmuxName);
         }
-        const created = createSession2(tmuxName, "main", cwd);
+        const created = createSession2(tmuxName, cwd);
         setSessionOption(tmuxName, "@sisyphus_cwd", cwd.replace(/\/+$/, ""));
         activeWindowId = created.windowId;
         initialPaneId = created.initialPaneId;
@@ -1874,6 +3109,10 @@ function onAllAgentsDone2(sessionId, cwd, windowId) {
         }
       }
       selectLayout(activeWindowId);
+      try {
+        recomputeDots();
+      } catch {
+      }
     } catch (err) {
       console.error(`[sisyphus] Failed to respawn orchestrator for session ${sessionId}:`, err);
     } finally {
@@ -1901,10 +3140,31 @@ async function handleSpawn(sessionId, cwd, agentType, name, instruction, repo) {
     repo
   });
   await appendAgentToLastCycle(cwd, sessionId, agent.id);
+  try {
+    recomputeDots();
+  } catch {
+  }
+  try {
+    const companion = loadCompanion();
+    onAgentSpawned(companion);
+    saveCompanion(companion);
+    generateNickname(companion).then((nickname) => {
+      if (nickname) {
+        updateAgent(cwd, sessionId, agent.id, { nickname }).catch(() => {
+        });
+      }
+    }).catch(() => {
+    });
+  } catch {
+  }
   return { agentId: agent.id };
 }
 async function handleSubmit(cwd, sessionId, agentId, report, windowId) {
   const allDone = await handleAgentSubmit(cwd, sessionId, agentId, report);
+  try {
+    recomputeDots();
+  } catch {
+  }
   if (allDone) {
     onAllAgentsDone2(sessionId, cwd, windowId);
   }
@@ -1920,7 +3180,12 @@ async function handleYield(sessionId, cwd, nextPrompt, mode) {
   respawningSessions.add(sessionId);
   await handleOrchestratorYield(sessionId, cwd, nextPrompt, mode);
   orchestratorDone.add(sessionId);
+  try {
+    recomputeDots();
+  } catch {
+  }
   const session = getSession(cwd, sessionId);
+  updateCycleCount(session.orchestratorCycles.length);
   const hasRunningAgents = session.agents.some((a) => a.status === "running");
   if (!hasRunningAgents) {
     const windowId = getWindowId(sessionId) ?? session.tmuxWindowId;
@@ -1934,10 +3199,42 @@ async function handleYield(sessionId, cwd, nextPrompt, mode) {
   }
 }
 async function handleComplete(sessionId, cwd, report) {
-  const session = getSession(cwd, sessionId);
   await flushTimers(sessionId);
   await handleOrchestratorComplete(sessionId, cwd, report);
+  const session = getSession(cwd, sessionId);
+  const wallClockMs = Date.now() - new Date(session.createdAt).getTime();
+  await updateSession(cwd, sessionId, { wallClockMs });
+  markSessionCompleted(sessionId, session.createdAt, cwd);
+  untrackSession(sessionId);
+  unregisterSessionPanes(sessionId);
+  clearAgentCounter(sessionId);
+  orchestratorDone.delete(sessionId);
+  try {
+    recomputeDots();
+  } catch {
+  }
+  try {
+    const companion = loadCompanion();
+    const prevLevel = companion.level;
+    const newAchievementIds = onSessionComplete(companion, session);
+    saveCompanion(companion);
+    markEventCompletion();
+    const leveledUp = companion.level > prevLevel;
+    fireCommentary("session-complete", companion, session.task, true);
+    if (leveledUp) {
+      markEventLevelUp();
+      fireCommentary("level-up", companion, void 0, true);
+    }
+    if (newAchievementIds.length > 0) {
+      const names = newAchievementIds.map((id) => ACHIEVEMENTS.find((a) => a.id === id)?.name ?? id).join(", ");
+      fireCommentary("achievement", companion, names, true);
+    }
+  } catch {
+  }
   switchToHomeSession(session);
+  if (session.tmuxSessionName) {
+    killSession(session.tmuxSessionName);
+  }
 }
 async function handleContinue(sessionId, cwd) {
   await continueSession(cwd, sessionId);
@@ -1972,6 +3269,10 @@ async function handleKill(sessionId, cwd) {
   }
   clearAgentCounter(sessionId);
   orchestratorDone.delete(sessionId);
+  try {
+    recomputeDots();
+  } catch {
+  }
   return killedAgents;
 }
 async function handleRestartAgent(sessionId, cwd, agentId) {
@@ -2039,8 +3340,16 @@ async function handlePaneExited(paneId, cwd, sessionId, role, agentId) {
     const agent = session.agents.find((a) => a.id === agentId);
     if (!agent || agent.status !== "running") return;
     const label = agent.name ? `${agent.name} (${agentId})` : agentId;
-    sendTerminalNotification("Sisyphus", `Agent ${label} exited without submitting a report`);
+    sendTerminalNotification("Sisyphus", `Agent ${label} exited without submitting a report`, session.tmuxSessionName);
     const allDone = await handleAgentKilled(cwd, sessionId, agentId, "pane exited");
+    try {
+      const companion = loadCompanion();
+      onAgentCrashed(companion);
+      saveCompanion(companion);
+      markEventCrash();
+      fireCommentary("agent-crash", companion);
+    } catch {
+    }
     if (allDone) {
       const windowId = getWindowId(sessionId) ?? session.tmuxWindowId;
       if (windowId) {
@@ -2049,7 +3358,7 @@ async function handlePaneExited(paneId, cwd, sessionId, role, agentId) {
     }
   } else if (role === "orchestrator") {
     const sessionName = session.name ?? sessionId.slice(0, 8);
-    sendTerminalNotification("Sisyphus", `Orchestrator exited without yielding (${sessionName})`);
+    sendTerminalNotification("Sisyphus", `Orchestrator exited without yielding (${sessionName})`, session.tmuxSessionName);
     respawningSessions.add(sessionId);
     const cycleActiveMs = flushCycleTimer(sessionId, session.orchestratorCycles.length);
     await completeOrchestratorCycle(cwd, sessionId, void 0, void 0, cycleActiveMs);
@@ -2077,22 +3386,22 @@ async function handlePaneExited(paneId, cwd, sessionId, role, agentId) {
 var server = null;
 var sessionTrackingMap = /* @__PURE__ */ new Map();
 function registryPath() {
-  return join5(globalDir(), "session-registry.json");
+  return join8(globalDir(), "session-registry.json");
 }
 function persistSessionRegistry() {
   const dir = globalDir();
-  mkdirSync3(dir, { recursive: true });
+  mkdirSync5(dir, { recursive: true });
   const registry = {};
   for (const [id, tracking] of sessionTrackingMap) {
     registry[id] = tracking.cwd;
   }
-  writeFileSync5(registryPath(), JSON.stringify(registry, null, 2), "utf-8");
+  writeFileSync7(registryPath(), JSON.stringify(registry, null, 2), "utf-8");
 }
 function loadSessionRegistry() {
   const p = registryPath();
-  if (!existsSync7(p)) return {};
+  if (!existsSync10(p)) return {};
   try {
-    return JSON.parse(readFileSync5(p, "utf-8"));
+    return JSON.parse(readFileSync8(p, "utf-8"));
   } catch {
     return {};
   }
@@ -2170,11 +3479,17 @@ async function handleRequest(req) {
         return { ok: true };
       }
       case "status": {
-        if (req.sessionId) {
-          const cwd = sessionTrackingMap.get(req.sessionId)?.cwd ?? req.cwd;
-          if (!cwd) return unknownSessionError(req.sessionId);
-          const session = getSessionStatus(cwd, req.sessionId);
-          const timers = getActiveTimers(req.sessionId);
+        let sessionId = req.sessionId;
+        if (!sessionId && req.cwd) {
+          const sessions = listSessions(req.cwd);
+          const active = sessions.find((s) => s.status === "active") ?? sessions.find((s) => s.status === "paused");
+          if (active) sessionId = active.id;
+        }
+        if (sessionId) {
+          const cwd = sessionTrackingMap.get(sessionId)?.cwd ?? req.cwd;
+          if (!cwd) return unknownSessionError(sessionId);
+          const session = getSessionStatus(cwd, sessionId);
+          const timers = getActiveTimers(sessionId);
           if (timers) {
             session.activeMs = timers.sessionMs;
             for (const agent of session.agents) {
@@ -2220,7 +3535,7 @@ async function handleRequest(req) {
         let tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) {
           const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-          if (existsSync7(stateFile)) {
+          if (existsSync10(stateFile)) {
             tracking = { cwd: req.cwd, messageCounter: 0 };
             sessionTrackingMap.set(req.sessionId, tracking);
             persistSessionRegistry();
@@ -2257,7 +3572,7 @@ async function handleRequest(req) {
         let tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) {
           const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-          if (existsSync7(stateFile)) {
+          if (existsSync10(stateFile)) {
             registerSessionCwd(req.sessionId, req.cwd);
             tracking = sessionTrackingMap.get(req.sessionId);
           } else {
@@ -2271,7 +3586,7 @@ async function handleRequest(req) {
         let tracking = sessionTrackingMap.get(req.sessionId);
         if (!tracking) {
           const stateFile = `${req.cwd}/.sisyphus/sessions/${req.sessionId}/state.json`;
-          if (existsSync7(stateFile)) {
+          if (existsSync10(stateFile)) {
             tracking = { cwd: req.cwd, messageCounter: 0 };
             sessionTrackingMap.set(req.sessionId, tracking);
             persistSessionRegistry();
@@ -2294,7 +3609,7 @@ async function handleRequest(req) {
           sessionTrackingMap.delete(req.sessionId);
           persistSessionRegistry();
         }
-        const { sessionDir: sessionDir2 } = await import("./paths-3EL2SCHI.js");
+        const { sessionDir: sessionDir2 } = await import("./paths-XRDEEJ5R.js");
         rmSync3(sessionDir2(req.cwd, req.sessionId), { recursive: true, force: true });
         return { ok: true };
       }
@@ -2326,9 +3641,9 @@ async function handleRequest(req) {
         let filePath;
         if (req.content.length > 200) {
           const dir = messagesDir(tracking.cwd, req.sessionId);
-          mkdirSync3(dir, { recursive: true });
-          filePath = join5(dir, `${id}.md`);
-          writeFileSync5(filePath, req.content, "utf-8");
+          mkdirSync5(dir, { recursive: true });
+          filePath = join8(dir, `${id}.md`);
+          writeFileSync7(filePath, req.content, "utf-8");
         }
         await appendMessage(tracking.cwd, req.sessionId, {
           id,
@@ -2340,6 +3655,14 @@ async function handleRequest(req) {
         });
         return { ok: true };
       }
+      case "companion": {
+        const companion = loadCompanion();
+        if (req.name !== void 0) {
+          companion.name = req.name;
+          saveCompanion(companion);
+        }
+        return { ok: true, data: companion };
+      }
       default:
         return { ok: false, error: `Unknown request type: ${req.type}` };
     }
@@ -2351,7 +3674,7 @@ async function handleRequest(req) {
 function startServer() {
   return new Promise((resolve5, reject) => {
     const sock = socketPath();
-    if (existsSync7(sock)) {
+    if (existsSync10(sock)) {
       unlinkSync(sock);
     }
     server = createServer((conn) => {
@@ -2397,7 +3720,7 @@ function stopServer() {
     }
     server.close(() => {
       const sock = socketPath();
-      if (existsSync7(sock)) {
+      if (existsSync10(sock)) {
         unlinkSync(sock);
       }
       server = null;
@@ -2408,7 +3731,7 @@ function stopServer() {
 
 // src/daemon/updater.ts
 import { execSync as execSync3 } from "child_process";
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync6, unlinkSync as unlinkSync2, lstatSync } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync8, unlinkSync as unlinkSync2, lstatSync } from "fs";
 import { resolve as resolve4 } from "path";
 import { get } from "https";
 function isNewer(latest, current) {
@@ -2425,7 +3748,7 @@ function isNewer(latest, current) {
 function readPackageVersion() {
   for (const rel of ["../package.json", "../../package.json"]) {
     try {
-      const raw = readFileSync6(resolve4(import.meta.dirname, rel), "utf-8");
+      const raw = readFileSync9(resolve4(import.meta.dirname, rel), "utf-8");
       const pkg = JSON.parse(raw);
       if (pkg.name === "sisyphi" && pkg.version) return pkg.version;
     } catch {
@@ -2491,7 +3814,7 @@ function applyUpdate(expectedVersion) {
 }
 function markUpdating(version) {
   try {
-    writeFileSync6(daemonUpdatingPath(), version, "utf-8");
+    writeFileSync8(daemonUpdatingPath(), version, "utf-8");
   } catch {
   }
 }
@@ -2558,7 +3881,7 @@ var origError = console.error.bind(console);
 console.log = (...args) => origLog(`[${ts()}]`, ...args);
 console.error = (...args) => origError(`[${ts()}]`, ...args);
 function ensureDirs() {
-  mkdirSync4(globalDir(), { recursive: true });
+  mkdirSync6(globalDir(), { recursive: true });
 }
 function isProcessAlive(pid) {
   try {
@@ -2571,7 +3894,7 @@ function isProcessAlive(pid) {
 function readPid() {
   const pidFile = daemonPidPath();
   try {
-    const pid = parseInt(readFileSync7(pidFile, "utf-8").trim(), 10);
+    const pid = parseInt(readFileSync10(pidFile, "utf-8").trim(), 10);
     return pid && isProcessAlive(pid) ? pid : null;
   } catch {
     return null;
@@ -2583,7 +3906,7 @@ function acquirePidLock() {
     console.error(`[sisyphus] Daemon already running (pid ${pid}). Use 'sisyphusd restart' or 'sisyphusd stop' first.`);
     process.exit(0);
   }
-  writeFileSync7(daemonPidPath(), String(process.pid), "utf-8");
+  writeFileSync9(daemonPidPath(), String(process.pid), "utf-8");
 }
 function isLaunchdManaged() {
   try {
@@ -2642,11 +3965,11 @@ async function recoverSessions() {
   let recovered = 0;
   for (const [sessionId, cwd] of entries) {
     const stateFile = statePath(cwd, sessionId);
-    if (!existsSync8(stateFile)) {
+    if (!existsSync11(stateFile)) {
       continue;
     }
     try {
-      const session = JSON.parse(readFileSync7(stateFile, "utf-8"));
+      const session = JSON.parse(readFileSync10(stateFile, "utf-8"));
       if (session.status === "active" || session.status === "paused") {
         registerSessionCwd(sessionId, cwd);
         resetAgentCounterFromState(sessionId, session.agents ?? []);
@@ -2720,9 +4043,21 @@ async function startDaemon() {
   }
   acquirePidLock();
   setRespawnCallback(onAllAgentsDone2);
+  setDotsCallback(() => {
+    recomputeDots();
+    try {
+      writeStatusBar();
+    } catch {
+    }
+  });
+  setTrackedEntriesProvider(getTrackedSessionEntries);
   await startServer();
   startMonitor(config.pollIntervalMs);
   await recoverSessions();
+  try {
+    writeStatusBar();
+  } catch {
+  }
   if (config.autoUpdate !== false) {
     startPeriodicUpdateCheck();
   }