pure-point-guard 0.1.0

package/dist/cli.js

@@ -0,0 +1,2896 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/lib/errors.ts
+var PgError, TmuxNotFoundError, NotGitRepoError, NotInitializedError, ManifestLockError, WorktreeNotFoundError, AgentNotFoundError, MergeFailedError;
+var init_errors = __esm({
+  "src/lib/errors.ts"() {
+    "use strict";
+    PgError = class extends Error {
+      constructor(message, code, exitCode = 1) {
+        super(message);
+        this.code = code;
+        this.exitCode = exitCode;
+        this.name = "PgError";
+      }
+    };
+    TmuxNotFoundError = class extends PgError {
+      constructor() {
+        super(
+          "tmux is not installed or not in PATH. Install it with: brew install tmux",
+          "TMUX_NOT_FOUND"
+        );
+        this.name = "TmuxNotFoundError";
+      }
+    };
+    NotGitRepoError = class extends PgError {
+      constructor(dir) {
+        super(
+          `Not a git repository: ${dir}`,
+          "NOT_GIT_REPO"
+        );
+        this.name = "NotGitRepoError";
+      }
+    };
+    NotInitializedError = class extends PgError {
+      constructor(dir) {
+        super(
+          `Point Guard not initialized in ${dir}. Run 'ppg init' first.`,
+          "NOT_INITIALIZED"
+        );
+        this.name = "NotInitializedError";
+      }
+    };
+    ManifestLockError = class extends PgError {
+      constructor() {
+        super(
+          "Could not acquire manifest lock. Another ppg process may be running.",
+          "MANIFEST_LOCK"
+        );
+        this.name = "ManifestLockError";
+      }
+    };
+    WorktreeNotFoundError = class extends PgError {
+      constructor(id) {
+        super(
+          `Worktree not found: ${id}`,
+          "WORKTREE_NOT_FOUND"
+        );
+        this.name = "WorktreeNotFoundError";
+      }
+    };
+    AgentNotFoundError = class extends PgError {
+      constructor(id) {
+        super(
+          `Agent not found: ${id}`,
+          "AGENT_NOT_FOUND"
+        );
+        this.name = "AgentNotFoundError";
+      }
+    };
+    MergeFailedError = class extends PgError {
+      constructor(message) {
+        super(message, "MERGE_FAILED");
+        this.name = "MergeFailedError";
+      }
+    };
+  }
+});
+
+// src/lib/output.ts
+function formatStatus(status) {
+  const color = STATUS_COLORS[status] ?? RESET;
+  return `${color}${status}${RESET}`;
+}
+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);
+  }
+}
+function outputError(error, json) {
+  if (json) {
+    const message = error instanceof Error ? error.message : String(error);
+    const code = error instanceof Error && "code" in error ? error.code : "UNKNOWN";
+    console.error(JSON.stringify({ error: message, code }));
+  } else {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`${RED}Error:${RESET} ${message}`);
+  }
+}
+function formatTable(rows, columns) {
+  if (rows.length === 0) return "No results.";
+  const widths = columns.map((col) => {
+    const headerLen = col.header.length;
+    const maxDataLen = rows.reduce((max, row) => {
+      const val = col.format ? col.format(row[col.key]) : String(row[col.key] ?? "");
+      const stripped = val.replace(/\x1b\[[0-9;]*m/g, "");
+      return Math.max(max, stripped.length);
+    }, 0);
+    return col.width ?? Math.max(headerLen, maxDataLen);
+  });
+  const header = columns.map((col, i) => `${BOLD}${col.header.padEnd(widths[i])}${RESET}`).join("  ");
+  const separator = widths.map((w) => DIM + "\u2500".repeat(w) + RESET).join("  ");
+  const body = rows.map(
+    (row) => columns.map((col, i) => {
+      const val = col.format ? col.format(row[col.key]) : String(row[col.key] ?? "");
+      const stripped = val.replace(/\x1b\[[0-9;]*m/g, "");
+      const padding = Math.max(0, widths[i] - stripped.length);
+      return val + " ".repeat(padding);
+    }).join("  ")
+  ).join("\n");
+  return `${header}
+${separator}
+${body}`;
+}
+function info(message) {
+  console.log(`${CYAN}\u25B8${RESET} ${message}`);
+}
+function success(message) {
+  console.log(`${GREEN}\u2713${RESET} ${message}`);
+}
+function warn(message) {
+  console.log(`${YELLOW}\u26A0${RESET} ${message}`);
+}
+var RESET, BOLD, DIM, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, GRAY, STATUS_COLORS;
+var init_output = __esm({
+  "src/lib/output.ts"() {
+    "use strict";
+    RESET = "\x1B[0m";
+    BOLD = "\x1B[1m";
+    DIM = "\x1B[2m";
+    RED = "\x1B[31m";
+    GREEN = "\x1B[32m";
+    YELLOW = "\x1B[33m";
+    BLUE = "\x1B[34m";
+    MAGENTA = "\x1B[35m";
+    CYAN = "\x1B[36m";
+    GRAY = "\x1B[90m";
+    STATUS_COLORS = {
+      spawning: YELLOW,
+      running: GREEN,
+      waiting: CYAN,
+      completed: BLUE,
+      failed: RED,
+      killed: MAGENTA,
+      lost: RED + BOLD,
+      active: GREEN,
+      merging: YELLOW,
+      merged: BLUE,
+      cleaned: GRAY
+    };
+  }
+});
+
+// src/lib/paths.ts
+import path from "path";
+function pgDir(projectRoot) {
+  return path.join(projectRoot, PG_DIR);
+}
+function manifestPath(projectRoot) {
+  return path.join(pgDir(projectRoot), "manifest.json");
+}
+function configPath(projectRoot) {
+  return path.join(pgDir(projectRoot), "config.yaml");
+}
+function resultsDir(projectRoot) {
+  return path.join(pgDir(projectRoot), "results");
+}
+function resultFile(projectRoot, agentId2) {
+  return path.join(resultsDir(projectRoot), `${agentId2}.md`);
+}
+function templatesDir(projectRoot) {
+  return path.join(pgDir(projectRoot), "templates");
+}
+function logsDir(projectRoot) {
+  return path.join(pgDir(projectRoot), "logs");
+}
+function promptsDir(projectRoot) {
+  return path.join(pgDir(projectRoot), "prompts");
+}
+function promptFile(projectRoot, agentId2) {
+  return path.join(promptsDir(projectRoot), `${agentId2}.md`);
+}
+function worktreeBaseDir(projectRoot) {
+  return path.join(projectRoot, ".worktrees");
+}
+function worktreePath(projectRoot, id) {
+  return path.join(worktreeBaseDir(projectRoot), id);
+}
+var PG_DIR;
+var init_paths = __esm({
+  "src/lib/paths.ts"() {
+    "use strict";
+    PG_DIR = ".pg";
+  }
+});
+
+// src/core/config.ts
+import fs from "fs/promises";
+import YAML from "yaml";
+async function loadConfig(projectRoot) {
+  const cfgPath = configPath(projectRoot);
+  try {
+    const raw = await fs.readFile(cfgPath, "utf-8");
+    const parsed = YAML.parse(raw);
+    return mergeConfig(DEFAULT_CONFIG, parsed);
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      return DEFAULT_CONFIG;
+    }
+    throw err;
+  }
+}
+function mergeConfig(defaults, overrides) {
+  return {
+    ...defaults,
+    ...overrides,
+    agents: {
+      ...defaults.agents,
+      ...overrides.agents ?? {}
+    }
+  };
+}
+async function writeDefaultConfig(projectRoot) {
+  const cfgPath = configPath(projectRoot);
+  const content = YAML.stringify(DEFAULT_CONFIG, { indent: 2 });
+  await fs.writeFile(cfgPath, content, "utf-8");
+}
+function resolveAgentConfig(config, name) {
+  const agentName = name ?? config.defaultAgent;
+  const agent = config.agents[agentName];
+  if (!agent) {
+    throw new Error(`Unknown agent type: ${agentName}. Available: ${Object.keys(config.agents).join(", ")}`);
+  }
+  return agent;
+}
+var DEFAULT_CONFIG;
+var init_config = __esm({
+  "src/core/config.ts"() {
+    "use strict";
+    init_paths();
+    DEFAULT_CONFIG = {
+      sessionName: "ppg",
+      defaultAgent: "claude",
+      agents: {
+        claude: {
+          name: "claude",
+          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:",
+            "",
+            "# Result: {{AGENT_ID}}",
+            "",
+            "## Summary",
+            "<what you accomplished>",
+            "",
+            "## Changes",
+            "<list of files changed>",
+            "",
+            "## Notes",
+            "<any important observations>"
+          ].join("\n")
+        }
+      },
+      worktreeBase: ".worktrees",
+      templateDir: ".pg/templates",
+      resultDir: ".pg/results",
+      logDir: ".pg/logs",
+      envFiles: [".env", ".env.local"],
+      symlinkNodeModules: true
+    };
+  }
+});
+
+// src/lib/cjs-compat.ts
+async function getLockfile() {
+  if (!_lockfile) {
+    const mod = await import("proper-lockfile");
+    _lockfile = mod.default ?? mod;
+  }
+  return _lockfile;
+}
+async function getWriteFileAtomic() {
+  if (!_writeFileAtomic) {
+    const mod = await import("write-file-atomic");
+    _writeFileAtomic = mod.default ?? mod;
+  }
+  return _writeFileAtomic;
+}
+var _lockfile, _writeFileAtomic;
+var init_cjs_compat = __esm({
+  "src/lib/cjs-compat.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/manifest.ts
+import fs2 from "fs/promises";
+function createEmptyManifest(projectRoot, sessionName) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: 1,
+    projectRoot,
+    sessionName,
+    worktrees: {},
+    createdAt: now,
+    updatedAt: now
+  };
+}
+async function readManifest(projectRoot) {
+  const mPath = manifestPath(projectRoot);
+  const raw = await fs2.readFile(mPath, "utf-8");
+  return JSON.parse(raw);
+}
+async function writeManifest(projectRoot, manifest) {
+  const writeFileAtomic = await getWriteFileAtomic();
+  const mPath = manifestPath(projectRoot);
+  manifest.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFileAtomic(mPath, JSON.stringify(manifest, null, 2) + "\n");
+}
+async function updateManifest(projectRoot, updater) {
+  const lockfile = await getLockfile();
+  const mPath = manifestPath(projectRoot);
+  let release;
+  try {
+    release = await lockfile.lock(mPath, {
+      stale: 1e4,
+      retries: {
+        retries: 5,
+        minTimeout: 100,
+        maxTimeout: 1e3
+      }
+    });
+  } catch {
+    throw new ManifestLockError();
+  }
+  try {
+    const manifest = await readManifest(projectRoot);
+    const updated = await updater(manifest);
+    await writeManifest(projectRoot, updated);
+    return updated;
+  } finally {
+    if (release) {
+      await release();
+    }
+  }
+}
+function getWorktree(manifest, id) {
+  return manifest.worktrees[id];
+}
+function findWorktreeByName(manifest, name) {
+  return Object.values(manifest.worktrees).find(
+    (wt) => wt.name === name || wt.branch === name
+  );
+}
+function resolveWorktree(manifest, ref) {
+  return getWorktree(manifest, ref) ?? findWorktreeByName(manifest, ref);
+}
+function findAgent(manifest, agentId2) {
+  for (const wt of Object.values(manifest.worktrees)) {
+    const agent = wt.agents[agentId2];
+    if (agent) {
+      return { worktree: wt, agent };
+    }
+  }
+  return void 0;
+}
+var init_manifest = __esm({
+  "src/core/manifest.ts"() {
+    "use strict";
+    init_paths();
+    init_cjs_compat();
+    init_errors();
+  }
+});
+
+// src/commands/init.ts
+var init_exports = {};
+__export(init_exports, {
+  initCommand: () => initCommand
+});
+import fs3 from "fs/promises";
+import path2 from "path";
+import { execa } from "execa";
+async function initCommand(options) {
+  const cwd = process.cwd();
+  let projectRoot;
+  try {
+    const result = await execa("git", ["rev-parse", "--show-toplevel"], { cwd });
+    projectRoot = result.stdout.trim();
+  } catch {
+    throw new NotGitRepoError(cwd);
+  }
+  try {
+    await execa("tmux", ["-V"]);
+  } catch {
+    throw new TmuxNotFoundError();
+  }
+  const dirs = [
+    pgDir(projectRoot),
+    resultsDir(projectRoot),
+    logsDir(projectRoot),
+    templatesDir(projectRoot),
+    promptsDir(projectRoot)
+  ];
+  for (const dir of dirs) {
+    await fs3.mkdir(dir, { recursive: true });
+  }
+  info("Created .pg/ directory structure");
+  await writeDefaultConfig(projectRoot);
+  info("Wrote default config.yaml");
+  const dirName = path2.basename(projectRoot);
+  const sessionName = `ppg-${dirName}`;
+  const manifest = createEmptyManifest(projectRoot, sessionName);
+  await writeManifest(projectRoot, manifest);
+  info("Wrote empty manifest.json");
+  await updateGitignore(projectRoot);
+  info("Updated .gitignore");
+  const templatePath = path2.join(templatesDir(projectRoot), "default.md");
+  try {
+    await fs3.access(templatePath);
+  } catch {
+    await fs3.writeFile(templatePath, DEFAULT_TEMPLATE, "utf-8");
+    info("Wrote sample template: default.md");
+  }
+  const conductorPath = path2.join(pgDir(projectRoot), "conductor-context.md");
+  await fs3.writeFile(conductorPath, CONDUCTOR_CONTEXT, "utf-8");
+  info("Wrote conductor-context.md");
+  const pluginRegistered = await registerClaudePlugin();
+  if (pluginRegistered) {
+    info("Registered ppg Claude Code plugin");
+  }
+  if (options.json) {
+    console.log(JSON.stringify({
+      success: true,
+      projectRoot,
+      sessionName,
+      pgDir: pgDir(projectRoot),
+      pluginRegistered
+    }));
+  } else {
+    success(`Point Guard initialized in ${projectRoot}`);
+  }
+}
+async function registerClaudePlugin() {
+  try {
+    const home = process.env.HOME;
+    if (!home) return false;
+    const skillsDir = path2.join(home, ".claude", "skills");
+    const pkgRoot = new URL("../../", import.meta.url);
+    const srcSkillsDir = new URL("skills/", pkgRoot).pathname;
+    try {
+      await fs3.access(srcSkillsDir);
+    } catch {
+      return false;
+    }
+    const skillFolders = ["ppg", "ppg-conductor"];
+    let copied = false;
+    for (const folder of skillFolders) {
+      const srcDir = path2.join(srcSkillsDir, folder);
+      const destDir = path2.join(skillsDir, folder);
+      try {
+        await fs3.access(srcDir);
+      } catch {
+        continue;
+      }
+      await fs3.cp(srcDir, destDir, { recursive: true, force: true });
+      copied = true;
+    }
+    return copied;
+  } catch {
+    return false;
+  }
+}
+async function updateGitignore(projectRoot) {
+  const gitignorePath = path2.join(projectRoot, ".gitignore");
+  const entriesToAdd = [
+    ".pg/results/",
+    ".pg/logs/",
+    ".pg/manifest.json",
+    ".pg/prompts/",
+    ".pg/conductor-context.md"
+  ];
+  let content = "";
+  try {
+    content = await fs3.readFile(gitignorePath, "utf-8");
+  } catch {
+  }
+  const lines = content.split("\n");
+  const toAdd = entriesToAdd.filter((entry) => !lines.includes(entry));
+  if (toAdd.length > 0) {
+    const addition = (content.endsWith("\n") || content === "" ? "" : "\n") + "\n# Point Guard\n" + toAdd.join("\n") + "\n";
+    await fs3.appendFile(gitignorePath, addition, "utf-8");
+  }
+}
+var CONDUCTOR_CONTEXT, DEFAULT_TEMPLATE;
+var init_init = __esm({
+  "src/commands/init.ts"() {
+    "use strict";
+    init_paths();
+    init_errors();
+    init_output();
+    init_config();
+    init_manifest();
+    CONDUCTOR_CONTEXT = `# PPG Conductor Context
+
+You are operating on the master branch of a ppg-managed project.
+
+## Critical Rule
+**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 status --json\` \u2014 Check statuses
+- \`ppg aggregate --all --json\` \u2014 Collect results
+- \`ppg merge <wt-id> --json\` \u2014 Merge completed work
+- \`ppg kill --agent <id> --json\` \u2014 Kill agent
+
+## 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
+
+Each agent prompt must be self-contained \u2014 agents have no memory of this conversation.
+Always use \`--json --no-open\`.
+`;
+    DEFAULT_TEMPLATE = `# Task: {{TASK_NAME}}
+
+## Context
+You are working in a git worktree at: {{WORKTREE_PATH}}
+Branch: {{BRANCH}}
+Project root: {{PROJECT_ROOT}}
+
+## Instructions
+{{PROMPT}}
+
+## Result Reporting
+When you have completed the task, write your results to:
+{{RESULT_FILE}}
+`;
+  }
+});
+
+// src/core/worktree.ts
+import { execa as execa2 } from "execa";
+async function getRepoRoot(cwd) {
+  try {
+    const result = await execa2("git", ["rev-parse", "--show-toplevel"], {
+      cwd: cwd ?? process.cwd()
+    });
+    return result.stdout.trim();
+  } catch {
+    throw new NotGitRepoError(cwd ?? process.cwd());
+  }
+}
+async function getCurrentBranch(cwd) {
+  const result = await execa2("git", ["branch", "--show-current"], {
+    cwd: cwd ?? process.cwd()
+  });
+  return result.stdout.trim();
+}
+async function createWorktree(repoRoot, id, options) {
+  const wtPath = worktreePath(repoRoot, id);
+  const args = ["worktree", "add", wtPath, "-b", options.branch];
+  if (options.base) {
+    args.push(options.base);
+  }
+  await execa2("git", args, { cwd: repoRoot });
+  return wtPath;
+}
+async function removeWorktree(repoRoot, wtPath, options) {
+  const args = ["worktree", "remove", wtPath];
+  if (options?.force) {
+    args.push("--force");
+  }
+  await execa2("git", args, { cwd: repoRoot });
+  if (options?.deleteBranch && options.branchName) {
+    try {
+      await execa2("git", ["branch", "-D", options.branchName], { cwd: repoRoot });
+    } catch {
+    }
+  }
+}
+async function pruneWorktrees(repoRoot) {
+  await execa2("git", ["worktree", "prune"], { cwd: repoRoot });
+}
+var init_worktree = __esm({
+  "src/core/worktree.ts"() {
+    "use strict";
+    init_paths();
+    init_errors();
+  }
+});
+
+// src/core/env.ts
+import fs4 from "fs/promises";
+import path3 from "path";
+async function setupWorktreeEnv(projectRoot, wtPath, config) {
+  for (const envFile of config.envFiles) {
+    const src = path3.join(projectRoot, envFile);
+    const dest = path3.join(wtPath, envFile);
+    try {
+      await fs4.access(src);
+      await fs4.copyFile(src, dest);
+    } catch {
+    }
+  }
+  if (config.symlinkNodeModules) {
+    const src = path3.join(projectRoot, "node_modules");
+    const dest = path3.join(wtPath, "node_modules");
+    try {
+      await fs4.access(src);
+      try {
+        await fs4.lstat(dest);
+      } catch {
+        await fs4.symlink(src, dest, "dir");
+      }
+    } catch {
+    }
+  }
+}
+async function teardownWorktreeEnv(wtPath) {
+  const nmPath = path3.join(wtPath, "node_modules");
+  try {
+    const stat = await fs4.lstat(nmPath);
+    if (stat.isSymbolicLink()) {
+      await fs4.unlink(nmPath);
+    }
+  } catch {
+  }
+}
+var init_env = __esm({
+  "src/core/env.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/template.ts
+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);
+      }
+    }
+  } catch {
+  }
+  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 sendCtrlC(target) {
+  await execa3("tmux", ["send-keys", "-t", target, "C-c"]);
+}
+var init_tmux = __esm({
+  "src/core/tmux.ts"() {
+    "use strict";
+    init_errors();
+  }
+});
+
+// src/core/agent.ts
+import fs6 from "fs/promises";
+async function spawnAgent(options) {
+  const {
+    agentId: agentId2,
+    agentConfig,
+    prompt,
+    worktreePath: worktreePath2,
+    tmuxTarget,
+    projectRoot,
+    branch
+  } = options;
+  const resFile = resultFile(projectRoot, agentId2);
+  let fullPrompt = prompt;
+  if (agentConfig.resultInstructions) {
+    const ctx = {
+      WORKTREE_PATH: worktreePath2,
+      BRANCH: branch,
+      AGENT_ID: agentId2,
+      RESULT_FILE: resFile,
+      PROJECT_ROOT: projectRoot
+    };
+    const instructions = renderTemplate(agentConfig.resultInstructions, ctx);
+    fullPrompt += `
+
+---
+
+${instructions}`;
+  }
+  const pFile = promptFile(projectRoot, agentId2);
+  await fs6.writeFile(pFile, fullPrompt, "utf-8");
+  const command = buildAgentCommand(agentConfig, pFile, options.sessionId);
+  await sendKeys(tmuxTarget, command);
+  return {
+    id: agentId2,
+    name: agentConfig.name,
+    agentType: agentConfig.name,
+    status: "running",
+    tmuxTarget,
+    prompt: prompt.slice(0, 500),
+    // Truncate for manifest storage
+    resultFile: resFile,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    ...options.sessionId ? { sessionId: options.sessionId } : {}
+  };
+}
+function buildAgentCommand(agentConfig, promptFilePath, sessionId2) {
+  const envPrefix = "unset CLAUDECODE;";
+  const { command, promptFlag } = agentConfig;
+  const sessionFlag = sessionId2 && command.includes("claude") ? ` --session-id ${sessionId2}` : "";
+  if (promptFlag) {
+    return `${envPrefix} ${command}${sessionFlag} ${promptFlag} "$(cat ${promptFilePath})"`;
+  }
+  return `${envPrefix} ${command}${sessionFlag} "$(cat ${promptFilePath})"`;
+}
+async function checkAgentStatus(agent, projectRoot, paneMap) {
+  if (["completed", "failed", "killed", "lost"].includes(agent.status)) {
+    return { status: agent.status, exitCode: agent.exitCode };
+  }
+  const hasResult = await fileExists(agent.resultFile);
+  if (hasResult) {
+    return { status: "completed" };
+  }
+  const paneInfo = paneMap ? paneMap.get(agent.tmuxTarget) ?? null : await getPaneInfo(agent.tmuxTarget);
+  if (!paneInfo) {
+    return { status: "lost" };
+  }
+  if (paneInfo.isDead) {
+    const exitCode = paneInfo.deadStatus;
+    const hasResultNow = await fileExists(agent.resultFile);
+    if (hasResultNow || exitCode === 0) {
+      return { status: "completed", exitCode: exitCode ?? 0 };
+    }
+    return { status: "failed", exitCode };
+  }
+  if (SHELL_COMMANDS.has(paneInfo.currentCommand)) {
+    const hasResultNow = await fileExists(agent.resultFile);
+    if (hasResultNow) {
+      return { status: "completed", exitCode: 0 };
+    }
+    return { status: "failed", exitCode: void 0 };
+  }
+  return { status: "running" };
+}
+async function refreshAllAgentStatuses(manifest, projectRoot) {
+  const paneMap = await listSessionPanes(manifest.sessionName);
+  const checks = [];
+  for (const wt of Object.values(manifest.worktrees)) {
+    for (const agent of Object.values(wt.agents)) {
+      checks.push({
+        agent,
+        promise: checkAgentStatus(agent, projectRoot, paneMap)
+      });
+    }
+  }
+  const results = await Promise.all(checks.map((c) => c.promise));
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  for (let i = 0; i < checks.length; i++) {
+    const { agent } = checks[i];
+    const { status, exitCode } = results[i];
+    if (status !== agent.status) {
+      agent.status = status;
+      if (exitCode !== void 0) agent.exitCode = exitCode;
+      if (["completed", "failed", "lost"].includes(status) && !agent.completedAt) {
+        agent.completedAt = now;
+      }
+    }
+  }
+  const wtChecks = Object.values(manifest.worktrees).filter((wt) => wt.status === "active").map(async (wt) => {
+    const exists = await fileExists(wt.path);
+    if (!exists) {
+      wt.status = "cleaned";
+      for (const agent of Object.values(wt.agents)) {
+        if (!["completed", "failed", "killed"].includes(agent.status)) {
+          agent.status = "lost";
+          if (!agent.completedAt) agent.completedAt = now;
+        }
+      }
+    }
+  });
+  await Promise.all(wtChecks);
+  return manifest;
+}
+async function resumeAgent(options) {
+  const { agent, worktreeId: worktreeId2, sessionName, cwd, windowName, projectRoot } = options;
+  if (!agent.sessionId) {
+    throw new PgError(
+      `Agent ${agent.id} has no session ID. Cannot resume agents spawned before session tracking was added.`,
+      "NO_SESSION_ID"
+    );
+  }
+  await ensureSession(sessionName);
+  const newTarget = await createWindow(sessionName, windowName, cwd);
+  await sendKeys(newTarget, `unset CLAUDECODE; claude --resume ${agent.sessionId}`);
+  await updateManifest(projectRoot, (m) => {
+    const mAgent = m.worktrees[worktreeId2]?.agents[agent.id];
+    if (mAgent) {
+      mAgent.tmuxTarget = newTarget;
+      mAgent.status = "running";
+    }
+    return m;
+  });
+  return newTarget;
+}
+async function killAgent(agent) {
+  await sendCtrlC(agent.tmuxTarget);
+  await new Promise((resolve) => setTimeout(resolve, 500));
+  const paneInfo = await getPaneInfo(agent.tmuxTarget);
+  if (paneInfo && !paneInfo.isDead) {
+    await killPane(agent.tmuxTarget);
+  }
+}
+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));
+  await Promise.all(agents.map(async (a) => {
+    const paneInfo = await getPaneInfo(a.tmuxTarget);
+    if (paneInfo && !paneInfo.isDead) {
+      await killPane(a.tmuxTarget);
+    }
+  }));
+}
+async function fileExists(filePath) {
+  try {
+    await fs6.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var SHELL_COMMANDS;
+var init_agent = __esm({
+  "src/core/agent.ts"() {
+    "use strict";
+    init_paths();
+    init_tmux();
+    init_manifest();
+    init_errors();
+    init_template();
+    init_tmux();
+    SHELL_COMMANDS = /* @__PURE__ */ new Set(["bash", "zsh", "sh", "fish", "dash", "tcsh", "csh"]);
+  }
+});
+
+// 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 script = `
+tell application "Terminal"
+  activate
+  set newTab to do script "${tmuxCmd}"
+  set custom title of newTab to "${title}"
+end tell
+`;
+  try {
+    await execa4("osascript", ["-e", script]);
+  } catch (err) {
+    warn(`Could not open Terminal window for "${title}": ${err instanceof Error ? err.message : err}`);
+  }
+}
+var init_terminal = __esm({
+  "src/core/terminal.ts"() {
+    "use strict";
+    init_output();
+  }
+});
+
+// src/lib/id.ts
+import { randomUUID } from "crypto";
+import { customAlphabet } from "nanoid";
+function worktreeId() {
+  return `wt-${shortId()}`;
+}
+function agentId() {
+  return `ag-${longId()}`;
+}
+function sessionId() {
+  return randomUUID();
+}
+var alphabet, shortId, longId;
+var init_id = __esm({
+  "src/lib/id.ts"() {
+    "use strict";
+    alphabet = "abcdefghijklmnopqrstuvwxyz0123456789";
+    shortId = customAlphabet(alphabet, 6);
+    longId = customAlphabet(alphabet, 8);
+  }
+});
+
+// src/commands/spawn.ts
+var spawn_exports = {};
+__export(spawn_exports, {
+  spawnCommand: () => spawnCommand
+});
+import fs7 from "fs/promises";
+async function spawnCommand(options) {
+  const projectRoot = await getRepoRoot();
+  const config = await loadConfig(projectRoot);
+  try {
+    await fs7.access(manifestPath(projectRoot));
+  } catch {
+    throw new NotInitializedError(projectRoot);
+  }
+  const agentConfig = resolveAgentConfig(config, options.agent);
+  const count = options.count ?? 1;
+  const promptText = await resolvePrompt(options, projectRoot);
+  if (options.worktree) {
+    await spawnIntoExistingWorktree(
+      projectRoot,
+      config,
+      agentConfig,
+      options.worktree,
+      promptText,
+      count,
+      options
+    );
+  } else {
+    await spawnNewWorktree(
+      projectRoot,
+      config,
+      agentConfig,
+      promptText,
+      count,
+      options
+    );
+  }
+}
+async function resolvePrompt(options, projectRoot) {
+  if (options.prompt) return options.prompt;
+  if (options.promptFile) {
+    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;
+  }
+  throw new PgError("One of --prompt, --prompt-file, or --template is required", "INVALID_ARGS");
+}
+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 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);
+  const agents = [];
+  for (let i = 0; i < count; i++) {
+    const aId = agentId();
+    let target;
+    if (i === 0) {
+      target = windowTarget;
+    } else if (options.split) {
+      const direction = i % 2 === 1 ? "horizontal" : "vertical";
+      const pane = await splitPane(windowTarget, direction, wtPath);
+      target = pane.target;
+    } else {
+      target = await createWindow(sessionName, `${name}-${i}`, wtPath);
+    }
+    const ctx = {
+      WORKTREE_PATH: wtPath,
+      BRANCH: branchName,
+      AGENT_ID: aId,
+      RESULT_FILE: resultFile(projectRoot, aId),
+      PROJECT_ROOT: projectRoot,
+      TASK_NAME: name,
+      PROMPT: promptText
+    };
+    for (const v of options.var ?? []) {
+      const [key, ...rest] = v.split("=");
+      ctx[key] = rest.join("=");
+    }
+    const renderedPrompt = renderTemplate(promptText, ctx);
+    const agentEntry = await spawnAgent({
+      agentId: aId,
+      agentConfig,
+      prompt: renderedPrompt,
+      worktreePath: wtPath,
+      tmuxTarget: target,
+      projectRoot,
+      branch: branchName,
+      sessionId: sessionId()
+    });
+    agents.push(agentEntry);
+  }
+  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 !== false) {
+    openTerminalWindow(sessionName, windowTarget, name).catch(() => {
+    });
+  }
+  if (options.json) {
+    output({
+      success: true,
+      worktree: {
+        id: wtId,
+        name,
+        branch: branchName,
+        path: wtPath,
+        tmuxWindow: windowTarget
+      },
+      agents: agents.map((a) => ({
+        id: a.id,
+        tmuxTarget: a.tmuxTarget,
+        sessionId: a.sessionId
+      }))
+    }, true);
+  } else {
+    success(`Spawned worktree ${wtId} with ${agents.length} agent(s)`);
+    for (const a of agents) {
+      info(`  Agent ${a.id} \u2192 ${a.tmuxTarget}`);
+    }
+    info(`Attach: ppg attach ${wtId}`);
+  }
+}
+async function spawnIntoExistingWorktree(projectRoot, config, agentConfig, worktreeRef, promptText, count, options) {
+  const manifest = await readManifest(projectRoot);
+  const wt = resolveWorktree(manifest, worktreeRef);
+  if (!wt) throw new WorktreeNotFoundError(worktreeRef);
+  let windowTarget = wt.tmuxWindow;
+  if (!windowTarget) {
+    await ensureSession(manifest.sessionName);
+    windowTarget = await createWindow(manifest.sessionName, wt.name, wt.path);
+  }
+  const agents = [];
+  for (let i = 0; i < count; i++) {
+    const aId = agentId();
+    let target;
+    if (i === 0 && options.split) {
+      target = windowTarget;
+    } else if (options.split) {
+      const direction = i % 2 === 1 ? "horizontal" : "vertical";
+      const pane = await splitPane(windowTarget, direction, wt.path);
+      target = pane.target;
+    } else {
+      target = await createWindow(manifest.sessionName, `${wt.name}-agent-${i}`, wt.path);
+    }
+    const ctx = {
+      WORKTREE_PATH: wt.path,
+      BRANCH: wt.branch,
+      AGENT_ID: aId,
+      RESULT_FILE: resultFile(projectRoot, aId),
+      PROJECT_ROOT: projectRoot,
+      TASK_NAME: wt.name,
+      PROMPT: promptText
+    };
+    for (const v of options.var ?? []) {
+      const [key, ...rest] = v.split("=");
+      ctx[key] = rest.join("=");
+    }
+    const renderedPrompt = renderTemplate(promptText, ctx);
+    const agentEntry = await spawnAgent({
+      agentId: aId,
+      agentConfig,
+      prompt: renderedPrompt,
+      worktreePath: wt.path,
+      tmuxTarget: target,
+      projectRoot,
+      branch: wt.branch,
+      sessionId: sessionId()
+    });
+    agents.push(agentEntry);
+  }
+  await updateManifest(projectRoot, (m) => {
+    const mWt = m.worktrees[wt.id];
+    if (!mWt.tmuxWindow) {
+      mWt.tmuxWindow = windowTarget;
+    }
+    for (const a of agents) {
+      mWt.agents[a.id] = a;
+    }
+    return m;
+  });
+  if (options.open !== false) {
+    openTerminalWindow(manifest.sessionName, windowTarget, wt.name).catch(() => {
+    });
+  }
+  if (options.json) {
+    output({
+      success: true,
+      worktree: {
+        id: wt.id,
+        name: wt.name,
+        branch: wt.branch,
+        path: wt.path,
+        tmuxWindow: windowTarget
+      },
+      agents: agents.map((a) => ({ id: a.id, tmuxTarget: a.tmuxTarget, sessionId: a.sessionId }))
+    }, true);
+  } else {
+    success(`Added ${agents.length} agent(s) to worktree ${wt.id}`);
+    for (const a of agents) {
+      info(`  Agent ${a.id} \u2192 ${a.tmuxTarget}`);
+    }
+  }
+}
+var init_spawn = __esm({
+  "src/commands/spawn.ts"() {
+    "use strict";
+    init_config();
+    init_manifest();
+    init_worktree();
+    init_env();
+    init_template();
+    init_agent();
+    init_tmux();
+    init_terminal();
+    init_id();
+    init_paths();
+    init_errors();
+    init_output();
+  }
+});
+
+// src/commands/status.ts
+var status_exports = {};
+__export(status_exports, {
+  statusCommand: () => statusCommand
+});
+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);
+  }
+  const filter = worktreeFilter ?? options?.worktree;
+  let worktrees = Object.values(manifest.worktrees);
+  if (filter) {
+    worktrees = worktrees.filter(
+      (wt) => wt.id === filter || wt.name === filter || wt.branch === filter
+    );
+  }
+  if (options?.json) {
+    output({
+      session: manifest.sessionName,
+      worktrees: Object.fromEntries(worktrees.map((wt) => [wt.id, wt]))
+    }, true);
+    return;
+  }
+  if (worktrees.length === 0) {
+    console.log("No active worktrees. Use `ppg spawn` to create one.");
+    return;
+  }
+  for (const wt of worktrees) {
+    printWorktreeStatus(wt);
+  }
+  if (options?.watch) {
+    const interval = setInterval(async () => {
+      console.clear();
+      try {
+        const m = await updateManifest(projectRoot, async (m2) => {
+          return refreshAllAgentStatuses(m2, projectRoot);
+        });
+        let wts = Object.values(m.worktrees);
+        if (filter) {
+          wts = wts.filter(
+            (wt) => wt.id === filter || wt.name === filter || wt.branch === filter
+          );
+        }
+        for (const wt of wts) {
+          printWorktreeStatus(wt);
+        }
+      } catch (err) {
+        console.error("Error refreshing status:", err);
+      }
+    }, 2e3);
+    process.on("SIGINT", () => {
+      clearInterval(interval);
+      process.exit(0);
+    });
+  }
+}
+function printWorktreeStatus(wt) {
+  const agents = Object.values(wt.agents);
+  const statusCounts = {
+    running: agents.filter((a) => a.status === "running").length,
+    completed: agents.filter((a) => a.status === "completed").length,
+    failed: agents.filter((a) => a.status === "failed").length,
+    lost: agents.filter((a) => a.status === "lost").length
+  };
+  console.log(
+    `
+${wt.name} (${wt.id}) [${formatStatus(wt.status)}] branch:${wt.branch}`
+  );
+  if (agents.length === 0) {
+    console.log("  No agents");
+    return;
+  }
+  const columns = [
+    { header: "Agent", key: "id", width: 14 },
+    { header: "Type", key: "agentType", width: 10 },
+    {
+      header: "Status",
+      key: "status",
+      width: 12,
+      format: (v) => formatStatus(v)
+    },
+    { header: "Started", key: "startedAt", width: 20, format: (v) => formatTime(v) },
+    { header: "Pane", key: "tmuxTarget", width: 20 }
+  ];
+  const table = formatTable(agents, columns);
+  console.log(table.split("\n").map((l) => `  ${l}`).join("\n"));
+}
+function formatTime(iso) {
+  if (!iso) return "\u2014";
+  const d = new Date(iso);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - d.getTime();
+  const diffMin = Math.floor(diffMs / 6e4);
+  if (diffMin < 1) return "just now";
+  if (diffMin < 60) return `${diffMin}m ago`;
+  const diffHr = Math.floor(diffMin / 60);
+  return `${diffHr}h ${diffMin % 60}m ago`;
+}
+var init_status = __esm({
+  "src/commands/status.ts"() {
+    "use strict";
+    init_manifest();
+    init_agent();
+    init_worktree();
+    init_errors();
+    init_output();
+  }
+});
+
+// src/core/cleanup.ts
+async function cleanupWorktree(projectRoot, wt) {
+  const windowKills = [];
+  for (const agent of Object.values(wt.agents)) {
+    if (agent.tmuxTarget) {
+      windowKills.push(killWindow(agent.tmuxTarget).catch(() => {
+      }));
+    }
+  }
+  if (wt.tmuxWindow) {
+    windowKills.push(killWindow(wt.tmuxWindow).catch(() => {
+    }));
+  }
+  await Promise.all(windowKills);
+  try {
+    await teardownWorktreeEnv(wt.path);
+  } catch {
+  }
+  try {
+    await removeWorktree(projectRoot, wt.path, {
+      force: true,
+      deleteBranch: true,
+      branchName: wt.branch
+    });
+  } 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;
+  });
+}
+var init_cleanup = __esm({
+  "src/core/cleanup.ts"() {
+    "use strict";
+    init_manifest();
+    init_worktree();
+    init_env();
+    init_tmux();
+    init_output();
+  }
+});
+
+// src/commands/kill.ts
+var kill_exports = {};
+__export(kill_exports, {
+  killCommand: () => killCommand
+});
+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");
+  }
+  if (options.agent) {
+    await killSingleAgent(projectRoot, options.agent, options);
+  } else if (options.worktree) {
+    await killWorktreeAgents(projectRoot, options.worktree, options);
+  } else if (options.all) {
+    await killAllAgents(projectRoot, options);
+  }
+}
+async function killSingleAgent(projectRoot, agentId2, options) {
+  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 (options.delete) {
+    if (!isTerminal) {
+      info(`Killing agent ${agentId2}`);
+      await killAgent(agent);
+    }
+    await Promise.resolve().then(() => (init_tmux(), tmux_exports)).then((tmux) => tmux.killPane(agent.tmuxTarget));
+    await updateManifest(projectRoot, (m) => {
+      const f = findAgent(m, agentId2);
+      if (f) {
+        delete f.worktree.agents[agentId2];
+      }
+      return m;
+    });
+    if (options.json) {
+      output({ success: true, killed: [agentId2], deleted: [agentId2] }, true);
+    } else {
+      success(`Deleted agent ${agentId2}`);
+    }
+  } else {
+    info(`Killing agent ${agentId2}`);
+    await killAgent(agent);
+    await updateManifest(projectRoot, (m) => {
+      const f = findAgent(m, agentId2);
+      if (f) {
+        f.agent.status = "killed";
+        f.agent.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      return m;
+    });
+    if (options.json) {
+      output({ success: true, killed: [agentId2] }, true);
+    } else {
+      success(`Killed agent ${agentId2}`);
+    }
+  }
+}
+async function killWorktreeAgents(projectRoot, worktreeRef, options) {
+  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));
+  const killedIds = toKill.map((a) => a.id);
+  for (const a of toKill) info(`Killing agent ${a.id}`);
+  await killAgents(toKill);
+  await updateManifest(projectRoot, (m) => {
+    const mWt = m.worktrees[wt.id];
+    if (mWt) {
+      for (const agent of Object.values(mWt.agents)) {
+        if (killedIds.includes(agent.id)) {
+          agent.status = "killed";
+          agent.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        }
+      }
+    }
+    return m;
+  });
+  const shouldRemove = options.remove || options.delete;
+  if (shouldRemove) {
+    await removeWorktreeCleanup(projectRoot, wt.id);
+  }
+  if (options.delete) {
+    await updateManifest(projectRoot, (m) => {
+      delete m.worktrees[wt.id];
+      return m;
+    });
+  }
+  if (options.json) {
+    output({
+      success: true,
+      killed: killedIds,
+      removed: shouldRemove ? [wt.id] : [],
+      deleted: options.delete ? [wt.id] : []
+    }, true);
+  } else {
+    success(`Killed ${killedIds.length} agent(s) in worktree ${wt.id}`);
+    if (options.delete) {
+      success(`Deleted worktree ${wt.id}`);
+    } else if (options.remove) {
+      success(`Removed worktree ${wt.id}`);
+    }
+  }
+}
+async function killAllAgents(projectRoot, options) {
+  const manifest = await readManifest(projectRoot);
+  const toKill = [];
+  for (const wt of Object.values(manifest.worktrees)) {
+    for (const agent of Object.values(wt.agents)) {
+      if (["running", "spawning", "waiting"].includes(agent.status)) {
+        toKill.push(agent);
+      }
+    }
+  }
+  const killedIds = toKill.map((a) => a.id);
+  for (const a of toKill) info(`Killing agent ${a.id}`);
+  await killAgents(toKill);
+  const activeWorktreeIds = Object.values(manifest.worktrees).filter((wt) => wt.status === "active").map((wt) => wt.id);
+  await updateManifest(projectRoot, (m) => {
+    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 = (/* @__PURE__ */ new Date()).toISOString();
+        }
+      }
+    }
+    return m;
+  });
+  const shouldRemove = options.remove || options.delete;
+  if (shouldRemove) {
+    for (const wtId of activeWorktreeIds) {
+      await removeWorktreeCleanup(projectRoot, wtId);
+    }
+  }
+  if (options.delete) {
+    await updateManifest(projectRoot, (m) => {
+      for (const wtId of activeWorktreeIds) {
+        delete m.worktrees[wtId];
+      }
+      return m;
+    });
+  }
+  if (options.json) {
+    output({
+      success: true,
+      killed: killedIds,
+      removed: shouldRemove ? activeWorktreeIds : [],
+      deleted: options.delete ? activeWorktreeIds : []
+    }, true);
+  } else {
+    success(`Killed ${killedIds.length} agent(s) across ${activeWorktreeIds.length} worktree(s)`);
+    if (options.delete) {
+      success(`Deleted ${activeWorktreeIds.length} worktree(s)`);
+    } else if (options.remove) {
+      success(`Removed ${activeWorktreeIds.length} worktree(s)`);
+    }
+  }
+}
+async function removeWorktreeCleanup(projectRoot, wtId) {
+  const manifest = await readManifest(projectRoot);
+  const wt = resolveWorktree(manifest, wtId);
+  if (!wt) return;
+  await cleanupWorktree(projectRoot, wt);
+}
+var init_kill = __esm({
+  "src/commands/kill.ts"() {
+    "use strict";
+    init_manifest();
+    init_agent();
+    init_worktree();
+    init_cleanup();
+    init_errors();
+    init_output();
+  }
+});
+
+// src/commands/attach.ts
+var attach_exports = {};
+__export(attach_exports, {
+  attachCommand: () => attachCommand
+});
+async function attachCommand(target) {
+  const projectRoot = await getRepoRoot();
+  let manifest;
+  try {
+    manifest = await readManifest(projectRoot);
+  } catch {
+    throw new NotInitializedError(projectRoot);
+  }
+  let tmuxTarget;
+  const sessionName = manifest.sessionName;
+  let agent;
+  let worktreeId2;
+  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");
+    }
+    tmuxTarget = wt.tmuxWindow;
+  } else {
+    const found = findAgent(manifest, target);
+    if (found) {
+      agent = found.agent;
+      worktreeId2 = found.worktree.id;
+      tmuxTarget = found.agent.tmuxTarget;
+    }
+  }
+  if (!tmuxTarget) {
+    throw new PgError(`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);
+    if (!paneInfo || paneInfo.isDead) {
+      info(`Pane is dead. Resuming session ${agent.sessionId}...`);
+      const resumeWt = manifest.worktrees[worktreeId2];
+      const cwd = resumeWt?.path ?? projectRoot;
+      const windowName = resumeWt?.name ?? agent.name ?? target;
+      tmuxTarget = await resumeAgent({
+        agent,
+        worktreeId: worktreeId2,
+        sessionName,
+        cwd,
+        windowName,
+        projectRoot
+      });
+      success(`Resumed agent ${agent.id} in ${tmuxTarget}`);
+    }
+  }
+  const insideTmux = await isInsideTmux();
+  if (insideTmux) {
+    await selectWindow(tmuxTarget);
+    info(`Switched to ${tmuxTarget}`);
+  } else {
+    const title = wt ? wt.name : target;
+    info(`Opening Terminal window for ${title}`);
+    await openTerminalWindow(sessionName, tmuxTarget, title);
+  }
+}
+var init_attach = __esm({
+  "src/commands/attach.ts"() {
+    "use strict";
+    init_manifest();
+    init_worktree();
+    init_tmux();
+    init_agent();
+    init_tmux();
+    init_terminal();
+    init_errors();
+    init_output();
+  }
+});
+
+// src/commands/logs.ts
+var logs_exports = {};
+__export(logs_exports, {
+  logsCommand: () => logsCommand
+});
+async function logsCommand(agentId2, options) {
+  const projectRoot = await getRepoRoot();
+  let manifest;
+  try {
+    manifest = await readManifest(projectRoot);
+  } catch {
+    throw new NotInitializedError(projectRoot);
+  }
+  const found = findAgent(manifest, agentId2);
+  if (!found) throw new AgentNotFoundError(agentId2);
+  const { agent } = found;
+  const lines = options.full ? void 0 : options.lines ?? 100;
+  if (options.follow) {
+    let lastOutput = "";
+    const interval = setInterval(async () => {
+      try {
+        const content = await capturePane(agent.tmuxTarget, lines);
+        if (content !== lastOutput) {
+          if (lastOutput) {
+            const oldLines = lastOutput.split("\n");
+            const newLines = content.split("\n");
+            const diff = newLines.slice(oldLines.length);
+            if (diff.length > 0) {
+              process.stdout.write(diff.join("\n") + "\n");
+            }
+          } else {
+            process.stdout.write(content + "\n");
+          }
+          lastOutput = content;
+        }
+      } catch {
+        clearInterval(interval);
+        outputError(new Error("Pane no longer available"), options.json ?? false);
+        process.exit(1);
+      }
+    }, 1e3);
+    process.on("SIGINT", () => {
+      clearInterval(interval);
+      process.exit(0);
+    });
+  } else {
+    try {
+      const content = await capturePane(agent.tmuxTarget, lines);
+      if (options.json) {
+        output({
+          agentId: agent.id,
+          status: agent.status,
+          tmuxTarget: agent.tmuxTarget,
+          output: content
+        }, true);
+      } else {
+        console.log(content);
+      }
+    } catch {
+      throw new PgError(`Could not capture pane for agent ${agentId2}. Pane may no longer exist.`, "PANE_NOT_FOUND");
+    }
+  }
+}
+var init_logs = __esm({
+  "src/commands/logs.ts"() {
+    "use strict";
+    init_manifest();
+    init_worktree();
+    init_tmux();
+    init_errors();
+    init_output();
+  }
+});
+
+// src/commands/aggregate.ts
+var aggregate_exports = {};
+__export(aggregate_exports, {
+  aggregateCommand: () => aggregateCommand
+});
+import fs8 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);
+  }
+  let worktrees;
+  if (options?.all) {
+    worktrees = Object.values(manifest.worktrees);
+  } else if (worktreeId2) {
+    const wt = resolveWorktree(manifest, worktreeId2);
+    if (!wt) throw new WorktreeNotFoundError(worktreeId2);
+    worktrees = [wt];
+  } else {
+    worktrees = Object.values(manifest.worktrees).filter(
+      (wt) => Object.values(wt.agents).some((a) => a.status === "completed")
+    );
+  }
+  const results = [];
+  for (const wt of worktrees) {
+    for (const agent of Object.values(wt.agents)) {
+      if (agent.status !== "completed" && agent.status !== "failed") continue;
+      const result = await collectAgentResult(agent, projectRoot);
+      results.push({
+        agentId: agent.id,
+        worktreeId: wt.id,
+        worktreeName: wt.name,
+        branch: wt.branch,
+        status: agent.status,
+        content: result
+      });
+    }
+  }
+  if (results.length === 0) {
+    if (options?.json) {
+      output({ results: [] }, true);
+    } else {
+      console.log("No completed agent results to aggregate.");
+    }
+    return;
+  }
+  if (options?.json) {
+    output({ results }, true);
+    return;
+  }
+  const combined = results.map((r) => {
+    return [
+      `# Agent: ${r.agentId}`,
+      `**Worktree:** ${r.worktreeName} (${r.worktreeId})`,
+      `**Branch:** ${r.branch}`,
+      `**Status:** ${r.status}`,
+      "",
+      r.content,
+      "",
+      "---",
+      ""
+    ].join("\n");
+  }).join("\n");
+  if (options?.output) {
+    await fs8.writeFile(options.output, combined, "utf-8");
+    success(`Wrote ${results.length} result(s) to ${options.output}`);
+  } else {
+    console.log(combined);
+  }
+}
+async function collectAgentResult(agent, projectRoot) {
+  try {
+    const content = await fs8.readFile(agent.resultFile, "utf-8");
+    return content;
+  } catch {
+  }
+  try {
+    const paneContent = await capturePane(agent.tmuxTarget, 500);
+    return `*[No result file \u2014 pane capture fallback]*
+
+\`\`\`
+${paneContent}
+\`\`\``;
+  } catch {
+    return "*[No result file and pane not available]*";
+  }
+}
+var init_aggregate = __esm({
+  "src/commands/aggregate.ts"() {
+    "use strict";
+    init_manifest();
+    init_agent();
+    init_worktree();
+    init_tmux();
+    init_errors();
+    init_output();
+  }
+});
+
+// src/commands/merge.ts
+var merge_exports = {};
+__export(merge_exports, {
+  mergeCommand: () => mergeCommand
+});
+import { execa as execa5 } 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);
+  }
+  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(
+      `${incomplete.length} agent(s) still running: ${ids}. Use --force to merge anyway.`,
+      "AGENTS_RUNNING"
+    );
+  }
+  if (options.dryRun) {
+    info("Dry run \u2014 no changes will be made");
+    info(`Would merge branch ${wt.branch} into ${wt.baseBranch} using ${options.strategy ?? "squash"} strategy`);
+    if (options.cleanup !== false) {
+      info(`Would remove worktree ${wt.id} and delete branch ${wt.branch}`);
+    }
+    return;
+  }
+  await updateManifest(projectRoot, (m) => {
+    if (m.worktrees[wt.id]) {
+      m.worktrees[wt.id].status = "merging";
+    }
+    return m;
+  });
+  const strategy = options.strategy ?? "squash";
+  try {
+    info(`Merging ${wt.branch} into ${wt.baseBranch} (${strategy})`);
+    if (strategy === "squash") {
+      await execa5("git", ["merge", "--squash", wt.branch], { cwd: projectRoot });
+      await execa5("git", ["commit", "-m", `ppg: merge ${wt.name} (${wt.branch})`], {
+        cwd: projectRoot
+      });
+    } else {
+      await execa5("git", ["merge", "--no-ff", wt.branch, "-m", `ppg: merge ${wt.name} (${wt.branch})`], {
+        cwd: projectRoot
+      });
+    }
+    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;
+  });
+  if (options.cleanup !== false) {
+    info("Cleaning up...");
+    await cleanupWorktree(projectRoot, wt);
+    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
+    }, true);
+  }
+}
+var init_merge = __esm({
+  "src/commands/merge.ts"() {
+    "use strict";
+    init_manifest();
+    init_agent();
+    init_worktree();
+    init_cleanup();
+    init_errors();
+    init_output();
+  }
+});
+
+// src/commands/list.ts
+var list_exports = {};
+__export(list_exports, {
+  listCommand: () => listCommand
+});
+import fs9 from "fs/promises";
+import path5 from "path";
+async function listCommand(type, options) {
+  if (type !== "templates") {
+    throw new PgError(`Unknown list type: ${type}. Available: templates`, "INVALID_ARGS");
+  }
+  const projectRoot = await getRepoRoot();
+  const templateNames = await listTemplates(projectRoot);
+  if (templateNames.length === 0) {
+    console.log("No templates found in .pg/templates/");
+    return;
+  }
+  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 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 };
+    })
+  );
+  if (options.json) {
+    output({ templates }, true);
+    return;
+  }
+  const columns = [
+    { header: "Name", key: "name", width: 20 },
+    { header: "Description", key: "description", width: 40 },
+    {
+      header: "Variables",
+      key: "variables",
+      width: 30,
+      format: (v) => v.join(", ")
+    }
+  ];
+  console.log(formatTable(templates, columns));
+}
+var init_list = __esm({
+  "src/commands/list.ts"() {
+    "use strict";
+    init_worktree();
+    init_template();
+    init_paths();
+    init_errors();
+    init_output();
+  }
+});
+
+// src/commands/restart.ts
+var restart_exports = {};
+__export(restart_exports, {
+  restartCommand: () => restartCommand
+});
+import fs10 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 found = findAgent(manifest, agentRef);
+  if (!found) throw new AgentNotFoundError(agentRef);
+  const { worktree: wt, agent: oldAgent } = found;
+  if (["running", "spawning", "waiting"].includes(oldAgent.status)) {
+    info(`Killing existing agent ${oldAgent.id}`);
+    await killAgent(oldAgent);
+  }
+  let promptText;
+  if (options.prompt) {
+    promptText = options.prompt;
+  } else {
+    const pFile = promptFile(projectRoot, oldAgent.id);
+    try {
+      promptText = await fs10.readFile(pFile, "utf-8");
+    } catch {
+      throw new PgError(
+        `Could not read original prompt for agent ${oldAgent.id}. Use --prompt to provide one.`,
+        "PROMPT_NOT_FOUND"
+      );
+    }
+  }
+  const agentConfig = resolveAgentConfig(config, options.agent ?? oldAgent.agentType);
+  await ensureSession(manifest.sessionName);
+  const newAgentId = agentId();
+  const windowTarget = await createWindow(manifest.sessionName, `${wt.name}-restart`, wt.path);
+  const ctx = {
+    WORKTREE_PATH: wt.path,
+    BRANCH: wt.branch,
+    AGENT_ID: newAgentId,
+    RESULT_FILE: resultFile(projectRoot, newAgentId),
+    PROJECT_ROOT: projectRoot,
+    TASK_NAME: wt.name,
+    PROMPT: promptText
+  };
+  const renderedPrompt = renderTemplate(promptText, ctx);
+  const newSessionId = sessionId();
+  const agentEntry = await spawnAgent({
+    agentId: newAgentId,
+    agentConfig,
+    prompt: renderedPrompt,
+    worktreePath: wt.path,
+    tmuxTarget: windowTarget,
+    projectRoot,
+    branch: wt.branch,
+    sessionId: newSessionId
+  });
+  await updateManifest(projectRoot, (m) => {
+    const mWt = m.worktrees[wt.id];
+    if (mWt) {
+      const mOldAgent = mWt.agents[oldAgent.id];
+      if (mOldAgent && !["completed", "failed", "killed", "lost"].includes(mOldAgent.status)) {
+        mOldAgent.status = "killed";
+        mOldAgent.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      }
+      mWt.agents[newAgentId] = agentEntry;
+    }
+    return m;
+  });
+  if (options.open !== false) {
+    openTerminalWindow(manifest.sessionName, windowTarget, `${wt.name}-restart`).catch(() => {
+    });
+  }
+  if (options.json) {
+    output({
+      success: true,
+      oldAgentId: oldAgent.id,
+      newAgent: {
+        id: newAgentId,
+        tmuxTarget: windowTarget,
+        sessionId: newSessionId,
+        worktreeId: wt.id,
+        worktreeName: wt.name,
+        branch: wt.branch,
+        path: wt.path
+      }
+    }, true);
+  } else {
+    success(`Restarted agent ${oldAgent.id} \u2192 ${newAgentId} in worktree ${wt.name}`);
+    info(`  New agent ${newAgentId} \u2192 ${windowTarget}`);
+  }
+}
+var init_restart = __esm({
+  "src/commands/restart.ts"() {
+    "use strict";
+    init_manifest();
+    init_config();
+    init_agent();
+    init_worktree();
+    init_tmux();
+    init_terminal();
+    init_id();
+    init_paths();
+    init_errors();
+    init_output();
+    init_template();
+  }
+});
+
+// src/commands/diff.ts
+var diff_exports = {};
+__export(diff_exports, {
+  diffCommand: () => diffCommand
+});
+import { execa as execa6 } from "execa";
+async function diffCommand(worktreeRef, options) {
+  const projectRoot = await getRepoRoot();
+  let manifest;
+  try {
+    manifest = await readManifest(projectRoot);
+  } catch {
+    throw new NotInitializedError(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], { cwd: projectRoot });
+    const files = result.stdout.trim().split("\n").filter(Boolean).map((line) => {
+      const [added, removed, file] = line.split("	");
+      return {
+        file,
+        added: added === "-" ? 0 : parseInt(added, 10),
+        removed: removed === "-" ? 0 : parseInt(removed, 10)
+      };
+    });
+    output({
+      worktreeId: wt.id,
+      branch: wt.branch,
+      baseBranch: wt.baseBranch,
+      files
+    }, true);
+  } else if (options.stat) {
+    const result = await execa6("git", ["diff", "--stat", diffRange], { cwd: projectRoot });
+    console.log(result.stdout);
+  } else if (options.nameOnly) {
+    const result = await execa6("git", ["diff", "--name-only", diffRange], { cwd: projectRoot });
+    console.log(result.stdout);
+  } else {
+    const result = await execa6("git", ["diff", diffRange], { cwd: projectRoot });
+    console.log(result.stdout);
+  }
+}
+var init_diff = __esm({
+  "src/commands/diff.ts"() {
+    "use strict";
+    init_manifest();
+    init_worktree();
+    init_errors();
+    init_output();
+  }
+});
+
+// src/commands/clean.ts
+var clean_exports = {};
+__export(clean_exports, {
+  cleanCommand: () => cleanCommand
+});
+async function cleanCommand(options) {
+  const projectRoot = await getRepoRoot();
+  let manifest;
+  try {
+    manifest = await readManifest(projectRoot);
+  } catch {
+    throw new NotInitializedError(projectRoot);
+  }
+  const terminalStatuses = ["merged", "cleaned"];
+  if (options.all) {
+    terminalStatuses.push("failed");
+  }
+  const toClean = Object.values(manifest.worktrees).filter((wt) => terminalStatuses.includes(wt.status));
+  const toRemoveFromManifest = Object.values(manifest.worktrees).filter((wt) => wt.status === "cleaned");
+  if (options.dryRun) {
+    if (toClean.length === 0 && toRemoveFromManifest.length === 0) {
+      info("Nothing to clean");
+    } else {
+      info("Dry run \u2014 would clean:");
+      for (const wt of toClean) {
+        if (wt.status !== "cleaned") {
+          info(`  ${wt.id} (${wt.name}) \u2014 ${wt.status}`);
+        }
+      }
+      for (const wt of toRemoveFromManifest) {
+        info(`  ${wt.id} (${wt.name}) \u2014 remove from manifest`);
+      }
+    }
+    if (options.json) {
+      output({
+        dryRun: true,
+        wouldClean: toClean.filter((wt) => wt.status !== "cleaned").map((wt) => ({
+          id: wt.id,
+          name: wt.name,
+          status: wt.status
+        })),
+        wouldRemoveFromManifest: toRemoveFromManifest.map((wt) => ({
+          id: wt.id,
+          name: wt.name
+        }))
+      }, true);
+    }
+    return;
+  }
+  const cleaned = [];
+  const removed = [];
+  for (const wt of toClean) {
+    if (wt.status !== "cleaned") {
+      info(`Cleaning worktree ${wt.id} (${wt.name})`);
+      await cleanupWorktree(projectRoot, wt);
+      cleaned.push(wt.id);
+    }
+  }
+  const allCleanedIds = [.../* @__PURE__ */ new Set([
+    ...toRemoveFromManifest.map((wt) => wt.id),
+    ...cleaned
+  ])];
+  if (allCleanedIds.length > 0) {
+    await updateManifest(projectRoot, (m) => {
+      for (const id of allCleanedIds) {
+        delete m.worktrees[id];
+      }
+      return m;
+    });
+    removed.push(...allCleanedIds);
+  }
+  if (options.prune) {
+    info("Pruning stale git worktrees");
+    await pruneWorktrees(projectRoot);
+  }
+  if (options.json) {
+    output({
+      success: true,
+      cleaned,
+      removedFromManifest: removed,
+      pruned: options.prune ?? false
+    }, true);
+  } else {
+    if (cleaned.length > 0) {
+      success(`Cleaned ${cleaned.length} worktree(s)`);
+    }
+    if (removed.length > 0) {
+      success(`Removed ${removed.length} worktree(s) from manifest`);
+    }
+    if (cleaned.length === 0 && removed.length === 0) {
+      info("Nothing to clean");
+    }
+    if (options.prune) {
+      success("Pruned stale git worktrees");
+    }
+  }
+}
+var init_clean = __esm({
+  "src/commands/clean.ts"() {
+    "use strict";
+    init_manifest();
+    init_worktree();
+    init_cleanup();
+    init_errors();
+    init_output();
+  }
+});
+
+// src/commands/send.ts
+var send_exports = {};
+__export(send_exports, {
+  sendCommand: () => sendCommand
+});
+async function sendCommand(agentId2, text, options) {
+  const projectRoot = await getRepoRoot();
+  let manifest;
+  try {
+    manifest = await readManifest(projectRoot);
+  } catch {
+    throw new NotInitializedError(projectRoot);
+  }
+  const found = findAgent(manifest, agentId2);
+  if (!found) throw new AgentNotFoundError(agentId2);
+  const { agent } = found;
+  if (options.keys) {
+    await sendRawKeys(agent.tmuxTarget, text);
+  } else if (options.enter === false) {
+    await sendLiteral(agent.tmuxTarget, text);
+  } else {
+    await sendKeys(agent.tmuxTarget, text);
+  }
+  if (options.json) {
+    output({
+      success: true,
+      agentId: agent.id,
+      tmuxTarget: agent.tmuxTarget,
+      text
+    }, true);
+  } else {
+    success(`Sent to agent ${agent.id}`);
+  }
+}
+var init_send = __esm({
+  "src/commands/send.ts"() {
+    "use strict";
+    init_manifest();
+    init_worktree();
+    init_tmux();
+    init_errors();
+    init_output();
+  }
+});
+
+// src/commands/wait.ts
+var wait_exports = {};
+__export(wait_exports, {
+  waitCommand: () => waitCommand
+});
+async function waitCommand(worktreeRef, options) {
+  const projectRoot = await getRepoRoot();
+  const interval = (options.interval ?? 5) * 1e3;
+  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");
+  }
+  if (!options.json) {
+    info("Waiting for agents to complete...");
+  }
+  while (true) {
+    if (timeout && Date.now() - startTime >= timeout) {
+      const manifest2 = await refreshAndGet(projectRoot);
+      const agents2 = collectAgents(manifest2, worktreeRef, options.all);
+      if (options.json) {
+        output({
+          timedOut: true,
+          agents: agents2.map(formatAgent)
+        }, true);
+      }
+      throw new PgError("Timed out waiting for agents", "WAIT_TIMEOUT", 2);
+    }
+    const manifest = await refreshAndGet(projectRoot);
+    const agents = collectAgents(manifest, worktreeRef, options.all);
+    const allTerminal = agents.every((a) => TERMINAL_STATUSES.includes(a.status));
+    if (allTerminal) {
+      const anyFailed = agents.some((a) => ["failed", "lost"].includes(a.status));
+      if (options.json) {
+        output({
+          timedOut: false,
+          agents: agents.map(formatAgent)
+        }, true);
+      } else {
+        for (const a of agents) {
+          info(`  ${a.id}: ${a.status}`);
+        }
+      }
+      if (anyFailed) {
+        throw new PgError("Some agents failed", "AGENTS_FAILED", 1);
+      }
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+}
+async function refreshAndGet(projectRoot) {
+  try {
+    return await updateManifest(projectRoot, async (m) => {
+      return refreshAllAgentStatuses(m, projectRoot);
+    });
+  } catch {
+    throw new NotInitializedError(projectRoot);
+  }
+}
+function collectAgents(manifest, worktreeRef, all) {
+  if (all) {
+    const agents = [];
+    for (const wt2 of Object.values(manifest.worktrees)) {
+      agents.push(...Object.values(wt2.agents));
+    }
+    return agents;
+  }
+  const wt = resolveWorktree(manifest, worktreeRef);
+  if (!wt) throw new WorktreeNotFoundError(worktreeRef);
+  return Object.values(wt.agents);
+}
+function formatAgent(a) {
+  return {
+    id: a.id,
+    status: a.status,
+    agentType: a.agentType,
+    exitCode: a.exitCode,
+    startedAt: a.startedAt,
+    completedAt: a.completedAt
+  };
+}
+var TERMINAL_STATUSES;
+var init_wait = __esm({
+  "src/commands/wait.ts"() {
+    "use strict";
+    init_manifest();
+    init_agent();
+    init_worktree();
+    init_errors();
+    init_output();
+    TERMINAL_STATUSES = ["completed", "failed", "killed", "lost"];
+  }
+});
+
+// src/commands/worktree.ts
+var worktree_exports = {};
+__export(worktree_exports, {
+  worktreeCreateCommand: () => worktreeCreateCommand
+});
+async function worktreeCreateCommand(options) {
+  const projectRoot = await getRepoRoot();
+  const config = await loadConfig(projectRoot);
+  try {
+    await readManifest(projectRoot);
+  } catch {
+    throw new NotInitializedError(projectRoot);
+  }
+  const baseBranch = options.base ?? await getCurrentBranch(projectRoot);
+  const wtId = worktreeId();
+  const name = options.name ?? wtId;
+  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 worktreeEntry = {
+    id: wtId,
+    name,
+    path: wtPath,
+    branch: branchName,
+    baseBranch,
+    status: "active",
+    tmuxWindow: "",
+    agents: {},
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await updateManifest(projectRoot, (m) => {
+    m.worktrees[wtId] = worktreeEntry;
+    return m;
+  });
+  if (options.json) {
+    output({
+      success: true,
+      worktree: {
+        id: wtId,
+        name,
+        branch: branchName,
+        baseBranch,
+        path: wtPath
+      }
+    }, true);
+  } else {
+    success(`Created worktree ${wtId} (${name}) on branch ${branchName}`);
+    info(`Path: ${wtPath}`);
+    info(`Spawn agents: ppg spawn --worktree ${wtId} --prompt "your task"`);
+  }
+}
+var init_worktree2 = __esm({
+  "src/commands/worktree.ts"() {
+    "use strict";
+    init_config();
+    init_manifest();
+    init_worktree();
+    init_env();
+    init_id();
+    init_errors();
+    init_output();
+  }
+});
+
+// src/commands/ui.ts
+var ui_exports = {};
+__export(ui_exports, {
+  findDashboardBinary: () => findDashboardBinary,
+  uiCommand: () => uiCommand
+});
+import { access } from "fs/promises";
+import path6 from "path";
+import { execa as execa7 } from "execa";
+async function findDashboardBinary(projectRoot) {
+  const localBuild = path6.join(
+    projectRoot,
+    "PPG CLI",
+    "build",
+    "Build",
+    "Products",
+    "Release",
+    "PPG CLI.app",
+    "Contents",
+    "MacOS",
+    "PPG CLI"
+  );
+  try {
+    await access(localBuild);
+    return localBuild;
+  } catch {
+  }
+  const appsBuild = "/Applications/PPG CLI.app/Contents/MacOS/PPG CLI";
+  try {
+    await access(appsBuild);
+    return appsBuild;
+  } catch {
+  }
+  try {
+    const result = await execa7("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");
+      try {
+        await access(binaryPath);
+        return binaryPath;
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function uiCommand() {
+  const projectRoot = await getRepoRoot();
+  let manifest;
+  try {
+    manifest = await readManifest(projectRoot);
+  } catch {
+    throw new NotInitializedError(projectRoot);
+  }
+  const binaryPath = await findDashboardBinary(projectRoot);
+  if (!binaryPath) {
+    throw new PgError(
+      `Dashboard app not found. Install it with:
+  ppg install-dashboard
+
+Or build from source:
+  cd "PPG CLI" && xcodebuild -scheme "PPG CLI" -configuration Release -derivedDataPath build build`,
+      "DASHBOARD_NOT_FOUND"
+    );
+  }
+  const mPath = manifestPath(projectRoot);
+  const proc = execa7(binaryPath, [
+    "--manifest-path",
+    mPath,
+    "--session-name",
+    manifest.sessionName,
+    "--project-root",
+    projectRoot
+  ], {
+    detached: true,
+    stdio: "ignore"
+  });
+  proc.unref();
+  info(`Dashboard launched for ${manifest.sessionName}`);
+}
+var init_ui = __esm({
+  "src/commands/ui.ts"() {
+    "use strict";
+    init_worktree();
+    init_manifest();
+    init_paths();
+    init_errors();
+    init_output();
+  }
+});
+
+// src/commands/install-dashboard.ts
+var install_dashboard_exports = {};
+__export(install_dashboard_exports, {
+  installDashboardCommand: () => installDashboardCommand
+});
+import { createWriteStream } from "fs";
+import { mkdir, cp, rm, readFile } from "fs/promises";
+import { tmpdir } from "os";
+import path7 from "path";
+import { pipeline } from "stream/promises";
+import { Readable } from "stream";
+import { execa as execa8 } from "execa";
+async function getVersion() {
+  const pkgPath = new URL("../../package.json", import.meta.url);
+  const raw = await readFile(pkgPath, "utf-8");
+  const pkg = JSON.parse(raw);
+  return pkg.version;
+}
+async function installDashboardCommand(options) {
+  const { dir, json } = options;
+  try {
+    const version = await getVersion();
+    const tag = `v${version}`;
+    const url = `https://github.com/${REPO}/releases/download/${tag}/${ASSET_NAME}`;
+    if (!json) info(`Downloading dashboard ${tag} from GitHub Releases\u2026`);
+    const res = await fetch(url);
+    if (!res.ok) {
+      if (res.status === 404) {
+        throw new PgError(
+          `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(
+        `Failed to download dashboard: HTTP ${res.status} ${res.statusText}`,
+        "DOWNLOAD_FAILED"
+      );
+    }
+    const tmp = path7.join(tmpdir(), `ppg-dashboard-${Date.now()}`);
+    await mkdir(tmp, { recursive: true });
+    const dmgPath = path7.join(tmp, ASSET_NAME);
+    const body = res.body;
+    if (!body) throw new PgError("Empty response body", "DOWNLOAD_FAILED");
+    await pipeline(
+      Readable.fromWeb(body),
+      createWriteStream(dmgPath)
+    );
+    if (!json) info("Mounting\u2026");
+    const mountResult = await execa8("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);
+      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]);
+      } catch {
+      }
+      if (json) {
+        output({ success: true, version, path: destApp }, true);
+      } else {
+        success(`Dashboard ${tag} installed to ${destApp}`);
+      }
+    } finally {
+      await execa8("hdiutil", ["detach", mountPoint, "-quiet"]).catch(() => {
+      });
+    }
+    await rm(tmp, { recursive: true, force: true });
+  } catch (err) {
+    if (err instanceof PgError) throw err;
+    const message = err instanceof Error ? err.message : String(err);
+    throw new PgError(`Dashboard installation failed: ${message}`, "INSTALL_FAILED");
+  }
+}
+var REPO, ASSET_NAME, APP_NAME;
+var init_install_dashboard = __esm({
+  "src/commands/install-dashboard.ts"() {
+    "use strict";
+    init_output();
+    init_errors();
+    REPO = "2witstudios/ppg-cli";
+    ASSET_NAME = "PPG-CLI-Dashboard.dmg";
+    APP_NAME = "PPG CLI.app";
+  }
+});
+
+// src/cli.ts
+init_errors();
+init_output();
+import { Command } from "commander";
+var program = new Command();
+program.name("ppg").description("Pure Point Guard \u2014 local orchestration runtime for parallel CLI coding agents").version("0.1.0");
+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("--no-open", "Do not 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);
+});
+program.command("status").description("Show status of worktrees and agents").argument("[worktree]", "Filter by worktree ID or name").option("--json", "Output as JSON").option("-w, --watch", "Watch for status changes").action(async (worktree, options) => {
+  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) => {
+  const { killCommand: killCommand2 } = await Promise.resolve().then(() => (init_kill(), kill_exports));
+  await killCommand2(options);
+});
+program.command("attach").description("Attach to a worktree or agent tmux pane").argument("<target>", "Worktree ID, agent ID, or name").action(async (target) => {
+  const { attachCommand: attachCommand2 } = await Promise.resolve().then(() => (init_attach(), attach_exports));
+  await attachCommand2(target);
+});
+program.command("logs").description("View agent pane output").argument("<agent-id>", "Agent ID").option("-l, --lines <n>", "Number of lines to show", (v) => Number(v), 100).option("-f, --follow", "Follow output (poll every 1s)").option("--full", "Show full pane history").option("--json", "Output as JSON").action(async (agentId2, options) => {
+  const { logsCommand: logsCommand2 } = await Promise.resolve().then(() => (init_logs(), logs_exports));
+  await logsCommand2(agentId2, options);
+});
+program.command("aggregate").description("Aggregate results from completed agents").argument("[worktree-id]", "Worktree ID to aggregate results from").option("--all", "Aggregate from all worktrees").option("-o, --output <file>", "Write output to file").option("--json", "Output as JSON").action(async (worktreeId2, options) => {
+  const { aggregateCommand: aggregateCommand2 } = await Promise.resolve().then(() => (init_aggregate(), aggregate_exports));
+  await aggregateCommand2(worktreeId2, options);
+});
+program.command("merge").description("Merge a worktree branch back into base").argument("<worktree-id>", "Worktree ID to merge").option("-s, --strategy <strategy>", "Merge strategy: squash or no-ff", "squash").option("--no-cleanup", "Do not remove worktree after merge").option("--dry-run", "Show what would be done without doing it").option("--force", "Merge even if agents are not completed").option("--json", "Output as JSON").action(async (worktreeId2, options) => {
+  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) => {
+  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) => {
+  const { restartCommand: restartCommand2 } = await Promise.resolve().then(() => (init_restart(), restart_exports));
+  await restartCommand2(agentId2, options);
+});
+program.command("diff").description("Show changes made in a worktree branch").argument("<worktree-id>", "Worktree ID or name").option("--stat", "Show diffstat summary").option("--name-only", "Show only changed file names").option("--json", "Output as JSON").action(async (worktreeId2, options) => {
+  const { diffCommand: diffCommand2 } = await Promise.resolve().then(() => (init_diff(), diff_exports));
+  await diffCommand2(worktreeId2, 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);
+});
+program.command("send").description("Send text to an agent's tmux pane").argument("<agent-id>", "Agent ID").argument("<text>", "Text to send").option("--keys", "Send raw tmux key names (e.g., C-c, Enter)").option("--no-enter", "Do not append Enter after the text").option("--json", "Output as JSON").action(async (agentId2, text, options) => {
+  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) => {
+  const { waitCommand: waitCommand2 } = await Promise.resolve().then(() => (init_wait(), wait_exports));
+  await waitCommand2(worktreeId2, options);
+});
+var worktreeCmd = program.command("worktree").description("Manage worktrees");
+worktreeCmd.command("create").description("Create a standalone worktree without spawning agents").option("-n, --name <name>", "Name for the worktree").option("-b, --base <branch>", "Base branch for the worktree").option("--json", "Output as JSON").action(async (options) => {
+  const { worktreeCreateCommand: worktreeCreateCommand2 } = await Promise.resolve().then(() => (init_worktree2(), worktree_exports));
+  await worktreeCreateCommand2(options);
+});
+program.command("ui").alias("dashboard").description("Open the native dashboard").action(async () => {
+  const { uiCommand: uiCommand2 } = await Promise.resolve().then(() => (init_ui(), ui_exports));
+  await uiCommand2();
+});
+program.command("install-dashboard").description("Download and install the macOS dashboard app").option("--dir <path>", "Install directory", "/Applications").option("--json", "JSON output").action(async (options) => {
+  const { installDashboardCommand: installDashboardCommand2 } = await Promise.resolve().then(() => (init_install_dashboard(), install_dashboard_exports));
+  await installDashboardCommand2(options);
+});
+program.exitOverride();
+function collectVars(value, previous) {
+  return previous.concat([value]);
+}
+async function main() {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    if (err instanceof PgError) {
+      outputError(err, program.opts().json ?? false);
+      process.exit(err.exitCode);
+    }
+    if (err instanceof Error && "code" in err) {
+      const code = err.code;
+      if (code === "commander.helpDisplayed" || code === "commander.version") {
+        process.exit(0);
+      }
+    }
+    outputError(err, false);
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=cli.js.map