pure-point-guard 0.1.2 → 0.2.0

package/dist/cli.js

@@ -10,7 +10,7 @@ var __export = (target, all) => {
 };
 
 // src/lib/errors.ts
-var PgError, TmuxNotFoundError, NotGitRepoError, NotInitializedError, ManifestLockError, WorktreeNotFoundError, AgentNotFoundError, MergeFailedError;
+var PgError, TmuxNotFoundError, NotGitRepoError, NotInitializedError, ManifestLockError, WorktreeNotFoundError, AgentNotFoundError, MergeFailedError, GhNotFoundError, UnmergedWorkError;
 var init_errors = __esm({
   "src/lib/errors.ts"() {
     "use strict";
@@ -82,6 +82,28 @@ var init_errors = __esm({
         this.name = "MergeFailedError";
       }
     };
+    GhNotFoundError = class extends PgError {
+      constructor() {
+        super(
+          "GitHub CLI (gh) is not installed or not in PATH. Install it with: brew install gh",
+          "GH_NOT_FOUND"
+        );
+        this.name = "GhNotFoundError";
+      }
+    };
+    UnmergedWorkError = class extends PgError {
+      constructor(names) {
+        const list = names.map((n) => `  ${n}`).join("\n");
+        super(
+          `${names.length} worktree(s) have completed work that hasn't been merged or PR'd:
+${list}
+
+Use --force to reset anyway, or create PRs first with: ppg pr <worktree-id>`,
+          "UNMERGED_WORK"
+        );
+        this.name = "UnmergedWorkError";
+      }
+    };
   }
 });
 
@@ -199,9 +221,18 @@ function logsDir(projectRoot) {
 function promptsDir(projectRoot) {
   return path.join(pgDir(projectRoot), "prompts");
 }
+function swarmsDir(projectRoot) {
+  return path.join(pgDir(projectRoot), "swarms");
+}
 function promptFile(projectRoot, agentId2) {
   return path.join(promptsDir(projectRoot), `${agentId2}.md`);
 }
+function agentPromptsDir(projectRoot) {
+  return path.join(pgDir(projectRoot), "agent-prompts");
+}
+function agentPromptFile(projectRoot, agentId2) {
+  return path.join(agentPromptsDir(projectRoot), `${agentId2}.md`);
+}
 function worktreeBaseDir(projectRoot) {
   return path.join(projectRoot, ".worktrees");
 }
@@ -398,6 +429,326 @@ var init_manifest = __esm({
   }
 });
 
