prloom 0.1.2 → 0.1.4

package/README.md

@@ -4,12 +4,12 @@
 
 You write a plan (a Markdown checklist), `prloom` turns it into a dedicated git worktree + branch, opens a draft PR, and then iterates one TODO at a time using a configurable coding agent. Review happens in GitHub: comments and review submissions are triaged into new TODOs and pushed back onto the same PR.
 
-`prloom` is designed to be safe to run from multiple clones: all runtime state lives in `.prloom/` (gitignored), so each developer can run their own dispatcher against the PRs they create/track in their local state.
+`prloom` is designed to be safe to run from multiple clones: all runtime state lives in `prloom/.local/` (gitignored), so each developer can run their own dispatcher against the PRs they create/track in their local state.
 
 ## How It Works
 
-- Plans start locally in `.prloom/inbox/` (gitignored; clean `git status`).
-- The dispatcher ingests a plan into a new branch/worktree at `plans/<id>.md` and opens a draft PR.
+- Plans start locally in `prloom/.local/inbox/` (gitignored; clean `git status`).
+- The dispatcher ingests a plan into a new branch/worktree at `prloom/plans/<id>.md` and opens a draft PR.
 - The worker agent executes exactly one TODO per iteration and updates the plan in-branch.
 - PR comments/reviews trigger a triage agent which updates the plan with new TODOs and posts a reply.
 - When all TODOs are complete, the PR is marked ready; you merge when satisfied.
@@ -88,13 +88,13 @@ bun run build
    - `npx -y prloom new my-feature`
 3. Start the dispatcher:
    - `npx -y prloom start`
-3. Review the draft PR in GitHub.
-4. Leave PR comments or a review; `prloom` triages feedback into TODOs.
-5. When the PR is ready, merge it.
+4. Review the draft PR in GitHub.
+5. Leave PR comments or a review; `prloom` triages feedback into TODOs.
+6. When the PR is ready, merge it.
 
 ## Configuration
 
-Create `prloom.config.json` in the repo root:
+Create `prloom/config.json`:
 
 ```json
 {
@@ -102,13 +102,32 @@ Create `prloom.config.json` in the repo root:
     "default": "opencode",
     "designer": "codex"
   },
-  "worktrees_dir": ".prloom/worktrees",
+  "worktrees_dir": "prloom/.local/worktrees",
   "poll_interval_ms": 60000,
   "base_branch": "main"
 }
 ```
 
+## Repository Context
+
+You can provide repository-specific context to agents by creating markdown files in the `prloom/` directory:
+
+```
+repo/
+├── prloom/
+│   ├── config.json   # Configuration
+│   ├── plans/        # Committed plans (on PR branches)
+│   ├── planner.md    # Appended to designer prompts
+│   ├── worker.md     # Appended to worker prompts
+│   └── .local/       # Gitignored (runtime state)
+```
+
+- **`prloom/planner.md`**: Architecture info, coding conventions, design patterns
+- **`prloom/worker.md`**: Build commands, test patterns, implementation guidelines
+
+These files are appended to the respective agent prompts automatically.
+
 ## Notes
 
-- Runtime state is stored under `.prloom/` (gitignored).
-- The plan file is committed on the PR branch at `plans/<id>.md` and lands on the configured `base_branch` only when you merge the PR.
+- Runtime state is stored under `prloom/.local/` (gitignored).
+- The plan file is committed on the PR branch at `prloom/plans/<id>.md` and lands on the configured `base_branch` when you merge the PR.

package/dist/cli/index.js

@@ -7238,14 +7238,46 @@ var init_execa = __esm(() => {
   } = getIpcExport());
 });
 
