pure-point-guard 0.2.0 → 0.3.0

package/dist/cli.js

@@ -10,19 +10,19 @@ var __export = (target, all) => {
 };
 
 // src/lib/errors.ts
-var PgError, TmuxNotFoundError, NotGitRepoError, NotInitializedError, ManifestLockError, WorktreeNotFoundError, AgentNotFoundError, MergeFailedError, GhNotFoundError, UnmergedWorkError;
+var PpgError, TmuxNotFoundError, NotGitRepoError, NotInitializedError, ManifestLockError, WorktreeNotFoundError, AgentNotFoundError, MergeFailedError, GhNotFoundError, UnmergedWorkError;
 var init_errors = __esm({
   "src/lib/errors.ts"() {
     "use strict";
-    PgError = class extends Error {
+    PpgError = class extends Error {
       constructor(message, code, exitCode = 1) {
         super(message);
         this.code = code;
         this.exitCode = exitCode;
-        this.name = "PgError";
+        this.name = "PpgError";
       }
     };
-    TmuxNotFoundError = class extends PgError {
+    TmuxNotFoundError = class extends PpgError {
       constructor() {
         super(
           "tmux is not installed or not in PATH. Install it with: brew install tmux",
@@ -31,7 +31,7 @@ var init_errors = __esm({
         this.name = "TmuxNotFoundError";
       }
     };
-    NotGitRepoError = class extends PgError {
+    NotGitRepoError = class extends PpgError {
       constructor(dir) {
         super(
           `Not a git repository: ${dir}`,
@@ -40,7 +40,7 @@ var init_errors = __esm({
         this.name = "NotGitRepoError";
       }
     };
-    NotInitializedError = class extends PgError {
+    NotInitializedError = class extends PpgError {
       constructor(dir) {
         super(
           `Point Guard not initialized in ${dir}. Run 'ppg init' first.`,
@@ -49,7 +49,7 @@ var init_errors = __esm({
         this.name = "NotInitializedError";
       }
     };
-    ManifestLockError = class extends PgError {
+    ManifestLockError = class extends PpgError {
       constructor() {
         super(
           "Could not acquire manifest lock. Another ppg process may be running.",
@@ -58,7 +58,7 @@ var init_errors = __esm({
         this.name = "ManifestLockError";
       }
     };
-    WorktreeNotFoundError = class extends PgError {
+    WorktreeNotFoundError = class extends PpgError {
       constructor(id) {
         super(
           `Worktree not found: ${id}`,
@@ -67,7 +67,7 @@ var init_errors = __esm({
         this.name = "WorktreeNotFoundError";
       }
     };
-    AgentNotFoundError = class extends PgError {
+    AgentNotFoundError = class extends PpgError {
       constructor(id) {
         super(
           `Agent not found: ${id}`,
@@ -76,13 +76,13 @@ var init_errors = __esm({
         this.name = "AgentNotFoundError";
       }
     };
-    MergeFailedError = class extends PgError {
+    MergeFailedError = class extends PpgError {
       constructor(message) {
         super(message, "MERGE_FAILED");
         this.name = "MergeFailedError";
       }
     };
-    GhNotFoundError = class extends PgError {
+    GhNotFoundError = class extends PpgError {
       constructor() {
         super(
           "GitHub CLI (gh) is not installed or not in PATH. Install it with: brew install gh",
@@ -91,7 +91,7 @@ var init_errors = __esm({
         this.name = "GhNotFoundError";
       }
     };
-    UnmergedWorkError = class extends PgError {
+    UnmergedWorkError = class extends PpgError {
       constructor(names) {
         const list = names.map((n) => `  ${n}`).join("\n");
         super(
@@ -115,8 +115,6 @@ function formatStatus(status) {
 function output(data, json) {
   if (json) {
     console.log(JSON.stringify(data, null, 2));
-  } else if (typeof data === "string") {
-    console.log(data);
   } else {
     console.log(data);
   }
@@ -196,54 +194,76 @@ var init_output = __esm({
 });
 
 // src/lib/paths.ts
+import os from "os";
 import path from "path";
-function pgDir(projectRoot) {
-  return path.join(projectRoot, PG_DIR);
+function globalPpgDir() {
+  return path.join(os.homedir(), PPG_DIR);
+}
+function globalPromptsDir() {
+  return path.join(globalPpgDir(), "prompts");
+}
+function globalTemplatesDir() {
+  return path.join(globalPpgDir(), "templates");
+}
+function globalSwarmsDir() {
+  return path.join(globalPpgDir(), "swarms");
+}
+function ppgDir(projectRoot) {
+  return path.join(projectRoot, PPG_DIR);
 }
 function manifestPath(projectRoot) {
-  return path.join(pgDir(projectRoot), "manifest.json");
+  return path.join(ppgDir(projectRoot), "manifest.json");
 }
 function configPath(projectRoot) {
-  return path.join(pgDir(projectRoot), "config.yaml");
+  return path.join(ppgDir(projectRoot), "config.yaml");
 }
 function resultsDir(projectRoot) {
-  return path.join(pgDir(projectRoot), "results");
+  return path.join(ppgDir(projectRoot), "results");
 }
 function resultFile(projectRoot, agentId2) {
   return path.join(resultsDir(projectRoot), `${agentId2}.md`);
 }
 function templatesDir(projectRoot) {
-  return path.join(pgDir(projectRoot), "templates");
+  return path.join(ppgDir(projectRoot), "templates");
 }
 function logsDir(projectRoot) {
-  return path.join(pgDir(projectRoot), "logs");
+  return path.join(ppgDir(projectRoot), "logs");
 }
 function promptsDir(projectRoot) {
-  return path.join(pgDir(projectRoot), "prompts");
+  return path.join(ppgDir(projectRoot), "prompts");
 }
 function swarmsDir(projectRoot) {
-  return path.join(pgDir(projectRoot), "swarms");
+  return path.join(ppgDir(projectRoot), "swarms");
 }
 function promptFile(projectRoot, agentId2) {
   return path.join(promptsDir(projectRoot), `${agentId2}.md`);
 }
 function agentPromptsDir(projectRoot) {
-  return path.join(pgDir(projectRoot), "agent-prompts");
+  return path.join(ppgDir(projectRoot), "agent-prompts");
 }
 function agentPromptFile(projectRoot, agentId2) {
   return path.join(agentPromptsDir(projectRoot), `${agentId2}.md`);
 }
+function schedulesPath(projectRoot) {
+  return path.join(ppgDir(projectRoot), "schedules.yaml");
+}
+function cronLogPath(projectRoot) {
+  return path.join(logsDir(projectRoot), "cron.log");
+}
+function cronPidPath(projectRoot) {
+  return path.join(ppgDir(projectRoot), "cron.pid");
+}
 function worktreeBaseDir(projectRoot) {
   return path.join(projectRoot, ".worktrees");
 }
 function worktreePath(projectRoot, id) {
   return path.join(worktreeBaseDir(projectRoot), id);
 }
-var PG_DIR;
+var PPG_DIR;
 var init_paths = __esm({
   "src/lib/paths.ts"() {
     "use strict";
-    PG_DIR = ".pg";
+    PPG_DIR = ".ppg";
   }
 });
 
@@ -264,13 +284,20 @@ async function loadConfig(projectRoot) {
   }
 }
 function mergeConfig(defaults, overrides) {
+  const mergedAgents = { ...defaults.agents };
+  if (overrides.agents) {
+    for (const [key, override] of Object.entries(overrides.agents)) {
+      if (mergedAgents[key]) {
+        mergedAgents[key] = { ...mergedAgents[key], ...override };
+      } else {
+        mergedAgents[key] = override;
+      }
+    }
+  }
   return {
     ...defaults,
     ...overrides,
-    agents: {
-      ...defaults.agents,
-      ...overrides.agents ?? {}
-    }
+    agents: mergedAgents
   };
 }
 async function writeDefaultConfig(projectRoot) {
@@ -300,12 +327,18 @@ var init_config = __esm({
           command: "claude --dangerously-skip-permissions",
           interactive: true,
           resultInstructions: [
-            "When you have completed the task, write a summary of what you did and any important notes",
-            "to the result file at: {{RESULT_FILE}}",
-            "Use this exact format:",
+            "When you have completed the task:",
+            "",
+            "1. Stage and commit all your changes with a descriptive commit message",
+            "2. Push your branch: git push -u origin {{BRANCH}}",
+            "3. Create a pull request: gh pr create --head {{BRANCH}} --base main --fill",
+            "4. Write your results to {{RESULT_FILE}} in this format:",
             "",
             "# Result: {{AGENT_ID}}",
             "",
+            "## PR",
+            "<the PR URL from step 3>",
+            "",
             "## Summary",
             "<what you accomplished>",
             "",
@@ -317,10 +350,6 @@ var init_config = __esm({
           ].join("\n")
         }
       },
-      worktreeBase: ".worktrees",
-      templateDir: ".pg/templates",
-      resultDir: ".pg/results",
-      logDir: ".pg/logs",
       envFiles: [".env", ".env.local"],
       symlinkNodeModules: true
     };
@@ -367,6 +396,16 @@ async function readManifest(projectRoot) {
   const raw = await fs2.readFile(mPath, "utf-8");
   return JSON.parse(raw);
 }
+async function requireManifest(projectRoot) {
+  try {
+    return await readManifest(projectRoot);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw new NotInitializedError(projectRoot);
+    }
+    throw err;
+  }
+}
 async function writeManifest(projectRoot, manifest) {
   const writeFileAtomic = await getWriteFileAtomic();
   const mPath = manifestPath(projectRoot);
@@ -537,18 +576,17 @@ var init_env = __esm({
 // src/core/tmux.ts
 var tmux_exports = {};
 __export(tmux_exports, {
-  attachSession: () => attachSession,
   capturePane: () => capturePane,
   checkTmux: () => checkTmux,
   createWindow: () => createWindow,
   ensureSession: () => ensureSession,
   getPaneInfo: () => getPaneInfo,
   isInsideTmux: () => isInsideTmux,
+  killOrphanWindows: () => killOrphanWindows,
   killPane: () => killPane,
   killWindow: () => killWindow,
-  listPanes: () => listPanes,
   listSessionPanes: () => listSessionPanes,
-  selectPane: () => selectPane,
+  listSessionWindows: () => listSessionWindows,
   selectWindow: () => selectWindow,
   sendCtrlC: () => sendCtrlC,
   sendKeys: () => sendKeys,
@@ -651,29 +689,6 @@ function isTmuxNotFoundError(err) {
   const msg = String(err.stderr ?? "").toLowerCase();
   return msg.includes("can't find") || msg.includes("not found") || msg.includes("no such") || msg.includes("session not found") || msg.includes("window not found") || msg.includes("pane not found");
 }
-async function listPanes(target) {
-  try {
-    const result = await execa("tmux", [
-      "list-panes",
-      "-t",
-      target,
-      "-F",
-      "#{pane_id}|#{pane_pid}|#{pane_current_command}|#{pane_dead}|#{pane_dead_status}"
-    ], execaEnv);
-    return result.stdout.trim().split("\n").filter(Boolean).map((line) => {
-      const [paneId, panePid, currentCommand, dead, deadStatus] = line.split("|");
-      return {
-        paneId,
-        panePid,
-        currentCommand,
-        isDead: dead === "1",
-        deadStatus: deadStatus ? parseInt(deadStatus, 10) : void 0
-      };
-    });
-  } catch {
-    return [];
-  }
-}
 async function getPaneInfo(target) {
   try {
     const result = await execa("tmux", [
@@ -726,15 +741,61 @@ async function listSessionPanes(session) {
   }
   return map;
 }
-async function selectPane(target) {
-  await execa("tmux", ["select-pane", "-t", target], execaEnv);
+async function listSessionWindows(session) {
+  try {
+    const result = await execa("tmux", [
+      "list-windows",
+      "-t",
+      `=${session}`,
+      "-F",
+      "#{window_index} #{window_name}"
+    ], execaEnv);
+    return result.stdout.trim().split("\n").filter(Boolean).map((line) => {
+      const spaceIdx = line.indexOf(" ");
+      return {
+        index: parseInt(line.slice(0, spaceIdx), 10),
+        name: line.slice(spaceIdx + 1)
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+async function killOrphanWindows(session, selfPaneId) {
+  const windows = await listSessionWindows(session);
+  let killed = 0;
+  let paneMap;
+  if (selfPaneId) {
+    paneMap = await listSessionPanes(session);
+  }
+  for (const win of windows) {
+    if (win.index === 0) continue;
+    if (selfPaneId && paneMap) {
+      const windowTarget = `${session}:${win.index}`;
+      let containsSelf = false;
+      for (const [key, info2] of paneMap) {
+        if (key.startsWith(windowTarget + ".") && info2.paneId === selfPaneId) {
+          containsSelf = true;
+          break;
+        }
+        if (key === windowTarget && info2.paneId === selfPaneId) {
+          containsSelf = true;
+          break;
+        }
+      }
+      if (containsSelf) continue;
+    }
+    try {
+      await killWindow(`${session}:${win.index}`);
+      killed++;
+    } catch {
+    }
+  }
+  return killed;
 }
 async function selectWindow(target) {
   await execa("tmux", ["select-window", "-t", target], execaEnv);
 }
-async function attachSession(session) {
-  await execa("tmux", ["attach-session", "-t", `=${session}`], { ...execaEnv, stdio: "inherit" });
-}
 async function isInsideTmux() {
   return !!process.env.TMUX;
 }
@@ -769,7 +830,7 @@ async function initCommand(options) {
   }
   await checkTmux();
   const dirs = [
-    pgDir(projectRoot),
+    ppgDir(projectRoot),
     resultsDir(projectRoot),
     logsDir(projectRoot),
     templatesDir(projectRoot),
@@ -780,9 +841,15 @@ async function initCommand(options) {
   for (const dir of dirs) {
     await fs3.mkdir(dir, { recursive: true });
   }
-  info("Created .pg/ directory structure");
-  await writeDefaultConfig(projectRoot);
-  info("Wrote default config.yaml");
+  info("Created .ppg/ directory structure");
+  const cfgPath = configPath(projectRoot);
+  try {
+    await fs3.access(cfgPath);
+    info("config.yaml already exists, skipping");
+  } catch {
+    await writeDefaultConfig(projectRoot);
+    info("Wrote default config.yaml");
+  }
   const dirName = path2.basename(projectRoot);
   const sessionName = `ppg-${dirName}`;
   const manifest = createEmptyManifest(projectRoot, sessionName);
@@ -815,7 +882,7 @@ async function initCommand(options) {
       info(`Wrote swarm template: ${name}.yaml`);
     }
   }
-  const conductorPath = path2.join(pgDir(projectRoot), "conductor-context.md");
+  const conductorPath = path2.join(ppgDir(projectRoot), "conductor-context.md");
   await fs3.writeFile(conductorPath, CONDUCTOR_CONTEXT, "utf-8");
   info("Wrote conductor-context.md");
   const pluginRegistered = await registerClaudePlugin();
@@ -827,7 +894,7 @@ async function initCommand(options) {
       success: true,
       projectRoot,
       sessionName,
-      pgDir: pgDir(projectRoot),
+      ppgDir: ppgDir(projectRoot),
       pluginRegistered
     }));
   } else {
@@ -873,13 +940,13 @@ async function registerClaudePlugin() {
 async function updateGitignore(projectRoot) {
   const gitignorePath = path2.join(projectRoot, ".gitignore");
   const entriesToAdd = [
-    ".pg/results/",
-    ".pg/logs/",
-    ".pg/manifest.json",
-    ".pg/prompts/",
-    ".pg/agent-prompts/",
-    ".pg/swarms/",
-    ".pg/conductor-context.md"
+    ".ppg/results/",
+    ".ppg/logs/",
+    ".ppg/manifest.json",
+    ".ppg/prompts/",
+    ".ppg/agent-prompts/",
+    ".ppg/swarms/",
+    ".ppg/conductor-context.md"
   ];
   let content = "";
   try {
@@ -914,27 +981,24 @@ You are operating on the master branch of a ppg-managed project.
 **NEVER make code changes directly on the master branch.** Use \`ppg spawn\` to create worktrees.
 
 ## Quick Reference
-- \`ppg spawn --name <name> --prompt "<task>" --json --no-open\` \u2014 Spawn worktree + agent
+- \`ppg spawn --name <name> --prompt "<task>" --json\` \u2014 Spawn worktree + agent
 - \`ppg status --json\` \u2014 Check statuses
-- \`ppg aggregate --all --json\` \u2014 Collect results
-- \`ppg pr <wt-id> --json\` \u2014 Create PR from worktree branch
+- \`ppg aggregate --all --json\` \u2014 Collect results (includes PR URLs)
 - \`ppg kill --agent <id> --json\` \u2014 Kill agent
-- \`ppg reset --json\` \u2014 Clean up all worktrees
+- \`ppg reset --json\` \u2014 Clean up all worktrees (skips worktrees with open PRs)
 
 ## Workflow
 1. Break request into parallelizable tasks
-2. Spawn each: \`ppg spawn --name <name> --prompt "<self-contained prompt>" --json --no-open\`
+2. Spawn: \`ppg spawn --name <name> --prompt "<prompt>" --json\`
 3. Poll: \`ppg status --json\` every 5s
-4. Aggregate: \`ppg aggregate --all --json\`
-5. Present results to the user and ask what they'd like to do next
-6. If the user wants PRs: \`ppg pr <wt-id> --json\`
-7. If the user wants direct merge: \`ppg merge <wt-id> --json\`
-8. Cleanup when done: \`ppg reset --json\` or \`ppg clean --json\`
-
-**Stop at step 5** \u2014 do not auto-merge or auto-PR. Let the user decide.
+4. Aggregate: \`ppg aggregate --all --json\` \u2014 result files include PR URLs
+5. Present PR links and summaries \u2014 let user decide next steps
+6. To merge remotely: \`gh pr merge <url> --squash --delete-branch\`
+7. To merge locally (power-user): \`ppg merge <wt-id> --json\`
+8. Cleanup: \`ppg reset --json\` (skips worktrees with open PRs)
 
 Each agent prompt must be self-contained \u2014 agents have no memory of this conversation.
-Always use \`--json --no-open\`.
+Always use \`--json\`.
 `;
     DEFAULT_TEMPLATE = `# Task: {{TASK_NAME}}
 
@@ -1053,8 +1117,7 @@ var init_env2 = __esm({
 // src/core/template.ts
 import fs5 from "fs/promises";
 import path4 from "path";
-async function listTemplates(projectRoot) {
-  const dir = templatesDir(projectRoot);
+async function readMdNames(dir) {
   try {
     const files = await fs5.readdir(dir);
     return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, ""));
@@ -1062,10 +1125,30 @@ async function listTemplates(projectRoot) {
     return [];
   }
 }
+async function listTemplatesWithSource(projectRoot) {
+  const localNames = await readMdNames(templatesDir(projectRoot));
+  const globalNames = await readMdNames(globalTemplatesDir());
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const name of localNames) {
+    seen.add(name);
+    result.push({ name, source: "local" });
+  }
+  for (const name of globalNames) {
+    if (!seen.has(name)) {
+      result.push({ name, source: "global" });
+    }
+  }
+  return result;
+}
 async function loadTemplate(projectRoot, name) {
-  const dir = templatesDir(projectRoot);
-  const filePath = path4.join(dir, `${name}.md`);
-  return fs5.readFile(filePath, "utf-8");
+  const localPath = path4.join(templatesDir(projectRoot), `${name}.md`);
+  try {
+    return await fs5.readFile(localPath, "utf-8");
+  } catch {
+    const globalPath = path4.join(globalTemplatesDir(), `${name}.md`);
+    return fs5.readFile(globalPath, "utf-8");
+  }
 }
 function renderTemplate(content, context) {
   return content.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
@@ -1093,7 +1176,7 @@ async function spawnAgent(options) {
   } = options;
   const resFile = resultFile(projectRoot, agentId2);
   let fullPrompt = prompt;
-  if (agentConfig.resultInstructions) {
+  if (agentConfig.resultInstructions && !options.skipResultInstructions) {
     const ctx = {
       WORKTREE_PATH: worktreePath2,
       BRANCH: branch,
@@ -1130,10 +1213,11 @@ function buildAgentCommand(agentConfig, promptFilePath, sessionId2) {
   const envPrefix = "unset CLAUDECODE;";
   const { command, promptFlag } = agentConfig;
   const sessionFlag = sessionId2 && command.includes("claude") ? ` --session-id ${sessionId2}` : "";
+  const catExpr = `"$(cat '${promptFilePath}')"`;
   if (promptFlag) {
-    return `${envPrefix} ${command}${sessionFlag} ${promptFlag} "$(cat ${promptFilePath})"`;
+    return `${envPrefix} ${command}${sessionFlag} ${promptFlag} ${catExpr}`;
   }
-  return `${envPrefix} ${command}${sessionFlag} "$(cat ${promptFilePath})"`;
+  return `${envPrefix} ${command}${sessionFlag} ${catExpr}`;
 }
 async function checkAgentStatus(agent, projectRoot, paneMap) {
   if (["completed", "failed", "killed", "lost"].includes(agent.status)) {
@@ -1206,7 +1290,7 @@ async function refreshAllAgentStatuses(manifest, projectRoot) {
 async function resumeAgent(options) {
   const { agent, worktreeId: worktreeId2, sessionName, cwd, windowName, projectRoot } = options;
   if (!agent.sessionId) {
-    throw new PgError(
+    throw new PpgError(
       `Agent ${agent.id} has no session ID. Cannot resume agents spawned before session tracking was added.`,
       "NO_SESSION_ID"
     );
@@ -1278,15 +1362,28 @@ var init_agent = __esm({
   }
 });
 
+// src/lib/shell.ts
+function shellEscape(text) {
+  return text.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\$/g, "\\$").replace(/`/g, "\\`");
+}
+var init_shell = __esm({
+  "src/lib/shell.ts"() {
+    "use strict";
+  }
+});
+
 // src/core/terminal.ts
 import { execa as execa4 } from "execa";
 async function openTerminalWindow(sessionName, windowTarget, title) {
-  const tmuxCmd = `if [ -x /usr/libexec/path_helper ]; then eval $(/usr/libexec/path_helper -s); fi; [ -f ~/.zprofile ] && source ~/.zprofile; [ -f ~/.zshrc ] && source ~/.zshrc; tmux attach-session -t ${sessionName} \\\\; select-window -t ${windowTarget}`;
+  const safeSession = shellEscape(sessionName);
+  const safeWindow = shellEscape(windowTarget);
+  const safeTitle = shellEscape(title);
+  const tmuxCmd = `if [ -x /usr/libexec/path_helper ]; then eval $(/usr/libexec/path_helper -s); fi; [ -f ~/.zprofile ] && source ~/.zprofile; [ -f ~/.zshrc ] && source ~/.zshrc; tmux attach-session -t ${safeSession} \\\\; select-window -t ${safeWindow}`;
   const script = `
 tell application "Terminal"
   activate
   set newTab to do script "${tmuxCmd}"
-  set custom title of newTab to "${title}"
+  set custom title of newTab to "${safeTitle}"
 end tell
 `;
   try {
@@ -1299,6 +1396,7 @@ var init_terminal = __esm({
   "src/core/terminal.ts"() {
     "use strict";
     init_output();
+    init_shell();
   }
 });
 
@@ -1343,6 +1441,25 @@ var init_name = __esm({
   }
 });
 
+// src/lib/vars.ts
+function parseVars(vars) {
+  const result = {};
+  for (const v of vars) {
+    const eqIdx = v.indexOf("=");
+    if (eqIdx < 1) {
+      throw new PpgError(`Invalid --var format: "${v}" \u2014 expected KEY=value`, "INVALID_ARGS");
+    }
+    result[v.slice(0, eqIdx)] = v.slice(eqIdx + 1);
+  }
+  return result;
+}
+var init_vars = __esm({
+  "src/lib/vars.ts"() {
+    "use strict";
+    init_errors();
+  }
+});
+
 // src/commands/spawn.ts
 var spawn_exports = {};
 __export(spawn_exports, {
@@ -1359,6 +1476,7 @@ async function spawnCommand(options) {
   }
   const agentConfig = resolveAgentConfig(config, options.agent);
   const count = options.count ?? 1;
+  const userVars = parseVars(options.var ?? []);
   const promptText = await resolvePrompt(options, projectRoot);
   if (options.worktree) {
     await spawnIntoExistingWorktree(
@@ -1368,7 +1486,8 @@ async function spawnCommand(options) {
       options.worktree,
       promptText,
       count,
-      options
+      options,
+      userVars
     );
   } else {
     await spawnNewWorktree(
@@ -1377,7 +1496,8 @@ async function spawnCommand(options) {
       agentConfig,
       promptText,
       count,
-      options
+      options,
+      userVars
     );
   }
 }
@@ -1387,17 +1507,11 @@ async function resolvePrompt(options, projectRoot) {
     return fs7.readFile(options.promptFile, "utf-8");
   }
   if (options.template) {
-    const templateContent = await loadTemplate(projectRoot, options.template);
-    const vars = {};
-    for (const v of options.var ?? []) {
-      const [key, ...rest] = v.split("=");
-      vars[key] = rest.join("=");
-    }
-    return templateContent;
+    return loadTemplate(projectRoot, options.template);
   }
-  throw new PgError("One of --prompt, --prompt-file, or --template is required", "INVALID_ARGS");
+  throw new PpgError("One of --prompt, --prompt-file, or --template is required", "INVALID_ARGS");
 }
-async function spawnNewWorktree(projectRoot, config, agentConfig, promptText, count, options) {
+async function spawnNewWorktree(projectRoot, config, agentConfig, promptText, count, options, userVars) {
   const baseBranch = options.base ?? await getCurrentBranch(projectRoot);
   const wtId = worktreeId();
   const name = options.name ? normalizeName(options.name, wtId) : wtId;
@@ -1408,9 +1522,25 @@ async function spawnNewWorktree(projectRoot, config, agentConfig, promptText, co
     base: baseBranch
   });
   await setupWorktreeEnv(projectRoot, wtPath, config);
-  const sessionName = config.sessionName;
+  const manifest = await readManifest(projectRoot);
+  const sessionName = manifest.sessionName;
   await ensureSession(sessionName);
   const windowTarget = await createWindow(sessionName, name, wtPath);
+  const worktreeEntry = {
+    id: wtId,
+    name,
+    path: wtPath,
+    branch: branchName,
+    baseBranch,
+    status: "active",
+    tmuxWindow: windowTarget,
+    agents: {},
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await updateManifest(projectRoot, (m) => {
+    m.worktrees[wtId] = worktreeEntry;
+    return m;
+  });
   const agents = [];
   for (let i = 0; i < count; i++) {
     const aId = agentId();
@@ -1433,10 +1563,7 @@ async function spawnNewWorktree(projectRoot, config, agentConfig, promptText, co
       TASK_NAME: name,
       PROMPT: promptText
     };
-    for (const v of options.var ?? []) {
-      const [key, ...rest] = v.split("=");
-      ctx[key] = rest.join("=");
-    }
+    Object.assign(ctx, userVars);
     const renderedPrompt = renderTemplate(promptText, ctx);
     const agentEntry = await spawnAgent({
       agentId: aId,
@@ -1449,22 +1576,13 @@ async function spawnNewWorktree(projectRoot, config, agentConfig, promptText, co
       sessionId: sessionId()
     });
     agents.push(agentEntry);
+    await updateManifest(projectRoot, (m) => {
+      if (m.worktrees[wtId]) {
+        m.worktrees[wtId].agents[agentEntry.id] = agentEntry;
+      }
+      return m;
+    });
   }
-  const worktreeEntry = {
-    id: wtId,
-    name,
-    path: wtPath,
-    branch: branchName,
-    baseBranch,
-    status: "active",
-    tmuxWindow: windowTarget,
-    agents: Object.fromEntries(agents.map((a) => [a.id, a])),
-    createdAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  await updateManifest(projectRoot, (m) => {
-    m.worktrees[wtId] = worktreeEntry;
-    return m;
-  });
   if (options.open === true) {
     openTerminalWindow(sessionName, windowTarget, name).catch(() => {
     });
@@ -1493,7 +1611,7 @@ async function spawnNewWorktree(projectRoot, config, agentConfig, promptText, co
     info(`Attach: ppg attach ${wtId}`);
   }
 }
-async function spawnIntoExistingWorktree(projectRoot, config, agentConfig, worktreeRef, promptText, count, options) {
+async function spawnIntoExistingWorktree(projectRoot, config, agentConfig, worktreeRef, promptText, count, options, userVars) {
   const manifest = await readManifest(projectRoot);
   const wt = resolveWorktree(manifest, worktreeRef);
   if (!wt) throw new WorktreeNotFoundError(worktreeRef);
@@ -1524,10 +1642,7 @@ async function spawnIntoExistingWorktree(projectRoot, config, agentConfig, workt
       TASK_NAME: wt.name,
       PROMPT: promptText
     };
-    for (const v of options.var ?? []) {
-      const [key, ...rest] = v.split("=");
-      ctx[key] = rest.join("=");
-    }
+    Object.assign(ctx, userVars);
     const renderedPrompt = renderTemplate(promptText, ctx);
     const agentEntry = await spawnAgent({
       agentId: aId,
@@ -1543,6 +1658,7 @@ async function spawnIntoExistingWorktree(projectRoot, config, agentConfig, workt
   }
   await updateManifest(projectRoot, (m) => {
     const mWt = m.worktrees[wt.id];
+    if (!mWt) return m;
     if (!mWt.tmuxWindow) {
       mWt.tmuxWindow = windowTarget;
     }
@@ -1590,6 +1706,7 @@ var init_spawn = __esm({
     init_errors();
     init_output();
     init_name();
+    init_vars();
   }
 });
 
@@ -1600,14 +1717,10 @@ __export(status_exports, {
 });
 async function statusCommand(worktreeFilter, options) {
   const projectRoot = await getRepoRoot();
-  let manifest;
-  try {
-    manifest = await updateManifest(projectRoot, async (m) => {
-      return refreshAllAgentStatuses(m, projectRoot);
-    });
-  } catch {
-    throw new NotInitializedError(projectRoot);
-  }
+  await requireManifest(projectRoot);
+  const manifest = await updateManifest(projectRoot, async (m) => {
+    return refreshAllAgentStatuses(m, projectRoot);
+  });
   const filter = worktreeFilter ?? options?.worktree;
   let worktrees = Object.values(manifest.worktrees);
   if (filter) {
@@ -1703,11 +1816,35 @@ var init_status = __esm({
     init_manifest();
     init_agent();
     init_worktree();
-    init_errors();
     init_output();
   }
 });
 
+// src/core/pr.ts
+import { execa as execa5 } from "execa";
+async function checkPrState(branch) {
+  try {
+    const result = await execa5(
+      "gh",
+      ["pr", "view", branch, "--json", "state", "--jq", ".state"],
+      execaEnv
+    );
+    const state = result.stdout.trim().toUpperCase();
+    if (state === "MERGED" || state === "OPEN" || state === "CLOSED") {
+      return state;
+    }
+    return "UNKNOWN";
+  } catch {
+    return "UNKNOWN";
+  }
+}
+var init_pr = __esm({
+  "src/core/pr.ts"() {
+    "use strict";
+    init_env();
+  }
+});
+
 // src/core/self.ts
 function getCurrentPaneId() {
   return process.env.TMUX_PANE ?? null;
@@ -1841,7 +1978,7 @@ __export(kill_exports, {
 async function killCommand(options) {
   const projectRoot = await getRepoRoot();
   if (!options.agent && !options.worktree && !options.all) {
-    throw new PgError("One of --agent, --worktree, or --all is required", "INVALID_ARGS");
+    throw new PpgError("One of --agent, --worktree, or --all is required", "INVALID_ARGS");
   }
   const selfPaneId = getCurrentPaneId();
   let paneMap;
@@ -1892,6 +2029,14 @@ async function killSingleAgent(projectRoot, agentId2, options, selfPaneId, paneM
       success(`Deleted agent ${agentId2}`);
     }
   } else {
+    if (isTerminal) {
+      if (options.json) {
+        output({ success: true, killed: [], message: `Agent ${agentId2} already ${agent.status}` }, true);
+      } else {
+        info(`Agent ${agentId2} already ${agent.status}, skipping kill`);
+      }
+      return;
+    }
     info(`Killing agent ${agentId2}`);
     await killAgent(agent);
     await updateManifest(projectRoot, (m) => {
@@ -1938,11 +2083,19 @@ async function killWorktreeAgents(projectRoot, worktreeRef, options, selfPaneId,
     }
     return m;
   });
-  const shouldRemove = options.remove || options.delete;
+  let skippedOpenPr = false;
+  if (options.delete && !options.includeOpenPrs) {
+    const prState = await checkPrState(wt.branch);
+    if (prState === "OPEN") {
+      skippedOpenPr = true;
+      warn(`Skipping deletion of worktree ${wt.id} (${wt.name}) \u2014 has open PR on branch ${wt.branch}. Use --include-open-prs to override.`);
+    }
+  }
+  const shouldRemove = (options.remove || options.delete) && !skippedOpenPr;
   if (shouldRemove) {
     await removeWorktreeCleanup(projectRoot, wt.id, selfPaneId, paneMap);
   }
-  if (options.delete) {
+  if (options.delete && !skippedOpenPr) {
     await updateManifest(projectRoot, (m) => {
       delete m.worktrees[wt.id];
       return m;
@@ -1954,16 +2107,17 @@ async function killWorktreeAgents(projectRoot, worktreeRef, options, selfPaneId,
       killed: killedIds,
       skipped: skippedIds.length > 0 ? skippedIds : void 0,
       removed: shouldRemove ? [wt.id] : [],
-      deleted: options.delete ? [wt.id] : []
+      deleted: options.delete && !skippedOpenPr ? [wt.id] : [],
+      skippedOpenPrs: skippedOpenPr ? [wt.id] : void 0
     }, true);
   } else {
     success(`Killed ${killedIds.length} agent(s) in worktree ${wt.id}`);
     if (skippedIds.length > 0) {
       warn(`Skipped ${skippedIds.length} agent(s) due to self-protection`);
     }
-    if (options.delete) {
+    if (options.delete && !skippedOpenPr) {
       success(`Deleted worktree ${wt.id}`);
-    } else if (options.remove) {
+    } else if (options.remove && !skippedOpenPr) {
       success(`Removed worktree ${wt.id}`);
     }
   }
@@ -2002,15 +2156,32 @@ async function killAllAgents(projectRoot, options, selfPaneId, paneMap) {
     }
     return m;
   });
+  let worktreesToRemove = activeWorktreeIds;
+  const openPrWorktreeIds = [];
+  if (options.delete && !options.includeOpenPrs) {
+    worktreesToRemove = [];
+    for (const wtId of activeWorktreeIds) {
+      const wt = manifest.worktrees[wtId];
+      if (wt) {
+        const prState = await checkPrState(wt.branch);
+        if (prState === "OPEN") {
+          openPrWorktreeIds.push(wtId);
+          warn(`Skipping deletion of worktree ${wtId} (${wt.name}) \u2014 has open PR`);
+        } else {
+          worktreesToRemove.push(wtId);
+        }
+      }
+    }
+  }
   const shouldRemove = options.remove || options.delete;
   if (shouldRemove) {
-    for (const wtId of activeWorktreeIds) {
+    for (const wtId of worktreesToRemove) {
       await removeWorktreeCleanup(projectRoot, wtId, selfPaneId, paneMap);
     }
   }
   if (options.delete) {
     await updateManifest(projectRoot, (m) => {
-      for (const wtId of activeWorktreeIds) {
+      for (const wtId of worktreesToRemove) {
         delete m.worktrees[wtId];
       }
       return m;
@@ -2021,18 +2192,22 @@ async function killAllAgents(projectRoot, options, selfPaneId, paneMap) {
       success: true,
       killed: killedIds,
       skipped: skippedIds.length > 0 ? skippedIds : void 0,
-      removed: shouldRemove ? activeWorktreeIds : [],
-      deleted: options.delete ? activeWorktreeIds : []
+      removed: shouldRemove ? worktreesToRemove : [],
+      deleted: options.delete ? worktreesToRemove : [],
+      skippedOpenPrs: openPrWorktreeIds.length > 0 ? openPrWorktreeIds : void 0
     }, true);
   } else {
     success(`Killed ${killedIds.length} agent(s) across ${activeWorktreeIds.length} worktree(s)`);
     if (skippedIds.length > 0) {
       warn(`Skipped ${skippedIds.length} agent(s) due to self-protection`);
     }
+    if (openPrWorktreeIds.length > 0) {
+      warn(`Skipped deletion of ${openPrWorktreeIds.length} worktree(s) with open PRs`);
+    }
     if (options.delete) {
-      success(`Deleted ${activeWorktreeIds.length} worktree(s)`);
+      success(`Deleted ${worktreesToRemove.length} worktree(s)`);
     } else if (options.remove) {
-      success(`Removed ${activeWorktreeIds.length} worktree(s)`);
+      success(`Removed ${worktreesToRemove.length} worktree(s)`);
     }
   }
 }
@@ -2050,6 +2225,7 @@ var init_kill = __esm({
     "use strict";
     init_manifest();
     init_agent();
+    init_pr();
     init_worktree();
     init_cleanup();
     init_self();
@@ -2066,12 +2242,7 @@ __export(attach_exports, {
 });
 async function attachCommand(target) {
   const projectRoot = await getRepoRoot();
-  let manifest;
-  try {
-    manifest = await readManifest(projectRoot);
-  } catch {
-    throw new NotInitializedError(projectRoot);
-  }
+  const manifest = await requireManifest(projectRoot);
   let tmuxTarget;
   const sessionName = manifest.sessionName;
   let agent;
@@ -2079,7 +2250,7 @@ async function attachCommand(target) {
   const wt = resolveWorktree(manifest, target);
   if (wt) {
     if (!wt.tmuxWindow) {
-      throw new PgError("Worktree has no tmux window. Spawn agents first with: ppg spawn --worktree " + wt.id + ' --prompt "your task"', "NO_TMUX_WINDOW");
+      throw new PpgError("Worktree has no tmux window. Spawn agents first with: ppg spawn --worktree " + wt.id + ' --prompt "your task"', "NO_TMUX_WINDOW");
     }
     tmuxTarget = wt.tmuxWindow;
   } else {
@@ -2091,7 +2262,7 @@ async function attachCommand(target) {
     }
   }
   if (!tmuxTarget) {
-    throw new PgError(`Could not resolve target: ${target}. Try a worktree ID, name, or agent ID.`, "TARGET_NOT_FOUND");
+    throw new PpgError(`Could not resolve target: ${target}. Try a worktree ID, name, or agent ID.`, "TARGET_NOT_FOUND");
   }
   if (agent?.sessionId && worktreeId2) {
     const paneInfo = await getPaneInfo(tmuxTarget);
@@ -2142,12 +2313,7 @@ __export(logs_exports, {
 });
 async function logsCommand(agentId2, options) {
   const projectRoot = await getRepoRoot();
-  let manifest;
-  try {
-    manifest = await readManifest(projectRoot);
-  } catch {
-    throw new NotInitializedError(projectRoot);
-  }
+  const manifest = await requireManifest(projectRoot);
   const found = findAgent(manifest, agentId2);
   if (!found) throw new AgentNotFoundError(agentId2);
   const { agent } = found;
@@ -2194,7 +2360,7 @@ async function logsCommand(agentId2, options) {
         console.log(content);
       }
     } catch {
-      throw new PgError(`Could not capture pane for agent ${agentId2}. Pane may no longer exist.`, "PANE_NOT_FOUND");
+      throw new PpgError(`Could not capture pane for agent ${agentId2}. Pane may no longer exist.`, "PANE_NOT_FOUND");
     }
   }
 }
@@ -2217,14 +2383,10 @@ __export(aggregate_exports, {
 import fs9 from "fs/promises";
 async function aggregateCommand(worktreeId2, options) {
   const projectRoot = await getRepoRoot();
-  let manifest;
-  try {
-    manifest = await updateManifest(projectRoot, async (m) => {
-      return refreshAllAgentStatuses(m, projectRoot);
-    });
-  } catch {
-    throw new NotInitializedError(projectRoot);
-  }
+  await requireManifest(projectRoot);
+  const manifest = await updateManifest(projectRoot, async (m) => {
+    return refreshAllAgentStatuses(m, projectRoot);
+  });
   let worktrees;
   if (options?.all) {
     worktrees = Object.values(manifest.worktrees);
@@ -2318,24 +2480,20 @@ var merge_exports = {};
 __export(merge_exports, {
   mergeCommand: () => mergeCommand
 });
-import { execa as execa5 } from "execa";
+import { execa as execa6 } from "execa";
 async function mergeCommand(worktreeId2, options) {
   const projectRoot = await getRepoRoot();
-  let manifest;
-  try {
-    manifest = await updateManifest(projectRoot, async (m) => {
-      return refreshAllAgentStatuses(m, projectRoot);
-    });
-  } catch {
-    throw new NotInitializedError(projectRoot);
-  }
+  await requireManifest(projectRoot);
+  const manifest = await updateManifest(projectRoot, async (m) => {
+    return refreshAllAgentStatuses(m, projectRoot);
+  });
   const wt = resolveWorktree(manifest, worktreeId2);
   if (!wt) throw new WorktreeNotFoundError(worktreeId2);
   const agents = Object.values(wt.agents);
   const incomplete = agents.filter((a) => !["completed", "failed", "killed"].includes(a.status));
   if (incomplete.length > 0 && !options.force) {
     const ids = incomplete.map((a) => a.id).join(", ");
-    throw new PgError(
+    throw new PpgError(
       `${incomplete.length} agent(s) still running: ${ids}. Use --force to merge anyway.`,
       "AGENTS_RUNNING"
     );
@@ -2356,15 +2514,20 @@ async function mergeCommand(worktreeId2, options) {
   });
   const strategy = options.strategy ?? "squash";
   try {
+    const currentBranch = await getCurrentBranch(projectRoot);
+    if (currentBranch !== wt.baseBranch) {
+      info(`Switching to base branch ${wt.baseBranch}`);
+      await execa6("git", ["checkout", wt.baseBranch], { ...execaEnv, cwd: projectRoot });
+    }
     info(`Merging ${wt.branch} into ${wt.baseBranch} (${strategy})`);
     if (strategy === "squash") {
-      await execa5("git", ["merge", "--squash", wt.branch], { ...execaEnv, cwd: projectRoot });
-      await execa5("git", ["commit", "-m", `ppg: merge ${wt.name} (${wt.branch})`], {
+      await execa6("git", ["merge", "--squash", wt.branch], { ...execaEnv, cwd: projectRoot });
+      await execa6("git", ["commit", "-m", `ppg: merge ${wt.name} (${wt.branch})`], {
         ...execaEnv,
         cwd: projectRoot
       });
     } else {
-      await execa5("git", ["merge", "--no-ff", wt.branch, "-m", `ppg: merge ${wt.name} (${wt.branch})`], {
+      await execa6("git", ["merge", "--no-ff", wt.branch, "-m", `ppg: merge ${wt.name} (${wt.branch})`], {
         ...execaEnv,
         cwd: projectRoot
       });
@@ -2434,8 +2597,7 @@ var init_merge = __esm({
 import fs10 from "fs/promises";
 import path5 from "path";
 import YAML2 from "yaml";
-async function listSwarms(projectRoot) {
-  const dir = swarmsDir(projectRoot);
+async function readSwarmNames(dir) {
   try {
     const files = await fs10.readdir(dir);
     return files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml")).map((f) => f.replace(/\.ya?ml$/, "")).sort();
@@ -2443,41 +2605,69 @@ async function listSwarms(projectRoot) {
     return [];
   }
 }
-async function loadSwarm(projectRoot, name) {
-  if (!SAFE_NAME.test(name)) {
-    throw new PgError(
-      `Invalid swarm template name: "${name}" \u2014 must be alphanumeric, hyphens, or underscores`,
-      "INVALID_ARGS"
-    );
+async function listSwarmsWithSource(projectRoot) {
+  const localNames = await readSwarmNames(swarmsDir(projectRoot));
+  const globalNames = await readSwarmNames(globalSwarmsDir());
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const name of localNames) {
+    seen.add(name);
+    result.push({ name, source: "local" });
+  }
+  for (const name of globalNames) {
+    if (!seen.has(name)) {
+      result.push({ name, source: "global" });
+    }
   }
-  const dir = swarmsDir(projectRoot);
-  let filePath = path5.join(dir, `${name}.yaml`);
+  return result;
+}
+async function trySwarmFile(dir, name) {
+  const yamlPath = path5.join(dir, `${name}.yaml`);
   try {
-    await fs10.access(filePath);
+    await fs10.access(yamlPath);
+    return yamlPath;
   } catch {
-    filePath = path5.join(dir, `${name}.yml`);
+    const ymlPath = path5.join(dir, `${name}.yml`);
     try {
-      await fs10.access(filePath);
+      await fs10.access(ymlPath);
+      return ymlPath;
     } catch {
-      throw new PgError(`Swarm template not found: ${name}`, "INVALID_ARGS");
+      return null;
     }
   }
+}
+async function resolveSwarmFile(projectRoot, name) {
+  const local = await trySwarmFile(swarmsDir(projectRoot), name);
+  if (local) return local;
+  return trySwarmFile(globalSwarmsDir(), name);
+}
+async function loadSwarm(projectRoot, name) {
+  if (!SAFE_NAME.test(name)) {
+    throw new PpgError(
+      `Invalid swarm template name: "${name}" \u2014 must be alphanumeric, hyphens, or underscores`,
+      "INVALID_ARGS"
+    );
+  }
+  const filePath = await resolveSwarmFile(projectRoot, name);
+  if (!filePath) {
+    throw new PpgError(`Swarm template not found: ${name}`, "INVALID_ARGS");
+  }
   const raw = await fs10.readFile(filePath, "utf-8");
   const parsed = YAML2.parse(raw);
   if (!parsed || typeof parsed !== "object") {
-    throw new PgError(`Invalid swarm template: ${name} (empty or malformed YAML)`, "INVALID_ARGS");
+    throw new PpgError(`Invalid swarm template: ${name} (empty or malformed YAML)`, "INVALID_ARGS");
   }
   if (!parsed.name || !parsed.agents || !Array.isArray(parsed.agents)) {
-    throw new PgError(`Invalid swarm template: ${name} (missing name or agents)`, "INVALID_ARGS");
+    throw new PpgError(`Invalid swarm template: ${name} (missing name or agents)`, "INVALID_ARGS");
   }
   if (!SAFE_NAME.test(parsed.name)) {
-    throw new PgError(
+    throw new PpgError(
       `Invalid swarm name: "${parsed.name}" \u2014 must be alphanumeric, hyphens, or underscores`,
       "INVALID_ARGS"
     );
   }
   if (parsed.strategy && parsed.strategy !== "shared" && parsed.strategy !== "isolated") {
-    throw new PgError(
+    throw new PpgError(
       `Invalid swarm strategy: ${parsed.strategy}. Must be 'shared' or 'isolated'`,
       "INVALID_ARGS"
     );
@@ -2485,13 +2675,13 @@ async function loadSwarm(projectRoot, name) {
   for (let i = 0; i < parsed.agents.length; i++) {
     const agent = parsed.agents[i];
     if (!agent.prompt || typeof agent.prompt !== "string") {
-      throw new PgError(
+      throw new PpgError(
         `Invalid swarm template: ${name} \u2014 agent[${i}] missing prompt field`,
         "INVALID_ARGS"
       );
     }
     if (!SAFE_NAME.test(agent.prompt)) {
-      throw new PgError(
+      throw new PpgError(
         `Invalid prompt name: "${agent.prompt}" \u2014 must be alphanumeric, hyphens, or underscores`,
         "INVALID_ARGS"
       );
@@ -2538,23 +2728,20 @@ async function swarmCommand(templateName, options) {
     await swarmShared(projectRoot, config, swarm, options, userVars);
   }
 }
-function parseVars(vars) {
-  const result = {};
-  for (const v of vars) {
-    const eqIdx = v.indexOf("=");
-    if (eqIdx < 1) {
-      throw new PgError(`Invalid --var format: "${v}" \u2014 expected KEY=value`, "INVALID_ARGS");
-    }
-    result[v.slice(0, eqIdx)] = v.slice(eqIdx + 1);
-  }
-  return result;
-}
 async function loadPromptFile(projectRoot, promptName) {
-  const filePath = path6.join(promptsDir(projectRoot), `${promptName}.md`);
+  const localPath = path6.join(promptsDir(projectRoot), `${promptName}.md`);
   try {
-    return await fs11.readFile(filePath, "utf-8");
+    return await fs11.readFile(localPath, "utf-8");
   } catch {
-    throw new PgError(`Prompt file not found: ${promptName}.md in .pg/prompts/`, "INVALID_ARGS");
+    const globalPath = path6.join(globalPromptsDir(), `${promptName}.md`);
+    try {
+      return await fs11.readFile(globalPath, "utf-8");
+    } catch {
+      throw new PpgError(
+        `Prompt file not found: ${promptName}.md (checked .ppg/prompts/ and ~/.ppg/prompts/)`,
+        "INVALID_ARGS"
+      );
+    }
   }
 }
 async function spawnSwarmAgent(opts) {
@@ -2595,7 +2782,8 @@ async function swarmShared(projectRoot, config, swarm, options, userVars) {
     base: baseBranch
   });
   await setupWorktreeEnv(projectRoot, wtPath, config);
-  const sessionName = config.sessionName;
+  const manifest = await readManifest(projectRoot);
+  const sessionName = manifest.sessionName;
   await ensureSession(sessionName);
   const windowTarget = await createWindow(sessionName, name, wtPath);
   await updateManifest(projectRoot, (m) => {
@@ -2640,7 +2828,8 @@ async function swarmShared(projectRoot, config, swarm, options, userVars) {
 async function swarmIsolated(projectRoot, config, swarm, options, userVars) {
   const baseBranch = options.base ?? await getCurrentBranch(projectRoot);
   const baseName = options.name ? normalizeName(options.name, swarm.name) : swarm.name;
-  const sessionName = config.sessionName;
+  const manifest = await readManifest(projectRoot);
+  const sessionName = manifest.sessionName;
   await ensureSession(sessionName);
   const worktrees = [];
   const allAgents = [];
@@ -2715,7 +2904,7 @@ async function swarmIntoExistingWorktree(projectRoot, config, swarm, options, us
   const manifest = await readManifest(projectRoot);
   const wt = resolveWorktree(manifest, options.worktree);
   if (!wt) throw new WorktreeNotFoundError(options.worktree);
-  const sessionName = config.sessionName;
+  const sessionName = manifest.sessionName;
   let windowTarget = wt.tmuxWindow;
   if (!windowTarget) {
     await ensureSession(sessionName);
@@ -2786,41 +2975,96 @@ var init_swarm2 = __esm({
     init_errors();
     init_output();
     init_name();
+    init_vars();
   }
 });
 
-// src/commands/list.ts
+// src/commands/prompt.ts
+var prompt_exports = {};
+__export(prompt_exports, {
+  promptCommand: () => promptCommand
+});
+import fs12 from "fs/promises";
+import path7 from "path";
+async function resolvePromptFile(projectRoot, promptName) {
+  const localPath = path7.join(promptsDir(projectRoot), `${promptName}.md`);
+  try {
+    await fs12.access(localPath);
+    return localPath;
+  } catch {
+    const globalPath = path7.join(globalPromptsDir(), `${promptName}.md`);
+    try {
+      await fs12.access(globalPath);
+      return globalPath;
+    } catch {
+      throw new PpgError(
+        `Prompt not found: ${promptName} (checked .ppg/prompts/ and ~/.ppg/prompts/)`,
+        "INVALID_ARGS"
+      );
+    }
+  }
+}
+async function promptCommand(promptName, options) {
+  const projectRoot = await getRepoRoot();
+  const promptFilePath = await resolvePromptFile(projectRoot, promptName);
+  const spawnOpts = {
+    name: options.name ?? promptName,
+    agent: options.agent,
+    promptFile: promptFilePath,
+    var: options.var,
+    base: options.base,
+    count: options.count,
+    split: options.split,
+    open: options.open,
+    json: options.json
+  };
+  await spawnCommand(spawnOpts);
+}
+var init_prompt = __esm({
+  "src/commands/prompt.ts"() {
+    "use strict";
+    init_worktree();
+    init_paths();
+    init_errors();
+    init_spawn();
+  }
+});
+
+// src/commands/list.ts
 var list_exports = {};
 __export(list_exports, {
   listCommand: () => listCommand
 });
-import fs12 from "fs/promises";
-import path7 from "path";
+import fs13 from "fs/promises";
+import path8 from "path";
 async function listCommand(type, options) {
   if (type === "templates") {
     await listTemplatesCommand(options);
   } else if (type === "swarms") {
     await listSwarmsCommand(options);
+  } else if (type === "prompts") {
+    await listPromptsCommand(options);
   } else {
-    throw new PgError(`Unknown list type: ${type}. Available: templates, swarms`, "INVALID_ARGS");
+    throw new PpgError(`Unknown list type: ${type}. Available: templates, swarms, prompts`, "INVALID_ARGS");
   }
 }
 async function listTemplatesCommand(options) {
   const projectRoot = await getRepoRoot();
-  const templateNames = await listTemplates(projectRoot);
-  if (templateNames.length === 0) {
-    console.log("No templates found in .pg/templates/");
+  const entries = await listTemplatesWithSource(projectRoot);
+  if (entries.length === 0) {
+    console.log("No templates found in .ppg/templates/ or ~/.ppg/templates/");
     return;
   }
   const templates = await Promise.all(
-    templateNames.map(async (name) => {
-      const filePath = path7.join(templatesDir(projectRoot), `${name}.md`);
-      const content = await fs12.readFile(filePath, "utf-8");
+    entries.map(async ({ name, source }) => {
+      const dir = source === "local" ? templatesDir(projectRoot) : globalTemplatesDir();
+      const filePath = path8.join(dir, `${name}.md`);
+      const content = await fs13.readFile(filePath, "utf-8");
       const firstLine = content.split("\n").find((l) => l.trim().length > 0) ?? "";
       const description = firstLine.replace(/^#+\s*/, "").trim();
       const vars = [...content.matchAll(/\{\{(\w+)\}\}/g)].map((m) => m[1]);
       const uniqueVars = [...new Set(vars)];
-      return { name, description, variables: uniqueVars };
+      return { name, description, variables: uniqueVars, source };
     })
   );
   if (options.json) {
@@ -2829,35 +3073,37 @@ async function listTemplatesCommand(options) {
   }
   const columns = [
     { header: "Name", key: "name", width: 20 },
-    { header: "Description", key: "description", width: 40 },
+    { header: "Description", key: "description", width: 36 },
     {
       header: "Variables",
       key: "variables",
-      width: 30,
+      width: 24,
       format: (v) => v.join(", ")
-    }
+    },
+    { header: "Source", key: "source", width: 8 }
   ];
   console.log(formatTable(templates, columns));
 }
 async function listSwarmsCommand(options) {
   const projectRoot = await getRepoRoot();
-  const swarmNames = await listSwarms(projectRoot);
-  if (swarmNames.length === 0) {
+  const entries = await listSwarmsWithSource(projectRoot);
+  if (entries.length === 0) {
     if (options.json) {
       output({ swarms: [] }, true);
     } else {
-      console.log("No swarm templates found in .pg/swarms/");
+      console.log("No swarm templates found in .ppg/swarms/ or ~/.ppg/swarms/");
     }
     return;
   }
   const swarms = await Promise.all(
-    swarmNames.map(async (name) => {
+    entries.map(async ({ name, source }) => {
       const swarm = await loadSwarm(projectRoot, name);
       return {
         name,
         description: swarm.description,
         strategy: swarm.strategy,
-        agents: swarm.agents.length
+        agents: swarm.agents.length,
+        source
       };
     })
   );
@@ -2867,12 +3113,81 @@ async function listSwarmsCommand(options) {
   }
   const columns = [
     { header: "Name", key: "name", width: 20 },
-    { header: "Description", key: "description", width: 40 },
+    { header: "Description", key: "description", width: 34 },
     { header: "Strategy", key: "strategy", width: 10 },
-    { header: "Agents", key: "agents", width: 8 }
+    { header: "Agents", key: "agents", width: 8 },
+    { header: "Source", key: "source", width: 8 }
   ];
   console.log(formatTable(swarms, columns));
 }
+async function listPromptEntries(projectRoot) {
+  const localDir = promptsDir(projectRoot);
+  const globalDir = globalPromptsDir();
+  let localFiles = [];
+  try {
+    localFiles = (await fs13.readdir(localDir)).filter((f) => f.endsWith(".md")).sort();
+  } catch {
+  }
+  let globalFiles = [];
+  try {
+    globalFiles = (await fs13.readdir(globalDir)).filter((f) => f.endsWith(".md")).sort();
+  } catch {
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const file of localFiles) {
+    const name = file.replace(/\.md$/, "");
+    seen.add(name);
+    result.push({ name, source: "local" });
+  }
+  for (const file of globalFiles) {
+    const name = file.replace(/\.md$/, "");
+    if (!seen.has(name)) {
+      result.push({ name, source: "global" });
+    }
+  }
+  return result;
+}
+async function listPromptsCommand(options) {
+  const projectRoot = await getRepoRoot();
+  const entries = await listPromptEntries(projectRoot);
+  if (entries.length === 0) {
+    if (options.json) {
+      output({ prompts: [] }, true);
+    } else {
+      console.log("No prompts found in .ppg/prompts/ or ~/.ppg/prompts/");
+    }
+    return;
+  }
+  const prompts = await Promise.all(
+    entries.map(async ({ name, source }) => {
+      const dir = source === "local" ? promptsDir(projectRoot) : globalPromptsDir();
+      const filePath = path8.join(dir, `${name}.md`);
+      const content = await fs13.readFile(filePath, "utf-8");
+      const firstLine = content.split("\n").find((l) => l.trim().length > 0) ?? "";
+      const description = firstLine.replace(/^#+\s*/, "").trim();
+      const vars = [...content.matchAll(/\{\{(\w+)\}\}/g)].map((m) => m[1]);
+      const uniqueVars = [...new Set(vars)];
+      return { name, description, variables: uniqueVars, source };
+    })
+  );
+  if (options.json) {
+    output({ prompts }, true);
+    return;
+  }
+  const columns = [
+    { header: "Name", key: "name", width: 20 },
+    { header: "Description", key: "description", width: 36 },
+    {
+      header: "Variables",
+      key: "variables",
+      width: 24,
+      format: (v) => v.join(", ")
+    },
+    { header: "Source", key: "source", width: 8 }
+  ];
+  console.log(formatTable(prompts, columns));
+}
 var init_list = __esm({
   "src/commands/list.ts"() {
     "use strict";
@@ -2890,16 +3205,11 @@ var restart_exports = {};
 __export(restart_exports, {
   restartCommand: () => restartCommand
 });
-import fs13 from "fs/promises";
+import fs14 from "fs/promises";
 async function restartCommand(agentRef, options) {
   const projectRoot = await getRepoRoot();
   const config = await loadConfig(projectRoot);
-  let manifest;
-  try {
-    manifest = await readManifest(projectRoot);
-  } catch {
-    throw new NotInitializedError(projectRoot);
-  }
+  const manifest = await requireManifest(projectRoot);
   const found = findAgent(manifest, agentRef);
   if (!found) throw new AgentNotFoundError(agentRef);
   const { worktree: wt, agent: oldAgent } = found;
@@ -2913,9 +3223,9 @@ async function restartCommand(agentRef, options) {
   } else {
     const pFile = agentPromptFile(projectRoot, oldAgent.id);
     try {
-      promptText = await fs13.readFile(pFile, "utf-8");
+      promptText = await fs14.readFile(pFile, "utf-8");
     } catch {
-      throw new PgError(
+      throw new PpgError(
         `Could not read original prompt for agent ${oldAgent.id}. Use --prompt to provide one.`,
         "PROMPT_NOT_FOUND"
       );
@@ -2944,7 +3254,8 @@ async function restartCommand(agentRef, options) {
     tmuxTarget: windowTarget,
     projectRoot,
     branch: wt.branch,
-    sessionId: newSessionId
+    sessionId: newSessionId,
+    skipResultInstructions: !options.prompt
   });
   await updateManifest(projectRoot, (m) => {
     const mWt = m.worktrees[wt.id];
@@ -3003,20 +3314,15 @@ var diff_exports = {};
 __export(diff_exports, {
   diffCommand: () => diffCommand
 });
-import { execa as execa6 } from "execa";
+import { execa as execa7 } from "execa";
 async function diffCommand(worktreeRef, options) {
   const projectRoot = await getRepoRoot();
-  let manifest;
-  try {
-    manifest = await readManifest(projectRoot);
-  } catch {
-    throw new NotInitializedError(projectRoot);
-  }
+  const manifest = await requireManifest(projectRoot);
   const wt = resolveWorktree(manifest, worktreeRef);
   if (!wt) throw new WorktreeNotFoundError(worktreeRef);
   const diffRange = `${wt.baseBranch}...${wt.branch}`;
   if (options.json) {
-    const result = await execa6("git", ["diff", "--numstat", diffRange], { ...execaEnv, cwd: projectRoot });
+    const result = await execa7("git", ["diff", "--numstat", diffRange], { ...execaEnv, cwd: projectRoot });
     const files = result.stdout.trim().split("\n").filter(Boolean).map((line) => {
       const [added, removed, file] = line.split("	");
       return {
@@ -3032,13 +3338,13 @@ async function diffCommand(worktreeRef, options) {
       files
     }, true);
   } else if (options.stat) {
-    const result = await execa6("git", ["diff", "--stat", diffRange], { ...execaEnv, cwd: projectRoot });
+    const result = await execa7("git", ["diff", "--stat", diffRange], { ...execaEnv, cwd: projectRoot });
     console.log(result.stdout);
   } else if (options.nameOnly) {
-    const result = await execa6("git", ["diff", "--name-only", diffRange], { ...execaEnv, cwd: projectRoot });
+    const result = await execa7("git", ["diff", "--name-only", diffRange], { ...execaEnv, cwd: projectRoot });
     console.log(result.stdout);
   } else {
-    const result = await execa6("git", ["diff", diffRange], { ...execaEnv, cwd: projectRoot });
+    const result = await execa7("git", ["diff", diffRange], { ...execaEnv, cwd: projectRoot });
     console.log(result.stdout);
   }
 }
@@ -3060,8 +3366,8 @@ __export(pr_exports, {
   prCommand: () => prCommand,
   truncateBody: () => truncateBody
 });
-import fs14 from "fs/promises";
-import { execa as execa7 } from "execa";
+import fs15 from "fs/promises";
+import { execa as execa8 } from "execa";
 async function prCommand(worktreeRef, options) {
   const projectRoot = await getRepoRoot();
   let manifest;
@@ -3075,15 +3381,15 @@ async function prCommand(worktreeRef, options) {
   const wt = resolveWorktree(manifest, worktreeRef);
   if (!wt) throw new WorktreeNotFoundError(worktreeRef);
   try {
-    await execa7("gh", ["--version"], execaEnv);
+    await execa8("gh", ["--version"], execaEnv);
   } catch {
     throw new GhNotFoundError();
   }
   info(`Pushing branch ${wt.branch} to origin`);
   try {
-    await execa7("git", ["push", "-u", "origin", wt.branch], { ...execaEnv, cwd: projectRoot });
+    await execa8("git", ["push", "-u", "origin", wt.branch], { ...execaEnv, cwd: projectRoot });
   } catch (err) {
-    throw new PgError(
+    throw new PpgError(
       `Failed to push branch ${wt.branch}: ${err instanceof Error ? err.message : err}`,
       "INVALID_ARGS"
     );
@@ -3108,10 +3414,10 @@ async function prCommand(worktreeRef, options) {
   info(`Creating PR: ${title}`);
   let prUrl;
   try {
-    const result = await execa7("gh", ghArgs, { ...execaEnv, cwd: projectRoot });
+    const result = await execa8("gh", ghArgs, { ...execaEnv, cwd: projectRoot });
     prUrl = result.stdout.trim();
   } catch (err) {
-    throw new PgError(
+    throw new PpgError(
       `Failed to create PR: ${err instanceof Error ? err.message : err}`,
       "INVALID_ARGS"
     );
@@ -3137,7 +3443,7 @@ async function prCommand(worktreeRef, options) {
 async function buildBodyFromResults(agents) {
   const reads = agents.map(async (agent) => {
     try {
-      return await fs14.readFile(agent.resultFile, "utf-8");
+      return await fs15.readFile(agent.resultFile, "utf-8");
     } catch {
       return null;
     }
@@ -3148,10 +3454,10 @@ async function buildBodyFromResults(agents) {
 }
 function truncateBody(body) {
   if (body.length <= MAX_BODY_LENGTH) return body;
-  return body.slice(0, MAX_BODY_LENGTH) + "\n\n---\n\n*[Truncated \u2014 full results available in `.pg/results/`]*";
+  return body.slice(0, MAX_BODY_LENGTH) + "\n\n---\n\n*[Truncated \u2014 full results available in `.ppg/results/`]*";
 }
 var MAX_BODY_LENGTH;
-var init_pr = __esm({
+var init_pr2 = __esm({
   "src/commands/pr.ts"() {
     "use strict";
     init_manifest();
@@ -3245,9 +3551,23 @@ async function resetCommand(options) {
       return m;
     });
   }
+  const openPrWorktreeIds = [];
+  if (!options.includeOpenPrs) {
+    for (const wt of worktrees) {
+      if (wt.status === "cleaned") continue;
+      const prState = await checkPrState(wt.branch);
+      if (prState === "OPEN") {
+        openPrWorktreeIds.push(wt.id);
+        warn(`Skipping worktree ${wt.id} (${wt.name}) \u2014 has open PR on branch ${wt.branch}`);
+      }
+    }
+  }
   const removedIds = [];
   const skippedWorktreeIds = [];
   for (const wt of worktrees) {
+    if (openPrWorktreeIds.includes(wt.id)) {
+      continue;
+    }
     if (selfPaneId && paneMap && wouldCleanupAffectSelf(wt, selfPaneId, paneMap)) {
       warn(`Skipping cleanup of worktree ${wt.id} (${wt.name}) \u2014 contains current ppg process`);
       skippedWorktreeIds.push(wt.id);
@@ -3267,6 +3587,10 @@ async function resetCommand(options) {
       return m;
     });
   }
+  const orphansKilled = await killOrphanWindows(manifest.sessionName, selfPaneId);
+  if (orphansKilled > 0) {
+    info(`Killed ${orphansKilled} orphaned tmux window(s)`);
+  }
   if (options.prune) {
     info("Pruning stale git worktrees");
     await pruneWorktrees(projectRoot);
@@ -3279,6 +3603,7 @@ async function resetCommand(options) {
       removed: removedIds,
       warned: warnedNames.length > 0 ? warnedNames : void 0,
       skipped: skippedWorktreeIds.length > 0 ? skippedWorktreeIds : void 0,
+      skippedOpenPrs: openPrWorktreeIds.length > 0 ? openPrWorktreeIds : void 0,
       pruned: options.prune ?? false
     }, true);
   } else {
@@ -3306,6 +3631,7 @@ var init_reset = __esm({
     "use strict";
     init_manifest();
     init_agent();
+    init_pr();
     init_worktree();
     init_cleanup();
     init_self();
@@ -3322,12 +3648,7 @@ __export(clean_exports, {
 });
 async function cleanCommand(options) {
   const projectRoot = await getRepoRoot();
-  let manifest;
-  try {
-    manifest = await readManifest(projectRoot);
-  } catch {
-    throw new NotInitializedError(projectRoot);
-  }
+  const manifest = await requireManifest(projectRoot);
   const selfPaneId = getCurrentPaneId();
   let paneMap;
   if (selfPaneId) {
@@ -3369,10 +3690,25 @@ async function cleanCommand(options) {
     }
     return;
   }
+  const openPrWorktreeIds = [];
+  if (options.all && !options.includeOpenPrs) {
+    for (const wt of toClean) {
+      if (wt.status === "failed") {
+        const prState = await checkPrState(wt.branch);
+        if (prState === "OPEN") {
+          openPrWorktreeIds.push(wt.id);
+          warn(`Skipping worktree ${wt.id} (${wt.name}) \u2014 has open PR on branch ${wt.branch}`);
+        }
+      }
+    }
+  }
   const cleaned = [];
   const skipped = [];
   const removed = [];
   for (const wt of toClean) {
+    if (openPrWorktreeIds.includes(wt.id)) {
+      continue;
+    }
     if (wt.status !== "cleaned") {
       if (selfPaneId && paneMap && wouldCleanupAffectSelf(wt, selfPaneId, paneMap)) {
         warn(`Skipping cleanup of worktree ${wt.id} (${wt.name}) \u2014 contains current ppg process`);
@@ -3406,6 +3742,7 @@ async function cleanCommand(options) {
       success: true,
       cleaned,
       skipped: skipped.length > 0 ? skipped : void 0,
+      skippedOpenPrs: openPrWorktreeIds.length > 0 ? openPrWorktreeIds : void 0,
       removedFromManifest: removed,
       pruned: options.prune ?? false
     }, true);
@@ -3431,11 +3768,11 @@ var init_clean = __esm({
   "src/commands/clean.ts"() {
     "use strict";
     init_manifest();
+    init_pr();
     init_worktree();
     init_cleanup();
     init_self();
     init_tmux();
-    init_errors();
     init_output();
   }
 });
@@ -3447,12 +3784,7 @@ __export(send_exports, {
 });
 async function sendCommand(agentId2, text, options) {
   const projectRoot = await getRepoRoot();
-  let manifest;
-  try {
-    manifest = await readManifest(projectRoot);
-  } catch {
-    throw new NotInitializedError(projectRoot);
-  }
+  const manifest = await requireManifest(projectRoot);
   const found = findAgent(manifest, agentId2);
   if (!found) throw new AgentNotFoundError(agentId2);
   const { agent } = found;
@@ -3496,7 +3828,7 @@ async function waitCommand(worktreeRef, options) {
   const timeout = options.timeout ? options.timeout * 1e3 : void 0;
   const startTime = Date.now();
   if (!worktreeRef && !options.all) {
-    throw new PgError("Specify a worktree ID or use --all", "INVALID_ARGS");
+    throw new PpgError("Specify a worktree ID or use --all", "INVALID_ARGS");
   }
   if (!options.json) {
     info("Waiting for agents to complete...");
@@ -3511,7 +3843,7 @@ async function waitCommand(worktreeRef, options) {
           agents: agents2.map(formatAgent)
         }, true);
       }
-      throw new PgError("Timed out waiting for agents", "WAIT_TIMEOUT", 2);
+      throw new PpgError("Timed out waiting for agents", "WAIT_TIMEOUT", 2);
     }
     const manifest = await refreshAndGet(projectRoot);
     const agents = collectAgents(manifest, worktreeRef, options.all);
@@ -3529,7 +3861,7 @@ async function waitCommand(worktreeRef, options) {
         }
       }
       if (anyFailed) {
-        throw new PgError("Some agents failed", "AGENTS_FAILED", 1);
+        throw new PpgError("Some agents failed", "AGENTS_FAILED", 1);
       }
       return;
     }
@@ -3537,13 +3869,10 @@ async function waitCommand(worktreeRef, options) {
   }
 }
 async function refreshAndGet(projectRoot) {
-  try {
-    return await updateManifest(projectRoot, async (m) => {
-      return refreshAllAgentStatuses(m, projectRoot);
-    });
-  } catch {
-    throw new NotInitializedError(projectRoot);
-  }
+  await requireManifest(projectRoot);
+  return await updateManifest(projectRoot, async (m) => {
+    return refreshAllAgentStatuses(m, projectRoot);
+  });
 }
 function collectAgents(manifest, worktreeRef, all) {
   if (all) {
@@ -3588,11 +3917,7 @@ __export(worktree_exports, {
 async function worktreeCreateCommand(options) {
   const projectRoot = await getRepoRoot();
   const config = await loadConfig(projectRoot);
-  try {
-    await readManifest(projectRoot);
-  } catch {
-    throw new NotInitializedError(projectRoot);
-  }
+  await requireManifest(projectRoot);
   const baseBranch = options.base ?? await getCurrentBranch(projectRoot);
   const wtId = worktreeId();
   const name = options.name ? normalizeName(options.name, wtId) : wtId;
@@ -3643,7 +3968,6 @@ var init_worktree2 = __esm({
     init_worktree();
     init_env2();
     init_id();
-    init_errors();
     init_output();
     init_name();
   }
@@ -3656,10 +3980,10 @@ __export(ui_exports, {
   uiCommand: () => uiCommand
 });
 import { access } from "fs/promises";
-import path8 from "path";
-import { execa as execa8 } from "execa";
+import path9 from "path";
+import { execa as execa9 } from "execa";
 async function findDashboardBinary(projectRoot) {
-  const localBuild = path8.join(
+  const localBuild = path9.join(
     projectRoot,
     "PPG CLI",
     "build",
@@ -3683,12 +4007,12 @@ async function findDashboardBinary(projectRoot) {
   } catch {
   }
   try {
-    const result = await execa8("mdfind", [
+    const result = await execa9("mdfind", [
       'kMDItemCFBundleIdentifier == "com.2wit.PPG-CLI"'
     ]);
     const appPath = result.stdout.trim().split("\n")[0];
     if (appPath) {
-      const binaryPath = path8.join(appPath, "Contents", "MacOS", "PPG CLI");
+      const binaryPath = path9.join(appPath, "Contents", "MacOS", "PPG CLI");
       try {
         await access(binaryPath);
         return binaryPath;
@@ -3709,7 +4033,7 @@ async function uiCommand() {
   }
   const binaryPath = await findDashboardBinary(projectRoot);
   if (!binaryPath) {
-    throw new PgError(
+    throw new PpgError(
       `Dashboard app not found. Install it with:
   ppg install-dashboard
 
@@ -3719,7 +4043,7 @@ Or build from source:
     );
   }
   const mPath = manifestPath(projectRoot);
-  const proc = execa8(binaryPath, [
+  const proc = execa9(binaryPath, [
     "--manifest-path",
     mPath,
     "--session-name",
@@ -3753,10 +4077,10 @@ import { createWriteStream } from "fs";
 import { mkdir, cp, rm } from "fs/promises";
 import { createRequire } from "module";
 import { tmpdir } from "os";
-import path9 from "path";
+import path10 from "path";
 import { pipeline } from "stream/promises";
 import { Readable } from "stream";
-import { execa as execa9 } from "execa";
+import { execa as execa10 } from "execa";
 function getVersion() {
   const pkg2 = require2("../package.json");
   return pkg2.version;
@@ -3771,41 +4095,41 @@ async function installDashboardCommand(options) {
     const res = await fetch(url);
     if (!res.ok) {
       if (res.status === 404) {
-        throw new PgError(
+        throw new PpgError(
           `Dashboard release not found for ${tag}. The dashboard may not be available for this version yet.
 Check: https://github.com/${REPO}/releases/tag/${tag}`,
           "DASHBOARD_NOT_FOUND"
         );
       }
-      throw new PgError(
+      throw new PpgError(
         `Failed to download dashboard: HTTP ${res.status} ${res.statusText}`,
         "DOWNLOAD_FAILED"
       );
     }
-    const tmp = path9.join(tmpdir(), `ppg-dashboard-${Date.now()}`);
+    const tmp = path10.join(tmpdir(), `ppg-dashboard-${Date.now()}`);
     await mkdir(tmp, { recursive: true });
-    const dmgPath = path9.join(tmp, ASSET_NAME);
+    const dmgPath = path10.join(tmp, ASSET_NAME);
     const body = res.body;
-    if (!body) throw new PgError("Empty response body", "DOWNLOAD_FAILED");
+    if (!body) throw new PpgError("Empty response body", "DOWNLOAD_FAILED");
     await pipeline(
       Readable.fromWeb(body),
       createWriteStream(dmgPath)
     );
     if (!json) info("Mounting\u2026");
-    const mountResult = await execa9("hdiutil", ["attach", dmgPath, "-nobrowse", "-quiet"]);
+    const mountResult = await execa10("hdiutil", ["attach", dmgPath, "-nobrowse", "-quiet"]);
     const mountLine = mountResult.stdout.trim().split("\n").pop() ?? "";
     const mountPoint = mountLine.split("	").pop()?.trim();
     if (!mountPoint) {
-      throw new PgError("Failed to mount DMG \u2014 could not determine mount point", "INSTALL_FAILED");
+      throw new PpgError("Failed to mount DMG \u2014 could not determine mount point", "INSTALL_FAILED");
     }
     try {
-      const srcApp = path9.join(mountPoint, APP_NAME);
-      const destApp = path9.join(dir, APP_NAME);
+      const srcApp = path10.join(mountPoint, APP_NAME);
+      const destApp = path10.join(dir, APP_NAME);
       if (!json) info("Installing\u2026");
       await rm(destApp, { recursive: true, force: true });
       await cp(srcApp, destApp, { recursive: true });
       try {
-        await execa9("xattr", ["-dr", "com.apple.quarantine", destApp]);
+        await execa10("xattr", ["-dr", "com.apple.quarantine", destApp]);
       } catch {
       }
       if (json) {
@@ -3814,14 +4138,14 @@ Check: https://github.com/${REPO}/releases/tag/${tag}`,
         success(`Dashboard ${tag} installed to ${destApp}`);
       }
     } finally {
-      await execa9("hdiutil", ["detach", mountPoint, "-quiet"]).catch(() => {
+      await execa10("hdiutil", ["detach", mountPoint, "-quiet"]).catch(() => {
       });
     }
     await rm(tmp, { recursive: true, force: true });
   } catch (err) {
-    if (err instanceof PgError) throw err;
+    if (err instanceof PpgError) throw err;
     const message = err instanceof Error ? err.message : String(err);
-    throw new PgError(`Dashboard installation failed: ${message}`, "INSTALL_FAILED");
+    throw new PpgError(`Dashboard installation failed: ${message}`, "INSTALL_FAILED");
   }
 }
 var require2, REPO, ASSET_NAME, APP_NAME;
@@ -3837,6 +4161,452 @@ var init_install_dashboard = __esm({
   }
 });
 
+// src/core/schedule.ts
+import fs16 from "fs/promises";
+import YAML3 from "yaml";
+import { CronExpressionParser } from "cron-parser";
+async function loadSchedules(projectRoot) {
+  const filePath = schedulesPath(projectRoot);
+  let raw;
+  try {
+    raw = await fs16.readFile(filePath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      throw new PpgError("No schedules file found. Create .ppg/schedules.yaml first.", "INVALID_ARGS");
+    }
+    throw err;
+  }
+  const parsed = YAML3.parse(raw);
+  if (!parsed || !Array.isArray(parsed.schedules)) {
+    throw new PpgError('Invalid schedules.yaml: missing "schedules" array', "INVALID_ARGS");
+  }
+  for (let i = 0; i < parsed.schedules.length; i++) {
+    validateScheduleEntry(parsed.schedules[i], i);
+  }
+  return parsed.schedules;
+}
+function validateScheduleEntry(entry, index) {
+  if (!entry.name || typeof entry.name !== "string") {
+    throw new PpgError(`schedules[${index}]: missing "name"`, "INVALID_ARGS");
+  }
+  if (!SAFE_NAME2.test(entry.name)) {
+    throw new PpgError(
+      `schedules[${index}]: invalid name "${entry.name}" \u2014 must be alphanumeric, hyphens, or underscores`,
+      "INVALID_ARGS"
+    );
+  }
+  if (!entry.cron || typeof entry.cron !== "string") {
+    throw new PpgError(`schedules[${index}]: missing "cron" expression`, "INVALID_ARGS");
+  }
+  validateCronExpression(entry.cron, index);
+  const hasSwarm = entry.swarm && typeof entry.swarm === "string";
+  const hasPrompt = entry.prompt && typeof entry.prompt === "string";
+  if (!hasSwarm && !hasPrompt) {
+    throw new PpgError(`schedules[${index}]: must specify either "swarm" or "prompt"`, "INVALID_ARGS");
+  }
+  if (hasSwarm && hasPrompt) {
+    throw new PpgError(`schedules[${index}]: specify either "swarm" or "prompt", not both`, "INVALID_ARGS");
+  }
+}
+function validateCronExpression(expr, index) {
+  const prefix = index !== void 0 ? `schedules[${index}]: ` : "";
+  if (!expr || !expr.trim()) {
+    throw new PpgError(`${prefix}invalid cron expression: "${expr}"`, "INVALID_ARGS");
+  }
+  try {
+    CronExpressionParser.parse(expr);
+  } catch {
+    throw new PpgError(`${prefix}invalid cron expression: "${expr}"`, "INVALID_ARGS");
+  }
+}
+function getNextRun(cronExpr) {
+  const expr = CronExpressionParser.parse(cronExpr);
+  return expr.next().toDate();
+}
+function formatCronHuman(cronExpr) {
+  const parts = cronExpr.trim().split(/\s+/);
+  if (parts.length !== 5) return cronExpr;
+  const [min, hour, dom, mon, dow] = parts;
+  if (min === "0" && hour !== "*" && dom === "*" && mon === "*" && dow === "*") {
+    return `daily at ${hour}:00`;
+  }
+  if (min.startsWith("*/") && hour === "*" && dom === "*" && mon === "*" && dow === "*") {
+    return `every ${min.slice(2)} minutes`;
+  }
+  if (min !== "*" && hour === "*" && dom === "*" && mon === "*" && dow === "*") {
+    return `every hour at :${min.padStart(2, "0")}`;
+  }
+  if (dow !== "*" && dom === "*" && mon === "*") {
+    const days = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+    const dayName = days[Number(dow)] ?? dow;
+    return `${dayName} at ${hour}:${min.padStart(2, "0")}`;
+  }
+  return cronExpr;
+}
+var SAFE_NAME2;
+var init_schedule = __esm({
+  "src/core/schedule.ts"() {
+    "use strict";
+    init_paths();
+    init_errors();
+    SAFE_NAME2 = /^[\w-]+$/;
+  }
+});
+
+// src/core/cron.ts
+import fs17 from "fs/promises";
+import { createReadStream } from "fs";
+import path11 from "path";
+import readline from "readline";
+import { execa as execa11 } from "execa";
+async function runCronDaemon(projectRoot) {
+  const pidPath = cronPidPath(projectRoot);
+  await fs17.mkdir(path11.dirname(pidPath), { recursive: true });
+  await fs17.writeFile(pidPath, String(process.pid), "utf-8");
+  await fs17.mkdir(logsDir(projectRoot), { recursive: true });
+  await logCron(projectRoot, "Cron daemon starting");
+  let states = await loadScheduleStates(projectRoot);
+  let lastConfigMtime = await getFileMtime(schedulesPath(projectRoot));
+  await logCron(projectRoot, `Loaded ${states.length} schedule(s)`);
+  for (const s of states) {
+    await logCron(projectRoot, `  ${s.entry.name}: next run at ${s.nextRun.toISOString()}`);
+  }
+  const cleanup = async () => {
+    await logCron(projectRoot, "Cron daemon stopping");
+    try {
+      await fs17.unlink(pidPath);
+    } catch {
+    }
+    process.exit(0);
+  };
+  process.on("SIGTERM", cleanup);
+  process.on("SIGINT", cleanup);
+  const tick = async () => {
+    const currentMtime = await getFileMtime(schedulesPath(projectRoot));
+    if (currentMtime !== lastConfigMtime) {
+      try {
+        states = await loadScheduleStates(projectRoot);
+        lastConfigMtime = currentMtime;
+        await logCron(projectRoot, `Reloaded schedules (${states.length} schedule(s))`);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        await logCron(projectRoot, `Failed to reload schedules: ${msg}`);
+      }
+    }
+    const now = /* @__PURE__ */ new Date();
+    const due = states.filter((s) => now >= s.nextRun);
+    await Promise.allSettled(
+      due.map(async (state) => {
+        await triggerSchedule(state, projectRoot);
+        state.nextRun = getNextRun(state.entry.cron);
+        state.lastTriggered = now;
+        await logCron(projectRoot, `  ${state.entry.name}: next run at ${state.nextRun.toISOString()}`);
+      })
+    );
+  };
+  await tick();
+  setInterval(tick, CHECK_INTERVAL_MS);
+  await new Promise(() => {
+  });
+}
+async function loadScheduleStates(projectRoot) {
+  const schedules = await loadSchedules(projectRoot);
+  return schedules.map((entry) => ({
+    entry,
+    nextRun: getNextRun(entry.cron)
+  }));
+}
+async function getFileMtime(filePath) {
+  try {
+    const stat = await fs17.stat(filePath);
+    return stat.mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+async function triggerSchedule(state, projectRoot) {
+  const { entry } = state;
+  await logCron(projectRoot, `Triggering schedule: ${entry.name}`);
+  const varArgs = [];
+  if (entry.vars) {
+    for (const [key, value] of Object.entries(entry.vars)) {
+      varArgs.push("--var", `${key}=${value}`);
+    }
+  }
+  try {
+    if (entry.swarm) {
+      const args = ["swarm", entry.swarm, ...varArgs, "--json"];
+      await logCron(projectRoot, `  Running: ppg ${args.join(" ")}`);
+      const result = await execa11("ppg", args, { cwd: projectRoot, reject: false });
+      if (result.exitCode === 0) {
+        await logCron(projectRoot, `  Success: ${entry.name} (swarm: ${entry.swarm})`);
+      } else {
+        await logCron(projectRoot, `  Failed: ${entry.name} \u2014 ${result.stderr || result.stdout}`);
+      }
+    } else if (entry.prompt) {
+      const args = [
+        "spawn",
+        "--name",
+        `cron-${entry.name}-${Date.now()}`,
+        "--template",
+        entry.prompt,
+        ...varArgs,
+        "--json"
+      ];
+      await logCron(projectRoot, `  Running: ppg ${args.join(" ")}`);
+      const result = await execa11("ppg", args, { cwd: projectRoot, reject: false });
+      if (result.exitCode === 0) {
+        await logCron(projectRoot, `  Success: ${entry.name} (prompt: ${entry.prompt})`);
+      } else {
+        await logCron(projectRoot, `  Failed: ${entry.name} \u2014 ${result.stderr || result.stdout}`);
+      }
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    await logCron(projectRoot, `  Error triggering ${entry.name}: ${message}`);
+  }
+}
+async function logCron(projectRoot, message) {
+  const logPath = cronLogPath(projectRoot);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const line = `[${timestamp}] ${message}
+`;
+  process.stdout.write(line);
+  try {
+    await fs17.appendFile(logPath, line, "utf-8");
+  } catch {
+    await fs17.mkdir(logsDir(projectRoot), { recursive: true });
+    await fs17.appendFile(logPath, line, "utf-8");
+  }
+}
+async function isCronRunning(projectRoot) {
+  return await getCronPid(projectRoot) !== null;
+}
+async function getCronPid(projectRoot) {
+  const pidPath = cronPidPath(projectRoot);
+  let raw;
+  try {
+    raw = await fs17.readFile(pidPath, "utf-8");
+  } catch {
+    return null;
+  }
+  const pid = parseInt(raw, 10);
+  if (isNaN(pid)) {
+    await cleanupPidFile(pidPath);
+    return null;
+  }
+  try {
+    process.kill(pid, 0);
+    return pid;
+  } catch {
+    await cleanupPidFile(pidPath);
+    return null;
+  }
+}
+async function cleanupPidFile(pidPath) {
+  try {
+    await fs17.unlink(pidPath);
+  } catch {
+  }
+}
+async function readCronLog(projectRoot, lines = 20) {
+  const logPath = cronLogPath(projectRoot);
+  try {
+    await fs17.access(logPath);
+  } catch {
+    return [];
+  }
+  const result = [];
+  const rl = readline.createInterface({
+    input: createReadStream(logPath, { encoding: "utf-8" }),
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    if (!line) continue;
+    result.push(line);
+    if (result.length > lines) {
+      result.shift();
+    }
+  }
+  return result;
+}
+var CHECK_INTERVAL_MS;
+var init_cron = __esm({
+  "src/core/cron.ts"() {
+    "use strict";
+    init_schedule();
+    init_paths();
+    CHECK_INTERVAL_MS = 3e4;
+  }
+});
+
+// src/commands/cron.ts
+var cron_exports = {};
+__export(cron_exports, {
+  cronDaemonCommand: () => cronDaemonCommand,
+  cronListCommand: () => cronListCommand,
+  cronStartCommand: () => cronStartCommand,
+  cronStatusCommand: () => cronStatusCommand,
+  cronStopCommand: () => cronStopCommand
+});
+import fs18 from "fs/promises";
+async function cronStartCommand(options) {
+  const projectRoot = await getRepoRoot();
+  await requireInit(projectRoot);
+  if (await isCronRunning(projectRoot)) {
+    const pid = await getCronPid(projectRoot);
+    if (options.json) {
+      output({ success: false, error: "Cron daemon is already running", pid }, true);
+    } else {
+      warn(`Cron daemon is already running (PID: ${pid})`);
+    }
+    return;
+  }
+  const schedules = await loadSchedules(projectRoot);
+  if (schedules.length === 0) {
+    throw new PpgError("No schedules defined in .ppg/schedules.yaml", "INVALID_ARGS");
+  }
+  const manifest = await readManifest(projectRoot);
+  const sessionName = manifest.sessionName;
+  await ensureSession(sessionName);
+  const windowTarget = await createWindow(sessionName, CRON_WINDOW_NAME, projectRoot);
+  const command = `ppg cron _daemon`;
+  await sendKeys(windowTarget, command);
+  if (options.json) {
+    output({
+      success: true,
+      tmuxWindow: windowTarget,
+      scheduleCount: schedules.length
+    }, true);
+  } else {
+    success(`Cron daemon started in tmux window: ${windowTarget}`);
+    info(`${schedules.length} schedule(s) loaded`);
+    info(`Attach: tmux select-window -t ${windowTarget}`);
+  }
+}
+async function cronStopCommand(options) {
+  const projectRoot = await getRepoRoot();
+  const pid = await getCronPid(projectRoot);
+  if (!pid) {
+    if (options.json) {
+      output({ success: false, error: "Cron daemon is not running" }, true);
+    } else {
+      warn("Cron daemon is not running");
+    }
+    return;
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+  }
+  try {
+    await fs18.unlink(cronPidPath(projectRoot));
+  } catch {
+  }
+  try {
+    const manifest = await readManifest(projectRoot);
+    const windows = await listSessionWindows(manifest.sessionName);
+    const cronWindow = windows.find((w) => w.name === CRON_WINDOW_NAME);
+    if (cronWindow) {
+      await killWindow(`${manifest.sessionName}:${cronWindow.index}`);
+    }
+  } catch {
+  }
+  if (options.json) {
+    output({ success: true, pid }, true);
+  } else {
+    success(`Cron daemon stopped (PID: ${pid})`);
+  }
+}
+async function cronListCommand(options) {
+  const projectRoot = await getRepoRoot();
+  await requireInit(projectRoot);
+  const schedules = await loadSchedules(projectRoot);
+  if (options.json) {
+    const data = schedules.map((s) => ({
+      name: s.name,
+      type: s.swarm ? "swarm" : "prompt",
+      target: s.swarm ?? s.prompt,
+      cron: s.cron,
+      nextRun: getNextRun(s.cron).toISOString(),
+      vars: s.vars ?? {}
+    }));
+    output({ schedules: data }, true);
+    return;
+  }
+  const columns = [
+    { header: "NAME", key: "name" },
+    { header: "TYPE", key: "type" },
+    { header: "TARGET", key: "target" },
+    { header: "CRON", key: "cron" },
+    { header: "SCHEDULE", key: "human" },
+    { header: "NEXT RUN", key: "nextRun" }
+  ];
+  const rows = schedules.map((s) => ({
+    name: s.name,
+    type: s.swarm ? "swarm" : "prompt",
+    target: s.swarm ?? s.prompt,
+    cron: s.cron,
+    human: formatCronHuman(s.cron),
+    nextRun: getNextRun(s.cron).toLocaleString()
+  }));
+  console.log(formatTable(rows, columns));
+}
+async function cronStatusCommand(options) {
+  const projectRoot = await getRepoRoot();
+  const running = await isCronRunning(projectRoot);
+  const pid = running ? await getCronPid(projectRoot) : null;
+  const recentLines = await readCronLog(projectRoot, options.lines ?? 20);
+  if (options.json) {
+    output({
+      running,
+      pid,
+      recentLog: recentLines
+    }, true);
+    return;
+  }
+  if (running) {
+    success(`Cron daemon is running (PID: ${pid})`);
+  } else {
+    warn("Cron daemon is not running");
+  }
+  if (recentLines.length > 0) {
+    console.log("\nRecent log:");
+    for (const line of recentLines) {
+      console.log(`  ${line}`);
+    }
+  } else {
+    info("No cron log entries yet");
+  }
+}
+async function cronDaemonCommand() {
+  const projectRoot = await getRepoRoot();
+  await requireInit(projectRoot);
+  await runCronDaemon(projectRoot);
+}
+async function requireInit(projectRoot) {
+  try {
+    await fs18.access(manifestPath(projectRoot));
+  } catch {
+    throw new NotInitializedError(projectRoot);
+  }
+}
+var CRON_WINDOW_NAME;
+var init_cron2 = __esm({
+  "src/commands/cron.ts"() {
+    "use strict";
+    init_worktree();
+    init_manifest();
+    init_schedule();
+    init_cron();
+    init_tmux();
+    init_paths();
+    init_errors();
+    init_output();
+    CRON_WINDOW_NAME = "ppg-cron";
+  }
+});
+
 // src/cli.ts
 init_errors();
 init_output();
@@ -3845,12 +4615,12 @@ import { Command } from "commander";
 var require3 = createRequire2(import.meta.url);
 var pkg = require3("../package.json");
 var program = new Command();
-program.name("ppg").description("Pure Point Guard \u2014 local orchestration runtime for parallel CLI coding agents").version(pkg.version);
+program.name("ppg").description("Pure Point Guard \u2014 local orchestration runtime for parallel CLI coding agents").version(pkg.version).option("--json", "Output as JSON");
 program.command("init").description("Initialize Point Guard in the current git repository").option("--json", "Output as JSON").action(async (options) => {
   const { initCommand: initCommand2 } = await Promise.resolve().then(() => (init_init(), init_exports));
   await initCommand2(options);
 });
-program.command("spawn").description("Spawn a new worktree and agent(s), or add agents to an existing worktree").option("-n, --name <name>", "Name for the worktree/task").option("-a, --agent <type>", "Agent type to use (default: claude)").option("-p, --prompt <text>", "Prompt text for the agent").option("-f, --prompt-file <path>", "File containing the prompt").option("-t, --template <name>", "Template name from .pg/templates/").option("--var <key=value...>", "Template variables", collectVars, []).option("-b, --base <branch>", "Base branch for the worktree").option("-w, --worktree <id>", "Add agent to existing worktree").option("-c, --count <n>", "Number of agents to spawn", (v) => Number(v), 1).option("--split", "Put all agents in one window as split panes").option("--open", "Open a Terminal window for the spawned agents").option("--json", "Output as JSON").action(async (options) => {
+program.command("spawn").description("Spawn a new worktree and agent(s), or add agents to an existing worktree").option("-n, --name <name>", "Name for the worktree/task").option("-a, --agent <type>", "Agent type to use (default: claude)").option("-p, --prompt <text>", "Prompt text for the agent").option("-f, --prompt-file <path>", "File containing the prompt").option("-t, --template <name>", "Template name from .ppg/templates/").option("--var <key=value...>", "Template variables", collectVars, []).option("-b, --base <branch>", "Base branch for the worktree").option("-w, --worktree <id>", "Add agent to existing worktree").option("-c, --count <n>", "Number of agents to spawn", parsePositiveInt("count"), 1).option("--split", "Put all agents in one window as split panes").option("--open", "Open a Terminal window for the spawned agents").option("--json", "Output as JSON").action(async (options) => {
   const { spawnCommand: spawnCommand2 } = await Promise.resolve().then(() => (init_spawn(), spawn_exports));
   await spawnCommand2(options);
 });
@@ -3858,7 +4628,7 @@ program.command("status").description("Show status of worktrees and agents").arg
   const { statusCommand: statusCommand2 } = await Promise.resolve().then(() => (init_status(), status_exports));
   await statusCommand2(worktree, options);
 });
-program.command("kill").description("Kill agents or worktrees").option("-a, --agent <id>", "Kill a specific agent").option("-w, --worktree <id>", "Kill all agents in a worktree").option("--all", "Kill all agents in all worktrees").option("-r, --remove", "Also remove the worktree after killing").option("-d, --delete", "Delete agent/worktree entry from manifest after killing").option("--json", "Output as JSON").action(async (options) => {
+program.command("kill").description("Kill agents or worktrees").option("-a, --agent <id>", "Kill a specific agent").option("-w, --worktree <id>", "Kill all agents in a worktree").option("--all", "Kill all agents in all worktrees").option("-r, --remove", "Also remove the worktree after killing").option("-d, --delete", "Delete agent/worktree entry from manifest after killing").option("--include-open-prs", "Include worktrees with open GitHub PRs in deletion").option("--json", "Output as JSON").action(async (options) => {
   const { killCommand: killCommand2 } = await Promise.resolve().then(() => (init_kill(), kill_exports));
   await killCommand2(options);
 });
@@ -3878,11 +4648,15 @@ program.command("merge").description("Merge a worktree branch back into base").a
   const { mergeCommand: mergeCommand2 } = await Promise.resolve().then(() => (init_merge(), merge_exports));
   await mergeCommand2(worktreeId2, options);
 });
-program.command("swarm").description("Run a swarm template \u2014 spawn multiple agents from a predefined workflow").argument("<template>", "Swarm template name from .pg/swarms/").option("-w, --worktree <ref>", "Target an existing worktree by ID, name, or branch").option("--var <key=value...>", "Template variables", collectVars, []).option("-n, --name <name>", "Override worktree name").option("-b, --base <branch>", "Base branch for new worktree(s)").option("--open", "Open Terminal windows for spawned agents").option("--json", "Output as JSON").action(async (template, options) => {
+program.command("swarm").description("Run a swarm template \u2014 spawn multiple agents from a predefined workflow").argument("<template>", "Swarm template name from .ppg/swarms/").option("-w, --worktree <ref>", "Target an existing worktree by ID, name, or branch").option("--var <key=value...>", "Template variables", collectVars, []).option("-n, --name <name>", "Override worktree name").option("-b, --base <branch>", "Base branch for new worktree(s)").option("--open", "Open Terminal windows for spawned agents").option("--json", "Output as JSON").action(async (template, options) => {
   const { swarmCommand: swarmCommand2 } = await Promise.resolve().then(() => (init_swarm2(), swarm_exports));
   await swarmCommand2(template, options);
 });
-program.command("list").description("List available templates or swarms").argument("<type>", "What to list: templates, swarms").option("--json", "Output as JSON").action(async (type, options) => {
+program.command("prompt").description("Spawn a worktree+agent using a named prompt from .ppg/prompts/").argument("<name>", "Prompt name (filename without .md)").option("-n, --name <name>", "Name for the worktree").option("-a, --agent <type>", "Agent type to use (default: claude)").option("--var <key=value...>", "Template variables", collectVars, []).option("-b, --base <branch>", "Base branch for the worktree").option("-c, --count <n>", "Number of agents to spawn", parsePositiveInt("count"), 1).option("--split", "Put all agents in one window as split panes").option("--open", "Open a Terminal window for the spawned agents").option("--json", "Output as JSON").action(async (name, options) => {
+  const { promptCommand: promptCommand2 } = await Promise.resolve().then(() => (init_prompt(), prompt_exports));
+  await promptCommand2(name, options);
+});
+program.command("list").description("List available templates, swarms, or prompts").argument("<type>", "What to list: templates, swarms, prompts").option("--json", "Output as JSON").action(async (type, options) => {
   const { listCommand: listCommand2 } = await Promise.resolve().then(() => (init_list(), list_exports));
   await listCommand2(type, options);
 });
@@ -3895,14 +4669,14 @@ program.command("diff").description("Show changes made in a worktree branch").ar
   await diffCommand2(worktreeId2, options);
 });
 program.command("pr").description("Create a GitHub PR from a worktree branch").argument("<worktree-id>", "Worktree ID or name").option("--title <text>", "PR title (default: worktree name)").option("--body <text>", "PR body (default: agent result content)").option("--draft", "Create as draft PR").option("--json", "Output as JSON").action(async (worktreeId2, options) => {
-  const { prCommand: prCommand2 } = await Promise.resolve().then(() => (init_pr(), pr_exports));
+  const { prCommand: prCommand2 } = await Promise.resolve().then(() => (init_pr2(), pr_exports));
   await prCommand2(worktreeId2, options);
 });
-program.command("reset").description("Kill all agents, remove all worktrees, and wipe manifest").option("--force", "Reset even if worktrees have unmerged/un-PR'd work").option("--prune", "Also run git worktree prune").option("--json", "Output as JSON").action(async (options) => {
+program.command("reset").description("Kill all agents, remove all worktrees, and wipe manifest").option("--force", "Reset even if worktrees have unmerged/un-PR'd work").option("--prune", "Also run git worktree prune").option("--include-open-prs", "Include worktrees with open GitHub PRs in cleanup").option("--json", "Output as JSON").action(async (options) => {
   const { resetCommand: resetCommand2 } = await Promise.resolve().then(() => (init_reset(), reset_exports));
   await resetCommand2(options);
 });
-program.command("clean").description("Remove worktrees in terminal states (merged/cleaned/failed)").option("--all", "Also clean failed worktrees").option("--dry-run", "Show what would be done without doing it").option("--prune", "Also run git worktree prune").option("--json", "Output as JSON").action(async (options) => {
+program.command("clean").description("Remove worktrees in terminal states (merged/cleaned/failed)").option("--all", "Also clean failed worktrees").option("--dry-run", "Show what would be done without doing it").option("--prune", "Also run git worktree prune").option("--include-open-prs", "Include worktrees with open GitHub PRs in cleanup").option("--json", "Output as JSON").action(async (options) => {
   const { cleanCommand: cleanCommand2 } = await Promise.resolve().then(() => (init_clean(), clean_exports));
   await cleanCommand2(options);
 });
@@ -3910,7 +4684,7 @@ program.command("send").description("Send text to an agent's tmux pane").argumen
   const { sendCommand: sendCommand2 } = await Promise.resolve().then(() => (init_send(), send_exports));
   await sendCommand2(agentId2, text, options);
 });
-program.command("wait").description("Wait for agents to reach terminal state").argument("[worktree-id]", "Worktree ID or name").option("--all", "Wait for all agents across all worktrees").option("--timeout <seconds>", "Timeout in seconds", parseInt).option("--interval <seconds>", "Poll interval in seconds", parseInt).option("--json", "Output as JSON").action(async (worktreeId2, options) => {
+program.command("wait").description("Wait for agents to reach terminal state").argument("[worktree-id]", "Worktree ID or name").option("--all", "Wait for all agents across all worktrees").option("--timeout <seconds>", "Timeout in seconds", parsePositiveInt("timeout")).option("--interval <seconds>", "Poll interval in seconds", parsePositiveInt("interval")).option("--json", "Output as JSON").action(async (worktreeId2, options) => {
   const { waitCommand: waitCommand2 } = await Promise.resolve().then(() => (init_wait(), wait_exports));
   await waitCommand2(worktreeId2, options);
 });
@@ -3927,15 +4701,45 @@ program.command("install-dashboard").description("Download and install the macOS
   const { installDashboardCommand: installDashboardCommand2 } = await Promise.resolve().then(() => (init_install_dashboard(), install_dashboard_exports));
   await installDashboardCommand2(options);
 });
+var cronCmd = program.command("cron").description("Manage scheduled runs");
+cronCmd.command("start").description("Start the cron scheduler daemon in a tmux window").option("--json", "Output as JSON").action(async (options) => {
+  const { cronStartCommand: cronStartCommand2 } = await Promise.resolve().then(() => (init_cron2(), cron_exports));
+  await cronStartCommand2(options);
+});
+cronCmd.command("stop").description("Stop the cron scheduler daemon").option("--json", "Output as JSON").action(async (options) => {
+  const { cronStopCommand: cronStopCommand2 } = await Promise.resolve().then(() => (init_cron2(), cron_exports));
+  await cronStopCommand2(options);
+});
+cronCmd.command("list").description("List configured schedules and next run times").option("--json", "Output as JSON").action(async (options) => {
+  const { cronListCommand: cronListCommand2 } = await Promise.resolve().then(() => (init_cron2(), cron_exports));
+  await cronListCommand2(options);
+});
+cronCmd.command("status").description("Show cron daemon status and recent log").option("-l, --lines <n>", "Number of recent log lines to show", (v) => Number(v), 20).option("--json", "Output as JSON").action(async (options) => {
+  const { cronStatusCommand: cronStatusCommand2 } = await Promise.resolve().then(() => (init_cron2(), cron_exports));
+  await cronStatusCommand2(options);
+});
+cronCmd.command("_daemon", { hidden: true }).description("Internal: run the cron daemon (called by ppg cron start)").action(async () => {
+  const { cronDaemonCommand: cronDaemonCommand2 } = await Promise.resolve().then(() => (init_cron2(), cron_exports));
+  await cronDaemonCommand2();
+});
 program.exitOverride();
 function collectVars(value, previous) {
   return previous.concat([value]);
 }
+function parsePositiveInt(optionName) {
+  return (v) => {
+    const n = Number(v);
+    if (!Number.isInteger(n) || n < 1) {
+      throw new Error(`--${optionName} must be a positive integer`);
+    }
+    return n;
+  };
+}
 async function main() {
   try {
     await program.parseAsync(process.argv);
   } catch (err) {
-    if (err instanceof PgError) {
+    if (err instanceof PpgError) {
       outputError(err, program.opts().json ?? false);
       process.exit(err.exitCode);
     }
@@ -3945,7 +4749,7 @@ async function main() {
         process.exit(0);
       }
     }
-    outputError(err, false);
+    outputError(err, program.opts().json ?? false);
     process.exit(1);
   }
 }