+// src/bundled/prompts.ts
+var bundledPrompts;
+var init_prompts = __esm({
+  "src/bundled/prompts.ts"() {
+    "use strict";
+    bundledPrompts = {
+      "review-quality": `# Code Quality Review
+
+## What to Review
+{{CONTEXT}}
+
+## Your Focus
+You are a senior engineer reviewing code for quality, readability, and maintainability.
+
+- Code clarity and naming conventions
+- Function and module organization
+- Error handling completeness
+- DRY violations and unnecessary complexity
+- API design and consistency
+- Documentation gaps for non-obvious logic
+
+## Output
+Write a structured review to {{RESULT_FILE}} with specific file:line references and improvement suggestions.
+`,
+      "review-security": `# Security Review
+
+## What to Review
+{{CONTEXT}}
+
+## Your Focus
+You are a security engineer reviewing code for vulnerabilities and risks.
+
+- Input validation and sanitization
+- Injection vulnerabilities (SQL, XSS, command)
+- Authentication and authorization issues
+- Sensitive data exposure
+- Dependency vulnerabilities
+- Secrets or credentials in code
+
+## Output
+Write a structured review to {{RESULT_FILE}} with severity ratings and remediation guidance.
+`,
+      "review-regression": `# Regression & Risk Review
+
+## What to Review
+{{CONTEXT}}
+
+## Your Focus
+You are a QA engineer reviewing code for regression risks and test coverage gaps.
+
+- Behavioral changes that could break existing functionality
+- Edge cases and boundary conditions not covered
+- Missing or inadequate test coverage
+- Integration points that may be affected
+- Data migration or compatibility concerns
+- Performance regressions
+
+## Output
+Write a structured review to {{RESULT_FILE}} with risk ratings and recommended test additions.
+`
+    };
+  }
+});
+
+// src/bundled/swarms.ts
+var bundledSwarms;
+var init_swarms = __esm({
+  "src/bundled/swarms.ts"() {
+    "use strict";
+    bundledSwarms = {
+      "code-review": `name: code-review
+description: Multi-perspective code review
+strategy: shared
+
+agents:
+  - prompt: review-quality
+  - prompt: review-security
+  - prompt: review-regression
+`
+    };
+  }
+});
+
+// src/lib/env.ts
+var extraDirs, home, augmentedPath, execaEnv;
+var init_env = __esm({
+  "src/lib/env.ts"() {
+    "use strict";
+    extraDirs = [
+      "/opt/homebrew/bin",
+      "/opt/homebrew/sbin",
+      "/opt/local/bin"
+      // MacPorts
+    ];
+    home = process.env.HOME ?? "";
+    if (home) {
+      extraDirs.push(`${home}/.nix-profile/bin`);
+    }
+    augmentedPath = [...extraDirs, process.env.PATH].filter(Boolean).join(":");
+    execaEnv = {
+      env: { PATH: augmentedPath }
+    };
+  }
+});
+
+// src/core/tmux.ts
+var tmux_exports = {};
+__export(tmux_exports, {
+  attachSession: () => attachSession,
+  capturePane: () => capturePane,
+  checkTmux: () => checkTmux,
+  createWindow: () => createWindow,
+  ensureSession: () => ensureSession,
+  getPaneInfo: () => getPaneInfo,
+  isInsideTmux: () => isInsideTmux,
+  killPane: () => killPane,
+  killWindow: () => killWindow,
+  listPanes: () => listPanes,
+  listSessionPanes: () => listSessionPanes,
+  selectPane: () => selectPane,
+  selectWindow: () => selectWindow,
+  sendCtrlC: () => sendCtrlC,
+  sendKeys: () => sendKeys,
+  sendLiteral: () => sendLiteral,
+  sendRawKeys: () => sendRawKeys,
+  sessionExists: () => sessionExists,
+  splitPane: () => splitPane
+});
+import { execa, ExecaError } from "execa";
+async function checkTmux() {
+  try {
+    await execa("tmux", ["-V"], execaEnv);
+  } catch {
+    throw new TmuxNotFoundError();
+  }
+}
+async function sessionExists(name) {
+  try {
+    await execa("tmux", ["has-session", "-t", `=${name}`], execaEnv);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureSession(name) {
+  if (!await sessionExists(name)) {
+    await execa("tmux", ["new-session", "-d", "-s", name, "-x", "220", "-y", "50"], execaEnv);
+    await execa("tmux", ["set-option", "-t", name, "mouse", "on"], execaEnv);
+    await execa("tmux", ["set-option", "-t", name, "history-limit", "50000"], execaEnv);
+  }
+}
+async function createWindow(session, name, cwd) {
+  const result = await execa("tmux", [
+    "new-window",
+    "-t",
+    `=${session}`,
+    "-n",
+    name,
+    "-c",
+    cwd,
+    "-P",
+    "-F",
+    "#{window_index}"
+  ], execaEnv);
+  const windowIndex = result.stdout.trim();
+  return `${session}:${windowIndex}`;
+}
+async function splitPane(target, direction, cwd) {
+  const flag = direction === "horizontal" ? "-h" : "-v";
+  const result = await execa("tmux", [
+    "split-window",
+    flag,
+    "-t",
+    target,
+    "-c",
+    cwd,
+    "-P",
+    "-F",
+    "#{session_name}:#{window_index}.#{pane_index}|#{pane_id}"
+  ], execaEnv);
+  const [canonicalTarget, paneId] = result.stdout.trim().split("|");
+  return { paneId, target: canonicalTarget };
+}
+async function sendKeys(target, command) {
+  await execa("tmux", ["send-keys", "-t", target, "-l", command], execaEnv);
+  await execa("tmux", ["send-keys", "-t", target, "Enter"], execaEnv);
+}
+async function sendLiteral(target, text) {
+  await execa("tmux", ["send-keys", "-t", target, "-l", text], execaEnv);
+}
+async function sendRawKeys(target, keys) {
+  await execa("tmux", ["send-keys", "-t", target, keys], execaEnv);
+}
+async function capturePane(target, lines) {
+  const args = ["capture-pane", "-t", target, "-p"];
+  if (lines) {
+    args.push("-S", `-${lines}`);
+  }
+  const result = await execa("tmux", args, execaEnv);
+  return result.stdout;
+}
+async function killPane(target) {
+  try {
+    await execa("tmux", ["kill-pane", "-t", target], execaEnv);
+  } catch (err) {
+    if (isTmuxNotFoundError(err)) return;
+    throw err;
+  }
+}
+async function killWindow(target) {
+  try {
+    await execa("tmux", ["kill-window", "-t", target], execaEnv);
+  } catch (err) {
+    if (isTmuxNotFoundError(err)) return;
+    throw err;
+  }
+}
+function isTmuxNotFoundError(err) {
+  if (!(err instanceof ExecaError)) return false;
+  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", [
+      "display-message",
+      "-t",
+      target,
+      "-p",
+      "#{pane_id}|#{pane_pid}|#{pane_current_command}|#{pane_dead}|#{pane_dead_status}"
+    ], execaEnv);
+    const [paneId, panePid, currentCommand, dead, deadStatus] = result.stdout.trim().split("|");
+    return {
+      paneId,
+      panePid,
+      currentCommand,
+      isDead: dead === "1",
+      deadStatus: deadStatus ? parseInt(deadStatus, 10) : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+async function listSessionPanes(session) {
+  const map = /* @__PURE__ */ new Map();
+  try {
+    const result = await execa("tmux", [
+      "list-panes",
+      "-s",
+      "-t",
+      `=${session}`,
+      "-F",
+      "#{session_name}:#{window_index}.#{pane_index}|#{pane_id}|#{pane_pid}|#{pane_current_command}|#{pane_dead}|#{pane_dead_status}"
+    ], execaEnv);
+    for (const line of result.stdout.trim().split("\n").filter(Boolean)) {
+      const [target, paneId, panePid, currentCommand, dead, deadStatus] = line.split("|");
+      const info2 = {
+        paneId,
+        panePid,
+        currentCommand,
+        isDead: dead === "1",
+        deadStatus: deadStatus ? parseInt(deadStatus, 10) : void 0
+      };
+      map.set(target, info2);
+      map.set(paneId, info2);
+      const dotIdx = target.lastIndexOf(".");
+      if (dotIdx !== -1) {
+        map.set(target.slice(0, dotIdx), info2);
+      }
+    }
+  } catch {
+  }
+  return map;
+}
+async function selectPane(target) {
+  await execa("tmux", ["select-pane", "-t", target], execaEnv);
+}
+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;
+}
+async function sendCtrlC(target) {
+  await execa("tmux", ["send-keys", "-t", target, "C-c"], execaEnv);
+}
+var init_tmux = __esm({
+  "src/core/tmux.ts"() {
+    "use strict";
+    init_errors();
+    init_env();
+  }
+});
+
 // src/commands/init.ts
 var init_exports = {};
 __export(init_exports, {
@@ -406,27 +757,25 @@ __export(init_exports, {
 import fs3 from "fs/promises";
 import path2 from "path";
 import { fileURLToPath } from "url";
-import { execa } from "execa";
+import { execa as execa2 } from "execa";
 async function initCommand(options) {
   const cwd = process.cwd();
   let projectRoot;
   try {
-    const result = await execa("git", ["rev-parse", "--show-toplevel"], { cwd });
+    const result = await execa2("git", ["rev-parse", "--show-toplevel"], { ...execaEnv, cwd });
     projectRoot = result.stdout.trim();
   } catch {
     throw new NotGitRepoError(cwd);
   }
-  try {
-    await execa("tmux", ["-V"]);
-  } catch {
-    throw new TmuxNotFoundError();
-  }
+  await checkTmux();
   const dirs = [
     pgDir(projectRoot),
     resultsDir(projectRoot),
     logsDir(projectRoot),
     templatesDir(projectRoot),
-    promptsDir(projectRoot)
+    promptsDir(projectRoot),
+    agentPromptsDir(projectRoot),
+    swarmsDir(projectRoot)
   ];
   for (const dir of dirs) {
     await fs3.mkdir(dir, { recursive: true });
@@ -448,6 +797,24 @@ async function initCommand(options) {
     await fs3.writeFile(templatePath, DEFAULT_TEMPLATE, "utf-8");
     info("Wrote sample template: default.md");
   }
+  for (const [name, content] of Object.entries(bundledPrompts)) {
+    const pPath = promptFile(projectRoot, name);
+    try {
+      await fs3.access(pPath);
+    } catch {
+      await fs3.writeFile(pPath, content, "utf-8");
+      info(`Wrote prompt: ${name}.md`);
+    }
+  }
+  for (const [name, content] of Object.entries(bundledSwarms)) {
+    const sPath = path2.join(swarmsDir(projectRoot), `${name}.yaml`);
+    try {
+      await fs3.access(sPath);
+    } catch {
+      await fs3.writeFile(sPath, content, "utf-8");
+      info(`Wrote swarm template: ${name}.yaml`);
+    }
+  }
   const conductorPath = path2.join(pgDir(projectRoot), "conductor-context.md");
   await fs3.writeFile(conductorPath, CONDUCTOR_CONTEXT, "utf-8");
   info("Wrote conductor-context.md");
@@ -469,9 +836,9 @@ async function initCommand(options) {
 }
 async function registerClaudePlugin() {
   try {
-    const home = process.env.HOME;
-    if (!home) return false;
-    const skillsDir = path2.join(home, ".claude", "skills");
+    const home2 = process.env.HOME;
+    if (!home2) return false;
+    const skillsDir = path2.join(home2, ".claude", "skills");
     const __dirname = path2.dirname(fileURLToPath(import.meta.url));
     let srcSkillsDir = path2.resolve(__dirname, "..", "skills");
     try {
@@ -510,6 +877,8 @@ async function updateGitignore(projectRoot) {
     ".pg/logs/",
     ".pg/manifest.json",
     ".pg/prompts/",
+    ".pg/agent-prompts/",
+    ".pg/swarms/",
     ".pg/conductor-context.md"
   ];
   let content = "";
@@ -533,6 +902,10 @@ var init_init = __esm({
     init_output();
     init_config();
     init_manifest();
+    init_prompts();
+    init_swarms();
+    init_env();
+    init_tmux();
     CONDUCTOR_CONTEXT = `# PPG Conductor Context
 
 You are operating on the master branch of a ppg-managed project.
@@ -544,15 +917,21 @@ You are operating on the master branch of a ppg-managed project.
 - \`ppg spawn --name <name> --prompt "<task>" --json --no-open\` \u2014 Spawn worktree + agent
 - \`ppg status --json\` \u2014 Check statuses
 - \`ppg aggregate --all --json\` \u2014 Collect results
-- \`ppg merge <wt-id> --json\` \u2014 Merge completed work
+- \`ppg pr <wt-id> --json\` \u2014 Create PR from worktree branch
 - \`ppg kill --agent <id> --json\` \u2014 Kill agent
+- \`ppg reset --json\` \u2014 Clean up all worktrees
 
 ## Workflow
 1. Break request into parallelizable tasks
 2. Spawn each: \`ppg spawn --name <name> --prompt "<self-contained prompt>" --json --no-open\`
 3. Poll: \`ppg status --json\` every 5s
 4. Aggregate: \`ppg aggregate --all --json\`
-5. Present results, then merge confirmed worktrees
+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.
 
 Each agent prompt must be self-contained \u2014 agents have no memory of this conversation.
 Always use \`--json --no-open\`.
@@ -575,10 +954,11 @@ When you have completed the task, write your results to:
 });
 
 // src/core/worktree.ts
-import { execa as execa2 } from "execa";
+import { execa as execa3 } from "execa";
 async function getRepoRoot(cwd) {
   try {
-    const result = await execa2("git", ["rev-parse", "--show-toplevel"], {
+    const result = await execa3("git", ["rev-parse", "--show-toplevel"], {
+      ...execaEnv,
       cwd: cwd ?? process.cwd()
     });
     return result.stdout.trim();
@@ -587,7 +967,8 @@ async function getRepoRoot(cwd) {
   }
 }
 async function getCurrentBranch(cwd) {
-  const result = await execa2("git", ["branch", "--show-current"], {
+  const result = await execa3("git", ["branch", "--show-current"], {
+    ...execaEnv,
     cwd: cwd ?? process.cwd()
   });
   return result.stdout.trim();
@@ -598,7 +979,7 @@ async function createWorktree(repoRoot, id, options) {
   if (options.base) {
     args.push(options.base);
   }
-  await execa2("git", args, { cwd: repoRoot });
+  await execa3("git", args, { ...execaEnv, cwd: repoRoot });
   return wtPath;
 }
 async function removeWorktree(repoRoot, wtPath, options) {
@@ -606,22 +987,23 @@ async function removeWorktree(repoRoot, wtPath, options) {
   if (options?.force) {
     args.push("--force");
   }
-  await execa2("git", args, { cwd: repoRoot });
+  await execa3("git", args, { ...execaEnv, cwd: repoRoot });
   if (options?.deleteBranch && options.branchName) {
     try {
-      await execa2("git", ["branch", "-D", options.branchName], { cwd: repoRoot });
+      await execa3("git", ["branch", "-D", options.branchName], { ...execaEnv, cwd: repoRoot });
     } catch {
     }
   }
 }
 async function pruneWorktrees(repoRoot) {
-  await execa2("git", ["worktree", "prune"], { cwd: repoRoot });
+  await execa3("git", ["worktree", "prune"], { ...execaEnv, cwd: repoRoot });
 }
 var init_worktree = __esm({
   "src/core/worktree.ts"() {
     "use strict";
     init_paths();
     init_errors();
+    init_env();
   }
 });
 
@@ -662,7 +1044,7 @@ async function teardownWorktreeEnv(wtPath) {
   } catch {
   }
 }
-var init_env = __esm({
+var init_env2 = __esm({
   "src/core/env.ts"() {
     "use strict";
   }
@@ -672,232 +1054,28 @@ var init_env = __esm({
 import fs5 from "fs/promises";
 import path4 from "path";
 async function listTemplates(projectRoot) {
-  const dir = templatesDir(projectRoot);
-  try {
-    const files = await fs5.readdir(dir);
-    return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, ""));
-  } catch {
-    return [];
-  }
-}
-async function loadTemplate(projectRoot, name) {
-  const dir = templatesDir(projectRoot);
-  const filePath = path4.join(dir, `${name}.md`);
-  return fs5.readFile(filePath, "utf-8");
-}
-function renderTemplate(content, context) {
-  return content.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
-    return context[key] ?? `{{${key}}}`;
-  });
-}
-var init_template = __esm({
-  "src/core/template.ts"() {
-    "use strict";
-    init_paths();
-  }
-});
-
-// src/core/tmux.ts
-var tmux_exports = {};
-__export(tmux_exports, {
-  attachSession: () => attachSession,
-  capturePane: () => capturePane,
-  checkTmux: () => checkTmux,
-  createWindow: () => createWindow,
-  ensureSession: () => ensureSession,
-  getPaneInfo: () => getPaneInfo,
-  isInsideTmux: () => isInsideTmux,
-  killPane: () => killPane,
-  killWindow: () => killWindow,
-  listPanes: () => listPanes,
-  listSessionPanes: () => listSessionPanes,
-  selectPane: () => selectPane,
-  selectWindow: () => selectWindow,
-  sendCtrlC: () => sendCtrlC,
-  sendKeys: () => sendKeys,
-  sendLiteral: () => sendLiteral,
-  sendRawKeys: () => sendRawKeys,
-  sessionExists: () => sessionExists,
-  splitPane: () => splitPane
-});
-import { execa as execa3 } from "execa";
-async function checkTmux() {
-  try {
-    await execa3("tmux", ["-V"]);
-  } catch {
-    throw new TmuxNotFoundError();
-  }
-}
-async function sessionExists(name) {
-  try {
-    await execa3("tmux", ["has-session", "-t", name]);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function ensureSession(name) {
-  if (!await sessionExists(name)) {
-    await execa3("tmux", ["new-session", "-d", "-s", name, "-x", "220", "-y", "50"]);
-    await execa3("tmux", ["set-option", "-t", name, "mouse", "on"]);
-    await execa3("tmux", ["set-option", "-t", name, "history-limit", "50000"]);
-  }
-}
-async function createWindow(session, name, cwd) {
-  const result = await execa3("tmux", [
-    "new-window",
-    "-t",
-    session,
-    "-n",
-    name,
-    "-c",
-    cwd,
-    "-P",
-    "-F",
-    "#{window_index}"
-  ]);
-  const windowIndex = result.stdout.trim();
-  return `${session}:${windowIndex}`;
-}
-async function splitPane(target, direction, cwd) {
-  const flag = direction === "horizontal" ? "-h" : "-v";
-  const result = await execa3("tmux", [
-    "split-window",
-    flag,
-    "-t",
-    target,
-    "-c",
-    cwd,
-    "-P",
-    "-F",
-    "#{session_name}:#{window_index}.#{pane_index}|#{pane_id}"
-  ]);
-  const [canonicalTarget, paneId] = result.stdout.trim().split("|");
-  return { paneId, target: canonicalTarget };
-}
-async function sendKeys(target, command) {
-  await execa3("tmux", ["send-keys", "-t", target, "-l", command + "\n"]);
-}
-async function sendLiteral(target, text) {
-  await execa3("tmux", ["send-keys", "-t", target, "-l", text]);
-}
-async function sendRawKeys(target, keys) {
-  await execa3("tmux", ["send-keys", "-t", target, keys]);
-}
-async function capturePane(target, lines) {
-  const args = ["capture-pane", "-t", target, "-p"];
-  if (lines) {
-    args.push("-S", `-${lines}`);
-  }
-  const result = await execa3("tmux", args);
-  return result.stdout;
-}
-async function killPane(target) {
-  try {
-    await execa3("tmux", ["kill-pane", "-t", target]);
-  } catch {
-  }
-}
-async function killWindow(target) {
-  try {
-    await execa3("tmux", ["kill-window", "-t", target]);
-  } catch {
-  }
-}
-async function listPanes(target) {
-  try {
-    const result = await execa3("tmux", [
-      "list-panes",
-      "-t",
-      target,
-      "-F",
-      "#{pane_id}|#{pane_pid}|#{pane_current_command}|#{pane_dead}|#{pane_dead_status}"
-    ]);
-    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 execa3("tmux", [
-      "display-message",
-      "-t",
-      target,
-      "-p",
-      "#{pane_id}|#{pane_pid}|#{pane_current_command}|#{pane_dead}|#{pane_dead_status}"
-    ]);
-    const [paneId, panePid, currentCommand, dead, deadStatus] = result.stdout.trim().split("|");
-    return {
-      paneId,
-      panePid,
-      currentCommand,
-      isDead: dead === "1",
-      deadStatus: deadStatus ? parseInt(deadStatus, 10) : void 0
-    };
-  } catch {
-    return null;
-  }
-}
-async function listSessionPanes(session) {
-  const map = /* @__PURE__ */ new Map();
-  try {
-    const result = await execa3("tmux", [
-      "list-panes",
-      "-s",
-      "-t",
-      session,
-      "-F",
-      "#{session_name}:#{window_index}.#{pane_index}|#{pane_id}|#{pane_pid}|#{pane_current_command}|#{pane_dead}|#{pane_dead_status}"
-    ]);
-    for (const line of result.stdout.trim().split("\n").filter(Boolean)) {
-      const [target, paneId, panePid, currentCommand, dead, deadStatus] = line.split("|");
-      const info2 = {
-        paneId,
-        panePid,
-        currentCommand,
-        isDead: dead === "1",
-        deadStatus: deadStatus ? parseInt(deadStatus, 10) : void 0
-      };
-      map.set(target, info2);
-      map.set(paneId, info2);
-      const dotIdx = target.lastIndexOf(".");
-      if (dotIdx !== -1) {
-        map.set(target.slice(0, dotIdx), info2);
-      }
-    }
+  const dir = templatesDir(projectRoot);
+  try {
+    const files = await fs5.readdir(dir);
+    return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, ""));
   } catch {
+    return [];
   }
-  return map;
-}
-async function selectPane(target) {
-  await execa3("tmux", ["select-pane", "-t", target]);
 }
-async function selectWindow(target) {
-  await execa3("tmux", ["select-window", "-t", target]);
-}
-async function attachSession(session) {
-  await execa3("tmux", ["attach-session", "-t", session], { stdio: "inherit" });
-}
-async function isInsideTmux() {
-  return !!process.env.TMUX;
+async function loadTemplate(projectRoot, name) {
+  const dir = templatesDir(projectRoot);
+  const filePath = path4.join(dir, `${name}.md`);
+  return fs5.readFile(filePath, "utf-8");
 }
-async function sendCtrlC(target) {
-  await execa3("tmux", ["send-keys", "-t", target, "C-c"]);
+function renderTemplate(content, context) {
+  return content.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
+    return context[key] ?? `{{${key}}}`;
+  });
 }
-var init_tmux = __esm({
-  "src/core/tmux.ts"() {
+var init_template = __esm({
+  "src/core/template.ts"() {
     "use strict";
-    init_errors();
+    init_paths();
   }
 });
 
@@ -930,7 +1108,8 @@ async function spawnAgent(options) {
 
 ${instructions}`;
   }
-  const pFile = promptFile(projectRoot, agentId2);
+  const pFile = agentPromptFile(projectRoot, agentId2);
+  await fs6.mkdir(agentPromptsDir(projectRoot), { recursive: true });
   await fs6.writeFile(pFile, fullPrompt, "utf-8");
   const command = buildAgentCommand(agentConfig, pFile, options.sessionId);
   await sendKeys(tmuxTarget, command);
@@ -1046,8 +1225,14 @@ async function resumeAgent(options) {
   return newTarget;
 }
 async function killAgent(agent) {
-  await sendCtrlC(agent.tmuxTarget);
-  await new Promise((resolve) => setTimeout(resolve, 500));
+  const initialInfo = await getPaneInfo(agent.tmuxTarget);
+  if (!initialInfo || initialInfo.isDead) return;
+  try {
+    await sendCtrlC(agent.tmuxTarget);
+  } catch {
+    return;
+  }
+  await new Promise((resolve) => setTimeout(resolve, 2e3));
   const paneInfo = await getPaneInfo(agent.tmuxTarget);
   if (paneInfo && !paneInfo.isDead) {
     await killPane(agent.tmuxTarget);
@@ -1055,10 +1240,16 @@ async function killAgent(agent) {
 }
 async function killAgents(agents) {
   if (agents.length === 0) return;
-  await Promise.all(agents.map((a) => sendCtrlC(a.tmuxTarget).catch(() => {
-  })));
-  await new Promise((resolve) => setTimeout(resolve, 500));
+  const alive = [];
   await Promise.all(agents.map(async (a) => {
+    const info2 = await getPaneInfo(a.tmuxTarget);
+    if (info2 && !info2.isDead) alive.push(a);
+  }));
+  if (alive.length === 0) return;
+  await Promise.all(alive.map((a) => sendCtrlC(a.tmuxTarget).catch(() => {
+  })));
+  await new Promise((resolve) => setTimeout(resolve, 2e3));
+  await Promise.all(alive.map(async (a) => {
     const paneInfo = await getPaneInfo(a.tmuxTarget);
     if (paneInfo && !paneInfo.isDead) {
       await killPane(a.tmuxTarget);
@@ -1090,7 +1281,7 @@ var init_agent = __esm({
 // src/core/terminal.ts
 import { execa as execa4 } from "execa";
 async function openTerminalWindow(sessionName, windowTarget, title) {
-  const tmuxCmd = `tmux attach-session -t ${sessionName} \\\\; select-window -t ${windowTarget}`;
+  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 script = `
 tell application "Terminal"
   activate
@@ -1133,6 +1324,25 @@ var init_id = __esm({
   }
 });
 
+// src/lib/name.ts
+function normalizeName(raw, fallback) {
+  const name = raw.toLowerCase().replace(/[\x00-\x1f\x7f]+/g, "").replace(/[\s_]+/g, "-").replace(/[~^:?*[\]\\@{}<>]+/g, "-").replace(/\.{2,}/g, ".").replace(/-{2,}/g, "-").split("/").map(normalizeSegment).filter(Boolean).join("/");
+  return name || fallback;
+}
+function normalizeSegment(segment) {
+  let s = segment;
+  while (s.endsWith(".lock")) {
+    s = s.slice(0, -5);
+  }
+  s = s.replace(/^[-.]+|[-.]+$/g, "");
+  return s;
+}
+var init_name = __esm({
+  "src/lib/name.ts"() {
+    "use strict";
+  }
+});
+
 // src/commands/spawn.ts
 var spawn_exports = {};
 __export(spawn_exports, {
@@ -1190,7 +1400,7 @@ async function resolvePrompt(options, projectRoot) {
 async function spawnNewWorktree(projectRoot, config, agentConfig, promptText, count, options) {
   const baseBranch = options.base ?? await getCurrentBranch(projectRoot);
   const wtId = worktreeId();
-  const name = options.name ?? wtId;
+  const name = options.name ? normalizeName(options.name, wtId) : wtId;
   const branchName = `ppg/${name}`;
   info(`Creating worktree ${wtId} on branch ${branchName}`);
   const wtPath = await createWorktree(projectRoot, wtId, {
@@ -1255,7 +1465,7 @@ async function spawnNewWorktree(projectRoot, config, agentConfig, promptText, co
     m.worktrees[wtId] = worktreeEntry;
     return m;
   });
-  if (options.open !== false) {
+  if (options.open === true) {
     openTerminalWindow(sessionName, windowTarget, name).catch(() => {
     });
   }
@@ -1341,7 +1551,7 @@ async function spawnIntoExistingWorktree(projectRoot, config, agentConfig, workt
     }
     return m;
   });
-  if (options.open !== false) {
+  if (options.open === true) {
     openTerminalWindow(manifest.sessionName, windowTarget, wt.name).catch(() => {
     });
   }
@@ -1370,7 +1580,7 @@ var init_spawn = __esm({
     init_config();
     init_manifest();
     init_worktree();
-    init_env();
+    init_env2();
     init_template();
     init_agent();
     init_tmux();
@@ -1379,6 +1589,7 @@ var init_spawn = __esm({
     init_paths();
     init_errors();
     init_output();
+    init_name();
   }
 });
 
@@ -1497,20 +1708,103 @@ var init_status = __esm({
   }
 });
 
-// src/core/cleanup.ts
-async function cleanupWorktree(projectRoot, wt) {
-  const windowKills = [];
+// src/core/self.ts
+function getCurrentPaneId() {
+  return process.env.TMUX_PANE ?? null;
+}
+function wouldAffectSelf(target, selfPaneId, paneMap) {
+  if (target === selfPaneId) return true;
+  const targetInfo = paneMap.get(target);
+  if (!targetInfo) return false;
+  if (targetInfo.paneId === selfPaneId) return true;
+  if (!target.includes(".") && target.includes(":")) {
+    for (const [key, info2] of paneMap) {
+      if (key.startsWith(target + ".") && info2.paneId === selfPaneId) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function excludeSelf(agents, selfPaneId, paneMap) {
+  const safe = [];
+  const skipped = [];
+  for (const agent of agents) {
+    if (wouldAffectSelf(agent.tmuxTarget, selfPaneId, paneMap)) {
+      skipped.push(agent);
+    } else {
+      safe.push(agent);
+    }
+  }
+  return { safe, skipped };
+}
+function wouldCleanupAffectSelf(wt, selfPaneId, paneMap) {
+  if (wt.tmuxWindow && wouldAffectSelf(wt.tmuxWindow, selfPaneId, paneMap)) {
+    return true;
+  }
   for (const agent of Object.values(wt.agents)) {
-    if (agent.tmuxTarget) {
-      windowKills.push(killWindow(agent.tmuxTarget).catch(() => {
-      }));
+    if (agent.tmuxTarget && wouldAffectSelf(agent.tmuxTarget, selfPaneId, paneMap)) {
+      return true;
     }
   }
-  if (wt.tmuxWindow) {
-    windowKills.push(killWindow(wt.tmuxWindow).catch(() => {
-    }));
+  return false;
+}
+var init_self = __esm({
+  "src/core/self.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/cleanup.ts
+import fs8 from "fs/promises";
+async function cleanupWorktree(projectRoot, wt, options) {
+  const selfPaneId = options?.selfPaneId ?? null;
+  const paneMap = options?.paneMap ?? /* @__PURE__ */ new Map();
+  const result = {
+    worktreeId: wt.id,
+    manifestUpdated: false,
+    tmuxKilled: 0,
+    tmuxSkipped: 0,
+    tmuxFailed: 0,
+    selfProtected: false,
+    selfProtectedTargets: []
+  };
+  const alreadyCleaned = wt.status === "cleaned";
+  if (!alreadyCleaned) {
+    await updateManifest(projectRoot, (m) => {
+      if (m.worktrees[wt.id]) {
+        m.worktrees[wt.id].status = "cleaned";
+      }
+      return m;
+    });
+    result.manifestUpdated = true;
+  }
+  if (!alreadyCleaned) {
+    const targets = /* @__PURE__ */ new Set();
+    for (const agent of Object.values(wt.agents)) {
+      if (agent.tmuxTarget) targets.add(agent.tmuxTarget);
+    }
+    if (wt.tmuxWindow) targets.add(wt.tmuxWindow);
+    for (const target of targets) {
+      if (selfPaneId && wouldAffectSelf(target, selfPaneId, paneMap)) {
+        result.selfProtected = true;
+        result.selfProtectedTargets.push(target);
+        warn(`Skipping tmux kill for ${target} \u2014 contains current process`);
+        continue;
+      }
+      try {
+        await killWindow(target);
+        result.tmuxKilled++;
+      } catch (err) {
+        result.tmuxFailed++;
+        warn(`Failed to kill tmux window ${target}: ${err instanceof Error ? err.message : err}`);
+      }
+    }
+  }
+  for (const agent of Object.values(wt.agents)) {
+    const pFile = agentPromptFile(projectRoot, agent.id);
+    await fs8.rm(pFile, { force: true });
   }
-  await Promise.all(windowKills);
   try {
     await teardownWorktreeEnv(wt.path);
   } catch {
@@ -1524,21 +1818,18 @@ async function cleanupWorktree(projectRoot, wt) {
   } catch (err) {
     warn(`Could not fully remove worktree ${wt.id}: ${err instanceof Error ? err.message : err}`);
   }
-  await updateManifest(projectRoot, (m) => {
-    if (m.worktrees[wt.id]) {
-      m.worktrees[wt.id].status = "cleaned";
-    }
-    return m;
-  });
+  return result;
 }
 var init_cleanup = __esm({
   "src/core/cleanup.ts"() {
     "use strict";
     init_manifest();
     init_worktree();
-    init_env();
+    init_env2();
     init_tmux();
+    init_paths();
     init_output();
+    init_self();
   }
 });
 
@@ -1552,20 +1843,36 @@ async function killCommand(options) {
   if (!options.agent && !options.worktree && !options.all) {
     throw new PgError("One of --agent, --worktree, or --all is required", "INVALID_ARGS");
   }
+  const selfPaneId = getCurrentPaneId();
+  let paneMap;
+  if (selfPaneId) {
+    const manifest = await readManifest(projectRoot);
+    paneMap = await listSessionPanes(manifest.sessionName);
+  }
   if (options.agent) {
-    await killSingleAgent(projectRoot, options.agent, options);
+    await killSingleAgent(projectRoot, options.agent, options, selfPaneId, paneMap);
   } else if (options.worktree) {
-    await killWorktreeAgents(projectRoot, options.worktree, options);
+    await killWorktreeAgents(projectRoot, options.worktree, options, selfPaneId, paneMap);
   } else if (options.all) {
-    await killAllAgents(projectRoot, options);
+    await killAllAgents(projectRoot, options, selfPaneId, paneMap);
   }
 }
-async function killSingleAgent(projectRoot, agentId2, options) {
+async function killSingleAgent(projectRoot, agentId2, options, selfPaneId, paneMap) {
   const manifest = await readManifest(projectRoot);
   const found = findAgent(manifest, agentId2);
   if (!found) throw new AgentNotFoundError(agentId2);
   const { agent } = found;
   const isTerminal = ["completed", "failed", "killed", "lost"].includes(agent.status);
+  if (selfPaneId && paneMap) {
+    const { skipped } = excludeSelf([agent], selfPaneId, paneMap);
+    if (skipped.length > 0) {
+      warn(`Cannot kill agent ${agentId2} \u2014 it contains the current ppg process`);
+      if (options.json) {
+        output({ success: false, skipped: [agentId2], reason: "self-protection" }, true);
+      }
+      return;
+    }
+  }
   if (options.delete) {
     if (!isTerminal) {
       info(`Killing agent ${agentId2}`);
@@ -1602,11 +1909,20 @@ async function killSingleAgent(projectRoot, agentId2, options) {
     }
   }
 }
-async function killWorktreeAgents(projectRoot, worktreeRef, options) {
+async function killWorktreeAgents(projectRoot, worktreeRef, options, selfPaneId, paneMap) {
   const manifest = await readManifest(projectRoot);
   const wt = resolveWorktree(manifest, worktreeRef);
   if (!wt) throw new WorktreeNotFoundError(worktreeRef);
-  const toKill = Object.values(wt.agents).filter((a) => ["running", "spawning", "waiting"].includes(a.status));
+  let toKill = Object.values(wt.agents).filter((a) => ["running", "spawning", "waiting"].includes(a.status));
+  const skippedIds = [];
+  if (selfPaneId && paneMap) {
+    const { safe, skipped } = excludeSelf(toKill, selfPaneId, paneMap);
+    toKill = safe;
+    for (const a of skipped) {
+      skippedIds.push(a.id);
+      warn(`Skipping agent ${a.id} \u2014 contains current ppg process`);
+    }
+  }
   const killedIds = toKill.map((a) => a.id);
   for (const a of toKill) info(`Killing agent ${a.id}`);
   await killAgents(toKill);
@@ -1624,7 +1940,7 @@ async function killWorktreeAgents(projectRoot, worktreeRef, options) {
   });
   const shouldRemove = options.remove || options.delete;
   if (shouldRemove) {
-    await removeWorktreeCleanup(projectRoot, wt.id);
+    await removeWorktreeCleanup(projectRoot, wt.id, selfPaneId, paneMap);
   }
   if (options.delete) {
     await updateManifest(projectRoot, (m) => {
@@ -1636,11 +1952,15 @@ async function killWorktreeAgents(projectRoot, worktreeRef, options) {
     output({
       success: true,
       killed: killedIds,
+      skipped: skippedIds.length > 0 ? skippedIds : void 0,
       removed: shouldRemove ? [wt.id] : [],
       deleted: options.delete ? [wt.id] : []
     }, 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) {
       success(`Deleted worktree ${wt.id}`);
     } else if (options.remove) {
@@ -1648,9 +1968,9 @@ async function killWorktreeAgents(projectRoot, worktreeRef, options) {
     }
   }
 }
-async function killAllAgents(projectRoot, options) {
+async function killAllAgents(projectRoot, options, selfPaneId, paneMap) {
   const manifest = await readManifest(projectRoot);
-  const toKill = [];
+  let toKill = [];
   for (const wt of Object.values(manifest.worktrees)) {
     for (const agent of Object.values(wt.agents)) {
       if (["running", "spawning", "waiting"].includes(agent.status)) {
@@ -1658,6 +1978,15 @@ async function killAllAgents(projectRoot, options) {
       }
     }
   }
+  const skippedIds = [];
+  if (selfPaneId && paneMap) {
+    const { safe, skipped } = excludeSelf(toKill, selfPaneId, paneMap);
+    toKill = safe;
+    for (const a of skipped) {
+      skippedIds.push(a.id);
+      warn(`Skipping agent ${a.id} \u2014 contains current ppg process`);
+    }
+  }
   const killedIds = toKill.map((a) => a.id);
   for (const a of toKill) info(`Killing agent ${a.id}`);
   await killAgents(toKill);
@@ -1676,7 +2005,7 @@ async function killAllAgents(projectRoot, options) {
   const shouldRemove = options.remove || options.delete;
   if (shouldRemove) {
     for (const wtId of activeWorktreeIds) {
-      await removeWorktreeCleanup(projectRoot, wtId);
+      await removeWorktreeCleanup(projectRoot, wtId, selfPaneId, paneMap);
     }
   }
   if (options.delete) {
@@ -1691,11 +2020,15 @@ async function killAllAgents(projectRoot, options) {
     output({
       success: true,
       killed: killedIds,
+      skipped: skippedIds.length > 0 ? skippedIds : void 0,
       removed: shouldRemove ? activeWorktreeIds : [],
       deleted: options.delete ? activeWorktreeIds : []
     }, 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 (options.delete) {
       success(`Deleted ${activeWorktreeIds.length} worktree(s)`);
     } else if (options.remove) {
@@ -1703,11 +2036,14 @@ async function killAllAgents(projectRoot, options) {
     }
   }
 }
-async function removeWorktreeCleanup(projectRoot, wtId) {
+async function removeWorktreeCleanup(projectRoot, wtId, selfPaneId, paneMap) {
   const manifest = await readManifest(projectRoot);
   const wt = resolveWorktree(manifest, wtId);
   if (!wt) return;
-  await cleanupWorktree(projectRoot, wt);
+  await cleanupWorktree(projectRoot, wt, {
+    selfPaneId,
+    paneMap
+  });
 }
 var init_kill = __esm({
   "src/commands/kill.ts"() {
@@ -1716,6 +2052,8 @@ var init_kill = __esm({
     init_agent();
     init_worktree();
     init_cleanup();
+    init_self();
+    init_tmux();
     init_errors();
     init_output();
   }
@@ -1876,7 +2214,7 @@ var aggregate_exports = {};
 __export(aggregate_exports, {
   aggregateCommand: () => aggregateCommand
 });
-import fs8 from "fs/promises";
+import fs9 from "fs/promises";
 async function aggregateCommand(worktreeId2, options) {
   const projectRoot = await getRepoRoot();
   let manifest;
@@ -1940,7 +2278,7 @@ async function aggregateCommand(worktreeId2, options) {
     ].join("\n");
   }).join("\n");
   if (options?.output) {
-    await fs8.writeFile(options.output, combined, "utf-8");
+    await fs9.writeFile(options.output, combined, "utf-8");
     success(`Wrote ${results.length} result(s) to ${options.output}`);
   } else {
     console.log(combined);
@@ -1948,7 +2286,7 @@ async function aggregateCommand(worktreeId2, options) {
 }
 async function collectAgentResult(agent, projectRoot) {
   try {
-    const content = await fs8.readFile(agent.resultFile, "utf-8");
+    const content = await fs9.readFile(agent.resultFile, "utf-8");
     return content;
   } catch {
   }
@@ -2020,59 +2358,434 @@ async function mergeCommand(worktreeId2, options) {
   try {
     info(`Merging ${wt.branch} into ${wt.baseBranch} (${strategy})`);
     if (strategy === "squash") {
-      await execa5("git", ["merge", "--squash", wt.branch], { cwd: projectRoot });
+      await execa5("git", ["merge", "--squash", wt.branch], { ...execaEnv, cwd: projectRoot });
       await execa5("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})`], {
+        ...execaEnv,
         cwd: projectRoot
       });
     }
-    success(`Merged ${wt.branch} into ${wt.baseBranch}`);
-  } catch (err) {
+    success(`Merged ${wt.branch} into ${wt.baseBranch}`);
+  } catch (err) {
+    await updateManifest(projectRoot, (m) => {
+      if (m.worktrees[wt.id]) {
+        m.worktrees[wt.id].status = "failed";
+      }
+      return m;
+    });
+    throw new MergeFailedError(
+      `Merge failed: ${err instanceof Error ? err.message : err}`
+    );
+  }
+  await updateManifest(projectRoot, (m) => {
+    if (m.worktrees[wt.id]) {
+      m.worktrees[wt.id].status = "merged";
+      m.worktrees[wt.id].mergedAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    return m;
+  });
+  let selfProtected = false;
+  if (options.cleanup !== false) {
+    info("Cleaning up...");
+    const selfPaneId = getCurrentPaneId();
+    let paneMap;
+    if (selfPaneId) {
+      paneMap = await listSessionPanes(manifest.sessionName);
+    }
+    const cleanupResult = await cleanupWorktree(projectRoot, wt, { selfPaneId, paneMap });
+    selfProtected = cleanupResult.selfProtected;
+    if (selfProtected) {
+      warn(`Some tmux targets skipped during cleanup \u2014 contains current ppg process`);
+    }
+    success(`Cleaned up worktree ${wt.id}`);
+  }
+  if (options.json) {
+    output({
+      success: true,
+      worktreeId: wt.id,
+      branch: wt.branch,
+      baseBranch: wt.baseBranch,
+      strategy,
+      cleaned: options.cleanup !== false,
+      selfProtected: selfProtected || void 0
+    }, true);
+  }
+}
+var init_merge = __esm({
+  "src/commands/merge.ts"() {
+    "use strict";
+    init_manifest();
+    init_agent();
+    init_worktree();
+    init_cleanup();
+    init_self();
+    init_tmux();
+    init_errors();
+    init_output();
+    init_env();
+  }
+});
+
+// src/core/swarm.ts
+import fs10 from "fs/promises";
+import path5 from "path";
+import YAML2 from "yaml";
+async function listSwarms(projectRoot) {
+  const dir = swarmsDir(projectRoot);
+  try {
+    const files = await fs10.readdir(dir);
+    return files.filter((f) => f.endsWith(".yaml") || f.endsWith(".yml")).map((f) => f.replace(/\.ya?ml$/, "")).sort();
+  } catch {
+    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"
+    );
+  }
+  const dir = swarmsDir(projectRoot);
+  let filePath = path5.join(dir, `${name}.yaml`);
+  try {
+    await fs10.access(filePath);
+  } catch {
+    filePath = path5.join(dir, `${name}.yml`);
+    try {
+      await fs10.access(filePath);
+    } catch {
+      throw new PgError(`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");
+  }
+  if (!parsed.name || !parsed.agents || !Array.isArray(parsed.agents)) {
+    throw new PgError(`Invalid swarm template: ${name} (missing name or agents)`, "INVALID_ARGS");
+  }
+  if (!SAFE_NAME.test(parsed.name)) {
+    throw new PgError(
+      `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(
+      `Invalid swarm strategy: ${parsed.strategy}. Must be 'shared' or 'isolated'`,
+      "INVALID_ARGS"
+    );
+  }
+  for (let i = 0; i < parsed.agents.length; i++) {
+    const agent = parsed.agents[i];
+    if (!agent.prompt || typeof agent.prompt !== "string") {
+      throw new PgError(
+        `Invalid swarm template: ${name} \u2014 agent[${i}] missing prompt field`,
+        "INVALID_ARGS"
+      );
+    }
+    if (!SAFE_NAME.test(agent.prompt)) {
+      throw new PgError(
+        `Invalid prompt name: "${agent.prompt}" \u2014 must be alphanumeric, hyphens, or underscores`,
+        "INVALID_ARGS"
+      );
+    }
+  }
+  return {
+    ...parsed,
+    strategy: parsed.strategy ?? "shared",
+    description: parsed.description ?? ""
+  };
+}
+var SAFE_NAME;
+var init_swarm = __esm({
+  "src/core/swarm.ts"() {
+    "use strict";
+    init_paths();
+    init_errors();
+    SAFE_NAME = /^[\w-]+$/;
+  }
+});
+
+// src/commands/swarm.ts
+var swarm_exports = {};
+__export(swarm_exports, {
+  swarmCommand: () => swarmCommand
+});
+import fs11 from "fs/promises";
+import path6 from "path";
+async function swarmCommand(templateName, options) {
+  const projectRoot = await getRepoRoot();
+  const config = await loadConfig(projectRoot);
+  try {
+    await fs11.access(manifestPath(projectRoot));
+  } catch {
+    throw new NotInitializedError(projectRoot);
+  }
+  const swarm = await loadSwarm(projectRoot, templateName);
+  const userVars = parseVars(options.var ?? []);
+  if (options.worktree) {
+    await swarmIntoExistingWorktree(projectRoot, config, swarm, options, userVars);
+  } else if (swarm.strategy === "isolated") {
+    await swarmIsolated(projectRoot, config, swarm, options, userVars);
+  } else {
+    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`);
+  try {
+    return await fs11.readFile(filePath, "utf-8");
+  } catch {
+    throw new PgError(`Prompt file not found: ${promptName}.md in .pg/prompts/`, "INVALID_ARGS");
+  }
+}
+async function spawnSwarmAgent(opts) {
+  const { projectRoot, config, swarmAgent, wtPath, branchName, tmuxTarget, taskName, userVars } = opts;
+  const agentConfig = resolveAgentConfig(config, swarmAgent.agent);
+  const aId = agentId();
+  const promptContent = await loadPromptFile(projectRoot, swarmAgent.prompt);
+  const ctx = {
+    WORKTREE_PATH: wtPath,
+    BRANCH: branchName,
+    AGENT_ID: aId,
+    RESULT_FILE: resultFile(projectRoot, aId),
+    PROJECT_ROOT: projectRoot,
+    TASK_NAME: taskName,
+    ...swarmAgent.vars ?? {},
+    ...userVars
+  };
+  const renderedPrompt = renderTemplate(promptContent, ctx);
+  return spawnAgent({
+    agentId: aId,
+    agentConfig,
+    prompt: renderedPrompt,
+    worktreePath: wtPath,
+    tmuxTarget,
+    projectRoot,
+    branch: branchName,
+    sessionId: sessionId()
+  });
+}
+async function swarmShared(projectRoot, config, swarm, options, userVars) {
+  const baseBranch = options.base ?? await getCurrentBranch(projectRoot);
+  const wtId = worktreeId();
+  const name = options.name ? normalizeName(options.name, swarm.name) : swarm.name;
+  const branchName = `ppg/${name}`;
+  info(`Creating worktree ${wtId} on branch ${branchName}`);
+  const wtPath = await createWorktree(projectRoot, wtId, {
+    branch: branchName,
+    base: baseBranch
+  });
+  await setupWorktreeEnv(projectRoot, wtPath, config);
+  const sessionName = config.sessionName;
+  await ensureSession(sessionName);
+  const windowTarget = await createWindow(sessionName, name, wtPath);
+  await updateManifest(projectRoot, (m) => {
+    m.worktrees[wtId] = {
+      id: wtId,
+      name,
+      path: wtPath,
+      branch: branchName,
+      baseBranch,
+      status: "active",
+      tmuxWindow: windowTarget,
+      agents: {},
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return m;
+  });
+  const agents = [];
+  for (let i = 0; i < swarm.agents.length; i++) {
+    const target = i === 0 ? windowTarget : await createWindow(sessionName, `${name}-${i}`, wtPath);
+    const agentEntry = await spawnSwarmAgent({
+      projectRoot,
+      config,
+      swarmAgent: swarm.agents[i],
+      wtPath,
+      branchName,
+      tmuxTarget: target,
+      taskName: name,
+      userVars
+    });
+    agents.push(agentEntry);
+    await updateManifest(projectRoot, (m) => {
+      m.worktrees[wtId].agents[agentEntry.id] = agentEntry;
+      return m;
+    });
+  }
+  if (options.open === true) {
+    openTerminalWindow(sessionName, windowTarget, name).catch(() => {
+    });
+  }
+  outputResult(options.json, swarm, wtId, name, branchName, wtPath, windowTarget, agents);
+}
+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;
+  await ensureSession(sessionName);
+  const worktrees = [];
+  const allAgents = [];
+  const usedNames = /* @__PURE__ */ new Set();
+  for (const swarmAgent of swarm.agents) {
+    const wtId = worktreeId();
+    let wtName = `${baseName}-${swarmAgent.prompt}`;
+    if (usedNames.has(wtName)) {
+      let suffix = 2;
+      while (usedNames.has(`${wtName}-${suffix}`)) suffix++;
+      wtName = `${wtName}-${suffix}`;
+    }
+    usedNames.add(wtName);
+    const branchName = `ppg/${wtName}`;
+    info(`Creating worktree ${wtId} on branch ${branchName}`);
+    const wtPath = await createWorktree(projectRoot, wtId, {
+      branch: branchName,
+      base: baseBranch
+    });
+    await setupWorktreeEnv(projectRoot, wtPath, config);
+    const windowTarget = await createWindow(sessionName, wtName, wtPath);
+    const agentEntry = await spawnSwarmAgent({
+      projectRoot,
+      config,
+      swarmAgent,
+      wtPath,
+      branchName,
+      tmuxTarget: windowTarget,
+      taskName: wtName,
+      userVars
+    });
+    const worktreeEntry = {
+      id: wtId,
+      name: wtName,
+      path: wtPath,
+      branch: branchName,
+      baseBranch,
+      status: "active",
+      tmuxWindow: windowTarget,
+      agents: { [agentEntry.id]: agentEntry },
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await updateManifest(projectRoot, (m) => {
+      m.worktrees[wtId] = worktreeEntry;
+      return m;
+    });
+    if (options.open === true) {
+      openTerminalWindow(sessionName, windowTarget, wtName).catch(() => {
+      });
+    }
+    worktrees.push({ id: wtId, name: wtName, branch: branchName, path: wtPath, tmuxWindow: windowTarget });
+    allAgents.push(agentEntry);
+  }
+  if (options.json) {
+    output({
+      success: true,
+      swarm: swarm.name,
+      strategy: "isolated",
+      worktrees: worktrees.map((wt, i) => ({
+        ...wt,
+        agents: [{ id: allAgents[i].id, tmuxTarget: allAgents[i].tmuxTarget, sessionId: allAgents[i].sessionId }]
+      }))
+    }, true);
+  } else {
+    success(`Swarm "${swarm.name}" spawned ${swarm.agents.length} agent(s) in isolated worktrees`);
+    for (let i = 0; i < worktrees.length; i++) {
+      info(`  ${worktrees[i].name} (${worktrees[i].id}) \u2192 agent ${allAgents[i].id}`);
+    }
+  }
+}
+async function swarmIntoExistingWorktree(projectRoot, config, swarm, options, userVars) {
+  const manifest = await readManifest(projectRoot);
+  const wt = resolveWorktree(manifest, options.worktree);
+  if (!wt) throw new WorktreeNotFoundError(options.worktree);
+  const sessionName = config.sessionName;
+  let windowTarget = wt.tmuxWindow;
+  if (!windowTarget) {
+    await ensureSession(sessionName);
+    windowTarget = await createWindow(sessionName, wt.name, wt.path);
+  }
+  if (!wt.tmuxWindow) {
     await updateManifest(projectRoot, (m) => {
-      if (m.worktrees[wt.id]) {
-        m.worktrees[wt.id].status = "failed";
-      }
+      m.worktrees[wt.id].tmuxWindow = windowTarget;
       return m;
     });
-    throw new MergeFailedError(
-      `Merge failed: ${err instanceof Error ? err.message : err}`
-    );
   }
-  await updateManifest(projectRoot, (m) => {
-    if (m.worktrees[wt.id]) {
-      m.worktrees[wt.id].status = "merged";
-      m.worktrees[wt.id].mergedAt = (/* @__PURE__ */ new Date()).toISOString();
-    }
-    return m;
-  });
-  if (options.cleanup !== false) {
-    info("Cleaning up...");
-    await cleanupWorktree(projectRoot, wt);
-    success(`Cleaned up worktree ${wt.id}`);
+  const agents = [];
+  for (let i = 0; i < swarm.agents.length; i++) {
+    const target = i === 0 ? windowTarget : await createWindow(sessionName, `${wt.name}-${swarm.name}-${i}`, wt.path);
+    const agentEntry = await spawnSwarmAgent({
+      projectRoot,
+      config,
+      swarmAgent: swarm.agents[i],
+      wtPath: wt.path,
+      branchName: wt.branch,
+      tmuxTarget: target,
+      taskName: wt.name,
+      userVars
+    });
+    agents.push(agentEntry);
+    await updateManifest(projectRoot, (m) => {
+      m.worktrees[wt.id].agents[agentEntry.id] = agentEntry;
+      return m;
+    });
   }
-  if (options.json) {
+  if (options.open === true) {
+    openTerminalWindow(sessionName, windowTarget, wt.name).catch(() => {
+    });
+  }
+  outputResult(options.json, swarm, wt.id, wt.name, wt.branch, wt.path, windowTarget, agents);
+}
+function outputResult(json, swarm, wtId, name, branch, wtPath, tmuxWindow, agents) {
+  if (json) {
     output({
       success: true,
-      worktreeId: wt.id,
-      branch: wt.branch,
-      baseBranch: wt.baseBranch,
-      strategy,
-      cleaned: options.cleanup !== false
+      swarm: swarm.name,
+      strategy: swarm.strategy,
+      worktree: { id: wtId, name, branch, path: wtPath, tmuxWindow },
+      agents: agents.map((a) => ({ id: a.id, tmuxTarget: a.tmuxTarget, sessionId: a.sessionId }))
     }, true);
+  } else {
+    success(`Swarm "${swarm.name}" spawned ${agents.length} agent(s) in worktree ${wtId}`);
+    for (const a of agents) {
+      info(`  Agent ${a.id} \u2192 ${a.tmuxTarget}`);
+    }
+    info(`Attach: ppg attach ${wtId}`);
   }
 }
-var init_merge = __esm({
-  "src/commands/merge.ts"() {
+var init_swarm2 = __esm({
+  "src/commands/swarm.ts"() {
     "use strict";
+    init_config();
     init_manifest();
-    init_agent();
     init_worktree();
-    init_cleanup();
+    init_env2();
+    init_template();
+    init_swarm();
+    init_agent();
+    init_tmux();
+    init_terminal();
+    init_id();
+    init_paths();
     init_errors();
     init_output();
+    init_name();
   }
 });
 
@@ -2081,12 +2794,18 @@ var list_exports = {};
 __export(list_exports, {
   listCommand: () => listCommand
 });
-import fs9 from "fs/promises";
-import path5 from "path";
+import fs12 from "fs/promises";
+import path7 from "path";
 async function listCommand(type, options) {
-  if (type !== "templates") {
-    throw new PgError(`Unknown list type: ${type}. Available: templates`, "INVALID_ARGS");
+  if (type === "templates") {
+    await listTemplatesCommand(options);
+  } else if (type === "swarms") {
+    await listSwarmsCommand(options);
+  } else {
+    throw new PgError(`Unknown list type: ${type}. Available: templates, swarms`, "INVALID_ARGS");
   }
+}
+async function listTemplatesCommand(options) {
   const projectRoot = await getRepoRoot();
   const templateNames = await listTemplates(projectRoot);
   if (templateNames.length === 0) {
@@ -2095,8 +2814,8 @@ async function listCommand(type, options) {
   }
   const templates = await Promise.all(
     templateNames.map(async (name) => {
-      const filePath = path5.join(templatesDir(projectRoot), `${name}.md`);
-      const content = await fs9.readFile(filePath, "utf-8");
+      const filePath = path7.join(templatesDir(projectRoot), `${name}.md`);
+      const content = await fs12.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]);
@@ -2120,11 +2839,46 @@ async function listCommand(type, options) {
   ];
   console.log(formatTable(templates, columns));
 }
+async function listSwarmsCommand(options) {
+  const projectRoot = await getRepoRoot();
+  const swarmNames = await listSwarms(projectRoot);
+  if (swarmNames.length === 0) {
+    if (options.json) {
+      output({ swarms: [] }, true);
+    } else {
+      console.log("No swarm templates found in .pg/swarms/");
+    }
+    return;
+  }
+  const swarms = await Promise.all(
+    swarmNames.map(async (name) => {
+      const swarm = await loadSwarm(projectRoot, name);
+      return {
+        name,
+        description: swarm.description,
+        strategy: swarm.strategy,
+        agents: swarm.agents.length
+      };
+    })
+  );
+  if (options.json) {
+    output({ swarms }, true);
+    return;
+  }
+  const columns = [
+    { header: "Name", key: "name", width: 20 },
+    { header: "Description", key: "description", width: 40 },
+    { header: "Strategy", key: "strategy", width: 10 },
+    { header: "Agents", key: "agents", width: 8 }
+  ];
+  console.log(formatTable(swarms, columns));
+}
 var init_list = __esm({
   "src/commands/list.ts"() {
     "use strict";
     init_worktree();
     init_template();
+    init_swarm();
     init_paths();
     init_errors();
     init_output();
@@ -2136,7 +2890,7 @@ var restart_exports = {};
 __export(restart_exports, {
   restartCommand: () => restartCommand
 });
-import fs10 from "fs/promises";
+import fs13 from "fs/promises";
 async function restartCommand(agentRef, options) {
   const projectRoot = await getRepoRoot();
   const config = await loadConfig(projectRoot);
@@ -2157,9 +2911,9 @@ async function restartCommand(agentRef, options) {
   if (options.prompt) {
     promptText = options.prompt;
   } else {
-    const pFile = promptFile(projectRoot, oldAgent.id);
+    const pFile = agentPromptFile(projectRoot, oldAgent.id);
     try {
-      promptText = await fs10.readFile(pFile, "utf-8");
+      promptText = await fs13.readFile(pFile, "utf-8");
     } catch {
       throw new PgError(
         `Could not read original prompt for agent ${oldAgent.id}. Use --prompt to provide one.`,
@@ -2204,7 +2958,7 @@ async function restartCommand(agentRef, options) {
     }
     return m;
   });
-  if (options.open !== false) {
+  if (options.open === true) {
     openTerminalWindow(manifest.sessionName, windowTarget, `${wt.name}-restart`).catch(() => {
     });
   }
@@ -2262,7 +3016,7 @@ async function diffCommand(worktreeRef, options) {
   if (!wt) throw new WorktreeNotFoundError(worktreeRef);
   const diffRange = `${wt.baseBranch}...${wt.branch}`;
   if (options.json) {
-    const result = await execa6("git", ["diff", "--numstat", diffRange], { cwd: projectRoot });
+    const result = await execa6("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 {
@@ -2278,13 +3032,13 @@ async function diffCommand(worktreeRef, options) {
       files
     }, true);
   } else if (options.stat) {
-    const result = await execa6("git", ["diff", "--stat", diffRange], { cwd: projectRoot });
+    const result = await execa6("git", ["diff", "--stat", diffRange], { ...execaEnv, cwd: projectRoot });
     console.log(result.stdout);
   } else if (options.nameOnly) {
-    const result = await execa6("git", ["diff", "--name-only", diffRange], { cwd: projectRoot });
+    const result = await execa6("git", ["diff", "--name-only", diffRange], { ...execaEnv, cwd: projectRoot });
     console.log(result.stdout);
   } else {
-    const result = await execa6("git", ["diff", diffRange], { cwd: projectRoot });
+    const result = await execa6("git", ["diff", diffRange], { ...execaEnv, cwd: projectRoot });
     console.log(result.stdout);
   }
 }
@@ -2295,6 +3049,269 @@ var init_diff = __esm({
     init_worktree();
     init_errors();
     init_output();
+    init_env();
+  }
+});
+
+// src/commands/pr.ts
+var pr_exports = {};
+__export(pr_exports, {
+  buildBodyFromResults: () => buildBodyFromResults,
+  prCommand: () => prCommand,
+  truncateBody: () => truncateBody
+});
+import fs14 from "fs/promises";
+import { execa as execa7 } from "execa";
+async function prCommand(worktreeRef, options) {
+  const projectRoot = await getRepoRoot();
+  let manifest;
+  try {
+    manifest = await updateManifest(projectRoot, async (m) => {
+      return refreshAllAgentStatuses(m, projectRoot);
+    });
+  } catch {
+    throw new NotInitializedError(projectRoot);
+  }
+  const wt = resolveWorktree(manifest, worktreeRef);
+  if (!wt) throw new WorktreeNotFoundError(worktreeRef);
+  try {
+    await execa7("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 });
+  } catch (err) {
+    throw new PgError(
+      `Failed to push branch ${wt.branch}: ${err instanceof Error ? err.message : err}`,
+      "INVALID_ARGS"
+    );
+  }
+  const title = options.title ?? wt.name;
+  const body = options.body ?? await buildBodyFromResults(Object.values(wt.agents));
+  const ghArgs = [
+    "pr",
+    "create",
+    "--head",
+    wt.branch,
+    "--base",
+    wt.baseBranch,
+    "--title",
+    title,
+    "--body",
+    body
+  ];
+  if (options.draft) {
+    ghArgs.push("--draft");
+  }
+  info(`Creating PR: ${title}`);
+  let prUrl;
+  try {
+    const result = await execa7("gh", ghArgs, { ...execaEnv, cwd: projectRoot });
+    prUrl = result.stdout.trim();
+  } catch (err) {
+    throw new PgError(
+      `Failed to create PR: ${err instanceof Error ? err.message : err}`,
+      "INVALID_ARGS"
+    );
+  }
+  await updateManifest(projectRoot, (m) => {
+    if (m.worktrees[wt.id]) {
+      m.worktrees[wt.id].prUrl = prUrl;
+    }
+    return m;
+  });
+  if (options.json) {
+    output({
+      success: true,
+      worktreeId: wt.id,
+      branch: wt.branch,
+      baseBranch: wt.baseBranch,
+      prUrl
+    }, true);
+  } else {
+    success(`PR created: ${prUrl}`);
+  }
+}
+async function buildBodyFromResults(agents) {
+  const reads = agents.map(async (agent) => {
+    try {
+      return await fs14.readFile(agent.resultFile, "utf-8");
+    } catch {
+      return null;
+    }
+  });
+  const contents = (await Promise.all(reads)).filter((c) => c !== null);
+  if (contents.length === 0) return "";
+  return truncateBody(contents.join("\n\n---\n\n"));
+}
+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/`]*";
+}
+var MAX_BODY_LENGTH;
+var init_pr = __esm({
+  "src/commands/pr.ts"() {
+    "use strict";
+    init_manifest();
+    init_agent();
+    init_worktree();
+    init_errors();
+    init_output();
+    init_env();
+    MAX_BODY_LENGTH = 6e4;
+  }
+});
+
+// src/commands/reset.ts
+var reset_exports = {};
+__export(reset_exports, {
+  findAtRiskWorktrees: () => findAtRiskWorktrees,
+  resetCommand: () => resetCommand
+});
+function findAtRiskWorktrees(worktrees) {
+  return worktrees.filter((wt) => {
+    if (wt.status === "merged" || wt.status === "cleaned") return false;
+    if (wt.prUrl) return false;
+    return Object.values(wt.agents).some((a) => a.status === "completed");
+  });
+}
+async function resetCommand(options) {
+  const projectRoot = await getRepoRoot();
+  let manifest;
+  try {
+    manifest = await updateManifest(projectRoot, async (m) => {
+      return refreshAllAgentStatuses(m, projectRoot);
+    });
+  } catch {
+    throw new NotInitializedError(projectRoot);
+  }
+  const worktrees = Object.values(manifest.worktrees);
+  if (worktrees.length === 0) {
+    if (options.json) {
+      output({ success: true, killed: [], removed: [], warned: [] }, true);
+    } else {
+      info("Nothing to reset \u2014 no worktrees in manifest");
+    }
+    return;
+  }
+  const atRisk = findAtRiskWorktrees(worktrees);
+  if (atRisk.length > 0 && !options.force) {
+    throw new UnmergedWorkError(atRisk.map((wt) => `${wt.name} (${wt.branch})`));
+  }
+  if (atRisk.length > 0) {
+    warn(`${atRisk.length} worktree(s) have unmerged/un-PR'd work \u2014 proceeding with --force`);
+  }
+  const selfPaneId = getCurrentPaneId();
+  let paneMap;
+  if (selfPaneId) {
+    paneMap = await listSessionPanes(manifest.sessionName);
+  }
+  const allAgents = [];
+  for (const wt of worktrees) {
+    for (const agent of Object.values(wt.agents)) {
+      if (["running", "spawning", "waiting"].includes(agent.status)) {
+        allAgents.push(agent);
+      }
+    }
+  }
+  let agentsToKill = allAgents;
+  const skippedAgentIds = [];
+  if (selfPaneId && paneMap) {
+    const { safe, skipped } = excludeSelf(allAgents, selfPaneId, paneMap);
+    agentsToKill = safe;
+    for (const a of skipped) {
+      skippedAgentIds.push(a.id);
+      warn(`Skipping agent ${a.id} \u2014 contains current ppg process`);
+    }
+  }
+  const killedIds = agentsToKill.map((a) => a.id);
+  if (agentsToKill.length > 0) {
+    info(`Killing ${agentsToKill.length} running agent(s)`);
+    await killAgents(agentsToKill);
+  }
+  if (killedIds.length > 0) {
+    await updateManifest(projectRoot, (m) => {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      for (const wt of Object.values(m.worktrees)) {
+        for (const agent of Object.values(wt.agents)) {
+          if (killedIds.includes(agent.id)) {
+            agent.status = "killed";
+            agent.completedAt = now;
+          }
+        }
+      }
+      return m;
+    });
+  }
+  const removedIds = [];
+  const skippedWorktreeIds = [];
+  for (const wt of worktrees) {
+    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);
+      continue;
+    }
+    if (wt.status !== "cleaned") {
+      info(`Removing worktree ${wt.id} (${wt.name})`);
+      await cleanupWorktree(projectRoot, wt, { selfPaneId, paneMap });
+    }
+    removedIds.push(wt.id);
+  }
+  if (removedIds.length > 0) {
+    await updateManifest(projectRoot, (m) => {
+      for (const id of removedIds) {
+        delete m.worktrees[id];
+      }
+      return m;
+    });
+  }
+  if (options.prune) {
+    info("Pruning stale git worktrees");
+    await pruneWorktrees(projectRoot);
+  }
+  const warnedNames = atRisk.map((wt) => wt.name);
+  if (options.json) {
+    output({
+      success: true,
+      killed: killedIds,
+      removed: removedIds,
+      warned: warnedNames.length > 0 ? warnedNames : void 0,
+      skipped: skippedWorktreeIds.length > 0 ? skippedWorktreeIds : void 0,
+      pruned: options.prune ?? false
+    }, true);
+  } else {
+    if (killedIds.length > 0) {
+      success(`Killed ${killedIds.length} agent(s)`);
+    }
+    if (removedIds.length > 0) {
+      success(`Removed ${removedIds.length} worktree(s)`);
+    }
+    if (skippedWorktreeIds.length > 0) {
+      warn(`Skipped ${skippedWorktreeIds.length} worktree(s) due to self-protection`);
+    }
+    if (options.prune) {
+      success("Pruned stale git worktrees");
+    }
+    if (killedIds.length > 0 || removedIds.length > 0) {
+      success("Reset complete");
+    } else {
+      info("Nothing to reset");
+    }
+  }
+}
+var init_reset = __esm({
+  "src/commands/reset.ts"() {
+    "use strict";
+    init_manifest();
+    init_agent();
+    init_worktree();
+    init_cleanup();
+    init_self();
+    init_tmux();
+    init_errors();
+    init_output();
   }
 });
 
@@ -2311,6 +3328,11 @@ async function cleanCommand(options) {
   } catch {
     throw new NotInitializedError(projectRoot);
   }
+  const selfPaneId = getCurrentPaneId();
+  let paneMap;
+  if (selfPaneId) {
+    paneMap = await listSessionPanes(manifest.sessionName);
+  }
   const terminalStatuses = ["merged", "cleaned"];
   if (options.all) {
     terminalStatuses.push("failed");
@@ -2348,11 +3370,17 @@ async function cleanCommand(options) {
     return;
   }
   const cleaned = [];
+  const skipped = [];
   const removed = [];
   for (const wt of toClean) {
     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`);
+        skipped.push(wt.id);
+        continue;
+      }
       info(`Cleaning worktree ${wt.id} (${wt.name})`);
-      await cleanupWorktree(projectRoot, wt);
+      await cleanupWorktree(projectRoot, wt, { selfPaneId, paneMap });
       cleaned.push(wt.id);
     }
   }
@@ -2377,6 +3405,7 @@ async function cleanCommand(options) {
     output({
       success: true,
       cleaned,
+      skipped: skipped.length > 0 ? skipped : void 0,
       removedFromManifest: removed,
       pruned: options.prune ?? false
     }, true);
@@ -2384,10 +3413,13 @@ async function cleanCommand(options) {
     if (cleaned.length > 0) {
       success(`Cleaned ${cleaned.length} worktree(s)`);
     }
+    if (skipped.length > 0) {
+      warn(`Skipped ${skipped.length} worktree(s) due to self-protection`);
+    }
     if (removed.length > 0) {
       success(`Removed ${removed.length} worktree(s) from manifest`);
     }
-    if (cleaned.length === 0 && removed.length === 0) {
+    if (cleaned.length === 0 && removed.length === 0 && skipped.length === 0) {
       info("Nothing to clean");
     }
     if (options.prune) {
@@ -2401,6 +3433,8 @@ var init_clean = __esm({
     init_manifest();
     init_worktree();
     init_cleanup();
+    init_self();
+    init_tmux();
     init_errors();
     init_output();
   }
@@ -2561,7 +3595,7 @@ async function worktreeCreateCommand(options) {
   }
   const baseBranch = options.base ?? await getCurrentBranch(projectRoot);
   const wtId = worktreeId();
-  const name = options.name ?? wtId;
+  const name = options.name ? normalizeName(options.name, wtId) : wtId;
   const branchName = `ppg/${name}`;
   info(`Creating worktree ${wtId} on branch ${branchName}`);
   const wtPath = await createWorktree(projectRoot, wtId, {
@@ -2607,10 +3641,11 @@ var init_worktree2 = __esm({
     init_config();
     init_manifest();
     init_worktree();
-    init_env();
+    init_env2();
     init_id();
     init_errors();
     init_output();
+    init_name();
   }
 });
 
@@ -2621,10 +3656,10 @@ __export(ui_exports, {
   uiCommand: () => uiCommand
 });
 import { access } from "fs/promises";
-import path6 from "path";
-import { execa as execa7 } from "execa";
+import path8 from "path";
+import { execa as execa8 } from "execa";
 async function findDashboardBinary(projectRoot) {
-  const localBuild = path6.join(
+  const localBuild = path8.join(
     projectRoot,
     "PPG CLI",
     "build",
@@ -2648,12 +3683,12 @@ async function findDashboardBinary(projectRoot) {
   } catch {
   }
   try {
-    const result = await execa7("mdfind", [
+    const result = await execa8("mdfind", [
       'kMDItemCFBundleIdentifier == "com.2wit.PPG-CLI"'
     ]);
     const appPath = result.stdout.trim().split("\n")[0];
     if (appPath) {
-      const binaryPath = path6.join(appPath, "Contents", "MacOS", "PPG CLI");
+      const binaryPath = path8.join(appPath, "Contents", "MacOS", "PPG CLI");
       try {
         await access(binaryPath);
         return binaryPath;
@@ -2684,7 +3719,7 @@ Or build from source:
     );
   }
   const mPath = manifestPath(projectRoot);
-  const proc = execa7(binaryPath, [
+  const proc = execa8(binaryPath, [
     "--manifest-path",
     mPath,
     "--session-name",
@@ -2718,10 +3753,10 @@ import { createWriteStream } from "fs";
 import { mkdir, cp, rm } from "fs/promises";
 import { createRequire } from "module";
 import { tmpdir } from "os";
-import path7 from "path";
+import path9 from "path";
 import { pipeline } from "stream/promises";
 import { Readable } from "stream";
-import { execa as execa8 } from "execa";
+import { execa as execa9 } from "execa";
 function getVersion() {
   const pkg2 = require2("../package.json");
   return pkg2.version;
@@ -2747,9 +3782,9 @@ Check: https://github.com/${REPO}/releases/tag/${tag}`,
         "DOWNLOAD_FAILED"
       );
     }
-    const tmp = path7.join(tmpdir(), `ppg-dashboard-${Date.now()}`);
+    const tmp = path9.join(tmpdir(), `ppg-dashboard-${Date.now()}`);
     await mkdir(tmp, { recursive: true });
-    const dmgPath = path7.join(tmp, ASSET_NAME);
+    const dmgPath = path9.join(tmp, ASSET_NAME);
     const body = res.body;
     if (!body) throw new PgError("Empty response body", "DOWNLOAD_FAILED");
     await pipeline(
@@ -2757,20 +3792,20 @@ Check: https://github.com/${REPO}/releases/tag/${tag}`,
       createWriteStream(dmgPath)
     );
     if (!json) info("Mounting\u2026");
-    const mountResult = await execa8("hdiutil", ["attach", dmgPath, "-nobrowse", "-quiet"]);
+    const mountResult = await execa9("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");
     }
     try {
-      const srcApp = path7.join(mountPoint, APP_NAME);
-      const destApp = path7.join(dir, APP_NAME);
+      const srcApp = path9.join(mountPoint, APP_NAME);
+      const destApp = path9.join(dir, APP_NAME);
       if (!json) info("Installing\u2026");
       await rm(destApp, { recursive: true, force: true });
       await cp(srcApp, destApp, { recursive: true });
       try {
-        await execa8("xattr", ["-dr", "com.apple.quarantine", destApp]);
+        await execa9("xattr", ["-dr", "com.apple.quarantine", destApp]);
       } catch {
       }
       if (json) {
@@ -2779,7 +3814,7 @@ Check: https://github.com/${REPO}/releases/tag/${tag}`,
         success(`Dashboard ${tag} installed to ${destApp}`);
       }
     } finally {
-      await execa8("hdiutil", ["detach", mountPoint, "-quiet"]).catch(() => {
+      await execa9("hdiutil", ["detach", mountPoint, "-quiet"]).catch(() => {
       });
     }
     await rm(tmp, { recursive: true, force: true });
@@ -2815,7 +3850,7 @@ program.command("init").description("Initialize Point Guard in the current git r
   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("--no-open", "Do not 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 .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) => {
   const { spawnCommand: spawnCommand2 } = await Promise.resolve().then(() => (init_spawn(), spawn_exports));
   await spawnCommand2(options);
 });
@@ -2843,11 +3878,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("list").description("List available templates").argument("<type>", "What to list: templates").option("--json", "Output as JSON").action(async (type, 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) => {
+  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) => {
   const { listCommand: listCommand2 } = await Promise.resolve().then(() => (init_list(), list_exports));
   await listCommand2(type, options);
 });
-program.command("restart").description("Restart a failed/killed agent in the same worktree").argument("<agent-id>", "Agent ID to restart").option("-p, --prompt <text>", "Override the original prompt").option("-a, --agent <type>", "Override the agent type").option("--no-open", "Do not open a Terminal window").option("--json", "Output as JSON").action(async (agentId2, options) => {
+program.command("restart").description("Restart a failed/killed agent in the same worktree").argument("<agent-id>", "Agent ID to restart").option("-p, --prompt <text>", "Override the original prompt").option("-a, --agent <type>", "Override the agent type").option("--open", "Open a Terminal window for the restarted agent").option("--json", "Output as JSON").action(async (agentId2, options) => {
   const { restartCommand: restartCommand2 } = await Promise.resolve().then(() => (init_restart(), restart_exports));
   await restartCommand2(agentId2, options);
 });
@@ -2855,6 +3894,14 @@ program.command("diff").description("Show changes made in a worktree branch").ar
   const { diffCommand: diffCommand2 } = await Promise.resolve().then(() => (init_diff(), diff_exports));
   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));
+  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) => {
+  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) => {
   const { cleanCommand: cleanCommand2 } = await Promise.resolve().then(() => (init_clean(), clean_exports));
   await cleanCommand2(options);