pure-point-guard 0.3.0 → 0.3.2

package/dist/cli.js

@@ -95,7 +95,7 @@ var init_errors = __esm({
       constructor(names) {
         const list = names.map((n) => `  ${n}`).join("\n");
         super(
-          `${names.length} worktree(s) have completed work that hasn't been merged or PR'd:
+          `${names.length} worktree(s) have unmerged work that hasn't been PR'd:
 ${list}
 
 Use --force to reset anyway, or create PRs first with: ppg pr <worktree-id>`,
@@ -163,7 +163,7 @@ function success(message) {
 function warn(message) {
   console.log(`${YELLOW}\u26A0${RESET} ${message}`);
 }
-var RESET, BOLD, DIM, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, GRAY, STATUS_COLORS;
+var RESET, BOLD, DIM, RED, GREEN, YELLOW, BLUE, CYAN, GRAY, STATUS_COLORS;
 var init_output = __esm({
   "src/lib/output.ts"() {
     "use strict";
@@ -174,20 +174,17 @@ var init_output = __esm({
     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,
+      idle: CYAN,
+      exited: BLUE,
+      gone: GRAY,
       active: GREEN,
       merging: YELLOW,
       merged: BLUE,
+      failed: RED,
       cleaned: GRAY
     };
   }
@@ -325,29 +322,17 @@ var init_config = __esm({
         claude: {
           name: "claude",
           command: "claude --dangerously-skip-permissions",
-          interactive: true,
-          resultInstructions: [
-            "When you have completed the task:",
-            "",
-            "1. Stage and commit all your changes with a descriptive commit message",
-            "2. Push your branch: git push -u origin {{BRANCH}}",
-            "3. Create a pull request: gh pr create --head {{BRANCH}} --base main --fill",
-            "4. Write your results to {{RESULT_FILE}} in this format:",
-            "",
-            "# Result: {{AGENT_ID}}",
-            "",
-            "## PR",
-            "<the PR URL from step 3>",
-            "",
-            "## Summary",
-            "<what you accomplished>",
-            "",
-            "## Changes",
-            "<list of files changed>",
-            "",
-            "## Notes",
-            "<any important observations>"
-          ].join("\n")
+          interactive: true
+        },
+        codex: {
+          name: "codex",
+          command: "codex --yolo",
+          interactive: true
+        },
+        opencode: {
+          name: "opencode",
+          command: "opencode --yolo",
+          interactive: true
         }
       },
       envFiles: [".env", ".env.local"],
@@ -490,7 +475,7 @@ You are a senior engineer reviewing code for quality, readability, and maintaina
 - Documentation gaps for non-obvious logic
 
 ## Output
-Write a structured review to {{RESULT_FILE}} with specific file:line references and improvement suggestions.
+Write a structured review with specific file:line references and improvement suggestions.
 `,
       "review-security": `# Security Review
 
@@ -508,7 +493,7 @@ You are a security engineer reviewing code for vulnerabilities and risks.
 - Secrets or credentials in code
 
 ## Output
-Write a structured review to {{RESULT_FILE}} with severity ratings and remediation guidance.
+Write a structured review with severity ratings and remediation guidance.
 `,
       "review-regression": `# Regression & Risk Review
 
@@ -526,7 +511,7 @@ You are a QA engineer reviewing code for regression risks and test coverage gaps
 - Performance regressions
 
 ## Output
-Write a structured review to {{RESULT_FILE}} with risk ratings and recommended test additions.
+Write a structured review with risk ratings and recommended test additions.
 `
     };
   }
@@ -977,11 +962,19 @@ var init_init = __esm({
 
 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.
+## When to Use ppg
+Use \`ppg spawn\` whenever you want work to appear in the **ppg dashboard** \u2014 parallel tasks, code reviews,
+batch issue work, multi-agent swarms. Agents spawned through ppg run in tmux panes the user can monitor,
+interact with, and manage. Available agent types: \`claude\` (default), \`codex\`, \`opencode\` via \`--agent\`.
+
+Direct edits, quick commands, and research are fine to do yourself \u2014 not everything needs an agent.
+Never run \`claude\`, \`codex\`, or \`opencode\` directly as bash commands \u2014 they won't appear in the dashboard.
 
 ## Quick Reference
 - \`ppg spawn --name <name> --prompt "<task>" --json\` \u2014 Spawn worktree + agent
+- \`ppg spawn --name <name> --agent codex --prompt "<task>" --json\` \u2014 Use Codex agent
+- \`ppg spawn --name <name> --agent opencode --prompt "<task>" --json\` \u2014 Use OpenCode agent
+- \`ppg spawn --worktree <id> --agent codex --prompt "review --base main" --json\` \u2014 Codex review
 - \`ppg status --json\` \u2014 Check statuses
 - \`ppg aggregate --all --json\` \u2014 Collect results (includes PR URLs)
 - \`ppg kill --agent <id> --json\` \u2014 Kill agent
@@ -1009,10 +1002,6 @@ Project root: {{PROJECT_ROOT}}
 
 ## Instructions
 {{PROMPT}}
-
-## Result Reporting
-When you have completed the task, write your results to:
-{{RESULT_FILE}}
 `;
   }
 });
@@ -1046,6 +1035,11 @@ async function createWorktree(repoRoot, id, options) {
   await execa3("git", args, { ...execaEnv, cwd: repoRoot });
   return wtPath;
 }
+async function adoptWorktree(repoRoot, id, branch) {
+  const wtPath = worktreePath(repoRoot, id);
+  await execa3("git", ["worktree", "add", wtPath, branch], { ...execaEnv, cwd: repoRoot });
+  return wtPath;
+}
 async function removeWorktree(repoRoot, wtPath, options) {
   const args = ["worktree", "remove", wtPath];
   if (options?.force) {
@@ -1169,31 +1163,12 @@ async function spawnAgent(options) {
     agentId: agentId2,
     agentConfig,
     prompt,
-    worktreePath: worktreePath2,
     tmuxTarget,
-    projectRoot,
-    branch
+    projectRoot
   } = options;
-  const resFile = resultFile(projectRoot, agentId2);
-  let fullPrompt = prompt;
-  if (agentConfig.resultInstructions && !options.skipResultInstructions) {
-    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 = agentPromptFile(projectRoot, agentId2);
   await fs6.mkdir(agentPromptsDir(projectRoot), { recursive: true });
-  await fs6.writeFile(pFile, fullPrompt, "utf-8");
+  await fs6.writeFile(pFile, prompt, "utf-8");
   const command = buildAgentCommand(agentConfig, pFile, options.sessionId);
   await sendKeys(tmuxTarget, command);
   return {
@@ -1204,7 +1179,6 @@ ${instructions}`;
     tmuxTarget,
     prompt: prompt.slice(0, 500),
     // Truncate for manifest storage
-    resultFile: resFile,
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     ...options.sessionId ? { sessionId: options.sessionId } : {}
   };
@@ -1219,32 +1193,16 @@ function buildAgentCommand(agentConfig, promptFilePath, sessionId2) {
   }
   return `${envPrefix} ${command}${sessionFlag} ${catExpr}`;
 }
-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" };
-  }
+async function checkAgentStatus(agent, _projectRoot, paneMap) {
   const paneInfo = paneMap ? paneMap.get(agent.tmuxTarget) ?? null : await getPaneInfo(agent.tmuxTarget);
   if (!paneInfo) {
-    return { status: "lost" };
+    return { status: "gone" };
   }
   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 };
+    return { status: "exited", exitCode: paneInfo.deadStatus };
   }
   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: "idle" };
   }
   return { status: "running" };
 }
@@ -1260,27 +1218,18 @@ async function refreshAllAgentStatuses(manifest, projectRoot) {
     }
   }
   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;
-      }
-    }
+    agent.status = status;
+    if (exitCode !== void 0) agent.exitCode = exitCode;
   }
   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;
-        }
+        agent.status = "gone";
       }
     }
   });
@@ -1356,7 +1305,6 @@ var init_agent = __esm({
     init_tmux();
     init_manifest();
     init_errors();
-    init_template();
     init_tmux();
     SHELL_COMMANDS = /* @__PURE__ */ new Set(["bash", "zsh", "sh", "fish", "dash", "tcsh", "csh"]);
   }
@@ -1478,6 +1426,12 @@ async function spawnCommand(options) {
   const count = options.count ?? 1;
   const userVars = parseVars(options.var ?? []);
   const promptText = await resolvePrompt(options, projectRoot);
+  if (options.branch && options.worktree) {
+    throw new PpgError("--branch and --worktree are mutually exclusive", "INVALID_ARGS");
+  }
+  if (options.branch && options.base) {
+    throw new PpgError("--branch and --base are mutually exclusive (--base is for new branches)", "INVALID_ARGS");
+  }
   if (options.worktree) {
     await spawnIntoExistingWorktree(
       projectRoot,
@@ -1489,6 +1443,17 @@ async function spawnCommand(options) {
       options,
       userVars
     );
+  } else if (options.branch) {
+    await spawnOnExistingBranch(
+      projectRoot,
+      config,
+      agentConfig,
+      options.branch,
+      promptText,
+      count,
+      options,
+      userVars
+    );
   } else {
     await spawnNewWorktree(
       projectRoot,
@@ -1558,7 +1523,6 @@ async function spawnNewWorktree(projectRoot, config, agentConfig, promptText, co
       WORKTREE_PATH: wtPath,
       BRANCH: branchName,
       AGENT_ID: aId,
-      RESULT_FILE: resultFile(projectRoot, aId),
       PROJECT_ROOT: projectRoot,
       TASK_NAME: name,
       PROMPT: promptText
@@ -1611,6 +1575,102 @@ async function spawnNewWorktree(projectRoot, config, agentConfig, promptText, co
     info(`Attach: ppg attach ${wtId}`);
   }
 }
+async function spawnOnExistingBranch(projectRoot, config, agentConfig, branch, promptText, count, options, userVars) {
+  const baseBranch = await getCurrentBranch(projectRoot);
+  const wtId = worktreeId();
+  const derivedName = branch.startsWith("ppg/") ? branch.slice(4) : branch;
+  const name = options.name ? normalizeName(options.name, wtId) : normalizeName(derivedName, wtId);
+  info(`Creating worktree ${wtId} from existing branch ${branch}`);
+  const wtPath = await adoptWorktree(projectRoot, wtId, branch);
+  await setupWorktreeEnv(projectRoot, wtPath, config);
+  const manifest = await readManifest(projectRoot);
+  const sessionName = manifest.sessionName;
+  await ensureSession(sessionName);
+  const windowTarget = await createWindow(sessionName, name, wtPath);
+  const worktreeEntry = {
+    id: wtId,
+    name,
+    path: wtPath,
+    branch,
+    baseBranch,
+    status: "active",
+    tmuxWindow: windowTarget,
+    agents: {},
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await updateManifest(projectRoot, (m) => {
+    m.worktrees[wtId] = worktreeEntry;
+    return m;
+  });
+  const agents = [];
+  for (let i = 0; i < count; i++) {
+    const aId = agentId();
+    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: branch,
+      AGENT_ID: aId,
+      PROJECT_ROOT: projectRoot,
+      TASK_NAME: name,
+      PROMPT: promptText
+    };
+    Object.assign(ctx, userVars);
+    const renderedPrompt = renderTemplate(promptText, ctx);
+    const agentEntry = await spawnAgent({
+      agentId: aId,
+      agentConfig,
+      prompt: renderedPrompt,
+      worktreePath: wtPath,
+      tmuxTarget: target,
+      projectRoot,
+      branch,
+      sessionId: sessionId()
+    });
+    agents.push(agentEntry);
+    await updateManifest(projectRoot, (m) => {
+      if (m.worktrees[wtId]) {
+        m.worktrees[wtId].agents[agentEntry.id] = agentEntry;
+      }
+      return m;
+    });
+  }
+  if (options.open === true) {
+    openTerminalWindow(sessionName, windowTarget, name).catch(() => {
+    });
+  }
+  if (options.json) {
+    output({
+      success: true,
+      worktree: {
+        id: wtId,
+        name,
+        branch,
+        path: wtPath,
+        tmuxWindow: windowTarget
+      },
+      agents: agents.map((a) => ({
+        id: a.id,
+        tmuxTarget: a.tmuxTarget,
+        sessionId: a.sessionId
+      }))
+    }, true);
+  } else {
+    success(`Spawned worktree ${wtId} from branch ${branch} 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, userVars) {
   const manifest = await readManifest(projectRoot);
   const wt = resolveWorktree(manifest, worktreeRef);
@@ -1637,7 +1697,6 @@ async function spawnIntoExistingWorktree(projectRoot, config, agentConfig, workt
       WORKTREE_PATH: wt.path,
       BRANCH: wt.branch,
       AGENT_ID: aId,
-      RESULT_FILE: resultFile(projectRoot, aId),
       PROJECT_ROOT: projectRoot,
       TASK_NAME: wt.name,
       PROMPT: promptText
@@ -1713,6 +1772,7 @@ var init_spawn = __esm({
 // src/commands/status.ts
 var status_exports = {};
 __export(status_exports, {
+  computeLifecycle: () => computeLifecycle,
   statusCommand: () => statusCommand
 });
 async function statusCommand(worktreeFilter, options) {
@@ -1731,7 +1791,7 @@ async function statusCommand(worktreeFilter, options) {
   if (options?.json) {
     output({
       session: manifest.sessionName,
-      worktrees: Object.fromEntries(worktrees.map((wt) => [wt.id, wt]))
+      worktrees: Object.fromEntries(worktrees.map((wt) => [wt.id, { ...wt, lifecycle: computeLifecycle(wt) }]))
     }, true);
     return;
   }
@@ -1770,12 +1830,6 @@ async function statusCommand(worktreeFilter, options) {
 }
 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}`
@@ -1799,6 +1853,14 @@ ${wt.name} (${wt.id}) [${formatStatus(wt.status)}] branch:${wt.branch}`
   const table = formatTable(agents, columns);
   console.log(table.split("\n").map((l) => `  ${l}`).join("\n"));
 }
+function computeLifecycle(wt) {
+  if (wt.status === "merged") return "merged";
+  if (wt.status === "cleaned") return "cleaned";
+  const agents = Object.values(wt.agents);
+  if (agents.some((a) => a.status === "running")) return "busy";
+  if (wt.prUrl) return "shipped";
+  return "idle";
+}
 function formatTime(iso) {
   if (!iso) return "\u2014";
   const d = new Date(iso);
@@ -1999,7 +2061,7 @@ async function killSingleAgent(projectRoot, agentId2, options, selfPaneId, paneM
   const found = findAgent(manifest, agentId2);
   if (!found) throw new AgentNotFoundError(agentId2);
   const { agent } = found;
-  const isTerminal = ["completed", "failed", "killed", "lost"].includes(agent.status);
+  const isTerminal = agent.status !== "running";
   if (selfPaneId && paneMap) {
     const { skipped } = excludeSelf([agent], selfPaneId, paneMap);
     if (skipped.length > 0) {
@@ -2042,8 +2104,7 @@ async function killSingleAgent(projectRoot, agentId2, options, selfPaneId, paneM
     await updateManifest(projectRoot, (m) => {
       const f = findAgent(m, agentId2);
       if (f) {
-        f.agent.status = "killed";
-        f.agent.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+        f.agent.status = "gone";
       }
       return m;
     });
@@ -2058,7 +2119,7 @@ async function killWorktreeAgents(projectRoot, worktreeRef, options, selfPaneId,
   const manifest = await readManifest(projectRoot);
   const wt = resolveWorktree(manifest, worktreeRef);
   if (!wt) throw new WorktreeNotFoundError(worktreeRef);
-  let toKill = Object.values(wt.agents).filter((a) => ["running", "spawning", "waiting"].includes(a.status));
+  let toKill = Object.values(wt.agents).filter((a) => a.status === "running");
   const skippedIds = [];
   if (selfPaneId && paneMap) {
     const { safe, skipped } = excludeSelf(toKill, selfPaneId, paneMap);
@@ -2076,8 +2137,7 @@ async function killWorktreeAgents(projectRoot, worktreeRef, options, selfPaneId,
     if (mWt) {
       for (const agent of Object.values(mWt.agents)) {
         if (killedIds.includes(agent.id)) {
-          agent.status = "killed";
-          agent.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+          agent.status = "gone";
         }
       }
     }
@@ -2127,7 +2187,7 @@ async function killAllAgents(projectRoot, options, selfPaneId, paneMap) {
   let toKill = [];
   for (const wt of Object.values(manifest.worktrees)) {
     for (const agent of Object.values(wt.agents)) {
-      if (["running", "spawning", "waiting"].includes(agent.status)) {
+      if (agent.status === "running") {
         toKill.push(agent);
       }
     }
@@ -2149,8 +2209,7 @@ async function killAllAgents(projectRoot, options, selfPaneId, paneMap) {
     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();
+          agent.status = "gone";
         }
       }
     }
@@ -2396,13 +2455,12 @@ async function aggregateCommand(worktreeId2, options) {
     worktrees = [wt];
   } else {
     worktrees = Object.values(manifest.worktrees).filter(
-      (wt) => Object.values(wt.agents).some((a) => a.status === "completed")
+      (wt) => Object.values(wt.agents).some((a) => a.status !== "running")
     );
   }
   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,
@@ -2418,7 +2476,7 @@ async function aggregateCommand(worktreeId2, options) {
     if (options?.json) {
       output({ results: [] }, true);
     } else {
-      console.log("No completed agent results to aggregate.");
+      console.log("No agent results to aggregate.");
     }
     return;
   }
@@ -2447,20 +2505,18 @@ async function aggregateCommand(worktreeId2, options) {
   }
 }
 async function collectAgentResult(agent, projectRoot) {
-  try {
-    const content = await fs9.readFile(agent.resultFile, "utf-8");
-    return content;
-  } catch {
-  }
   try {
     const paneContent = await capturePane(agent.tmuxTarget, 500);
-    return `*[No result file \u2014 pane capture fallback]*
-
-\`\`\`
+    return `\`\`\`
 ${paneContent}
 \`\`\``;
   } catch {
-    return "*[No result file and pane not available]*";
+  }
+  try {
+    const content = await fs9.readFile(resultFile(projectRoot, agent.id), "utf-8");
+    return content;
+  } catch {
+    return "*[Pane not available and no legacy result file]*";
   }
 }
 var init_aggregate = __esm({
@@ -2470,6 +2526,7 @@ var init_aggregate = __esm({
     init_agent();
     init_worktree();
     init_tmux();
+    init_paths();
     init_errors();
     init_output();
   }
@@ -2490,7 +2547,7 @@ async function mergeCommand(worktreeId2, options) {
   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));
+  const incomplete = agents.filter((a) => a.status === "running");
   if (incomplete.length > 0 && !options.force) {
     const ids = incomplete.map((a) => a.id).join(", ");
     throw new PpgError(
@@ -2753,7 +2810,6 @@ async function spawnSwarmAgent(opts) {
     WORKTREE_PATH: wtPath,
     BRANCH: branchName,
     AGENT_ID: aId,
-    RESULT_FILE: resultFile(projectRoot, aId),
     PROJECT_ROOT: projectRoot,
     TASK_NAME: taskName,
     ...swarmAgent.vars ?? {},
@@ -3213,7 +3269,7 @@ async function restartCommand(agentRef, options) {
   const found = findAgent(manifest, agentRef);
   if (!found) throw new AgentNotFoundError(agentRef);
   const { worktree: wt, agent: oldAgent } = found;
-  if (["running", "spawning", "waiting"].includes(oldAgent.status)) {
+  if (oldAgent.status === "running") {
     info(`Killing existing agent ${oldAgent.id}`);
     await killAgent(oldAgent);
   }
@@ -3239,7 +3295,6 @@ async function restartCommand(agentRef, options) {
     WORKTREE_PATH: wt.path,
     BRANCH: wt.branch,
     AGENT_ID: newAgentId,
-    RESULT_FILE: resultFile(projectRoot, newAgentId),
     PROJECT_ROOT: projectRoot,
     TASK_NAME: wt.name,
     PROMPT: promptText
@@ -3254,16 +3309,14 @@ async function restartCommand(agentRef, options) {
     tmuxTarget: windowTarget,
     projectRoot,
     branch: wt.branch,
-    sessionId: newSessionId,
-    skipResultInstructions: !options.prompt
+    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();
+      if (mOldAgent && mOldAgent.status === "running") {
+        mOldAgent.status = "gone";
       }
       mWt.agents[newAgentId] = agentEntry;
     }
@@ -3366,7 +3419,6 @@ __export(pr_exports, {
   prCommand: () => prCommand,
   truncateBody: () => truncateBody
 });
-import fs15 from "fs/promises";
 import { execa as execa8 } from "execa";
 async function prCommand(worktreeRef, options) {
   const projectRoot = await getRepoRoot();
@@ -3441,16 +3493,11 @@ async function prCommand(worktreeRef, options) {
   }
 }
 async function buildBodyFromResults(agents) {
-  const reads = agents.map(async (agent) => {
-    try {
-      return await fs15.readFile(agent.resultFile, "utf-8");
-    } catch {
-      return null;
-    }
-  });
-  const contents = (await Promise.all(reads)).filter((c) => c !== null);
-  if (contents.length === 0) return "";
-  return truncateBody(contents.join("\n\n---\n\n"));
+  if (agents.length === 0) return "";
+  const sections = agents.map((a) => `## Agent: ${a.id}
+
+${a.prompt}`);
+  return truncateBody(sections.join("\n\n---\n\n"));
 }
 function truncateBody(body) {
   if (body.length <= MAX_BODY_LENGTH) return body;
@@ -3480,7 +3527,7 @@ function findAtRiskWorktrees(worktrees) {
   return worktrees.filter((wt) => {
     if (wt.status === "merged" || wt.status === "cleaned") return false;
     if (wt.prUrl) return false;
-    return Object.values(wt.agents).some((a) => a.status === "completed");
+    return Object.values(wt.agents).some((a) => a.status === "idle" || a.status === "exited");
   });
 }
 async function resetCommand(options) {
@@ -3517,7 +3564,7 @@ async function resetCommand(options) {
   const allAgents = [];
   for (const wt of worktrees) {
     for (const agent of Object.values(wt.agents)) {
-      if (["running", "spawning", "waiting"].includes(agent.status)) {
+      if (agent.status === "running") {
         allAgents.push(agent);
       }
     }
@@ -3539,12 +3586,10 @@ async function resetCommand(options) {
   }
   if (killedIds.length > 0) {
     await updateManifest(projectRoot, (m) => {
-      const now = (/* @__PURE__ */ new Date()).toISOString();
       for (const wt of Object.values(m.worktrees)) {
         for (const agent of Object.values(wt.agents)) {
           if (killedIds.includes(agent.id)) {
-            agent.status = "killed";
-            agent.completedAt = now;
+            agent.status = "gone";
           }
         }
       }
@@ -3847,9 +3892,9 @@ async function waitCommand(worktreeRef, options) {
     }
     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));
+    const allDone = agents.every((a) => a.status !== "running");
+    if (allDone) {
+      const anyFailed = agents.some((a) => a.status === "exited" && a.exitCode !== void 0 && a.exitCode !== 0);
       if (options.json) {
         output({
           timedOut: false,
@@ -3892,11 +3937,9 @@ function formatAgent(a) {
     status: a.status,
     agentType: a.agentType,
     exitCode: a.exitCode,
-    startedAt: a.startedAt,
-    completedAt: a.completedAt
+    startedAt: a.startedAt
   };
 }
-var TERMINAL_STATUSES;
 var init_wait = __esm({
   "src/commands/wait.ts"() {
     "use strict";
@@ -3905,7 +3948,6 @@ var init_wait = __esm({
     init_worktree();
     init_errors();
     init_output();
-    TERMINAL_STATUSES = ["completed", "failed", "killed", "lost"];
   }
 });
 
@@ -3915,18 +3957,34 @@ __export(worktree_exports, {
   worktreeCreateCommand: () => worktreeCreateCommand
 });
 async function worktreeCreateCommand(options) {
+  if (options.branch && options.base) {
+    throw new PpgError("--branch and --base are mutually exclusive (--base is for new branches)", "INVALID_ARGS");
+  }
   const projectRoot = await getRepoRoot();
   const config = await loadConfig(projectRoot);
   await requireManifest(projectRoot);
-  const baseBranch = options.base ?? await getCurrentBranch(projectRoot);
   const wtId = worktreeId();
-  const name = options.name ? normalizeName(options.name, wtId) : wtId;
-  const branchName = `ppg/${name}`;
-  info(`Creating worktree ${wtId} on branch ${branchName}`);
-  const wtPath = await createWorktree(projectRoot, wtId, {
-    branch: branchName,
-    base: baseBranch
-  });
+  let name;
+  let branchName;
+  let baseBranch;
+  let wtPath;
+  if (options.branch) {
+    branchName = options.branch;
+    const derivedName = branchName.startsWith("ppg/") ? branchName.slice(4) : branchName;
+    name = options.name ? normalizeName(options.name, wtId) : normalizeName(derivedName, wtId);
+    baseBranch = await getCurrentBranch(projectRoot);
+    info(`Creating worktree ${wtId} from existing branch ${branchName}`);
+    wtPath = await adoptWorktree(projectRoot, wtId, branchName);
+  } else {
+    baseBranch = options.base ?? await getCurrentBranch(projectRoot);
+    name = options.name ? normalizeName(options.name, wtId) : wtId;
+    branchName = `ppg/${name}`;
+    info(`Creating worktree ${wtId} on branch ${branchName}`);
+    wtPath = await createWorktree(projectRoot, wtId, {
+      branch: branchName,
+      base: baseBranch
+    });
+  }
   await setupWorktreeEnv(projectRoot, wtPath, config);
   const worktreeEntry = {
     id: wtId,
@@ -3968,6 +4026,7 @@ var init_worktree2 = __esm({
     init_worktree();
     init_env2();
     init_id();
+    init_errors();
     init_output();
     init_name();
   }
@@ -4162,14 +4221,14 @@ var init_install_dashboard = __esm({
 });
 
 // src/core/schedule.ts
-import fs16 from "fs/promises";
+import fs15 from "fs/promises";
 import YAML3 from "yaml";
 import { CronExpressionParser } from "cron-parser";
 async function loadSchedules(projectRoot) {
   const filePath = schedulesPath(projectRoot);
   let raw;
   try {
-    raw = await fs16.readFile(filePath, "utf-8");
+    raw = await fs15.readFile(filePath, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") {
       throw new PpgError("No schedules file found. Create .ppg/schedules.yaml first.", "INVALID_ARGS");
@@ -4254,16 +4313,16 @@ var init_schedule = __esm({
 });
 
 // src/core/cron.ts
-import fs17 from "fs/promises";
+import fs16 from "fs/promises";
 import { createReadStream } from "fs";
 import path11 from "path";
 import readline from "readline";
 import { execa as execa11 } from "execa";
 async function runCronDaemon(projectRoot) {
   const pidPath = cronPidPath(projectRoot);
-  await fs17.mkdir(path11.dirname(pidPath), { recursive: true });
-  await fs17.writeFile(pidPath, String(process.pid), "utf-8");
-  await fs17.mkdir(logsDir(projectRoot), { recursive: true });
+  await fs16.mkdir(path11.dirname(pidPath), { recursive: true });
+  await fs16.writeFile(pidPath, String(process.pid), "utf-8");
+  await fs16.mkdir(logsDir(projectRoot), { recursive: true });
   await logCron(projectRoot, "Cron daemon starting");
   let states = await loadScheduleStates(projectRoot);
   let lastConfigMtime = await getFileMtime(schedulesPath(projectRoot));
@@ -4274,7 +4333,7 @@ async function runCronDaemon(projectRoot) {
   const cleanup = async () => {
     await logCron(projectRoot, "Cron daemon stopping");
     try {
-      await fs17.unlink(pidPath);
+      await fs16.unlink(pidPath);
     } catch {
     }
     process.exit(0);
@@ -4318,7 +4377,7 @@ async function loadScheduleStates(projectRoot) {
 }
 async function getFileMtime(filePath) {
   try {
-    const stat = await fs17.stat(filePath);
+    const stat = await fs16.stat(filePath);
     return stat.mtimeMs;
   } catch {
     return 0;
@@ -4373,10 +4432,10 @@ async function logCron(projectRoot, message) {
 `;
   process.stdout.write(line);
   try {
-    await fs17.appendFile(logPath, line, "utf-8");
+    await fs16.appendFile(logPath, line, "utf-8");
   } catch {
-    await fs17.mkdir(logsDir(projectRoot), { recursive: true });
-    await fs17.appendFile(logPath, line, "utf-8");
+    await fs16.mkdir(logsDir(projectRoot), { recursive: true });
+    await fs16.appendFile(logPath, line, "utf-8");
   }
 }
 async function isCronRunning(projectRoot) {
@@ -4386,7 +4445,7 @@ async function getCronPid(projectRoot) {
   const pidPath = cronPidPath(projectRoot);
   let raw;
   try {
-    raw = await fs17.readFile(pidPath, "utf-8");
+    raw = await fs16.readFile(pidPath, "utf-8");
   } catch {
     return null;
   }
@@ -4405,14 +4464,14 @@ async function getCronPid(projectRoot) {
 }
 async function cleanupPidFile(pidPath) {
   try {
-    await fs17.unlink(pidPath);
+    await fs16.unlink(pidPath);
   } catch {
   }
 }
 async function readCronLog(projectRoot, lines = 20) {
   const logPath = cronLogPath(projectRoot);
   try {
-    await fs17.access(logPath);
+    await fs16.access(logPath);
   } catch {
     return [];
   }
@@ -4443,13 +4502,17 @@ var init_cron = __esm({
 // src/commands/cron.ts
 var cron_exports = {};
 __export(cron_exports, {
+  cronAddCommand: () => cronAddCommand,
   cronDaemonCommand: () => cronDaemonCommand,
   cronListCommand: () => cronListCommand,
+  cronRemoveCommand: () => cronRemoveCommand,
   cronStartCommand: () => cronStartCommand,
   cronStatusCommand: () => cronStatusCommand,
   cronStopCommand: () => cronStopCommand
 });
-import fs18 from "fs/promises";
+import fs17 from "fs/promises";
+import path12 from "path";
+import YAML4 from "yaml";
 async function cronStartCommand(options) {
   const projectRoot = await getRepoRoot();
   await requireInit(projectRoot);
@@ -4500,7 +4563,7 @@ async function cronStopCommand(options) {
   } catch {
   }
   try {
-    await fs18.unlink(cronPidPath(projectRoot));
+    await fs17.unlink(cronPidPath(projectRoot));
   } catch {
   }
   try {
@@ -4584,9 +4647,119 @@ async function cronDaemonCommand() {
   await requireInit(projectRoot);
   await runCronDaemon(projectRoot);
 }
+async function cronAddCommand(options) {
+  const projectRoot = options.project ?? await getRepoRoot();
+  await requireInit(projectRoot);
+  const SAFE_NAME3 = /^[\w-]+$/;
+  if (!options.name || !SAFE_NAME3.test(options.name)) {
+    throw new PpgError(
+      `Invalid schedule name "${options.name}" \u2014 must be alphanumeric, hyphens, or underscores`,
+      "INVALID_ARGS"
+    );
+  }
+  if (!options.swarm && !options.prompt) {
+    throw new PpgError("Must specify either --swarm or --prompt", "INVALID_ARGS");
+  }
+  if (options.swarm && options.prompt) {
+    throw new PpgError("Specify either --swarm or --prompt, not both", "INVALID_ARGS");
+  }
+  validateCronExpression(options.cron);
+  const entry = {
+    name: options.name,
+    cron: options.cron
+  };
+  if (options.swarm) entry.swarm = options.swarm;
+  if (options.prompt) entry.prompt = options.prompt;
+  if (options.var && options.var.length > 0) {
+    const vars = {};
+    for (const v of options.var) {
+      const eqIdx = v.indexOf("=");
+      if (eqIdx === -1) {
+        throw new PpgError(`Invalid --var format: "${v}" (expected KEY=VALUE)`, "INVALID_ARGS");
+      }
+      const key = v.slice(0, eqIdx);
+      if (key.length === 0) {
+        throw new PpgError(`Invalid --var format: "${v}" (key must not be empty)`, "INVALID_ARGS");
+      }
+      vars[key] = v.slice(eqIdx + 1);
+    }
+    entry.vars = vars;
+  }
+  const filePath = schedulesPath(projectRoot);
+  const ppgDirPath = path12.dirname(filePath);
+  await fs17.mkdir(ppgDirPath, { recursive: true });
+  await updateSchedulesFile(filePath, (config) => {
+    if (config.schedules.some((s) => s.name === options.name)) {
+      throw new PpgError(`Schedule "${options.name}" already exists`, "INVALID_ARGS");
+    }
+    config.schedules.push(entry);
+    return config;
+  });
+  if (options.json) {
+    output({ success: true, name: options.name, schedule: entry }, true);
+  } else {
+    success(`Schedule "${options.name}" added`);
+  }
+}
+async function cronRemoveCommand(options) {
+  const projectRoot = options.project ?? await getRepoRoot();
+  await requireInit(projectRoot);
+  const filePath = schedulesPath(projectRoot);
+  await updateSchedulesFile(filePath, (config) => {
+    const idx = config.schedules.findIndex((s) => s.name === options.name);
+    if (idx === -1) {
+      throw new PpgError(`Schedule "${options.name}" not found`, "INVALID_ARGS");
+    }
+    config.schedules.splice(idx, 1);
+    return config;
+  });
+  if (options.json) {
+    output({ success: true, name: options.name }, true);
+  } else {
+    success(`Schedule "${options.name}" removed`);
+  }
+}
+async function updateSchedulesFile(filePath, updater) {
+  const lockfile = await getLockfile();
+  const writeFileAtomic = await getWriteFileAtomic();
+  let release;
+  try {
+    release = await lockfile.lock(filePath, {
+      stale: 1e4,
+      retries: { retries: 5, minTimeout: 100, maxTimeout: 1e3 },
+      realpath: false
+    });
+  } catch {
+    throw new PpgError("Could not acquire lock on schedules.yaml", "MANIFEST_LOCK");
+  }
+  try {
+    let config;
+    try {
+      const raw = await fs17.readFile(filePath, "utf-8");
+      const parsed = YAML4.parse(raw);
+      if (!parsed || !Array.isArray(parsed.schedules)) {
+        throw new PpgError(
+          'Invalid schedules.yaml: missing or malformed "schedules" array. Fix the file manually or delete it to start fresh.',
+          "INVALID_ARGS"
+        );
+      }
+      config = parsed;
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        config = { schedules: [] };
+      } else {
+        throw err;
+      }
+    }
+    const updated = updater(config);
+    await writeFileAtomic(filePath, YAML4.stringify(updated));
+  } finally {
+    if (release) await release();
+  }
+}
 async function requireInit(projectRoot) {
   try {
-    await fs18.access(manifestPath(projectRoot));
+    await fs17.access(manifestPath(projectRoot));
   } catch {
     throw new NotInitializedError(projectRoot);
   }
@@ -4601,6 +4774,7 @@ var init_cron2 = __esm({
     init_cron();
     init_tmux();
     init_paths();
+    init_cjs_compat();
     init_errors();
     init_output();
     CRON_WINDOW_NAME = "ppg-cron";
@@ -4620,7 +4794,7 @@ program.command("init").description("Initialize Point Guard in the current git r
   const { initCommand: initCommand2 } = await Promise.resolve().then(() => (init_init(), init_exports));
   await initCommand2(options);
 });
-program.command("spawn").description("Spawn a new worktree and agent(s), or add agents to an existing worktree").option("-n, --name <name>", "Name for the worktree/task").option("-a, --agent <type>", "Agent type to use (default: claude)").option("-p, --prompt <text>", "Prompt text for the agent").option("-f, --prompt-file <path>", "File containing the prompt").option("-t, --template <name>", "Template name from .ppg/templates/").option("--var <key=value...>", "Template variables", collectVars, []).option("-b, --base <branch>", "Base branch for the worktree").option("-w, --worktree <id>", "Add agent to existing worktree").option("-c, --count <n>", "Number of agents to spawn", parsePositiveInt("count"), 1).option("--split", "Put all agents in one window as split panes").option("--open", "Open a Terminal window for the spawned agents").option("--json", "Output as JSON").action(async (options) => {
+program.command("spawn").description("Spawn a new worktree and agent(s), or add agents to an existing worktree").option("-n, --name <name>", "Name for the worktree/task").option("-a, --agent <type>", "Agent type to use (default: claude)").option("-p, --prompt <text>", "Prompt text for the agent").option("-f, --prompt-file <path>", "File containing the prompt").option("-t, --template <name>", "Template name from .ppg/templates/").option("--var <key=value...>", "Template variables", collectVars, []).option("-b, --base <branch>", "Base branch for the worktree").option("--branch <name>", "Check out an existing branch into a new worktree").option("-w, --worktree <id>", "Add agent to existing worktree").option("-c, --count <n>", "Number of agents to spawn", parsePositiveInt("count"), 1).option("--split", "Put all agents in one window as split panes").option("--open", "Open a Terminal window for the spawned agents").option("--json", "Output as JSON").action(async (options) => {
   const { spawnCommand: spawnCommand2 } = await Promise.resolve().then(() => (init_spawn(), spawn_exports));
   await spawnCommand2(options);
 });
@@ -4640,11 +4814,11 @@ program.command("logs").description("View agent pane output").argument("<agent-i
   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) => {
+program.command("aggregate").description("Aggregate results from agents (captures pane output)").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) => {
+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 still running").option("--json", "Output as JSON").action(async (worktreeId2, options) => {
   const { mergeCommand: mergeCommand2 } = await Promise.resolve().then(() => (init_merge(), merge_exports));
   await mergeCommand2(worktreeId2, options);
 });
@@ -4660,7 +4834,7 @@ program.command("list").description("List available templates, swarms, or prompt
   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("--open", "Open a Terminal window for the restarted agent").option("--json", "Output as JSON").action(async (agentId2, options) => {
+program.command("restart").description("Restart an agent in the same worktree").argument("<agent-id>", "Agent ID to restart").option("-p, --prompt <text>", "Override the original prompt").option("-a, --agent <type>", "Override the agent type").option("--open", "Open a Terminal window for the restarted agent").option("--json", "Output as JSON").action(async (agentId2, options) => {
   const { restartCommand: restartCommand2 } = await Promise.resolve().then(() => (init_restart(), restart_exports));
   await restartCommand2(agentId2, options);
 });
@@ -4689,7 +4863,7 @@ program.command("wait").description("Wait for agents to reach terminal state").a
   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) => {
+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("--branch <name>", "Check out an existing branch into a new worktree").option("--json", "Output as JSON").action(async (options) => {
   const { worktreeCreateCommand: worktreeCreateCommand2 } = await Promise.resolve().then(() => (init_worktree2(), worktree_exports));
   await worktreeCreateCommand2(options);
 });
@@ -4722,6 +4896,14 @@ cronCmd.command("_daemon", { hidden: true }).description("Internal: run the cron
   const { cronDaemonCommand: cronDaemonCommand2 } = await Promise.resolve().then(() => (init_cron2(), cron_exports));
   await cronDaemonCommand2();
 });
+cronCmd.command("add").description("Add a new schedule entry").requiredOption("--name <name>", "Schedule name").requiredOption("--cron <expression>", "Cron expression").option("--swarm <name>", "Swarm template name").option("--prompt <name>", "Prompt template name").option("--var <key=value...>", "Template variables", collectVars, []).option("--project <path>", "Project root path").option("--json", "Output as JSON").action(async (options) => {
+  const { cronAddCommand: cronAddCommand2 } = await Promise.resolve().then(() => (init_cron2(), cron_exports));
+  await cronAddCommand2(options);
+});
+cronCmd.command("remove").description("Remove a schedule entry").requiredOption("--name <name>", "Schedule name to remove").option("--project <path>", "Project root path").option("--json", "Output as JSON").action(async (options) => {
+  const { cronRemoveCommand: cronRemoveCommand2 } = await Promise.resolve().then(() => (init_cron2(), cron_exports));
+  await cronRemoveCommand2(options);
+});
 program.exitOverride();
 function collectVars(value, previous) {
   return previous.concat([value]);