sisyphi 1.1.16 → 1.1.17

package/dist/daemon.js

@@ -37,13 +37,13 @@ import {
 } from "./chunk-GSXF3TCZ.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 mkdirSync4, readFileSync as readFileSync8, writeFileSync as writeFileSync7, unlinkSync as unlinkSync3, existsSync as existsSync8 } 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 { unlinkSync, existsSync as existsSync7, writeFileSync as writeFileSync5, readFileSync as readFileSync6, mkdirSync as mkdirSync3, rmSync as rmSync3 } from "fs";
 import { join as join5 } from "path";
 
 // src/daemon/session-manager.ts
@@ -632,6 +632,12 @@ 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 configureSessionDefaults(sessionName, windowId) {
   execSafe(`tmux set -w -t "${windowId}" pane-border-status top`);
   execSafe(`tmux set -w -t "${windowId}" allow-rename off`);
@@ -1094,6 +1100,7 @@ var respawningSessions = /* @__PURE__ */ new Set();
 // src/daemon/pane-monitor.ts
 var monitorInterval = null;
 var onAllAgentsDone = null;
+var onDotsUpdate = null;
 var lastPollTime = 0;
 var storedPollIntervalMs = 5e3;
 var activeTimers = /* @__PURE__ */ new Map();
@@ -1160,6 +1167,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;
@@ -1200,6 +1213,10 @@ async function pollAllSessions() {
       await pollSession(sessionId, cwd, windowId, increment);
     }
   }
+  try {
+    onDotsUpdate?.();
+  } catch {
+  }
 }
 async function pollSession(sessionId, cwd, windowId, increment) {
   let session;
@@ -1623,6 +1640,145 @@ function sendTerminalNotification(title, message) {
   });
 }
 
+// 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") {
+      return "orchestrator:idle";
+    }
+    return "orchestrator:processing";
+  }
+  if (hasRunningAgents) return "agents:running";
+  return "between-cycles";
+}
+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();
+  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);
+        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 tmuxSessionName = tmuxSessionMap.get(sessionId);
+        if (tmuxSessionName) {
+          setSessionOption(tmuxSessionName, "@sisyphus_phase", phase);
+        }
+      } 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/session-manager.ts
 var NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
 function switchToHomeSession(session) {
@@ -1691,6 +1847,10 @@ async function startSession(task, cwd, context, name) {
       console.error(`[sisyphus] Name generation failed for session ${sessionId}:`, err);
     });
   }
+  try {
+    recomputeDots();
+  } catch {
+  }
   return { ...getSession(cwd, sessionId), tmuxSessionName: tmuxName };
 }
 var PRUNE_KEEP_COUNT = 10;
@@ -1784,6 +1944,10 @@ async function resumeSession(sessionId, cwd, message) {
   if (initialPaneId) {
     killPane(initialPaneId);
   }
+  try {
+    recomputeDots();
+  } catch {
+  }
   return getSession(cwd, sessionId);
 }
 function getSessionStatus(cwd, sessionId) {
@@ -1874,6 +2038,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 +2069,18 @@ async function handleSpawn(sessionId, cwd, agentType, name, instruction, repo) {
     repo
   });
   await appendAgentToLastCycle(cwd, sessionId, agent.id);
+  try {
+    recomputeDots();
+  } 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,6 +2096,10 @@ 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);
   const hasRunningAgents = session.agents.some((a) => a.status === "running");
   if (!hasRunningAgents) {
@@ -1937,6 +2117,11 @@ async function handleComplete(sessionId, cwd, report) {
   const session = getSession(cwd, sessionId);
   await flushTimers(sessionId);
   await handleOrchestratorComplete(sessionId, cwd, report);
+  markSessionCompleted(sessionId, session.createdAt, cwd);
+  try {
+    recomputeDots();
+  } catch {
+  }
   switchToHomeSession(session);
 }
 async function handleContinue(sessionId, cwd) {
@@ -1972,6 +2157,10 @@ async function handleKill(sessionId, cwd) {
   }
   clearAgentCounter(sessionId);
   orchestratorDone.delete(sessionId);
+  try {
+    recomputeDots();
+  } catch {
+  }
   return killedAgents;
 }
 async function handleRestartAgent(sessionId, cwd, agentId) {
@@ -2092,7 +2281,7 @@ function loadSessionRegistry() {
   const p = registryPath();
   if (!existsSync7(p)) return {};
   try {
-    return JSON.parse(readFileSync5(p, "utf-8"));
+    return JSON.parse(readFileSync6(p, "utf-8"));
   } catch {
     return {};
   }
@@ -2408,7 +2597,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 readFileSync7, writeFileSync as writeFileSync6, unlinkSync as unlinkSync2, lstatSync } from "fs";
 import { resolve as resolve4 } from "path";
 import { get } from "https";
 function isNewer(latest, current) {
@@ -2425,7 +2614,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 = readFileSync7(resolve4(import.meta.dirname, rel), "utf-8");
       const pkg = JSON.parse(raw);
       if (pkg.name === "sisyphi" && pkg.version) return pkg.version;
     } catch {
@@ -2571,7 +2760,7 @@ function isProcessAlive(pid) {
 function readPid() {
   const pidFile = daemonPidPath();
   try {
-    const pid = parseInt(readFileSync7(pidFile, "utf-8").trim(), 10);
+    const pid = parseInt(readFileSync8(pidFile, "utf-8").trim(), 10);
     return pid && isProcessAlive(pid) ? pid : null;
   } catch {
     return null;
@@ -2646,7 +2835,7 @@ async function recoverSessions() {
       continue;
     }
     try {
-      const session = JSON.parse(readFileSync7(stateFile, "utf-8"));
+      const session = JSON.parse(readFileSync8(stateFile, "utf-8"));
       if (session.status === "active" || session.status === "paused") {
         registerSessionCwd(sessionId, cwd);
         resetAgentCounterFromState(sessionId, session.agents ?? []);
@@ -2720,6 +2909,8 @@ async function startDaemon() {
   }
   acquirePidLock();
   setRespawnCallback(onAllAgentsDone2);
+  setDotsCallback(recomputeDots);
+  setTrackedEntriesProvider(getTrackedSessionEntries);
   await startServer();
   startMonitor(config.pollIntervalMs);
   await recoverSessions();