sisyphi 1.0.4 → 1.0.6

package/dist/cli.js

@@ -1,8 +1,14 @@
 #!/usr/bin/env node
 import {
   buildCompanionContext,
-  computeActiveTimeMs
-} from "./chunk-DBR33QHM.js";
+  computeActiveTimeMs,
+  formatDuration,
+  rawSend,
+  statusColor
+} from "./chunk-T7ETTIQK.js";
+import {
+  shellQuote
+} from "./chunk-6G226ZK7.js";
 import {
   daemonLogPath,
   daemonPidPath,
@@ -10,17 +16,15 @@ import {
   globalDir,
   roadmapPath,
   socketPath
-} from "./chunk-YGBGKMTF.js";
+} from "./chunk-JXKUI4P6.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4 } from "fs";
 
 // src/cli/commands/start.ts
 import { execSync as execSync5 } from "child_process";
 
-// src/cli/client.ts
-import { connect as connect2 } from "net";
-
 // src/cli/install.ts
 import { execSync as execSync2 } from "child_process";
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
@@ -304,37 +308,8 @@ async function waitForDaemon(maxWaitMs = 6e3) {
 }
 
 // src/cli/client.ts
-function rawSend(request) {
-  const sock = socketPath();
-  return new Promise((resolve2, reject) => {
-    const socket = connect2(sock);
-    let data = "";
-    const timeout = setTimeout(() => {
-      socket.destroy();
-      reject(new Error("Request timed out after 10s"));
-    }, 1e4);
-    socket.on("connect", () => {
-      socket.write(JSON.stringify(request) + "\n");
-    });
-    socket.on("data", (chunk) => {
-      data += chunk.toString();
-      const newlineIdx = data.indexOf("\n");
-      if (newlineIdx !== -1) {
-        clearTimeout(timeout);
-        const line = data.slice(0, newlineIdx);
-        socket.destroy();
-        try {
-          resolve2(JSON.parse(line));
-        } catch {
-          reject(new Error(`Invalid JSON response from daemon: ${line}`));
-        }
-      }
-    });
-    socket.on("error", (err) => {
-      clearTimeout(timeout);
-      reject(err);
-    });
-  });
+function rawSend2(request) {
+  return rawSend(request, 1e4);
 }
 async function sendRequest(request) {
   const sleep2 = (ms) => new Promise((resolve2) => setTimeout(resolve2, ms));
@@ -344,7 +319,7 @@ async function sendRequest(request) {
   let lastErr;
   for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
     try {
-      return await rawSend(request);
+      return await rawSend2(request);
     } catch (err) {
       lastErr = err;
       const code = err.code;
@@ -364,17 +339,51 @@ async function sendRequest(request) {
     }
   }
   if (process.platform !== "darwin") {
-    throw new Error(
-      `Sisyphus daemon is not running.
-  Start it manually: sisyphusd &
-  Or check logs at: ~/.sisyphus/daemon.log`
+    const lines = [`Sisyphus daemon is not running.`];
+    if (process.platform === "linux") {
+      lines.push(
+        "",
+        "  Start options:",
+        "    sisyphusd &                                    # Run in background",
+        "    nohup sisyphusd > ~/.sisyphus/daemon.log 2>&1 & # Persist after logout",
+        "",
+        "  For systemd (recommended):",
+        "    # Create ~/.config/systemd/user/sisyphus.service with:",
+        "    #   [Unit]",
+        "    #   Description=Sisyphus Daemon",
+        "    #   [Service]",
+        "    #   ExecStart=/usr/bin/env node <path-to-sisyphusd>",
+        "    #   Restart=always",
+        "    #   [Install]",
+        "    #   WantedBy=default.target",
+        "    systemctl --user enable --now sisyphus"
+      );
+    } else {
+      lines.push(
+        "",
+        "  Start it manually: sisyphusd &"
+      );
+    }
+    lines.push(
+      "",
+      "  Diagnose: sisyphus doctor",
+      "  Logs: tail -f ~/.sisyphus/daemon.log"
     );
+    throw new Error(lines.join("\n"));
   }
   throw lastErr;
 }
 
 // src/cli/tmux.ts
 import { execSync as execSync3 } from "child_process";
+function isTmuxInstalled() {
+  try {
+    execSync3("which tmux", { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
 function assertTmux() {
   if (!process.env.TMUX) {
     throw new Error("Not running inside a tmux pane. Sisyphus requires tmux.");
@@ -388,21 +397,21 @@ function getTmuxSession() {
 // src/cli/commands/dashboard.ts
 import { join as join3 } from "path";
 import { execSync as execSync4 } from "child_process";
-function shellQuote(s) {
-  return `'${s.replace(/'/g, "'\\''")}'`;
-}
-function isDashboardOpen(tmuxSession) {
+function ensureDashboard(tmuxSession, cwd) {
   try {
     const windows = execSync4(
       `tmux list-windows -t ${shellQuote(tmuxSession)} -F "#{window_name}"`,
       { encoding: "utf-8" }
     );
-    return windows.split("\n").some((name) => name.trim() === "sisyphus-dashboard");
+    const isOpen = windows.split("\n").some((name) => name.trim() === "sisyphus-dashboard");
+    if (isOpen) {
+      execSync4(
+        `tmux select-window -t ${shellQuote(tmuxSession)}:sisyphus-dashboard`
+      );
+      return false;
+    }
   } catch {
-    return false;
   }
-}
-function launchDashboard(tmuxSession, cwd) {
   const tuiPath = join3(import.meta.dirname, "tui.js");
   const windowId = execSync4(
     `tmux new-window -n "sisyphus-dashboard" -c ${shellQuote(cwd)} -P -F "#{window_id}"`,
@@ -412,36 +421,33 @@ function launchDashboard(tmuxSession, cwd) {
   execSync4(
     `tmux send-keys -t ${shellQuote(windowId)} ${shellQuote(cmd)} Enter`
   );
+  return true;
 }
 function registerDashboard(program2) {
   program2.command("dashboard").description("Launch the TUI dashboard for monitoring and managing sessions").action(async () => {
     assertTmux();
     const tmuxSession = getTmuxSession();
-    const cwd = process.cwd();
-    launchDashboard(tmuxSession, cwd);
+    ensureDashboard(tmuxSession, process.cwd());
   });
 }
 
 // src/cli/commands/start.ts
-function shellQuote2(s) {
-  return `'${s.replace(/'/g, "'\\''")}'`;
-}
-function isTmuxInstalled() {
-  try {
-    execSync5("which tmux", { stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
-}
 function registerStart(program2) {
-  program2.command("start").description("Start a new sisyphus session").argument("<task>", "Task description for the orchestrator").option("-c, --context <context>", "Background context for the orchestrator").option("-n, --name <name>", "Human-readable name for the session").action(async (task, opts) => {
+  program2.command("start").description("Start a new sisyphus session").argument("<task>", "Task description for the orchestrator").option("-c, --context <context>", "Background context for the orchestrator").option("-n, --name <name>", "Human-readable name for the session").option("--no-tmux-check", "Skip the tmux session check").action(async (task, opts) => {
     const cwd = process.env["SISYPHUS_CWD"] ?? process.cwd();
-    if (!process.env["TMUX"] && isTmuxInstalled()) {
-      console.log("Note: Sisyphus uses tmux to manage agent panes.");
-      console.log("It is highly recommended to run sisyphus from inside a tmux session.");
-      console.log("  tmux new-session");
-      console.log("");
+    if (!process.env["TMUX"] && opts.tmuxCheck !== false) {
+      if (!isTmuxInstalled()) {
+        console.error("Error: tmux is not installed. Sisyphus requires tmux for agent panes.");
+        console.error("  Install: brew install tmux (macOS) or apt install tmux (Linux)");
+        console.error("  Then: tmux new-session");
+        process.exit(1);
+      }
+      console.error("Error: Not running inside a tmux session.");
+      console.error("  Sisyphus uses tmux to manage agent panes.");
+      console.error("  Start a tmux session first: tmux new-session");
+      console.error("");
+      console.error('  To skip this check: sisyphus start --no-tmux-check "task"');
+      process.exit(1);
     }
     const request = { type: "start", task, context: opts.context, cwd, name: opts.name };
     const response = await sendRequest(request);
@@ -450,13 +456,12 @@ function registerStart(program2) {
       const tmuxSessionName = response.data?.tmuxSessionName;
       if (process.env["TMUX"]) {
         try {
-          execSync5(`tmux set-option @sisyphus_cwd ${shellQuote2(cwd)}`, { stdio: "ignore" });
+          execSync5(`tmux set-option @sisyphus_cwd ${shellQuote(cwd)}`, { stdio: "ignore" });
         } catch {
         }
         try {
           const tmuxSession = getTmuxSession();
-          if (!isDashboardOpen(tmuxSession)) {
-            launchDashboard(tmuxSession, cwd);
+          if (ensureDashboard(tmuxSession, cwd)) {
             console.log(`Dashboard opened in tmux window "sisyphus-dashboard"`);
           }
         } catch {
@@ -636,7 +641,7 @@ Follow up:`);
 
 // src/cli/commands/continue.ts
 function registerContinue(program2) {
-  program2.command("continue").description("Reactivate a completed session (orchestrator only)").action(async () => {
+  program2.command("continue").description("Clear roadmap and continue working on a completed session (stays in current cycle)").addHelpText("after", "\n  Use `continue` when a session completed but you want to add more work.\n  Use `resume` when you want to restart with specific new instructions.\n").action(async () => {
     assertTmux();
     const sessionId = process.env.SISYPHUS_SESSION_ID;
     if (!sessionId) {
@@ -656,47 +661,22 @@ function registerContinue(program2) {
 
 // src/cli/commands/status.ts
 import { readFileSync as readFileSync3 } from "fs";
-var STATUS_COLORS = {
-  active: "\x1B[32m",
-  // green
-  paused: "\x1B[33m",
-  // yellow
-  completed: "\x1B[36m",
-  // cyan
-  running: "\x1B[32m",
-  // green
-  killed: "\x1B[31m",
-  // red
-  crashed: "\x1B[31m",
-  // red
-  lost: "\x1B[90m"
-  // gray
+var COLOR_CODES = {
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  red: "\x1B[31m",
+  gray: "\x1B[90m",
+  white: "\x1B[37m"
 };
 var RESET = "\x1B[0m";
 var BOLD = "\x1B[1m";
 var DIM = "\x1B[2m";
 function colorize(text, status) {
-  const color = STATUS_COLORS[status];
-  if (!color) return `${text}${RESET}`;
-  return `${color}${text}${RESET}`;
-}
-function formatMs(ms) {
-  const totalSeconds = Math.floor(ms / 1e3);
-  if (totalSeconds < 0) return "0s";
-  const hours = Math.floor(totalSeconds / 3600);
-  const minutes = Math.floor(totalSeconds % 3600 / 60);
-  const seconds = totalSeconds % 60;
-  const parts = [];
-  if (hours > 0) parts.push(`${hours}h`);
-  if (minutes > 0) parts.push(`${minutes}m`);
-  parts.push(`${seconds}s`);
-  return parts.join(" ");
-}
-function formatDuration(startOrMs, endIso) {
-  if (typeof startOrMs === "number") return formatMs(startOrMs);
-  const start = new Date(startOrMs).getTime();
-  const end = endIso ? new Date(endIso).getTime() : Date.now();
-  return formatMs(end - start);
+  const colorName = statusColor(status);
+  const code = COLOR_CODES[colorName];
+  if (!code) return `${text}\x1B[0m`;
+  return `${code}${text}\x1B[0m`;
 }
 function inferOrchestratorPhase(session) {
   const cycles = session.orchestratorCycles;
@@ -788,7 +768,7 @@ ${BOLD}Session: ${session.id}${RESET}`);
   console.log(`  Duration: ${sessionDuration}${session.completedAt ? "" : " (ongoing)"} (${activeTime} active)`);
   const lastActivity = computeLastActivity(session);
   if (lastActivity) {
-    console.log(`  Last activity: ${formatMs(Date.now() - lastActivity.getTime())} ago`);
+    console.log(`  Last activity: ${formatDuration(Date.now() - lastActivity.getTime())} ago`);
   }
   console.log(`  Orchestrator cycles: ${session.orchestratorCycles.length}`);
   const runningAgents = session.agents.filter((a) => a.status === "running");
@@ -849,7 +829,7 @@ function registerStatus(program2) {
 
 // src/cli/commands/list.ts
 import { basename } from "path";
-var STATUS_COLORS2 = {
+var STATUS_COLORS = {
   active: "\x1B[32m",
   paused: "\x1B[33m",
   completed: "\x1B[36m"
@@ -880,7 +860,7 @@ function registerList(program2) {
         return;
       }
       for (const s of sessions) {
-        const color = STATUS_COLORS2[s.status] ?? "";
+        const color = STATUS_COLORS[s.status] ?? "";
         const status = `${color}${s.status}${RESET2}`;
         const agents = `${DIM2}${s.agentCount} agent(s)${RESET2}`;
         const task = truncateTask(s.task, 60);
@@ -927,7 +907,7 @@ function registerReport(program2) {
 
 // src/cli/commands/resume.ts
 function registerResume(program2) {
-  program2.command("resume").description("Resume a paused session").argument("<session-id>", "Session ID to resume").argument("[message]", "Additional instructions for the orchestrator").action(async (sessionId, message) => {
+  program2.command("resume").description("Respawn orchestrator with new instructions (for paused/completed sessions)").addHelpText("after", "\n  Use `resume` to restart a paused or completed session with new instructions.\n  Use `continue` to keep working on a completed session without new instructions.\n").argument("<session-id>", "Session ID to resume").argument("[message]", "Additional instructions for the orchestrator").action(async (sessionId, message) => {
     const cwd = process.cwd();
     const request = { type: "resume", sessionId, cwd, message };
     const response = await sendRequest(request);
@@ -994,7 +974,7 @@ function registerNotify(program2) {
   notify.command("pane-exited").description("Notify daemon that a tmux pane exited").requiredOption("--pane-id <paneId>", "Pane ID that exited").action(async (opts) => {
     try {
       const request = { type: "pane-exited", paneId: opts.paneId };
-      await rawSend(request);
+      await rawSend2(request);
     } catch {
     }
   });
@@ -1107,25 +1087,81 @@ function registerSetupKeybind(program2) {
 // src/cli/commands/doctor.ts
 import { execSync as execSync7 } from "child_process";
 import { existsSync as existsSync3, statSync } from "fs";
+function checkNodeVersion() {
+  const major = parseInt(process.versions.node.split(".")[0], 10);
+  if (major < 22) {
+    return { name: "Node.js", status: "fail", detail: `v${process.versions.node} (v22+ required)`, fix: "Install Node.js 22+: https://nodejs.org" };
+  }
+  return { name: "Node.js", status: "ok", detail: `v${process.versions.node}` };
+}
+function checkClaudeCli() {
+  try {
+    execSync7("which claude", { stdio: "pipe" });
+    return { name: "Claude CLI", status: "ok", detail: "Found on PATH" };
+  } catch {
+    return {
+      name: "Claude CLI",
+      status: "fail",
+      detail: "Not found on PATH",
+      fix: "Install Claude Code: https://docs.anthropic.com/en/docs/claude-code/overview"
+    };
+  }
+}
+function checkGit() {
+  try {
+    const version = execSync7("git --version", { encoding: "utf-8", stdio: "pipe" }).trim();
+    return { name: "git", status: "ok", detail: version };
+  } catch {
+    return { name: "git", status: "fail", detail: "Not found on PATH", fix: "Install git: https://git-scm.com/downloads" };
+  }
+}
+function checkTmuxVersion() {
+  try {
+    const version = execSync7("tmux -V", { encoding: "utf-8", stdio: "pipe" }).trim();
+    const match = version.match(/(\d+\.\d+)/);
+    if (!match) return { name: "tmux version", status: "warn", detail: `Could not parse version: ${version}` };
+    const ver = parseFloat(match[1]);
+    if (ver < 3.2) {
+      const upgradeHint = process.platform === "darwin" ? "brew install tmux (or upgrade)" : "apt install tmux (Debian/Ubuntu) or your package manager";
+      return { name: "tmux version", status: "warn", detail: `${version} (3.2+ recommended for popup support)`, fix: upgradeHint };
+    }
+    return { name: "tmux version", status: "ok", detail: version };
+  } catch {
+    return { name: "tmux version", status: "warn", detail: "Could not determine version" };
+  }
+}
 function checkDaemonInstalled() {
-  if (isInstalled()) {
-    return { name: "Daemon plist", status: "ok", detail: "Installed in LaunchAgents" };
+  if (process.platform === "darwin") {
+    if (isInstalled()) {
+      return { name: "Daemon plist", status: "ok", detail: "Installed in LaunchAgents" };
+    }
+    return {
+      name: "Daemon plist",
+      status: "fail",
+      detail: "Not installed",
+      fix: 'Run any sisyphus command to auto-install, or: sisyphus start "test"'
+    };
+  }
+  const pid = daemonPidPath();
+  if (existsSync3(pid)) {
+    return { name: "Daemon setup", status: "ok", detail: `PID file found at ${pid}` };
   }
   return {
-    name: "Daemon plist",
+    name: "Daemon setup",
     status: "fail",
-    detail: "Not installed",
-    fix: 'Run any sisyphus command to auto-install, or: sisyphus start "test"'
+    detail: "Daemon not running (no PID file)",
+    fix: "Start manually: sisyphusd & \u2014 or configure via systemd"
   };
 }
 function checkDaemonRunning() {
   const pid = daemonPidPath();
   if (!existsSync3(pid)) {
+    const fix = process.platform === "darwin" ? "launchctl load -w ~/Library/LaunchAgents/com.sisyphus.daemon.plist" : "sisyphusd & \u2014 or check if the process is running";
     return {
       name: "Daemon process",
       status: "fail",
       detail: "No PID file found",
-      fix: "launchctl load -w ~/Library/LaunchAgents/com.sisyphus.daemon.plist"
+      fix
     };
   }
   try {
@@ -1145,7 +1181,8 @@ function checkTmux() {
   try {
     execSync7("which tmux", { stdio: "pipe" });
   } catch {
-    return { name: "tmux", status: "fail", detail: "Not found on PATH", fix: "brew install tmux" };
+    const installHint = process.platform === "darwin" ? "brew install tmux" : "apt install tmux (Debian/Ubuntu) or your package manager";
+    return { name: "tmux", status: "fail", detail: "Not found on PATH", fix: installHint };
   }
   try {
     execSync7("tmux list-sessions", { stdio: "pipe" });
@@ -1216,10 +1253,14 @@ var SYMBOLS = { ok: "\u2713", warn: "!", fail: "\u2717" };
 function registerDoctor(program2) {
   program2.command("doctor").description("Check sisyphus installation health").action(async () => {
     const checks = [
+      checkNodeVersion(),
+      checkClaudeCli(),
+      checkGit(),
+      checkTmux(),
+      checkTmuxVersion(),
       checkGlobalDir(),
       checkDaemonInstalled(),
       checkDaemonRunning(),
-      checkTmux(),
       checkCycleScript(),
       checkTmuxKeybind()
     ];
@@ -1229,7 +1270,7 @@ function registerDoctor(program2) {
       console.log(`  ${sym} ${c.name}: ${c.detail}`);
       if (c.status !== "ok") hasIssues = true;
     }
-    const fixable = checks.filter((c) => c.fix);
+    const fixable = checks.filter((c) => c.fix && c.status !== "ok");
     if (fixable.length > 0) {
       console.log("\nFixes:");
       for (const c of fixable) {
@@ -1251,18 +1292,9 @@ function registerCompanionContext(program2) {
 }
 
 // src/cli/commands/getting-started.ts
-import { execSync as execSync8 } from "child_process";
-function isTmuxInstalled2() {
-  try {
-    execSync8("which tmux", { stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
-}
 function registerGettingStarted(program2) {
   program2.command("getting-started").description("Show a complete guide to using sisyphus effectively").action(() => {
-    const hasTmux = isTmuxInstalled2();
+    const hasTmux = isTmuxInstalled();
     const inTmux = !!process.env["TMUX"];
     const lines = [
       "",
@@ -1374,15 +1406,67 @@ function registerGettingStarted(program2) {
       "  Health:",
       "    sisyphus doctor                     Check installation health",
       "    tail -f ~/.sisyphus/daemon.log      Watch daemon logs",
+      "",
+      "  \u2500\u2500\u2500 Next Steps \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+      "",
+      "  1. Run `sisyphus doctor` to check your setup",
+      "  2. Start a tmux session: `tmux new-session`",
+      '  3. Try it: `sisyphus start "your task description"`',
       ""
     );
     console.log(lines.join("\n"));
   });
 }
 
+// src/cli/commands/init.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join4 } from "path";
+var DEFAULT_CONFIG = {};
+var ORCHESTRATOR_TEMPLATE = `# Custom Orchestrator Prompt
+
+<!-- This file overrides the default orchestrator system prompt. -->
+<!-- Delete this file to use the built-in prompt. -->
+<!-- See: https://github.com/silasrhyneer/sisyphi for details. -->
+`;
+function registerInit(program2) {
+  program2.command("init").description("Initialize sisyphus configuration for this project").option("--orchestrator", "Also create a custom orchestrator prompt template").action((opts) => {
+    const cwd = process.cwd();
+    const sisDir = join4(cwd, ".sisyphus");
+    const configPath = join4(sisDir, "config.json");
+    if (existsSync4(configPath)) {
+      console.log(`Already initialized: ${configPath}`);
+      return;
+    }
+    mkdirSync3(sisDir, { recursive: true });
+    writeFileSync3(configPath, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n", "utf-8");
+    console.log(`Created ${configPath}`);
+    if (opts.orchestrator) {
+      const orchPath = join4(sisDir, "orchestrator.md");
+      if (!existsSync4(orchPath)) {
+        writeFileSync3(orchPath, ORCHESTRATOR_TEMPLATE, "utf-8");
+        console.log(`Created ${orchPath}`);
+      }
+    }
+    console.log("");
+    console.log("Configuration options (add to .sisyphus/config.json):");
+    console.log('  orchestratorEffort  \u2014 "low" | "medium" | "high" | "max" (default: "high")');
+    console.log('  agentEffort         \u2014 "low" | "medium" | "high" | "max" (default: "medium")');
+    console.log("  pollIntervalMs      \u2014 Daemon poll interval in ms (default: 5000)");
+    console.log("  autoUpdate          \u2014 Auto-update daemon on restart (default: true)");
+  });
+}
+
 // src/cli/index.ts
+var nodeVersion = parseInt(process.versions.node.split(".")[0], 10);
+if (nodeVersion < 22) {
+  console.error(`Sisyphus requires Node.js v22+ (current: v${process.versions.node})`);
+  process.exit(1);
+}
 var program = new Command();
 program.name("sisyphus").description("tmux-integrated orchestration daemon for Claude Code").version("0.1.0");
+program.configureHelp({
+  sortSubcommands: false
+});
 registerStart(program);
 registerSpawn(program);
 registerSubmit(program);
@@ -1405,6 +1489,30 @@ registerSetupKeybind(program);
 registerDoctor(program);
 registerCompanionContext(program);
 registerGettingStarted(program);
+registerInit(program);
+program.addHelpText("after", `
+Examples:
+  $ sisyphus start "Implement auth system"     Start a new session
+  $ sisyphus start "Build @spec.md" -n auth    Start with a name and spec reference
+  $ sisyphus status                            Check current sessions
+  $ sisyphus dashboard                         Open the TUI
+  $ sisyphus doctor                            Verify installation
+
+Run 'sisyphus getting-started' for a complete usage guide.
+`);
+var args = process.argv.slice(2);
+var firstArg = args[0];
+var skipWelcome = ["doctor", "getting-started", "help", "--help", "-h", "init", "uninstall", "--version", "-V"];
+if (!existsSync5(globalDir()) && firstArg && !skipWelcome.includes(firstArg)) {
+  mkdirSync4(globalDir(), { recursive: true });
+  console.log("");
+  console.log("  Welcome to Sisyphus \u2014 multi-agent orchestration for Claude Code.");
+  console.log("");
+  console.log("  First time? Run these commands:");
+  console.log("    sisyphus doctor           Check your setup");
+  console.log("    sisyphus getting-started   Learn the basics");
+  console.log("");
+}
 program.parseAsync(process.argv).catch((err) => {
   console.error(err.message);
   process.exit(1);