sisyphi 0.1.3 → 0.1.5

package/dist/daemon.js

@@ -48,18 +48,15 @@ import { join as join4 } from "path";
 
 // src/daemon/session-manager.ts
 import { v4 as uuidv4 } from "uuid";
-import { existsSync as existsSync4, readdirSync as readdirSync4 } from "fs";
+import { existsSync as existsSync4, readdirSync as readdirSync4, rmSync as rmSync2 } from "fs";
 
 // src/daemon/state.ts
-import { readFileSync as readFileSync2, writeFileSync, mkdirSync, renameSync } from "fs";
-import { dirname, join } from "path";
 import { randomUUID } from "crypto";
+import { mkdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
 var PLAN_SEED = `---
 description: >
-  Living document of what still needs to happen. Write your remaining work plan
-  here: phases, next steps, file references, open questions. Remove or collapse
-  items as they're completed so this file only reflects outstanding work. The
-  orchestrator sees this every cycle \u2014 keep it focused and current.
+  Living document of what still needs to happen. Write out ne
 ---
 `;
 var LOGS_SEED = `---
@@ -67,7 +64,7 @@ description: >
   Session memory. Record important observations, decisions, and findings here.
   This is your persistent memory across cycles: things you tried, what
   worked/failed, design decisions and their rationale, gotchas discovered during
-  implementation. Unlike plan.md, entries here accumulate \u2014 they're a log.
+  implementation.
 ---
 `;
 var sessionLocks = /* @__PURE__ */ new Map();
@@ -388,10 +385,13 @@ function formatStateForOrchestrator(session) {
   if (worktreeAgents.length > 0) {
     const wtLines = worktreeAgents.map((a) => {
       if (a.mergeStatus === "conflict") {
-        return `- ${a.id}: conflict \u2014 ${a.mergeDetails ?? "unknown"}
+        return `- ${a.id}: CONFLICT \u2014 ${a.mergeDetails ?? "unknown"}
   Branch: ${a.branchName}
   Worktree: ${a.worktreePath}`;
       }
+      if (a.mergeStatus === "no-changes") {
+        return `- ${a.id}: NO CHANGES \u2014 agent did not commit any work to branch ${a.branchName}`;
+      }
       const status = a.mergeStatus ?? "pending";
       return `- ${a.id}: ${status} (branch ${a.branchName})`;
     }).join("\n");
@@ -493,7 +493,7 @@ async function handleOrchestratorYield(sessionId, cwd, nextPrompt) {
   const session = getSession(cwd, sessionId);
   const runningAgents = session.agents.filter((a) => a.status === "running");
   if (runningAgents.length === 0) {
-    console.error(`[sisyphus] WARNING: Orchestrator yielded but no agents are running for session ${sessionId}`);
+    console.log(`[sisyphus] Orchestrator yielded with no running agents for session ${sessionId}`);
   }
 }
 async function handleOrchestratorComplete(sessionId, cwd, report) {
@@ -539,23 +539,17 @@ function loadWorktreeConfig(cwd) {
     return null;
   }
 }
-function createWorktree(cwd, sessionId, agentId) {
+function createWorktreeShell(cwd, sessionId, agentId) {
   const branchName = `sisyphus/${sessionId.slice(0, 8)}/${agentId}`;
-  const worktreePath = join3(worktreeBaseDir(cwd), agentId);
+  const worktreePath = join3(worktreeBaseDir(cwd), sessionId.slice(0, 8), agentId);
   mkdirSync2(dirname2(worktreePath), { recursive: true });
+  execSafe2(`git -C ${shellQuote2(cwd)} worktree prune`);
+  if (existsSync2(worktreePath)) {
+    execSafe2(`git -C ${shellQuote2(cwd)} worktree remove --force ${shellQuote2(worktreePath)}`);
+  }
+  execSafe2(`git -C ${shellQuote2(cwd)} branch -D ${shellQuote2(branchName)}`);
   exec2(`git -C ${shellQuote2(cwd)} branch ${shellQuote2(branchName)} HEAD`);
   exec2(`git -C ${shellQuote2(cwd)} worktree add ${shellQuote2(worktreePath)} ${shellQuote2(branchName)}`);
-  const symlinks = [".sisyphus", ".claude"];
-  for (const entry of symlinks) {
-    const src = join3(cwd, entry);
-    if (existsSync2(src)) {
-      execSafe2(`ln -s ${shellQuote2(src)} ${shellQuote2(join3(worktreePath, entry))}`);
-    }
-  }
-  const config = loadWorktreeConfig(cwd);
-  if (config) {
-    bootstrapWorktree(cwd, worktreePath, config);
-  }
   return { worktreePath, branchName };
 }
 function bootstrapWorktree(cwd, worktreePath, config) {
@@ -615,6 +609,8 @@ function mergeWorktrees(cwd, agents) {
     (a) => a.worktreePath && a.mergeStatus === "pending"
   );
   const results = [];
+  execSafe2(`git -C ${shellQuote2(cwd)} add .sisyphus`);
+  execSafe2(`git -C ${shellQuote2(cwd)} commit -m 'sisyphus: snapshot session state before merge'`);
   for (const agent of pending) {
     const branch = resolveWorktreeBranch(cwd, agent.worktreePath);
     if (!branch) {
@@ -637,8 +633,10 @@ function mergeWorktrees(cwd, agents) {
       results.push({ agentId: agent.id, name: agent.name, status: "merged" });
     } catch (err) {
       execSafe2(`git -C ${shellQuote2(cwd)} merge --abort`);
-      const stderr = err?.stderr;
-      const conflictDetails = stderr ? (typeof stderr === "string" ? stderr : stderr.toString("utf-8")).trim() : err instanceof Error ? err.message : String(err);
+      const errObj = err;
+      const stdout = errObj.stdout ? (typeof errObj.stdout === "string" ? errObj.stdout : errObj.stdout.toString("utf-8")).trim() : "";
+      const stderr = errObj.stderr ? (typeof errObj.stderr === "string" ? errObj.stderr : errObj.stderr.toString("utf-8")).trim() : "";
+      const conflictDetails = stdout || stderr || (err instanceof Error ? err.message : String(err));
       results.push({ agentId: agent.id, name: agent.name, status: "conflict", conflictDetails });
     }
   }
@@ -687,7 +685,7 @@ Task: {{INSTRUCTION}}`;
   if (worktreeContext) {
     worktreeBlock = [
       "## Worktree Context",
-      `You are working in worktree ${worktreeContext.offset} of ${worktreeContext.total} concurrent worktrees on branch \`${worktreeContext.branchName}\`.`,
+      `You are working in an isolated git worktree on branch \`${worktreeContext.branchName}\`.`,
       `If you start any services that require ports, add ${worktreeContext.offset} to the default port.`
     ].join("\n");
   }
@@ -705,7 +703,7 @@ async function spawnAgent(opts) {
   let branchName;
   let worktreeContext;
   if (opts.worktree) {
-    const wt = createWorktree(cwd, sessionId, agentId);
+    const wt = createWorktreeShell(cwd, sessionId, agentId);
     worktreePath = wt.worktreePath;
     branchName = wt.branchName;
     paneCwd = worktreePath;
@@ -728,7 +726,7 @@ async function spawnAgent(opts) {
   ].join(" && ");
   const agentFlag = agentType ? ` --agent ${shellQuote3(agentType)}` : "";
   const claudeCmd = `claude --dangerously-skip-permissions --plugin-dir "${pluginPath}"${agentFlag} --append-system-prompt "$(cat '${suffixFilePath}')" ${shellQuote3(instruction)}`;
-  sendKeys(paneId, `${bannerCmd} ${envExports} && ${claudeCmd}`);
+  const fullCmd = `${bannerCmd} ${envExports} && ${claudeCmd}`;
   const agent = {
     id: agentId,
     name,
@@ -743,6 +741,24 @@ async function spawnAgent(opts) {
     ...worktreePath ? { worktreePath, branchName, mergeStatus: "pending" } : {}
   };
   await addAgent(cwd, sessionId, agent);
+  if (opts.worktree && worktreePath) {
+    const config = loadWorktreeConfig(cwd);
+    if (config) {
+      const wtPath = worktreePath;
+      setImmediate(() => {
+        try {
+          bootstrapWorktree(cwd, wtPath, config);
+        } catch (err) {
+          console.error(`[sisyphus] worktree bootstrap failed for ${agentId}: ${err instanceof Error ? err.message : err}`);
+        }
+        sendKeys(paneId, fullCmd);
+      });
+    } else {
+      sendKeys(paneId, fullCmd);
+    }
+  } else {
+    sendKeys(paneId, fullCmd);
+  }
   return agent;
 }
 function nextReportNumber(cwd, sessionId, agentId) {
@@ -914,8 +930,44 @@ async function startSession(task, cwd, tmuxSession, windowId) {
   trackSession(sessionId, cwd, tmuxSession);
   await spawnOrchestrator(sessionId, cwd, windowId);
   updateTrackedWindow(sessionId, windowId);
+  pruneOldSessions(cwd);
   return session;
 }
+var PRUNE_KEEP_COUNT = 10;
+var PRUNE_KEEP_DAYS = 7;
+function pruneOldSessions(cwd) {
+  try {
+    const dir = sessionsDir(cwd);
+    if (!existsSync4(dir)) return;
+    const entries = readdirSync4(dir, { withFileTypes: true });
+    const candidates = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      try {
+        const session = getSession(cwd, entry.name);
+        if (session.status === "active" || session.status === "paused") continue;
+        candidates.push({ id: session.id, createdAt: new Date(session.createdAt).getTime() });
+      } catch {
+      }
+    }
+    if (candidates.length <= PRUNE_KEEP_COUNT) return;
+    candidates.sort((a, b) => b.createdAt - a.createdAt);
+    const cutoff = Date.now() - PRUNE_KEEP_DAYS * 24 * 60 * 60 * 1e3;
+    const keep = /* @__PURE__ */ new Set();
+    for (let i = 0; i < Math.min(PRUNE_KEEP_COUNT, candidates.length); i++) {
+      keep.add(candidates[i].id);
+    }
+    for (const c of candidates) {
+      if (c.createdAt >= cutoff) keep.add(c.id);
+    }
+    for (const c of candidates) {
+      if (keep.has(c.id)) continue;
+      rmSync2(sessionDir(cwd, c.id), { recursive: true, force: true });
+    }
+  } catch (err) {
+    console.error("[sisyphus] Session pruning failed:", err);
+  }
+}
 async function resumeSession(sessionId, cwd, tmuxSession, windowId, message) {
   const session = getSession(cwd, sessionId);
   if (session.status !== "active") {
@@ -973,14 +1025,17 @@ function listSessions(cwd) {
   }
   return sessions;
 }
+var pendingRespawns = /* @__PURE__ */ new Set();
 function onAllAgentsDone2(sessionId, cwd, windowId) {
+  if (pendingRespawns.has(sessionId)) return;
   const session = getSession(cwd, sessionId);
   if (session.status !== "active") return;
+  pendingRespawns.add(sessionId);
   const worktreeAgents = session.agents.filter((a) => a.worktreePath && a.mergeStatus === "pending");
   if (worktreeAgents.length > 0) {
     const results = mergeWorktrees(cwd, worktreeAgents);
     for (const result of results) {
-      const mergeStatus = result.status === "conflict" ? "conflict" : "merged";
+      const mergeStatus = result.status;
       updateAgent(cwd, sessionId, result.agentId, {
         mergeStatus,
         mergeDetails: result.conflictDetails
@@ -988,6 +1043,7 @@ function onAllAgentsDone2(sessionId, cwd, windowId) {
     }
   }
   setTimeout(() => {
+    pendingRespawns.delete(sessionId);
     spawnOrchestrator(sessionId, cwd, windowId).then(() => updateTrackedWindow(sessionId, windowId)).catch((err) => console.error(`[sisyphus] Failed to respawn orchestrator for session ${sessionId}:`, err));
   }, 2e3);
 }
@@ -1016,7 +1072,19 @@ async function handleReport(cwd, sessionId, agentId, content) {
   await handleAgentReport(cwd, sessionId, agentId, content);
 }
 async function handleYield(sessionId, cwd, nextPrompt) {
+  const pre = getSession(cwd, sessionId);
+  if (pre.status === "paused") {
+    await updateSessionStatus(cwd, sessionId, "active");
+  }
   await handleOrchestratorYield(sessionId, cwd, nextPrompt);
+  const session = getSession(cwd, sessionId);
+  const hasRunningAgents = session.agents.some((a) => a.status === "running");
+  if (!hasRunningAgents) {
+    const windowId = getWindowId(sessionId);
+    if (windowId) {
+      onAllAgentsDone2(sessionId, cwd, windowId);
+    }
+  }
 }
 async function handleComplete(sessionId, cwd, report) {
   await handleOrchestratorComplete(sessionId, cwd, report);
@@ -1415,6 +1483,11 @@ switch (command) {
     const wait = Date.now() + 500;
     while (Date.now() < wait) {
     }
+    const respawnedPid = readPid();
+    if (respawnedPid) {
+      console.log(`[sisyphus] Daemon restarted (pid ${respawnedPid}) by process manager`);
+      break;
+    }
     startDaemon().catch((err) => {
       console.error("[sisyphus] Fatal error:", err);
       process.exit(1);
@@ -1428,9 +1501,20 @@ switch (command) {
       process.exit(1);
     });
     break;
+  case "help":
+  case "--help":
+  case "-h":
+    console.log("Usage: sisyphusd [command]");
+    console.log("");
+    console.log("Commands:");
+    console.log("  start     Start the daemon (default if no command given)");
+    console.log("  stop      Stop the running daemon");
+    console.log("  restart   Stop and restart the daemon");
+    console.log("  help      Show this help message");
+    break;
   default:
     console.error(`[sisyphus] Unknown command: ${command}`);
-    console.error("Usage: sisyphusd [start|stop|restart]");
+    console.error("Usage: sisyphusd [start|stop|restart|help]");
     process.exit(1);
 }
 //# sourceMappingURL=daemon.js.map