+// src/lib/adapters/tmux.ts
+async function waitForTmuxSession(sessionName) {
+  while (true) {
+    const { exitCode } = await execa("tmux", ["has-session", "-t", sessionName], {
+      reject: false
+    });
+    if (exitCode !== 0) {
+      return;
+    }
+    await new Promise((resolve5) => setTimeout(resolve5, 1000));
+  }
+}
+var init_tmux = __esm(() => {
+  init_execa();
+});
+
 // src/lib/adapters/codex.ts
 var codexAdapter;
 var init_codex = __esm(() => {
   init_execa();
+  init_tmux();
   codexAdapter = {
     name: "codex",
-    async execute({ cwd, prompt }) {
-      const result = await execa("codex", ["exec", prompt, "--full-auto"], {
+    async execute({ cwd, prompt, tmux }) {
+      const args = ["exec", prompt, "--full-auto"];
+      if (tmux) {
+        await execa("tmux", [
+          "new-session",
+          "-d",
+          "-s",
+          tmux.sessionName,
+          "-c",
+          cwd,
+          "codex",
+          ...args
+        ], { reject: false });
+        await waitForTmuxSession(tmux.sessionName);
+        return { exitCode: 0 };
+      }
+      const result = await execa("codex", args, {
         cwd,
         timeout: 0,
         reject: false
@@ -7266,9 +7298,25 @@ var init_codex = __esm(() => {
 var opencodeAdapter;
 var init_opencode = __esm(() => {
   init_execa();
+  init_tmux();
   opencodeAdapter = {
     name: "opencode",
-    async execute({ cwd, prompt }) {
+    async execute({ cwd, prompt, tmux }) {
+      if (tmux) {
+        await execa("tmux", [
+          "new-session",
+          "-d",
+          "-s",
+          tmux.sessionName,
+          "-c",
+          cwd,
+          "opencode",
+          "run",
+          prompt
+        ], { reject: false });
+        await waitForTmuxSession(tmux.sessionName);
+        return { exitCode: 0 };
+      }
       const result = await execa("opencode", ["run", prompt], {
         cwd,
         timeout: 0,
@@ -7290,10 +7338,26 @@ var init_opencode = __esm(() => {
 var claudeAdapter;
 var init_claude = __esm(() => {
   init_execa();
+  init_tmux();
   claudeAdapter = {
     name: "claude",
-    async execute({ cwd, prompt }) {
-      const result = await execa("claude", ["-p", prompt, "--dangerously-skip-permissions"], {
+    async execute({ cwd, prompt, tmux }) {
+      const args = ["-p", prompt, "--dangerously-skip-permissions"];
+      if (tmux) {
+        await execa("tmux", [
+          "new-session",
+          "-d",
+          "-s",
+          tmux.sessionName,
+          "-c",
+          cwd,
+          "claude",
+          ...args
+        ], { reject: false });
+        await waitForTmuxSession(tmux.sessionName);
+        return { exitCode: 0 };
+      }
+      const result = await execa("claude", args, {
         cwd,
         timeout: 0,
         reject: false
@@ -7314,7 +7378,7 @@ var manualAdapter;
 var init_manual = __esm(() => {
   manualAdapter = {
     name: "manual",
-    async execute({ cwd, prompt }) {
+    async execute({ cwd, prompt, tmux }) {
       console.log("⚠️  Manual agent: execute() called but should be skipped by dispatcher.");
       console.log("   This plan is intended for IDE-driven execution.");
       return { exitCode: 0 };
@@ -7357,7 +7421,7 @@ var init_adapters = __esm(() => {
 import { join as join2, resolve as resolve5 } from "path";
 import { existsSync, readFileSync as readFileSync6 } from "fs";
 function loadConfig(repoRoot) {
-  const configPath = join2(repoRoot, "prloom.config.json");
+  const configPath = join2(repoRoot, "prloom", "config.json");
   if (!existsSync(configPath)) {
     return { ...DEFAULTS };
   }
@@ -7394,7 +7458,7 @@ var init_config = __esm(() => {
     agents: {
       default: "opencode"
     },
-    worktrees_dir: ".prloom/worktrees",
+    worktrees_dir: "prloom/.local/worktrees",
     poll_interval_ms: 60000,
     base_branch: "main"
   };
@@ -7415,7 +7479,9 @@ async function runInit(cwd, opts = {}) {
   await ensureGhAuthed();
   await ensureGhRepoResolvable(repoRoot);
   const defaultBranch = await detectDefaultBranch(repoRoot);
-  const configPath = join3(repoRoot, "prloom.config.json");
+  const configPath = join3(repoRoot, "prloom", "config.json");
+  const prloomDir = join3(repoRoot, "prloom");
+  mkdirSync(prloomDir, { recursive: true });
   if (!existsSync2(configPath) || opts.force) {
     const existing = loadConfig(repoRoot);
     const config = {
@@ -7430,12 +7496,14 @@ async function runInit(cwd, opts = {}) {
   } else {
     console.log(`Found existing ${configPath} (leaving unchanged)`);
   }
-  const prloomDir = join3(repoRoot, ".prloom");
-  const inboxDir = join3(prloomDir, "inbox");
-  const plansDir = join3(prloomDir, "plans");
+  const localDir = join3(prloomDir, ".local");
+  const inboxDir = join3(localDir, "inbox");
+  const plansStateDir = join3(localDir, "plans");
   mkdirSync(inboxDir, { recursive: true });
+  mkdirSync(plansStateDir, { recursive: true });
+  const plansDir = join3(prloomDir, "plans");
   mkdirSync(plansDir, { recursive: true });
-  await ensureGitignoreEntry(repoRoot, ".prloom/");
+  await ensureGitignoreEntry(repoRoot, "prloom/.local/");
   console.log("✅ prloom initialized");
   console.log(`Base branch: ${defaultBranch}`);
   if (!opts.yes) {
@@ -11138,7 +11206,7 @@ ${plan.progressLog}`;
 function generatePlanSkeleton(id, agent, baseBranch) {
   const frontmatter = {
     id,
-    status: "queued"
+    status: "draft"
   };
   if (agent) {
     frontmatter.agent = agent;
@@ -16834,11 +16902,10 @@ You are implementing exactly ONE task from this plan.
 
 You are processing PR feedback for an active plan. Your job is to:
 
-1. Analyze all review feedback (comments, reviews, inline comments)
-2. Create specific, actionable TODO items for the plan
-3. Group related feedback into fewer tasks where appropriate
+1. **Classify** each feedback item by type
+2. **Respond** appropriately based on the type
+3. **Update** the plan if changes are needed
 4. Detect if a rebase was requested
-5. Compose a reply message for the reviewer(s)
 
 ## Feedback to Process
 
@@ -16848,9 +16915,36 @@ You are processing PR feedback for an active plan. Your job is to:
 
 {{plan}}
 
-## Instructions
+---
+
+## Step 1: Classify Each Feedback Item
+
+Before acting, identify the type of each feedback item:
+
+| Type                | Description                                   | Action                   |
+| ------------------- | --------------------------------------------- | ------------------------ |
+| **Question**        | Asking "why", "how", or seeking clarification | Answer in reply, NO TODO |
+| **Change Request**  | Asking for code modifications                 | Create specific TODO     |
+| **Approval/Praise** | Positive feedback, LGTM, approval             | Acknowledge briefly      |
+| **Process Request** | Rebase, update branch, etc.                   | Set flag, acknowledge    |
+
+## Step 2: Handle Each Type
+
+### Questions → Answer Directly
+
+For questions, **answer them substantively in your reply**:
+
+- Explore the codebase to find the answer if needed
+- Explain the reasoning behind implementation decisions
+- Reference specific code locations or commits if helpful
+- Do NOT create a TODO like "answer the question" - just answer it
 
-### Adding TODOs
+Example question: "Why did you use a polling approach instead of webhooks?"
+→ Reply with the actual reasoning, don't create a TODO.
+
+### Change Requests → Create TODOs
+
+For explicit requests to modify code:
 
 - Edit the plan file directly to add actionable TODOs
 - Add them at the end of the ## TODO section
@@ -16860,13 +16954,23 @@ You are processing PR feedback for an active plan. Your job is to:
   - "Update function X to handle null input"
   - "Add test for Y edge case"
   - "Rename Z for clarity"
-  - "Remove deprecated code in file A"
-- Group related comments into single tasks when logical
+- Group related requests into single tasks when logical
 - If the plan status is \`done\` and you add TODOs, change status to \`active\`
 
-### Writing the Result File
+### Approval/Praise → Acknowledge
+
+Simply thank the reviewer in your reply. No TODO needed.
+
+### Process Requests → Set Flag
+
+If any comment mentions rebase, update branch, or similar:
+
+- Set \`rebase_requested: true\` in the result file
+- Acknowledge in your reply
 
-After editing the plan, you MUST write \`.prloom/triage-result.json\` with:
+## Step 3: Write the Result File
+
+After processing, you MUST write \`prloom/.local/triage-result.json\`:
 
 \`\`\`json
 {
@@ -16877,22 +16981,23 @@ After editing the plan, you MUST write \`.prloom/triage-result.json\` with:
 
 **Required fields:**
 
-- \`reply_markdown\`: Your response to post on the PR (ALWAYS required, even for no-ops)
-- \`rebase_requested\`: Set to \`true\` if any comment mentions rebase, update branch, or similar
+- \`reply_markdown\`: Your response to post on the PR (ALWAYS required)
+- \`rebase_requested\`: Set to \`true\` if rebase was requested
 
 ### Reply Guidelines
 
 - Be polite and professional
-- Acknowledge specific feedback points
-- Explain what TODOs were created
-- If no changes needed, explain why
-- Keep it concise
+- **Answer questions directly** - this is the most important part
+- Explain what TODOs were created (if any)
+- If a request doesn't require changes, explain why
+- Keep it concise but complete
 
 ## Critical Rules
 
-1. You MUST write \`.prloom/triage-result.json\` even if you add no TODOs
+1. You MUST write \`prloom/.local/triage-result.json\` even if you add no TODOs
 2. The result file must contain valid JSON only, no markdown wrapper
 3. Failure to write the result file will mark the plan as blocked
+4. **Questions should be answered, not converted to TODOs**
 `
   };
 });
@@ -16903,32 +17008,72 @@ import { join as join4 } from "path";
 function loadTemplate(_repoRoot, name) {
   return BUILTIN_PROMPTS[name];
 }
+function loadAgentContext(repoRoot, agentType) {
+  const contextPath = join4(repoRoot, "prloom", `${agentType}.md`);
+  if (!existsSync3(contextPath)) {
+    return "";
+  }
+  return readFileSync9(contextPath, "utf-8");
+}
 function renderWorkerPrompt(repoRoot, plan, todo) {
   const template = loadTemplate(repoRoot, "worker");
   const compiled = import_handlebars.default.compile(template);
-  return compiled({
+  let prompt = compiled({
     current_todo: `TODO #${todo.index}: ${todo.text}`,
     plan: plan.raw
   });
+  const context = loadAgentContext(repoRoot, "worker");
+  if (context) {
+    prompt += `
+
+---
+
+# Repository Context
+
+${context}`;
+  }
+  return prompt;
 }
 function renderDesignerNewPrompt(repoPath, planPath, baseBranch, workerAgent, userDescription) {
   const template = BUILTIN_PROMPTS["designer_new"];
   const compiled = import_handlebars.default.compile(template);
-  return compiled({
+  let prompt = compiled({
     repo_path: repoPath,
     plan_path: planPath,
     base_branch: baseBranch,
     worker_agent: workerAgent,
     user_description: userDescription ?? ""
   });
+  const context = loadAgentContext(repoPath, "planner");
+  if (context) {
+    prompt += `
+
+---
+
+# Repository Context
+
+${context}`;
+  }
+  return prompt;
 }
-function renderDesignerEditPrompt(planPath, existingPlan) {
+function renderDesignerEditPrompt(repoPath, planPath, existingPlan) {
   const template = BUILTIN_PROMPTS["designer_edit"];
   const compiled = import_handlebars.default.compile(template);
-  return compiled({
+  let prompt = compiled({
     plan_path: planPath,
     existing_plan: existingPlan
   });
+  const context = loadAgentContext(repoPath, "planner");
+  if (context) {
+    prompt += `
+
+---
+
+# Repository Context
+
+${context}`;
+  }
+  return prompt;
 }
 function renderTriagePrompt(repoRoot, plan, feedback) {
   const template = loadTemplate(repoRoot, "review_triage");
@@ -16944,6 +17089,10 @@ ${f.body}`;
       entry += `
 
 *Review: ${f.reviewState}*`;
+    if (f.inReplyToId)
+      entry += `
+
+*In reply to comment #${f.inReplyToId}*`;
     return entry;
   }).join(`
 
@@ -16975,7 +17124,7 @@ function readTriageResultFile(worktreePath) {
     rebase_requested: result.rebase_requested
   };
 }
-var import_handlebars, TRIAGE_RESULT_FILE = ".prloom/triage-result.json";
+var import_handlebars, TRIAGE_RESULT_FILE = "prloom/.local/triage-result.json";
 var init_template2 = __esm(() => {
   init_prompt_sources();
   import_handlebars = __toESM(require_lib(), 1);
@@ -17110,7 +17259,7 @@ function deleteInboxPlan(repoRoot, planId) {
     unlinkSync2(inboxPath);
   }
 }
-var SWARM_DIR = ".prloom", STATE_FILE = "state.json", LOCK_FILE = "lock", PLANS_DIR = "plans", INBOX_DIR = "inbox";
+var SWARM_DIR = "prloom/.local", STATE_FILE = "state.json", LOCK_FILE = "lock", PLANS_DIR = "plans", INBOX_DIR = "inbox";
 var init_state = () => {};
 
 // node_modules/nanoid/url-alphabet/index.js
@@ -17237,7 +17386,7 @@ function copyFileToWorktree(srcPath, worktreePath, destRelPath) {
   copyFileSync(srcPath, destPath);
 }
 function ensureWorktreePrloomDir(worktreePath) {
-  const prloomDir = join6(worktreePath, ".prloom");
+  const prloomDir = join6(worktreePath, "prloom", ".local");
   if (!existsSync5(prloomDir)) {
     mkdirSync3(prloomDir, { recursive: true });
   }
@@ -17247,6 +17396,23 @@ var init_git = __esm(() => {
   init_nanoid();
 });
 
+// src/cli/prompt.ts
+import * as readline from "readline";
+function confirm(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve6) => {
+    rl.question(`${message} (y/N) `, (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      resolve6(normalized === "y" || normalized === "yes");
+    });
+  });
+}
+var init_prompt = () => {};
+
 // src/cli/new.ts
 var exports_new = {};
 __export(exports_new, {
@@ -17284,8 +17450,8 @@ async function runNew(repoRoot, planId, agentOverride, noDesigner) {
   console.log(`Worker agent: ${workerAgent}`);
   if (noDesigner) {
     console.log("");
-    console.log("Plan skeleton created. Edit manually or use your IDE.");
-    console.log("Run 'prloom start' to dispatch when ready.");
+    console.log("Plan skeleton created (status: draft).");
+    console.log("Use 'prloom edit' to design, then queue for dispatch.");
     return;
   }
   const adapter = getAdapter(designerAgent);
@@ -17294,8 +17460,15 @@ async function runNew(repoRoot, planId, agentOverride, noDesigner) {
   console.log("Starting Designer session to fill in the plan...");
   const prompt = renderDesignerNewPrompt(repoRoot, planPath, baseBranch, workerAgent);
   await adapter.interactive({ cwd: repoRoot, prompt });
+  console.log("");
   console.log("Designer session ended.");
-  console.log("Plan is now in inbox. Run 'prloom start' to dispatch.");
+  const shouldQueue = await confirm("Queue this plan for the dispatcher?");
+  if (shouldQueue) {
+    setStatus(planPath, "queued");
+    console.log("Plan queued. Run 'prloom start' to dispatch.");
+  } else {
+    console.log("Plan left as draft. Use 'prloom edit' to continue later.");
+  }
 }
 var init_new = __esm(() => {
   init_config();
@@ -17304,6 +17477,7 @@ var init_new = __esm(() => {
   init_template2();
   init_state();
   init_git();
+  init_prompt();
 });
 
 // src/cli/edit.ts
@@ -17319,9 +17493,11 @@ async function runEdit(repoRoot, planId, agentOverride, noDesigner) {
   const inboxPath = getInboxPath(repoRoot, planId);
   let planPath;
   let cwd;
+  let isInbox = false;
   if (existsSync7(inboxPath)) {
     planPath = inboxPath;
     cwd = repoRoot;
+    isInbox = true;
     console.log(`Editing inbox plan: ${planId}`);
   } else {
     const ps = state.plans[planId];
@@ -17349,15 +17525,30 @@ async function runEdit(repoRoot, planId, agentOverride, noDesigner) {
   const agentName = agentOverride ?? config.agents.designer ?? config.agents.default;
   const adapter = getAdapter(agentName);
   console.log(`Agent: ${agentName}`);
-  const prompt = renderDesignerEditPrompt(planPath, existingPlan);
+  const prompt = renderDesignerEditPrompt(cwd, planPath, existingPlan);
   await adapter.interactive({ cwd, prompt });
+  console.log("");
   console.log("Designer session ended.");
+  if (isInbox) {
+    const plan = parsePlan(planPath);
+    if (plan.frontmatter.status === "draft") {
+      const shouldQueue = await confirm("Queue this plan for the dispatcher?");
+      if (shouldQueue) {
+        setStatus(planPath, "queued");
+        console.log("Plan queued. Run 'prloom start' to dispatch.");
+      } else {
+        console.log("Plan left as draft.");
+      }
+    }
+  }
 }
 var init_edit = __esm(() => {
   init_config();
   init_adapters();
   init_template2();
   init_state();
+  init_plan();
+  init_prompt();
 });
 
 // src/lib/ipc.ts
@@ -17375,10 +17566,10 @@ import {
   mkdirSync as mkdirSync4
 } from "fs";
 function getControlPath(repoRoot) {
-  return join8(repoRoot, ".prloom", CONTROL_FILE);
+  return join8(repoRoot, "prloom", ".local", CONTROL_FILE);
 }
 function enqueue(repoRoot, cmd) {
-  const prloomDir = join8(repoRoot, ".prloom");
+  const prloomDir = join8(repoRoot, "prloom", ".local");
   if (!existsSync8(prloomDir)) {
     mkdirSync4(prloomDir, { recursive: true });
   }
@@ -17508,7 +17699,7 @@ async function getPRReviewComments(repoRoot, prNumber) {
     "api",
     `repos/{owner}/{repo}/pulls/${prNumber}/comments`,
     "--jq",
-    ".[] | {id: .id, author: .user.login, body: .body, path: .path, line: .line, createdAt: .created_at}"
+    ".[] | {id: .id, author: .user.login, body: .body, path: .path, line: .line, createdAt: .created_at, inReplyToId: .in_reply_to_id}"
   ], { cwd: repoRoot });
   if (!stdout.trim())
     return [];
@@ -17522,7 +17713,8 @@ async function getPRReviewComments(repoRoot, prNumber) {
       body: obj.body,
       path: obj.path,
       line: obj.line,
-      createdAt: obj.createdAt
+      createdAt: obj.createdAt,
+      inReplyToId: obj.inReplyToId || undefined
     };
   });
 }
@@ -17582,7 +17774,7 @@ __export(exports_dispatcher, {
 });
 import { join as join9 } from "path";
 import { existsSync as existsSync9, statSync as statSync5 } from "fs";
-async function runDispatcher(repoRoot) {
+async function runDispatcher(repoRoot, options2 = {}) {
   const config = loadConfig(repoRoot);
   const worktreesDir = resolveWorktreesDir(repoRoot, config);
   acquireLock(repoRoot);
@@ -17610,7 +17802,7 @@ async function runDispatcher(repoRoot) {
         await handleCommand2(state, cmd);
       }
       await ingestInboxPlans(repoRoot, worktreesDir, config, state);
-      await processActivePlans(repoRoot, config, state, botLogin);
+      await processActivePlans(repoRoot, config, state, botLogin, options2);
       saveState(repoRoot, state);
       await sleepUntilIpcOrTimeout(repoRoot, state.control_cursor, config.poll_interval_ms);
     } catch (error) {
@@ -17629,11 +17821,14 @@ async function ingestInboxPlans(repoRoot, worktreesDir, config, state) {
         console.error(`ID mismatch: file ${planId}.md has id: ${plan.frontmatter.id}, skipping`);
         continue;
       }
+      if (plan.frontmatter.status === "draft") {
+        continue;
+      }
       console.log(`\uD83D\uDCE5 Ingesting inbox plan: ${planId}`);
       const baseBranch = plan.frontmatter.base_branch ?? config.base_branch;
       const branch = await createBranchName(planId);
       const worktreePath = await createWorktree(repoRoot, worktreesDir, branch, baseBranch);
-      const planRelpath = `plans/${planId}.md`;
+      const planRelpath = `prloom/plans/${planId}.md`;
       copyFileToWorktree(inboxPath, worktreePath, planRelpath);
       const worktreePlanPath = join9(worktreePath, planRelpath);
       setStatus(worktreePlanPath, "active");
@@ -17667,7 +17862,7 @@ function getFeedbackPollDecision(opts) {
     shouldUpdateLastPolledAt: !pollOnce && shouldPoll
   };
 }
-async function processActivePlans(repoRoot, config, state, botLogin) {
+async function processActivePlans(repoRoot, config, state, botLogin, options2 = {}) {
   for (const [planId, ps] of Object.entries(state.plans)) {
     try {
       const planPath = join9(ps.worktree, ps.planRelpath);
@@ -17702,7 +17897,7 @@ async function processActivePlans(repoRoot, config, state, botLogin) {
           if (newFeedback.length > 0) {
             console.log(`\uD83D\uDCAC ${newFeedback.length} new feedback for ${planId}`);
             if (!isManualAgent) {
-              await runTriage(repoRoot, config, ps, plan, newFeedback);
+              await runTriage(repoRoot, config, ps, plan, newFeedback, options2);
             }
             plan = parsePlan(planPath);
             const maxIds = getMaxFeedbackIds(newFeedback);
@@ -17725,7 +17920,15 @@ async function processActivePlans(repoRoot, config, state, botLogin) {
           const prompt = renderWorkerPrompt(repoRoot, plan, todo);
           const agentName = plan.frontmatter.agent ?? config.agents.default;
           const adapter = getAdapter(agentName);
-          await adapter.execute({ cwd: ps.worktree, prompt });
+          const tmuxConfig = options2.tmux ? { sessionName: `prloom-${planId}` } : undefined;
+          if (tmuxConfig) {
+            ps.tmuxSession = tmuxConfig.sessionName;
+            console.log(`   [spawned in tmux session: ${tmuxConfig.sessionName}]`);
+          }
+          await adapter.execute({ cwd: ps.worktree, prompt, tmux: tmuxConfig });
+          if (tmuxConfig) {
+            ps.tmuxSession = undefined;
+          }
           const committed = await commitAll(ps.worktree, `[prloom] ${planId}: TODO #${todo.index}`);
           if (committed) {
             await push(ps.worktree, ps.branch);
@@ -17773,13 +17976,14 @@ async function pollNewFeedback(repoRoot, ps, botLogin) {
   };
   return filterNewFeedback(allFeedback, cursors, botLogin);
 }
-async function runTriage(repoRoot, config, ps, plan, feedback) {
+async function runTriage(repoRoot, config, ps, plan, feedback, options2 = {}) {
   ensureWorktreePrloomDir(ps.worktree);
   const triageAgent = config.agents.designer ?? config.agents.default;
   const adapter = getAdapter(triageAgent);
   const prompt = renderTriagePrompt(repoRoot, plan, feedback);
   console.log(`\uD83D\uDD0D Running triage for ${plan.frontmatter.id}...`);
-  await adapter.execute({ cwd: ps.worktree, prompt });
+  const tmuxConfig = options2.tmux ? { sessionName: `prloom-triage-${plan.frontmatter.id}` } : undefined;
+  await adapter.execute({ cwd: ps.worktree, prompt, tmux: tmuxConfig });
   try {
     const result = readTriageResultFile(ps.worktree);
     if (result.rebase_requested) {
@@ -17789,12 +17993,44 @@ async function runTriage(repoRoot, config, ps, plan, feedback) {
         const planPath = join9(ps.worktree, ps.planRelpath);
         setStatus(planPath, "blocked");
         ps.lastError = `Rebase conflict: ${rebaseResult.conflictFiles?.join(", ")}`;
-        await postPRComment(repoRoot, ps.pr, `⚠️ Rebase conflict detected:
+        await postPRComment(repoRoot, ps.pr, `⚠️ **Rebase conflict detected**
+
+The following files have conflicts:
 \`\`\`
 ${rebaseResult.conflictFiles?.join(`
 `)}
 \`\`\`
-Please resolve manually.`);
+
+**To resolve:**
+
+1. Navigate to the worktree:
+   \`\`\`
+   cd ${ps.worktree}
+   \`\`\`
+
+2. Fetch and rebase manually:
+   \`\`\`
+   git fetch origin ${ps.baseBranch}
+   git rebase origin/${ps.baseBranch}
+   \`\`\`
+
+3. Resolve conflicts in your editor, then:
+   \`\`\`
+   git add .
+   git rebase --continue
+   \`\`\`
+
+4. Force push the resolved branch:
+   \`\`\`
+   git push --force-with-lease
+   \`\`\`
+
+5. Unblock the plan:
+   \`\`\`
+   prloom unpause ${plan.frontmatter.id}
+   \`\`\`
+
+The plan is now **blocked** until conflicts are resolved.`);
       } else if (rebaseResult.success) {
         await forcePush(ps.worktree, ps.branch);
         console.log(`  Rebased and force-pushed`);
@@ -17993,6 +18229,35 @@ var init_open = __esm(() => {
   init_adapters();
 });
 
+// src/cli/watch.ts
+var exports_watch = {};
+__export(exports_watch, {
+  runWatch: () => runWatch
+});
+async function runWatch(repoRoot, planId) {
+  const state = loadState(repoRoot);
+  const ps = state.plans[planId];
+  if (!ps) {
+    console.error(`Plan not found in state: ${planId}`);
+    console.error("Make sure the plan has been dispatched at least once.");
+    process.exit(1);
+  }
+  if (!ps.tmuxSession) {
+    console.error(`No active tmux session for ${planId}`);
+    console.error("This plan may not be running, or dispatcher wasn't started with --tmux");
+    process.exit(1);
+  }
+  console.log(`Attaching to ${ps.tmuxSession} (read-only)...`);
+  console.log("Press Ctrl+B D to detach without interrupting the worker.");
+  await execa("tmux", ["attach", "-t", ps.tmuxSession, "-r"], {
+    stdio: "inherit"
+  });
+}
+var init_watch = __esm(() => {
+  init_execa();
+  init_state();
+});
+
 // src/cli/logs.ts
 var exports_logs = {};
 __export(exports_logs, {
@@ -18139,8 +18404,8 @@ async function runClean(repoRoot) {
   console.log("");
   console.log(`Found ${planIds.length} plan(s) in inbox.`);
   console.log("");
-  const readline = await import("readline");
-  const rl = readline.createInterface({
+  const readline2 = await import("readline");
+  const rl = readline2.createInterface({
     input: process.stdin,
     output: process.stdout
   });
@@ -23508,9 +23773,13 @@ yargs_default(hideBin(process.argv)).scriptName("prloom").usage("$0 <command> [o
 }), async (argv) => {
   const { runEdit: runEdit2 } = await Promise.resolve().then(() => (init_edit(), exports_edit));
   await runEdit2(await getRepoRoot(), argv["plan-id"], argv.agent, argv["no-designer"]);
-}).command("start", "Start the dispatcher", () => {}, async () => {
+}).command("start", "Start the dispatcher", (yargs) => yargs.option("tmux", {
+  type: "boolean",
+  describe: "Run workers in tmux sessions for observation",
+  default: false
+}), async (argv) => {
   const { runDispatcher: runDispatcher2 } = await Promise.resolve().then(() => (init_dispatcher(), exports_dispatcher));
-  await runDispatcher2(await getRepoRoot());
+  await runDispatcher2(await getRepoRoot(), { tmux: argv.tmux });
 }).command("status", "Show plan states", () => {}, async () => {
   const { runStatus: runStatus2 } = await Promise.resolve().then(() => (init_status(), exports_status));
   await runStatus2(await getRepoRoot());
@@ -23523,6 +23792,9 @@ yargs_default(hideBin(process.argv)).scriptName("prloom").usage("$0 <command> [o
 }).command("open <plan-id>", "Open TUI for manual work (requires paused)", (yargs) => yargs.positional("plan-id", { type: "string", demandOption: true }), async (argv) => {
   const { runOpen: runOpen2 } = await Promise.resolve().then(() => (init_open(), exports_open));
   await runOpen2(await getRepoRoot(), argv["plan-id"]);
+}).command("watch <plan-id>", "Observe a running worker (requires --tmux mode)", (yargs) => yargs.positional("plan-id", { type: "string", demandOption: true }), async (argv) => {
+  const { runWatch: runWatch2 } = await Promise.resolve().then(() => (init_watch(), exports_watch));
+  await runWatch2(await getRepoRoot(), argv["plan-id"]);
 }).command("logs <plan-id>", "Show session ID for a plan", (yargs) => yargs.positional("plan-id", { type: "string", demandOption: true }), async (argv) => {
   const { runLogs: runLogs2 } = await Promise.resolve().then(() => (init_logs(), exports_logs));
   await runLogs2(await getRepoRoot(), argv["plan-id"]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prloom",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "bin": {
     "prloom": "./dist/cli/index.js"

package/prompts/review_triage.md

@@ -2,11 +2,10 @@
 
 You are processing PR feedback for an active plan. Your job is to:
 
-1. Analyze all review feedback (comments, reviews, inline comments)
-2. Create specific, actionable TODO items for the plan
-3. Group related feedback into fewer tasks where appropriate
+1. **Classify** each feedback item by type
+2. **Respond** appropriately based on the type
+3. **Update** the plan if changes are needed
 4. Detect if a rebase was requested
-5. Compose a reply message for the reviewer(s)
 
 ## Feedback to Process
 
@@ -16,9 +15,36 @@ You are processing PR feedback for an active plan. Your job is to:
 
 {{plan}}
 
-## Instructions
+---
 
-### Adding TODOs
+## Step 1: Classify Each Feedback Item
+
+Before acting, identify the type of each feedback item:
+
+| Type                | Description                                   | Action                   |
+| ------------------- | --------------------------------------------- | ------------------------ |
+| **Question**        | Asking "why", "how", or seeking clarification | Answer in reply, NO TODO |
+| **Change Request**  | Asking for code modifications                 | Create specific TODO     |
+| **Approval/Praise** | Positive feedback, LGTM, approval             | Acknowledge briefly      |
+| **Process Request** | Rebase, update branch, etc.                   | Set flag, acknowledge    |
+
+## Step 2: Handle Each Type
+
+### Questions → Answer Directly
+
+For questions, **answer them substantively in your reply**:
+
+- Explore the codebase to find the answer if needed
+- Explain the reasoning behind implementation decisions
+- Reference specific code locations or commits if helpful
+- Do NOT create a TODO like "answer the question" - just answer it
+
+Example question: "Why did you use a polling approach instead of webhooks?"
+→ Reply with the actual reasoning, don't create a TODO.
+
+### Change Requests → Create TODOs
+
+For explicit requests to modify code:
 
 - Edit the plan file directly to add actionable TODOs
 - Add them at the end of the ## TODO section
@@ -28,13 +54,23 @@ You are processing PR feedback for an active plan. Your job is to:
   - "Update function X to handle null input"
   - "Add test for Y edge case"
   - "Rename Z for clarity"
-  - "Remove deprecated code in file A"
-- Group related comments into single tasks when logical
+- Group related requests into single tasks when logical
 - If the plan status is `done` and you add TODOs, change status to `active`
 
-### Writing the Result File
+### Approval/Praise → Acknowledge
+
+Simply thank the reviewer in your reply. No TODO needed.
+
+### Process Requests → Set Flag
+
+If any comment mentions rebase, update branch, or similar:
+
+- Set `rebase_requested: true` in the result file
+- Acknowledge in your reply
+
+## Step 3: Write the Result File
 
-After editing the plan, you MUST write `.prloom/triage-result.json` with:
+After processing, you MUST write `prloom/.local/triage-result.json`:
 
 ```json
 {
@@ -45,19 +81,20 @@ After editing the plan, you MUST write `.prloom/triage-result.json` with:
 
 **Required fields:**
 
-- `reply_markdown`: Your response to post on the PR (ALWAYS required, even for no-ops)
-- `rebase_requested`: Set to `true` if any comment mentions rebase, update branch, or similar
+- `reply_markdown`: Your response to post on the PR (ALWAYS required)
+- `rebase_requested`: Set to `true` if rebase was requested
 
 ### Reply Guidelines
 
 - Be polite and professional
-- Acknowledge specific feedback points
-- Explain what TODOs were created
-- If no changes needed, explain why
-- Keep it concise
+- **Answer questions directly** - this is the most important part
+- Explain what TODOs were created (if any)
+- If a request doesn't require changes, explain why
+- Keep it concise but complete
 
 ## Critical Rules
 
-1. You MUST write `.prloom/triage-result.json` even if you add no TODOs
+1. You MUST write `prloom/.local/triage-result.json` even if you add no TODOs
 2. The result file must contain valid JSON only, no markdown wrapper
 3. Failure to write the result file will mark the plan as blocked
+4. **Questions should be answered, not converted to TODOs**