sisyphi 1.1.18 → 1.1.19

package/dist/chunk-SVGIQ2G4.js

@@ -0,0 +1,1076 @@
+#!/usr/bin/env node
+import {
+  askDecisionsPath,
+  askDir,
+  askMetaPath,
+  askOutputPath,
+  askProgressPath,
+  askVisualsDir,
+  contextDir,
+  globalConfigPath,
+  goalPath,
+  historyBaseDir,
+  historyEventsPath,
+  historySessionDir,
+  historySessionSummaryPath,
+  initialPromptPath,
+  legacyLogsPath,
+  logsDir,
+  projectConfigPath,
+  promptsDir,
+  roadmapPath,
+  sessionDir,
+  snapshotDir,
+  snapshotsDir,
+  statePath,
+  strategyPath
+} from "./chunk-PNDCVKBN.js";
+
+// src/shared/config.ts
+import { readFileSync } from "fs";
+var DEFAULT_CONFIG = {
+  model: "claude-opus-4-7[1m]",
+  pollIntervalMs: 5e3,
+  orchestratorEffort: "xhigh",
+  agentEffort: "medium",
+  notifications: {
+    enabled: true,
+    sound: "/System/Library/Sounds/Hero.aiff"
+  },
+  companionPopup: true,
+  requiredPlugins: [
+    { name: "devcore", marketplace: "crouton-kit" }
+  ]
+};
+function readJsonFile(filePath) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+function loadConfig(cwd) {
+  const globalConfig = readJsonFile(globalConfigPath());
+  const projectConfig = readJsonFile(projectConfigPath(cwd));
+  if (projectConfig.upload !== void 0) {
+    console.warn(
+      "ignoring `upload` block from project-local .sisyphus/config.json \u2014 only the global config can set upload credentials"
+    );
+    delete projectConfig.upload;
+  }
+  const merged = { ...DEFAULT_CONFIG, ...globalConfig, ...projectConfig };
+  if (globalConfig.statusBar || projectConfig.statusBar) {
+    merged.statusBar = {
+      ...merged.statusBar,
+      ...globalConfig.statusBar,
+      ...projectConfig.statusBar,
+      colors: {
+        ...merged.statusBar?.colors,
+        ...globalConfig.statusBar?.colors,
+        ...projectConfig.statusBar?.colors
+      },
+      segments: {
+        ...merged.statusBar?.segments,
+        ...globalConfig.statusBar?.segments,
+        ...projectConfig.statusBar?.segments
+      }
+    };
+  }
+  return merged;
+}
+
+// src/daemon/state.ts
+import { copyFileSync, cpSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, readdirSync, rmSync, statSync, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
+
+// src/daemon/lib/atomic.ts
+import { randomUUID } from "crypto";
+import { dirname, join } from "path";
+import { renameSync, writeFileSync } from "fs";
+function atomicWrite(filePath, data) {
+  const dir = dirname(filePath);
+  const tmpPath = join(dir, `.atomic.${randomUUID()}.tmp`);
+  writeFileSync(tmpPath, data, "utf-8");
+  renameSync(tmpPath, filePath);
+}
+var locks = /* @__PURE__ */ new Map();
+async function withLock(key, fn) {
+  const prev = locks.get(key) ?? Promise.resolve();
+  let resolve;
+  const next = new Promise((r) => {
+    resolve = r;
+  });
+  locks.set(key, next);
+  await prev;
+  try {
+    return fn();
+  } finally {
+    resolve();
+    if (locks.get(key) === next) {
+      locks.delete(key);
+    }
+  }
+}
+
+// src/shared/gitignore.ts
+import { existsSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
+var SISYPHUS_ENTRIES = [".sisyphus"];
+var SISYPHUS_HEADER = "# Sisyphus";
+function ensureSisyphusGitignore(cwd) {
+  if (!existsSync(join2(cwd, ".git"))) return;
+  const gitignorePath = join2(cwd, ".gitignore");
+  let content = "";
+  if (existsSync(gitignorePath)) {
+    content = readFileSync2(gitignorePath, "utf-8");
+  }
+  const lines = content.split("\n");
+  const missing = SISYPHUS_ENTRIES.filter((entry) => !lines.some((line) => line.trim() === entry));
+  if (missing.length === 0) return;
+  const block = [SISYPHUS_HEADER, ...missing].join("\n");
+  const separator = content.length > 0 && !content.endsWith("\n\n") ? content.endsWith("\n") ? "\n" : "\n\n" : "";
+  writeFileSync2(gitignorePath, content + separator + block + "\n", "utf-8");
+}
+
+// src/shared/types.ts
+var ORCHESTRATOR_ASKED_BY = "orchestrator";
+
+// src/daemon/state.ts
+var ROADMAP_SEED = `---
+description: >
+  Living document tracking development phases and outstanding work.
+---
+`;
+var CONTEXT_CLAUDE_MD = `# context/
+
+Agents save exploration findings, architectural notes, and reference material here for use across cycles.
+`;
+function withSessionLock(sessionId, fn) {
+  return withLock(sessionId, fn);
+}
+function createSession(id, task, cwd, context, name, effort) {
+  ensureSisyphusGitignore(cwd);
+  const dir = sessionDir(cwd, id);
+  mkdirSync(dir, { recursive: true });
+  mkdirSync(contextDir(cwd, id), { recursive: true });
+  mkdirSync(promptsDir(cwd, id), { recursive: true });
+  writeFileSync3(roadmapPath(cwd, id), ROADMAP_SEED, "utf-8");
+  mkdirSync(logsDir(cwd, id), { recursive: true });
+  writeFileSync3(goalPath(cwd, id), task, "utf-8");
+  writeFileSync3(initialPromptPath(cwd, id), task, "utf-8");
+  writeFileSync3(join3(contextDir(cwd, id), "CLAUDE.md"), CONTEXT_CLAUDE_MD, "utf-8");
+  if (context) {
+    writeFileSync3(join3(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 } : {},
+    task,
+    ...context ? { context } : {},
+    cwd,
+    status: "active",
+    createdAt,
+    activeMs: 0,
+    userBlockedMs: 0,
+    agents: [],
+    orchestratorCycles: [],
+    messages: [],
+    startHour: created.getHours(),
+    startDayOfWeek: created.getDay(),
+    orphaned: false,
+    ...effort ? { effort } : {}
+  };
+  atomicWrite(statePath(cwd, id), JSON.stringify(session, null, 2));
+  return session;
+}
+function getSession(cwd, sessionId) {
+  const content = readFileSync3(statePath(cwd, sessionId), "utf-8");
+  const session = JSON.parse(content);
+  if (session.activeMs == null) session.activeMs = 0;
+  if (session.userBlockedMs == null) session.userBlockedMs = 0;
+  for (const agent of session.agents) {
+    if (!agent.repo) agent.repo = ".";
+    if (agent.activeMs == null) agent.activeMs = 0;
+    if (agent.orphaned == null) agent.orphaned = false;
+  }
+  if (session.orphaned == null) session.orphaned = false;
+  for (const cycle of session.orchestratorCycles) {
+    if (cycle.activeMs == null) cycle.activeMs = 0;
+    if (cycle.userBlockedMs == null) cycle.userBlockedMs = 0;
+  }
+  return session;
+}
+function saveSession(session) {
+  atomicWrite(statePath(session.cwd, session.id), JSON.stringify(session, null, 2));
+}
+async function addAgent(cwd, sessionId, agent) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    session.agents.push(agent);
+    saveSession(session);
+  });
+}
+async function updateAgent(cwd, sessionId, agentId, updates) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    const agent = session.agents.slice().reverse().find((a) => a.id === agentId);
+    if (!agent) throw new Error(`Agent ${agentId} not found in session ${sessionId}`);
+    Object.assign(agent, updates);
+    saveSession(session);
+  });
+}
+async function markAgentOrphan(cwd, sessionId, agentId, opts) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    const agent = session.agents.slice().reverse().find((a) => a.id === agentId);
+    if (!agent) throw new Error(`Agent ${agentId} not found in session ${sessionId}`);
+    agent.orphaned = true;
+    agent.status = opts.status !== void 0 ? opts.status : "lost";
+    agent.killedReason = opts.reason;
+    agent.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (opts.activeMs !== void 0) agent.activeMs = opts.activeMs;
+    delete agent.pid;
+    delete agent.pidLstart;
+    saveSession(session);
+  });
+}
+async function markSessionOrphan(cwd, sessionId, opts) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    session.orphaned = true;
+    session.orphanReason = opts.reason;
+    saveSession(session);
+  });
+}
+async function clearSessionOrphan(cwd, sessionId) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    if (!session.orphaned && session.orphanReason == null) return;
+    session.orphaned = false;
+    delete session.orphanReason;
+    saveSession(session);
+  });
+}
+async function setAgentPid(cwd, sessionId, agentId, pid, pidLstart) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    const agent = session.agents.slice().reverse().find((a) => a.id === agentId);
+    if (!agent) return;
+    agent.pid = pid;
+    agent.pidLstart = pidLstart;
+    saveSession(session);
+  });
+}
+async function setAgentConsumedInline(cwd, sessionId, agentId) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    const agent = session.agents.slice().reverse().find((a) => a.id === agentId);
+    if (!agent) throw new Error(`Agent ${agentId} not found in session ${sessionId}`);
+    if (agent.consumedInline) return;
+    agent.consumedInline = true;
+    saveSession(session);
+  });
+}
+async function addOrchestratorCycle(cwd, sessionId, cycle) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    session.orchestratorCycles.push(cycle);
+    saveSession(session);
+  });
+}
+async function updateSessionStatus(cwd, sessionId, status, completionReport) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    session.status = status;
+    if (completionReport !== void 0) {
+      session.completionReport = completionReport;
+    }
+    saveSession(session);
+  });
+}
+async function appendAgentToLastCycle(cwd, sessionId, agentId) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    const cycles = session.orchestratorCycles;
+    if (cycles.length === 0) return;
+    cycles[cycles.length - 1].agentsSpawned.push(agentId);
+    saveSession(session);
+  });
+}
+async function completeSession(cwd, sessionId, report) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    session.status = "completed";
+    session.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    session.completionReport = report;
+    saveSession(session);
+  });
+}
+async function continueSession(cwd, sessionId) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    if (session.status !== "completed") {
+      throw new Error(`Session ${sessionId} is not completed (status: ${session.status})`);
+    }
+    session.status = "active";
+    session.completedAt = void 0;
+    session.completionReport = void 0;
+    const cycles = session.orchestratorCycles;
+    if (cycles.length > 0) {
+      cycles[cycles.length - 1].completedAt = void 0;
+    }
+    saveSession(session);
+    writeFileSync3(roadmapPath(cwd, sessionId), "", "utf-8");
+  });
+}
+async function appendAgentReport(cwd, sessionId, agentId, entry) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    const agent = session.agents.slice().reverse().find((a) => a.id === agentId);
+    if (!agent) throw new Error(`Agent ${agentId} not found in session ${sessionId}`);
+    agent.reports.push(entry);
+    saveSession(session);
+  });
+}
+async function updateReportSummary(cwd, sessionId, agentId, filePath, summary) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    const agent = session.agents.slice().reverse().find((a) => a.id === agentId);
+    if (!agent) return;
+    const report = agent.reports.find((r) => r.filePath === filePath);
+    if (report) {
+      report.summary = summary;
+      saveSession(session);
+    }
+  });
+}
+async function updateSessionName(cwd, sessionId, name) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    session.name = name;
+    saveSession(session);
+  });
+}
+async function updateSessionTmux(cwd, sessionId, tmuxSessionName, tmuxWindowId, tmuxSessionId) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    session.tmuxSessionName = tmuxSessionName;
+    session.tmuxSessionId = tmuxSessionId;
+    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);
+    if (!session.messages || count <= 0) return;
+    session.messages = session.messages.slice(count);
+    saveSession(session);
+  });
+}
+async function appendMessage(cwd, sessionId, message) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    if (!session.messages) session.messages = [];
+    session.messages.push(message);
+    saveSession(session);
+  });
+}
+async function updateTask(cwd, sessionId, task) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    session.task = task;
+    saveSession(session);
+    writeFileSync3(goalPath(cwd, sessionId), task, "utf-8");
+  });
+}
+async function completeOrchestratorCycle(cwd, sessionId, nextPrompt, mode, activeMs) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    const cycles = session.orchestratorCycles;
+    if (cycles.length === 0) return;
+    const cycle = cycles[cycles.length - 1];
+    if (cycle.completedAt) return;
+    cycle.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+    if (nextPrompt) cycle.nextPrompt = nextPrompt;
+    if (mode) cycle.mode = mode;
+    if (activeMs != null) cycle.activeMs += activeMs;
+    saveSession(session);
+  });
+}
+async function incrementUserBlockedMs(cwd, sessionId, deltaMs, askedAt, askedBy) {
+  if (deltaMs <= 0) return;
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    session.userBlockedMs = (session.userBlockedMs ?? 0) + deltaMs;
+    if (askedAt) {
+      const askedAtMs = new Date(askedAt).getTime();
+      const cycle = session.orchestratorCycles.find((c) => {
+        const startMs = new Date(c.timestamp).getTime();
+        const endMs = c.completedAt ? new Date(c.completedAt).getTime() : Infinity;
+        return startMs <= askedAtMs && askedAtMs < endMs;
+      });
+      if (cycle) cycle.userBlockedMs = (cycle.userBlockedMs ?? 0) + deltaMs;
+    }
+    if (askedBy && askedBy !== ORCHESTRATOR_ASKED_BY) {
+      const agent = session.agents.slice().reverse().find((a) => a.id === askedBy);
+      if (agent) agent.userBlockedMs = (agent.userBlockedMs ?? 0) + deltaMs;
+    }
+    saveSession(session);
+  });
+}
+async function incrementActiveTime(cwd, sessionId, sessionDelta, agentDeltas, cycleDeltas) {
+  return withSessionLock(sessionId, () => {
+    const session = getSession(cwd, sessionId);
+    session.activeMs += sessionDelta;
+    for (const [agentId, delta] of agentDeltas) {
+      const agent = session.agents.slice().reverse().find((a) => a.id === agentId);
+      if (agent) agent.activeMs += delta;
+    }
+    for (const [cycleNum, delta] of cycleDeltas) {
+      const cycle = session.orchestratorCycles.find((c) => c.cycle === cycleNum);
+      if (cycle) cycle.activeMs += delta;
+    }
+    saveSession(session);
+  });
+}
+function createSnapshot(cwd, sessionId, cycleNumber) {
+  const dir = snapshotDir(cwd, sessionId, cycleNumber);
+  mkdirSync(dir, { recursive: true });
+  copyFileSync(statePath(cwd, sessionId), join3(dir, "state.json"));
+  const roadmap = roadmapPath(cwd, sessionId);
+  if (existsSync2(roadmap)) copyFileSync(roadmap, join3(dir, "roadmap.md"));
+  const strategy = strategyPath(cwd, sessionId);
+  if (existsSync2(strategy)) copyFileSync(strategy, join3(dir, "strategy.md"));
+  const ld = logsDir(cwd, sessionId);
+  if (existsSync2(ld)) cpSync(ld, join3(dir, "logs"), { recursive: true });
+  const legacyLogs = legacyLogsPath(cwd, sessionId);
+  if (existsSync2(legacyLogs)) copyFileSync(legacyLogs, join3(dir, "logs.md"));
+}
+async function restoreSnapshot(cwd, sessionId, toCycle) {
+  return withSessionLock(sessionId, () => {
+    const dir = snapshotDir(cwd, sessionId, toCycle);
+    if (!existsSync2(dir)) throw new Error(`No snapshot found for cycle ${toCycle}`);
+    const snapshotState = readFileSync3(join3(dir, "state.json"), "utf-8");
+    const session = JSON.parse(snapshotState);
+    session.status = "paused";
+    session.completedAt = void 0;
+    session.completionReport = void 0;
+    session.tmuxSessionName = void 0;
+    session.tmuxSessionId = void 0;
+    session.tmuxWindowId = void 0;
+    atomicWrite(statePath(cwd, sessionId), JSON.stringify(session, null, 2));
+    const snapshotRoadmap = join3(dir, "roadmap.md");
+    if (existsSync2(snapshotRoadmap)) copyFileSync(snapshotRoadmap, roadmapPath(cwd, sessionId));
+    const snapshotStrategy = join3(dir, "strategy.md");
+    if (existsSync2(snapshotStrategy)) copyFileSync(snapshotStrategy, strategyPath(cwd, sessionId));
+    const snapshotLogsDir = join3(dir, "logs");
+    if (existsSync2(snapshotLogsDir)) {
+      const currentLogsDir = logsDir(cwd, sessionId);
+      if (existsSync2(currentLogsDir)) rmSync(currentLogsDir, { recursive: true, force: true });
+      cpSync(snapshotLogsDir, currentLogsDir, { recursive: true });
+    } else {
+      const snapshotLogs = join3(dir, "logs.md");
+      if (existsSync2(snapshotLogs)) copyFileSync(snapshotLogs, legacyLogsPath(cwd, sessionId));
+    }
+  });
+}
+function listSnapshots(cwd, sessionId) {
+  const dir = snapshotsDir(cwd, sessionId);
+  if (!existsSync2(dir)) return [];
+  return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("cycle-")).map((e) => parseInt(e.name.replace("cycle-", ""), 10)).filter((n) => !isNaN(n)).sort((a, b) => a - b);
+}
+function deleteSnapshotsAfter(cwd, sessionId, afterCycle) {
+  const dir = snapshotsDir(cwd, sessionId);
+  if (!existsSync2(dir)) return;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !entry.name.startsWith("cycle-")) continue;
+    const num = parseInt(entry.name.replace("cycle-", ""), 10);
+    if (!isNaN(num) && num > afterCycle) {
+      rmSync(join3(dir, entry.name), { recursive: true, force: true });
+    }
+  }
+}
+function replaceIdInDir(dir, sourceId, cloneId) {
+  if (!existsSync2(dir)) return;
+  const entries = readdirSync(dir, { recursive: true });
+  for (const rel of entries) {
+    const fullPath = join3(dir, rel);
+    if (!statSync(fullPath).isFile()) continue;
+    const buf = readFileSync3(fullPath);
+    const sample = buf.subarray(0, 8192);
+    if (sample.includes(0)) continue;
+    const text = buf.toString("utf-8");
+    if (text.includes(sourceId)) {
+      writeFileSync3(fullPath, text.replaceAll(sourceId, cloneId), "utf-8");
+    }
+  }
+}
+function cloneSessionDir(sourceCwd, sourceId, cloneId, goal, context, strategy) {
+  const srcDir = sessionDir(sourceCwd, sourceId);
+  const dstDir = sessionDir(sourceCwd, cloneId);
+  mkdirSync(dstDir, { recursive: true });
+  const dirsToCopy = ["context", "prompts", "reports", "snapshots"];
+  for (const sub of dirsToCopy) {
+    const src = join3(srcDir, sub);
+    const dst = join3(dstDir, sub);
+    if (existsSync2(src)) {
+      cpSync(src, dst, { recursive: true });
+    } else {
+      mkdirSync(dst, { recursive: true });
+    }
+  }
+  if (strategy) {
+    const srcStrategy = strategyPath(sourceCwd, sourceId);
+    if (existsSync2(srcStrategy)) {
+      const text = readFileSync3(srcStrategy, "utf-8");
+      writeFileSync3(strategyPath(sourceCwd, cloneId), text.replaceAll(sourceId, cloneId), "utf-8");
+    }
+  }
+  for (const sub of dirsToCopy) {
+    replaceIdInDir(join3(dstDir, sub), sourceId, cloneId);
+  }
+  writeFileSync3(goalPath(sourceCwd, cloneId), goal, "utf-8");
+  writeFileSync3(initialPromptPath(sourceCwd, cloneId), goal, "utf-8");
+  writeFileSync3(roadmapPath(sourceCwd, cloneId), ROADMAP_SEED, "utf-8");
+  mkdirSync(logsDir(sourceCwd, cloneId), { recursive: true });
+  writeFileSync3(join3(contextDir(sourceCwd, cloneId), "CLAUDE.md"), CONTEXT_CLAUDE_MD, "utf-8");
+  if (context) {
+    writeFileSync3(join3(contextDir(sourceCwd, cloneId), "initial-context.md"), context, "utf-8");
+  }
+}
+async function createCloneState(sourceCwd, sourceId, cloneId, goal, context, configModel, configOrchestratorPrompt) {
+  return withSessionLock(cloneId, () => {
+    const source = getSession(sourceCwd, sourceId);
+    const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+    const created = new Date(createdAt);
+    const agents = structuredClone(source.agents);
+    const orchestratorCycles = structuredClone(source.orchestratorCycles);
+    const messages = structuredClone(source.messages);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const agent of agents) {
+      if (agent.status === "running") {
+        agent.status = "killed";
+        agent.completedAt = now;
+        agent.killedReason = "inherited from source session";
+      }
+    }
+    const model = source.model ?? configModel;
+    const launchConfig = source.launchConfig ? structuredClone(source.launchConfig) : {
+      model,
+      context,
+      orchestratorPrompt: configOrchestratorPrompt
+    };
+    const clone = {
+      id: cloneId,
+      task: goal,
+      ...context ? { context } : {},
+      cwd: sourceCwd,
+      status: "active",
+      createdAt,
+      activeMs: 0,
+      agents,
+      orchestratorCycles,
+      messages,
+      startHour: created.getHours(),
+      startDayOfWeek: created.getDay(),
+      parentSessionId: sourceId,
+      ...model ? { model } : {},
+      launchConfig,
+      ...source.effort != null ? { effort: source.effort } : {}
+    };
+    atomicWrite(statePath(sourceCwd, cloneId), JSON.stringify(clone, null, 2));
+    return clone;
+  });
+}
+
+// src/daemon/ask-store.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync5, readdirSync as readdirSync3 } from "fs";
+
+// src/daemon/history.ts
+import { appendFileSync, mkdirSync as mkdirSync2, writeFileSync as writeFileSync4, renameSync as renameSync2, readdirSync as readdirSync2, readFileSync as readFileSync4, rmSync as rmSync2, statSync as statSync2 } from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+import { dirname as dirname2, join as join4 } from "path";
+var knownDirs = /* @__PURE__ */ new Set();
+function ensureDir(sessionId) {
+  if (knownDirs.has(sessionId)) return;
+  mkdirSync2(historySessionDir(sessionId), { recursive: true });
+  knownDirs.add(sessionId);
+}
+function emitHistoryEvent(sessionId, event, data) {
+  try {
+    ensureDir(sessionId);
+    const line = JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), event, sessionId, data }) + "\n";
+    appendFileSync(historyEventsPath(sessionId), line, "utf-8");
+  } catch {
+  }
+}
+function writeSessionSummary(session, extra) {
+  try {
+    ensureDir(session.id);
+    const summary = {
+      sessionId: session.id,
+      name: session.name ?? null,
+      task: session.task,
+      cwd: session.cwd,
+      model: session.model ?? null,
+      status: session.status,
+      startedAt: session.createdAt,
+      completedAt: session.completedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+      activeMs: session.activeMs,
+      wallClockMs: session.wallClockMs ?? null,
+      userBlockedMs: session.userBlockedMs ?? 0,
+      agentCount: session.agents.length,
+      crashCount: session.agents.filter((a) => a.status === "crashed").length,
+      lostCount: session.agents.filter((a) => a.status === "lost").length,
+      killedAgentCount: session.agents.filter((a) => a.status === "killed").length,
+      rollbackCount: session.rollbackCount ?? 0,
+      efficiency: session.wallClockMs ? Math.max(0, session.activeMs - (session.userBlockedMs ?? 0)) / Math.max(1, session.wallClockMs - (session.userBlockedMs ?? 0)) : null,
+      cycleCount: session.orchestratorCycles.length,
+      context: session.context ?? null,
+      completionReport: session.completionReport ?? null,
+      agents: session.agents.map((a) => ({
+        id: a.id,
+        name: a.name,
+        nickname: a.nickname ?? null,
+        agentType: a.agentType,
+        status: a.status,
+        activeMs: a.activeMs,
+        userBlockedMs: a.userBlockedMs ?? 0,
+        spawnedAt: a.spawnedAt,
+        completedAt: a.completedAt,
+        restartCount: a.restartCount ?? 0
+      })),
+      cycles: session.orchestratorCycles.map((c) => ({
+        cycle: c.cycle,
+        mode: c.mode ?? null,
+        agentsSpawned: c.agentsSpawned.length,
+        activeMs: c.activeMs,
+        userBlockedMs: c.userBlockedMs ?? 0,
+        startedAt: c.timestamp,
+        completedAt: c.completedAt ?? null
+      })),
+      messages: session.messages.map((m) => ({
+        id: m.id,
+        source: typeof m.source === "string" ? m.source : m.source.type,
+        content: m.content,
+        timestamp: m.timestamp
+      })),
+      finalMoodSignals: extra?.finalSignals ?? null,
+      achievements: extra?.achievements ?? [],
+      xpGained: extra?.xpGained ?? 0,
+      sentiment: extra?.sentiment ?? null
+    };
+    const filePath = historySessionSummaryPath(session.id);
+    const tmp = join4(dirname2(filePath), `.session-${randomUUID2()}.tmp`);
+    writeFileSync4(tmp, JSON.stringify(summary, null, 2), "utf-8");
+    renameSync2(tmp, filePath);
+  } catch (err) {
+    console.error(`[history] Failed to write session summary for ${session.id}:`, err);
+  }
+}
+function getRecentSentiments(count = 5, scanLimit = 30, overrideBaseDir) {
+  try {
+    const base = overrideBaseDir ?? historyBaseDir();
+    let entries;
+    try {
+      entries = readdirSync2(base);
+    } catch {
+      return [];
+    }
+    const withMtime = [];
+    for (const name of entries) {
+      try {
+        const st = statSync2(join4(base, name));
+        if (st.isDirectory()) withMtime.push({ name, mtime: st.mtimeMs });
+      } catch {
+        continue;
+      }
+    }
+    withMtime.sort((a, b) => b.mtime - a.mtime);
+    const results = [];
+    const limit = Math.min(withMtime.length, scanLimit);
+    for (let i = 0; i < limit && results.length < count; i++) {
+      try {
+        const raw = readFileSync4(join4(base, withMtime[i].name, "session.json"), "utf-8");
+        const summary = JSON.parse(raw);
+        if (summary.sentiment && summary.completedAt) {
+          results.push({
+            sentiment: summary.sentiment,
+            task: summary.task.slice(0, 100),
+            completedAt: summary.completedAt
+          });
+        }
+      } catch {
+        continue;
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+var PRUNE_KEEP_COUNT = 200;
+var PRUNE_KEEP_DAYS = 90;
+function pruneHistory() {
+  try {
+    const base = historyBaseDir();
+    let entries;
+    try {
+      entries = readdirSync2(base);
+    } catch {
+      return;
+    }
+    const sessions = [];
+    for (const name of entries) {
+      const dir = join4(base, name);
+      try {
+        const summaryPath = join4(dir, "session.json");
+        const raw = readFileSync4(summaryPath, "utf-8");
+        const summary = JSON.parse(raw);
+        sessions.push({ dir, startedAt: new Date(summary.startedAt ?? 0).getTime() });
+      } catch {
+        try {
+          const eventsPath = join4(dir, "events.jsonl");
+          const firstLine = readFileSync4(eventsPath, "utf-8").split("\n")[0];
+          const firstEvent = JSON.parse(firstLine);
+          sessions.push({ dir, startedAt: new Date(firstEvent.ts ?? 0).getTime() });
+        } catch {
+          try {
+            const st = statSync2(dir);
+            sessions.push({ dir, startedAt: st.mtimeMs });
+          } catch {
+            continue;
+          }
+        }
+      }
+    }
+    if (sessions.length <= PRUNE_KEEP_COUNT) return;
+    sessions.sort((a, b) => b.startedAt - a.startedAt);
+    const cutoff = Date.now() - PRUNE_KEEP_DAYS * 24 * 60 * 60 * 1e3;
+    for (let i = PRUNE_KEEP_COUNT; i < sessions.length; i++) {
+      if (sessions[i].startedAt < cutoff) {
+        rmSync2(sessions[i].dir, { recursive: true, force: true });
+      }
+    }
+  } catch {
+  }
+}
+
+// src/daemon/notify.ts
+import { spawn, execFile } from "child_process";
+import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync3, existsSync as existsSync3 } from "fs";
+import { join as join5 } from "path";
+import { homedir } from "os";
+
+// src/shared/shell.ts
+function shellQuote(s) {
+  return `'${s.replace(/'/g, "'\\''")}'`;
+}
+var SESSION_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+function validateSessionId(id) {
+  return SESSION_ID_PATTERN.test(id) && !id.includes("..");
+}
+function validateRepoName(repo) {
+  return !repo.includes("/") && !repo.includes("\\") && !repo.includes("..");
+}
+function escapeAppleScript(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+
+// src/daemon/notify.ts
+var TMUX_SOCKET = `/tmp/tmux-${process.getuid?.() ?? 0}/default`;
+var SWITCH_SCRIPT = [
+  "#!/bin/bash",
+  'SESSION="$1"',
+  `TMUX_SOCKET="${TMUX_SOCKET}"`,
+  "TMUX=/opt/homebrew/bin/tmux",
+  "",
+  "# Find any attached client (user is likely on a different session)",
+  `CLIENT_TTY=$("$TMUX" -S "$TMUX_SOCKET" list-clients -F '#{client_tty}' 2>/dev/null | head -1)`,
+  '[ -z "$CLIENT_TTY" ] && exit 0',
+  "",
+  "# Switch that client to the target session",
+  '"$TMUX" -S "$TMUX_SOCKET" switch-client -c "$CLIENT_TTY" -t "$SESSION" 2>/dev/null',
+  '"$TMUX" -S "$TMUX_SOCKET" select-window -t "$SESSION" 2>/dev/null',
+  "",
+  "# Bring iTerm2 to front and select the tab with this client",
+  `TTY_SHORT=$(echo "$CLIENT_TTY" | sed 's|/dev/||')`,
+  '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_SHORT\\" then',
+  "                  select t",
+  "                  return",
+  "                end if",
+  "              end tell",
+  "            end repeat",
+  "          end tell",
+  "        end repeat",
+  "      end tell",
+  "    end repeat",
+  "  end tell",
+  `" 2>/dev/null || osascript -e 'tell application "iTerm2" to activate' 2>/dev/null`,
+  ""
+].join("\n");
+function ensureSwitchScript() {
+  const dir = join5(homedir(), ".sisyphus");
+  const scriptPath = join5(dir, "notify-switch.sh");
+  try {
+    mkdirSync3(dir, { recursive: true });
+    writeFileSync5(scriptPath, SWITCH_SCRIPT, { mode: 493 });
+  } catch {
+  }
+}
+var notifyProcess = null;
+function getNotifyBinary() {
+  return join5(homedir(), ".sisyphus", "SisyphusNotify.app", "Contents", "MacOS", "sisyphus-notify");
+}
+function ensureNotifyProcess() {
+  if (notifyProcess && !notifyProcess.killed && notifyProcess.stdin?.writable) {
+    return notifyProcess;
+  }
+  const binary = getNotifyBinary();
+  if (!existsSync3(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;
+  });
+  notifyProcess.unref();
+  notifyProcess.stdin?.unref();
+  notifyProcess.stderr?.unref();
+  return notifyProcess;
+}
+function sendTerminalNotification(titleOrOpts, message, tmuxSession, level) {
+  let title;
+  let msg;
+  let tmuxSess;
+  let lvl;
+  if (typeof titleOrOpts === "object") {
+    title = titleOrOpts.title;
+    msg = titleOrOpts.message;
+    tmuxSess = titleOrOpts.tmuxSession;
+    lvl = titleOrOpts.level ?? "urgent";
+  } else {
+    title = titleOrOpts;
+    msg = message;
+    tmuxSess = tmuxSession;
+    lvl = level ?? "urgent";
+  }
+  if (tmuxSess) ensureSwitchScript();
+  const proc = ensureNotifyProcess();
+  if (proc?.stdin?.writable) {
+    const payload = { title, message: msg, level: lvl };
+    if (tmuxSess) payload.tmuxSession = tmuxSess;
+    proc.stdin.write(JSON.stringify(payload) + "\n");
+    return;
+  }
+  const tnArgs = ["-title", title, "-message", msg];
+  if (lvl === "urgent") tnArgs.push("-sound", "default");
+  execFile("terminal-notifier", tnArgs, (err) => {
+    if (err) {
+      const soundClause = lvl === "urgent" ? ' sound name "default"' : "";
+      execFile("osascript", [
+        "-e",
+        `display notification "${escapeAppleScript(msg)}" with title "${escapeAppleScript(title)}"${soundClause}`
+      ], () => {
+      });
+    }
+  });
+}
+
+// src/daemon/ask-store.ts
+var ACTIONABLE_KINDS = /* @__PURE__ */ new Set([
+  "validation",
+  "decision",
+  "context",
+  "error"
+]);
+var HEARTBEAT_ASKED_BY = "system:heartbeat";
+function maybeNotifyOnAskCreated(cwd, sessionId, meta) {
+  const isActionable = meta.kind !== void 0 && ACTIONABLE_KINDS.has(meta.kind);
+  const isHeartbeat = meta.askedBy === HEARTBEAT_ASKED_BY;
+  if (!isActionable && !isHeartbeat) return;
+  try {
+    const config = loadConfig(cwd);
+    if (config.notifications?.enabled === false) return;
+    const session = getSession(cwd, sessionId);
+    const label = session.name ?? sessionId.slice(0, 8);
+    const body = meta.title ?? "Question pending";
+    sendTerminalNotification(label, body, session.tmuxSessionName, "urgent");
+  } catch {
+  }
+}
+function createAsk(cwd, sessionId, params) {
+  mkdirSync4(askVisualsDir(cwd, sessionId, params.askId), { recursive: true });
+  const askedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const meta = {
+    askId: params.askId,
+    askedBy: params.askedBy,
+    askedAt,
+    status: "pending",
+    blocking: params.blocking,
+    cwd: params.cwd,
+    ...params.pid !== void 0 ? { pid: params.pid, startedAt: askedAt } : {},
+    ...params.claudeSessionId !== void 0 ? { claudeSessionId: params.claudeSessionId } : {},
+    ...params.title !== void 0 ? { title: params.title } : {},
+    ...params.subtitle !== void 0 ? { subtitle: params.subtitle } : {},
+    ...params.kind !== void 0 ? { kind: params.kind } : {},
+    ...params.orphanTarget !== void 0 ? { orphanTarget: params.orphanTarget } : {},
+    ...params.modeTransition !== void 0 ? { modeTransition: params.modeTransition } : {}
+  };
+  atomicWrite(askMetaPath(cwd, sessionId, params.askId), JSON.stringify(meta, null, 2));
+  emitHistoryEvent(sessionId, "ask-issued", {
+    askId: params.askId,
+    askedBy: params.askedBy,
+    blocking: params.blocking,
+    askedAt
+  });
+  maybeNotifyOnAskCreated(cwd, sessionId, meta);
+  return meta;
+}
+function writeDecisions(cwd, sessionId, askId, deck) {
+  atomicWrite(askDecisionsPath(cwd, sessionId, askId), JSON.stringify(deck, null, 2));
+}
+function readDecisions(cwd, sessionId, askId) {
+  const p = askDecisionsPath(cwd, sessionId, askId);
+  try {
+    return JSON.parse(readFileSync5(p, { encoding: "utf-8" }));
+  } catch (_e) {
+    return null;
+  }
+}
+function readProgress(cwd, sessionId, askId) {
+  const p = askProgressPath(cwd, sessionId, askId);
+  try {
+    const data = JSON.parse(readFileSync5(p, { encoding: "utf-8" }));
+    if (!Array.isArray(data["responses"])) return null;
+    return { responses: data["responses"], savedAt: data["savedAt"] };
+  } catch (_e) {
+    return null;
+  }
+}
+function writeOutput(cwd, sessionId, askId, responses, completedAt) {
+  atomicWrite(askOutputPath(cwd, sessionId, askId), JSON.stringify({
+    responses,
+    completedAt: completedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  }, null, 2));
+}
+function readMeta(cwd, sessionId, askId) {
+  const p = askMetaPath(cwd, sessionId, askId);
+  if (!existsSync4(p)) {
+    return null;
+  }
+  return JSON.parse(readFileSync5(p, "utf-8"));
+}
+async function updateMeta(cwd, sessionId, askId, patch) {
+  return withLock(askId, () => {
+    const cur = readMeta(cwd, sessionId, askId);
+    if (!cur) {
+      throw new Error(`updateMeta: askId ${askId} not found`);
+    }
+    const next = { ...cur, ...patch };
+    atomicWrite(askMetaPath(cwd, sessionId, askId), JSON.stringify(next, null, 2));
+    return next;
+  });
+}
+function listAsks(cwd, sessionId) {
+  const dir = askDir(cwd, sessionId);
+  if (!existsSync4(dir)) {
+    return [];
+  }
+  return readdirSync3(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+}
+function listOpenAsksFor(cwd, sessionId, askedBy) {
+  const out = [];
+  for (const askId of listAsks(cwd, sessionId)) {
+    const meta = readMeta(cwd, sessionId, askId);
+    if (!meta) continue;
+    if (meta.askedBy !== askedBy) continue;
+    if (meta.orphaned) continue;
+    if (!meta.blocking) continue;
+    if (meta.status !== "pending" && meta.status !== "in-progress") continue;
+    if (existsSync4(askOutputPath(cwd, sessionId, askId))) continue;
+    out.push({ askId, status: meta.status, ...meta.title !== void 0 ? { title: meta.title } : {} });
+  }
+  return out;
+}
+
+export {
+  loadConfig,
+  shellQuote,
+  validateSessionId,
+  validateRepoName,
+  atomicWrite,
+  ORCHESTRATOR_ASKED_BY,
+  createSession,
+  getSession,
+  addAgent,
+  updateAgent,
+  markAgentOrphan,
+  markSessionOrphan,
+  clearSessionOrphan,
+  setAgentPid,
+  setAgentConsumedInline,
+  addOrchestratorCycle,
+  updateSessionStatus,
+  appendAgentToLastCycle,
+  completeSession,
+  continueSession,
+  appendAgentReport,
+  updateReportSummary,
+  updateSessionName,
+  updateSessionTmux,
+  updateSession,
+  drainMessages,
+  appendMessage,
+  updateTask,
+  completeOrchestratorCycle,
+  incrementUserBlockedMs,
+  incrementActiveTime,
+  createSnapshot,
+  restoreSnapshot,
+  listSnapshots,
+  deleteSnapshotsAfter,
+  cloneSessionDir,
+  createCloneState,
+  emitHistoryEvent,
+  writeSessionSummary,
+  getRecentSentiments,
+  pruneHistory,
+  sendTerminalNotification,
+  createAsk,
+  writeDecisions,
+  readDecisions,
+  readProgress,
+  writeOutput,
+  readMeta,
+  updateMeta,
+  listAsks,
+  listOpenAsksFor
+};
+//# sourceMappingURL=chunk-SVGIQ2G4.js.map