@markmdev/pebble 0.1.11 → 0.1.13

package/dist/cli/index.js

@@ -37,7 +37,7 @@ var TYPE_LABELS = {
 
 // src/cli/lib/storage.ts
 import * as fs from "fs";
-import * as path from "path";
+import * as path2 from "path";
 
 // src/cli/lib/id.ts
 import * as crypto from "crypto";
@@ -59,23 +59,78 @@ function derivePrefix(folderName) {
   return clean.slice(0, 4).toUpperCase().padEnd(4, "X");
 }
 
+// src/cli/lib/git.ts
+import { execSync } from "child_process";
+import path from "path";
+function getMainWorktreeRoot() {
+  try {
+    const gitCommonDir = execSync("git rev-parse --git-common-dir", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const gitDir = execSync("git rev-parse --git-dir", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    const normalizedCommon = path.resolve(gitCommonDir);
+    const normalizedGit = path.resolve(gitDir);
+    if (normalizedCommon === normalizedGit) {
+      return null;
+    }
+    const mainRoot = path.dirname(normalizedCommon);
+    return mainRoot;
+  } catch {
+    return null;
+  }
+}
+
 // src/cli/lib/storage.ts
 var PEBBLE_DIR = ".pebble";
 var ISSUES_FILE = "issues.jsonl";
 var CONFIG_FILE = "config.json";
+function getConfigSafe(pebbleDir) {
+  try {
+    const configPath = path2.join(pebbleDir, CONFIG_FILE);
+    if (!fs.existsSync(configPath)) {
+      return null;
+    }
+    const content = fs.readFileSync(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function resolveWorktreePebbleDir(localPebbleDir) {
+  if (process.env.PEBBLE_LOCAL === "1") {
+    return localPebbleDir;
+  }
+  const config = getConfigSafe(localPebbleDir);
+  if (config?.useMainTreePebble === false) {
+    return localPebbleDir;
+  }
+  const mainRoot = getMainWorktreeRoot();
+  if (!mainRoot) {
+    return localPebbleDir;
+  }
+  const mainPebble = path2.join(mainRoot, PEBBLE_DIR);
+  if (fs.existsSync(mainPebble) && fs.statSync(mainPebble).isDirectory()) {
+    return mainPebble;
+  }
+  return localPebbleDir;
+}
 function discoverPebbleDir(startDir = process.cwd()) {
-  let currentDir = path.resolve(startDir);
-  const root = path.parse(currentDir).root;
+  let currentDir = path2.resolve(startDir);
+  const root = path2.parse(currentDir).root;
   while (currentDir !== root) {
-    const pebbleDir = path.join(currentDir, PEBBLE_DIR);
+    const pebbleDir = path2.join(currentDir, PEBBLE_DIR);
     if (fs.existsSync(pebbleDir) && fs.statSync(pebbleDir).isDirectory()) {
-      return pebbleDir;
+      return resolveWorktreePebbleDir(pebbleDir);
     }
-    currentDir = path.dirname(currentDir);
+    currentDir = path2.dirname(currentDir);
   }
-  const rootPebble = path.join(root, PEBBLE_DIR);
+  const rootPebble = path2.join(root, PEBBLE_DIR);
   if (fs.existsSync(rootPebble) && fs.statSync(rootPebble).isDirectory()) {
-    return rootPebble;
+    return resolveWorktreePebbleDir(rootPebble);
   }
   return null;
 }
@@ -87,23 +142,35 @@ function getPebbleDir() {
   return dir;
 }
 function ensurePebbleDir(baseDir = process.cwd()) {
-  const pebbleDir = path.join(baseDir, PEBBLE_DIR);
+  let targetDir = baseDir;
+  if (process.env.PEBBLE_LOCAL !== "1") {
+    const mainRoot = getMainWorktreeRoot();
+    if (mainRoot) {
+      const mainPebble = path2.join(mainRoot, PEBBLE_DIR);
+      if (fs.existsSync(mainPebble) && fs.statSync(mainPebble).isDirectory()) {
+        return mainPebble;
+      }
+      targetDir = mainRoot;
+    }
+  }
+  const pebbleDir = path2.join(targetDir, PEBBLE_DIR);
   if (!fs.existsSync(pebbleDir)) {
     fs.mkdirSync(pebbleDir, { recursive: true });
-    const folderName = path.basename(baseDir);
+    const folderName = path2.basename(targetDir);
     const config = {
       prefix: derivePrefix(folderName),
-      version: "0.1.0"
+      version: "0.1.0",
+      useMainTreePebble: true
     };
     setConfig(config, pebbleDir);
-    const issuesPath = path.join(pebbleDir, ISSUES_FILE);
+    const issuesPath = path2.join(pebbleDir, ISSUES_FILE);
     fs.writeFileSync(issuesPath, "", "utf-8");
   }
   return pebbleDir;
 }
 function getIssuesPath(pebbleDir) {
   const dir = pebbleDir ?? getPebbleDir();
-  return path.join(dir, ISSUES_FILE);
+  return path2.join(dir, ISSUES_FILE);
 }
 function appendEvent(event, pebbleDir) {
   const issuesPath = getIssuesPath(pebbleDir);
@@ -129,7 +196,7 @@ function readEvents(pebbleDir) {
   if (!dir) {
     return [];
   }
-  const issuesPath = path.join(dir, ISSUES_FILE);
+  const issuesPath = path2.join(dir, ISSUES_FILE);
   if (!fs.existsSync(issuesPath)) {
     return [];
   }
@@ -145,7 +212,7 @@ function readEvents(pebbleDir) {
 }
 function getConfigPath(pebbleDir) {
   const dir = pebbleDir ?? getPebbleDir();
-  return path.join(dir, CONFIG_FILE);
+  return path2.join(dir, CONFIG_FILE);
 }
 function getConfig(pebbleDir) {
   const configPath = getConfigPath(pebbleDir);
@@ -157,7 +224,7 @@ function getConfig(pebbleDir) {
 }
 function setConfig(config, pebbleDir) {
   const dir = pebbleDir ?? getPebbleDir();
-  const configPath = path.join(dir, CONFIG_FILE);
+  const configPath = path2.join(dir, CONFIG_FILE);
   fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
 }
 function getOrCreatePebbleDir() {
@@ -491,6 +558,21 @@ function getOpenBlockers(issueId) {
   const state = computeState(events);
   return issue.blockedBy.map((id) => state.get(id)).filter((i) => i !== void 0 && i.status !== "closed");
 }
+function getComputedState() {
+  const events = readEvents();
+  return computeState(events);
+}
+function getAncestryChain(issueId, state) {
+  const chain = [];
+  let current = state.get(issueId);
+  while (current?.parent) {
+    const parent = state.get(current.parent);
+    if (!parent) break;
+    chain.push({ id: parent.id, title: parent.title });
+    current = parent;
+  }
+  return chain;
+}
 
 // src/shared/time.ts
 import { formatDistanceToNow, parseISO } from "date-fns";
@@ -536,7 +618,10 @@ function formatIssueDetailPretty(issue, ctx) {
   lines.push(`Type:     ${formatType(issue.type)}`);
   lines.push(`Priority: ${formatPriority(issue.priority)}`);
   lines.push(`Status:   ${formatStatus(issue.status)}`);
-  if (issue.parent) {
+  if (ctx.ancestry && ctx.ancestry.length > 0) {
+    const chain = [...ctx.ancestry].reverse().map((a) => a.id).join(" > ");
+    lines.push(`Ancestry: ${chain}`);
+  } else if (issue.parent) {
     lines.push(`Parent:   ${issue.parent}`);
   }
   if (issue.description) {
@@ -602,7 +687,8 @@ function outputIssueDetail(issue, ctx, pretty) {
       blocking: ctx.blocking.map((i) => i.id),
       children: ctx.children.map((i) => ({ id: i.id, title: i.title, status: i.status })),
       verifications: ctx.verifications.map((i) => ({ id: i.id, title: i.title, status: i.status })),
-      related: ctx.related.map((i) => i.id)
+      related: ctx.related.map((i) => i.id),
+      ...ctx.ancestry && ctx.ancestry.length > 0 && { ancestry: ctx.ancestry }
     };
     console.log(formatJson(output));
   }
@@ -798,11 +884,12 @@ function formatIssueListVerbose(issues, sectionHeader) {
     lines.push("");
   }
   for (const info of issues) {
-    const { issue, blocking, children, verifications, blockers, parent } = info;
+    const { issue, blocking, children, verifications, blockers, ancestry } = info;
     lines.push(`${issue.id}: ${issue.title}`);
     lines.push(`  Type: ${formatType(issue.type)} | Priority: P${issue.priority} | Created: ${formatRelativeTime(issue.createdAt)}`);
-    if (parent) {
-      lines.push(`  Epic: ${parent.id} (${parent.title})`);
+    if (ancestry.length > 0) {
+      const chain = [...ancestry].reverse().map((a) => a.id).join(" > ");
+      lines.push(`  Ancestry: ${chain}`);
     }
     if (blocking.length > 0) {
       lines.push(`  Blocking: ${blocking.join(", ")}`);
@@ -824,13 +911,13 @@ function outputIssueListVerbose(issues, pretty, sectionHeader, limitInfo) {
       console.log(formatLimitMessage(limitInfo));
     }
   } else {
-    const output = issues.map(({ issue, blocking, children, verifications, blockers, parent }) => ({
+    const output = issues.map(({ issue, blocking, children, verifications, blockers, ancestry }) => ({
       ...issue,
       blocking,
       childrenCount: issue.type === "epic" ? children : void 0,
       verificationsCount: verifications,
       ...blockers && { openBlockers: blockers },
-      ...parent && { parentInfo: parent }
+      ...ancestry.length > 0 && { ancestry }
     }));
     if (limitInfo?.limited) {
       console.log(formatJson({ issues: output, _meta: limitInfo }));
@@ -1137,11 +1224,31 @@ function closeCommand(program2) {
           };
           appendEvent(closeEvent, pebbleDir);
           const unblocked = getNewlyUnblocked(resolvedId);
+          let autoClosed;
+          if (issue.verifies) {
+            const targetIssue = getIssue(issue.verifies);
+            if (targetIssue && targetIssue.status === "pending_verification") {
+              const remainingVerifications = getVerifications(issue.verifies).filter((v) => v.status !== "closed");
+              if (remainingVerifications.length === 0) {
+                const autoCloseEvent = {
+                  type: "close",
+                  issueId: issue.verifies,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                  data: {
+                    reason: "All verifications completed"
+                  }
+                };
+                appendEvent(autoCloseEvent, pebbleDir);
+                autoClosed = { id: targetIssue.id, title: targetIssue.title };
+              }
+            }
+          }
           results.push({
             id: resolvedId,
             success: true,
             status: "closed",
-            unblocked: unblocked.length > 0 ? unblocked.map((i) => ({ id: i.id, title: i.title })) : void 0
+            unblocked: unblocked.length > 0 ? unblocked.map((i) => ({ id: i.id, title: i.title })) : void 0,
+            autoClosed
           });
         } catch (error) {
           results.push({ id, success: false, error: error.message });
@@ -1169,6 +1276,10 @@ Unblocked:`);
                   console.log(`  \u2192 ${u.id} - ${u.title}`);
                 }
               }
+              if (result.autoClosed) {
+                console.log(`
+\u2713 ${result.autoClosed.id} auto-closed (all verifications complete)`);
+              }
             }
           } else {
             console.log(formatJson({
@@ -1177,7 +1288,8 @@ Unblocked:`);
               status: result.status,
               ...result.pendingVerifications && { pendingVerifications: result.pendingVerifications },
               ...result.pendingVerifications && { hint: `pb verifications ${result.id}` },
-              ...result.unblocked && { unblocked: result.unblocked }
+              ...result.unblocked && { unblocked: result.unblocked },
+              ...result.autoClosed && { autoClosed: result.autoClosed }
             }));
           }
         } else {
@@ -1200,6 +1312,9 @@ Unblocked:`);
                     console.log(`  \u2192 ${u.id} - ${u.title}`);
                   }
                 }
+                if (result.autoClosed) {
+                  console.log(`  \u2713 ${result.autoClosed.id} auto-closed (all verifications complete)`);
+                }
               }
             } else {
               console.log(`\u2717 ${result.id}: ${result.error}`);
@@ -1213,7 +1328,8 @@ Unblocked:`);
             ...r.error && { error: r.error },
             ...r.pendingVerifications && { pendingVerifications: r.pendingVerifications },
             ...r.pendingVerifications && { hint: `pb verifications ${r.id}` },
-            ...r.unblocked && { unblocked: r.unblocked }
+            ...r.unblocked && { unblocked: r.unblocked },
+            ...r.autoClosed && { autoClosed: r.autoClosed }
           }))));
         }
       }
@@ -1374,20 +1490,15 @@ function listCommand(program2) {
         limited: limit > 0 && total > limit
       };
       if (options.verbose) {
+        const state = getComputedState();
         const verboseIssues = issues.map((issue) => {
-          const info = {
+          return {
             issue,
             blocking: getBlocking(issue.id).map((i) => i.id),
             children: getChildren(issue.id).length,
-            verifications: getVerifications(issue.id).length
+            verifications: getVerifications(issue.id).length,
+            ancestry: getAncestryChain(issue.id, state)
           };
-          if (issue.parent) {
-            const parentIssue = getIssue(issue.parent);
-            if (parentIssue) {
-              info.parent = { id: parentIssue.id, title: parentIssue.title };
-            }
-          }
-          return info;
         });
         let sectionHeader = "Issues";
         if (filters.status) {
@@ -1424,7 +1535,9 @@ function showCommand(program2) {
       const children = issue.type === "epic" ? getChildren(resolvedId) : [];
       const verifications = getVerifications(resolvedId);
       const related = getRelated(resolvedId);
-      outputIssueDetail(issue, { blocking, children, verifications, related }, pretty);
+      const state = getComputedState();
+      const ancestry = getAncestryChain(resolvedId, state);
+      outputIssueDetail(issue, { blocking, children, verifications, related, ancestry }, pretty);
     } catch (error) {
       outputError(error, pretty);
     }
@@ -1457,20 +1570,15 @@ function readyCommand(program2) {
         limited: limit > 0 && total > limit
       };
       if (options.verbose) {
+        const state = getComputedState();
         const verboseIssues = issues.map((issue) => {
-          const info = {
+          return {
             issue,
             blocking: getBlocking(issue.id).map((i) => i.id),
             children: getChildren(issue.id).length,
-            verifications: getVerifications(issue.id).length
+            verifications: getVerifications(issue.id).length,
+            ancestry: getAncestryChain(issue.id, state)
           };
-          if (issue.parent) {
-            const parentIssue = getIssue(issue.parent);
-            if (parentIssue) {
-              info.parent = { id: parentIssue.id, title: parentIssue.title };
-            }
-          }
-          return info;
         });
         outputIssueListVerbose(verboseIssues, pretty, "Ready Issues", limitInfo);
       } else {
@@ -1501,23 +1609,18 @@ function blockedCommand(program2) {
         limited: limit > 0 && total > limit
       };
       if (options.verbose) {
+        const state = getComputedState();
         const verboseIssues = issues.map((issue) => {
           const allBlockers = getBlockers(issue.id);
           const openBlockers = allBlockers.filter((b) => b.status !== "closed").map((b) => b.id);
-          const info = {
+          return {
             issue,
             blocking: getBlocking(issue.id).map((i) => i.id),
             children: getChildren(issue.id).length,
             verifications: getVerifications(issue.id).length,
-            blockers: openBlockers
+            blockers: openBlockers,
+            ancestry: getAncestryChain(issue.id, state)
           };
-          if (issue.parent) {
-            const parentIssue = getIssue(issue.parent);
-            if (parentIssue) {
-              info.parent = { id: parentIssue.id, title: parentIssue.title };
-            }
-          }
-          return info;
         });
         outputIssueListVerbose(verboseIssues, pretty, "Blocked Issues", limitInfo);
       } else {
@@ -2007,7 +2110,7 @@ function formatGraphPretty(issues) {
 import express from "express";
 import cors from "cors";
 import { fileURLToPath } from "url";
-import path2 from "path";
+import path3 from "path";
 import fs2 from "fs";
 import net from "net";
 import open from "open";
@@ -2102,14 +2205,14 @@ function uiCommand(program2) {
           console.error("Error: --files option requires at least one path");
           process.exit(1);
         }
-        issueFiles = issueFiles.map((p) => path2.resolve(process.cwd(), p));
+        issueFiles = issueFiles.map((p) => path3.resolve(process.cwd(), p));
         console.log(`Multi-worktree mode: watching ${issueFiles.length} file(s)`);
         for (const f of issueFiles) {
           console.log(`  - ${f}`);
         }
       } else {
         const pebbleDir = getOrCreatePebbleDir();
-        issueFiles = [path2.join(pebbleDir, "issues.jsonl")];
+        issueFiles = [path3.join(pebbleDir, "issues.jsonl")];
       }
       if (!options.files) {
         getOrCreatePebbleDir();
@@ -2132,7 +2235,7 @@ function uiCommand(program2) {
             res.status(400).json({ error: "path is required" });
             return;
           }
-          const resolved = path2.resolve(process.cwd(), filePath);
+          const resolved = path3.resolve(process.cwd(), filePath);
           if (!fs2.existsSync(resolved)) {
             res.status(400).json({ error: `File not found: ${filePath}` });
             return;
@@ -2170,10 +2273,10 @@ function uiCommand(program2) {
       });
       app.get("/api/worktrees", (_req, res) => {
         try {
-          const { execSync } = __require("child_process");
+          const { execSync: execSync2 } = __require("child_process");
           let worktreeOutput;
           try {
-            worktreeOutput = execSync("git worktree list --porcelain", {
+            worktreeOutput = execSync2("git worktree list --porcelain", {
               encoding: "utf-8",
               cwd: process.cwd()
             });
@@ -2195,7 +2298,7 @@ function uiCommand(program2) {
               }
             }
             if (worktreePath) {
-              const issuesFile = path2.join(worktreePath, ".pebble", "issues.jsonl");
+              const issuesFile = path3.join(worktreePath, ".pebble", "issues.jsonl");
               const hasIssues = fs2.existsSync(issuesFile);
               const isActive = issueFiles.includes(issuesFile);
               let issueCount = 0;
@@ -2289,7 +2392,7 @@ data: ${message}
             }
             targetFile = issueFiles[targetIndex];
           }
-          const pebbleDir = targetFile ? path2.dirname(targetFile) : getOrCreatePebbleDir();
+          const pebbleDir = targetFile ? path3.dirname(targetFile) : getOrCreatePebbleDir();
           const config = getConfig(pebbleDir);
           const { title, type, priority, description, parent } = req.body;
           if (!title || typeof title !== "string") {
@@ -2480,7 +2583,7 @@ data: ${message}
               return;
             }
             issue = localIssue;
-            targetFile = path2.join(pebbleDir, "issues.jsonl");
+            targetFile = path3.join(pebbleDir, "issues.jsonl");
           }
           const { title, type, priority, status, description, parent, relatedTo } = req.body;
           const updates = {};
@@ -2608,7 +2711,7 @@ data: ${message}
               return;
             }
             issue = localIssue;
-            targetFile = path2.join(pebbleDir, "issues.jsonl");
+            targetFile = path3.join(pebbleDir, "issues.jsonl");
           }
           if (issue.status === "closed") {
             res.status(400).json({ error: "Issue is already closed" });
@@ -2651,11 +2754,49 @@ data: ${message}
             data: { reason }
           };
           appendEventToFile(event, targetFile);
+          let autoClosed;
+          if (issue.verifies) {
+            let targetIssue;
+            let targetVerifications = [];
+            if (isMultiWorktree()) {
+              const found = findIssueInSources(issue.verifies, issueFiles);
+              if (found) {
+                targetIssue = found.issue;
+                const allIssues = mergeIssuesFromFiles(issueFiles);
+                targetVerifications = allIssues.filter(
+                  (i) => i.verifies === issue.verifies && i.status !== "closed"
+                );
+              }
+            } else {
+              targetIssue = getIssue(issue.verifies);
+              targetVerifications = getVerifications(issue.verifies).filter((v) => v.status !== "closed");
+            }
+            if (targetIssue && targetIssue.status === "pending_verification" && targetVerifications.length === 0) {
+              const autoCloseEvent = {
+                type: "close",
+                issueId: issue.verifies,
+                timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+                data: { reason: "All verifications completed" }
+              };
+              if (isMultiWorktree()) {
+                const targetFound = findIssueInSources(issue.verifies, issueFiles);
+                if (targetFound) {
+                  appendEventToFile(autoCloseEvent, targetFound.targetFile);
+                }
+              } else {
+                const pebbleDir = getOrCreatePebbleDir();
+                appendEventToFile(autoCloseEvent, path3.join(pebbleDir, "issues.jsonl"));
+              }
+              autoClosed = { id: targetIssue.id, title: targetIssue.title };
+            }
+          }
           if (isMultiWorktree()) {
             const updated = findIssueInSources(issueId, issueFiles);
-            res.json(updated?.issue || { ...issue, status: "closed", updatedAt: timestamp });
+            const result = updated?.issue || { ...issue, status: "closed", updatedAt: timestamp };
+            res.json(autoClosed ? { ...result, _autoClosed: autoClosed } : result);
           } else {
-            res.json(getIssue(issueId));
+            const result = getIssue(issueId);
+            res.json(autoClosed ? { ...result, _autoClosed: autoClosed } : result);
           }
         } catch (error) {
           res.status(500).json({ error: error.message });
@@ -2684,7 +2825,7 @@ data: ${message}
               return;
             }
             issue = localIssue;
-            targetFile = path2.join(pebbleDir, "issues.jsonl");
+            targetFile = path3.join(pebbleDir, "issues.jsonl");
           }
           if (issue.status !== "closed") {
             res.status(400).json({ error: "Issue is not closed" });
@@ -2732,7 +2873,7 @@ data: ${message}
               return;
             }
             issue = localIssue;
-            targetFile = path2.join(pebbleDir, "issues.jsonl");
+            targetFile = path3.join(pebbleDir, "issues.jsonl");
           }
           const { text, author } = req.body;
           if (!text || typeof text !== "string" || text.trim() === "") {
@@ -2784,7 +2925,7 @@ data: ${message}
               return;
             }
             issue = localIssue;
-            targetFile = path2.join(pebbleDir, "issues.jsonl");
+            targetFile = path3.join(pebbleDir, "issues.jsonl");
           }
           const { blockerId } = req.body;
           if (!blockerId) {
@@ -2858,7 +2999,7 @@ data: ${message}
               return;
             }
             issue = localIssue;
-            targetFile = path2.join(pebbleDir, "issues.jsonl");
+            targetFile = path3.join(pebbleDir, "issues.jsonl");
           }
           let resolvedBlockerId;
           if (isMultiWorktree()) {
@@ -2897,11 +3038,11 @@ data: ${message}
         }
       });
       const __filename2 = fileURLToPath(import.meta.url);
-      const __dirname2 = path2.dirname(__filename2);
-      const uiPath = path2.resolve(__dirname2, "../ui");
+      const __dirname2 = path3.dirname(__filename2);
+      const uiPath = path3.resolve(__dirname2, "../ui");
       app.use(express.static(uiPath));
       app.get("*", (_req, res) => {
-        res.sendFile(path2.join(uiPath, "index.html"));
+        res.sendFile(path3.join(uiPath, "index.html"));
       });
       const requestedPort = parseInt(options.port, 10);
       const actualPort = await findAvailablePort(requestedPort);
@@ -2925,7 +3066,7 @@ data: ${message}
 // src/cli/commands/import.ts
 import * as fs3 from "fs";
 import * as readline from "readline";
-import * as path3 from "path";
+import * as path4 from "path";
 function importCommand(program2) {
   program2.command("import <file>").description("Import issues from a Beads issues.jsonl file").option("--dry-run", "Show what would be imported without writing").option("--prefix <prefix>", "Override the ID prefix (default: derive from folder name)").action(async (file, options) => {
     const pretty = program2.opts().pretty ?? false;
@@ -2938,7 +3079,7 @@ function importCommand(program2) {
         console.log(pretty ? "No issues found in file." : formatJson({ imported: 0 }));
         return;
       }
-      const prefix = options.prefix ?? derivePrefix(path3.basename(process.cwd()));
+      const prefix = options.prefix ?? derivePrefix(path4.basename(process.cwd()));
       const { events, idMap, stats } = convertToPebbleEvents(beadsIssues, prefix);
       if (options.dryRun) {
         if (pretty) {
@@ -3116,7 +3257,7 @@ function generateSuffix() {
 
 // src/cli/commands/merge.ts
 import * as fs4 from "fs";
-import * as path4 from "path";
+import * as path5 from "path";
 function mergeEvents(filePaths) {
   const seen = /* @__PURE__ */ new Map();
   for (const filePath of filePaths) {
@@ -3159,7 +3300,7 @@ function mergeCommand(program2) {
     const pretty = program2.opts().pretty ?? false;
     const filePaths = [];
     for (const file of files) {
-      const resolved = path4.resolve(process.cwd(), file);
+      const resolved = path5.resolve(process.cwd(), file);
       if (!fs4.existsSync(resolved)) {
         console.error(`Error: File not found: ${file}`);
         process.exit(1);
@@ -3561,7 +3702,7 @@ function verificationsCommand(program2) {
 }
 
 // src/cli/commands/init.ts
-import * as path5 from "path";
+import * as path6 from "path";
 function initCommand(program2) {
   program2.command("init").description("Initialize a new .pebble directory in the current directory").option("--force", "Re-initialize even if .pebble already exists").action((options) => {
     const existing = discoverPebbleDir();
@@ -3577,8 +3718,8 @@ function initCommand(program2) {
     console.log(JSON.stringify({
       initialized: true,
       path: pebbleDir,
-      configPath: path5.join(pebbleDir, "config.json"),
-      issuesPath: path5.join(pebbleDir, "issues.jsonl")
+      configPath: path6.join(pebbleDir, "config.json"),
+      issuesPath: path6.join(pebbleDir, "issues.jsonl")
     }));
   });
 }
@@ -3588,6 +3729,12 @@ var program = new Command();
 program.name("pebble").description("A lightweight JSONL-based issue tracker").version("0.1.0");
 program.option("-P, --pretty", "Human-readable output (default: JSON)");
 program.option("--json", "JSON output (this is the default, flag not needed)");
+program.option("--local", "Use local .pebble directory even in a git worktree");
+program.hook("preAction", () => {
+  if (program.opts().local) {
+    process.env.PEBBLE_LOCAL = "1";
+  }
+});
 createCommand(program);
 updateCommand(program);
 closeCommand(program);