@helmsmith/workbrokr 0.2.0 → 0.3.1

package/dist/cli.js

@@ -61,7 +61,8 @@ var REFUSALS = /* @__PURE__ */ new Set([
   "PORT_RANGE_TAKEN",
   "SYNC_CONFLICT",
   "DIRTY_WORKTREE",
-  "UNPUSHED"
+  "UNPUSHED",
+  "PR_CLOSED"
 ]);
 function exitCodeFor(code) {
   return REFUSALS.has(code) ? 2 : 1;
@@ -164,12 +165,43 @@ var Git = class _Git {
     else if (this.remoteBranchExists(this.currentBranch())) ref = `origin/${this.currentBranch()}`;
     return this.lines(["rev-list", `${ref}..HEAD`]).length;
   }
+  /** Non-merge commits on HEAD that origin/<base> does not have: the branch's own work (sync merges do not count). */
+  ownCommitCount(base) {
+    const r = this.tryRun(["rev-list", "--count", "--no-merges", `origin/${base}..HEAD`]);
+    return r.code === 0 ? Number(r.out.trim()) || 0 : 0;
+  }
+  /** `branch` is already in origin/<base>: an ancestor of it, patch-equivalent (squash-merged), or without own commits. */
+  branchMergedInto(branch, base) {
+    const target = `origin/${base}`;
+    if (this.isAncestor(branch, target)) return true;
+    const own = this.tryRun(["rev-list", "--count", "--no-merges", `${target}..${branch}`]);
+    if (own.code === 0 && Number(own.out.trim()) === 0) return true;
+    const cherry = this.tryRun(["cherry", target, branch]);
+    if (cherry.code !== 0) return false;
+    const lines = cherry.out.split("\n").map((l) => l.trim()).filter(Boolean);
+    return lines.length > 0 && lines.every((l) => l.startsWith("- "));
+  }
+  /** Commits on origin/<base> that HEAD does not have (0 when the ref is unknown). */
+  behindCount(base) {
+    const r = this.tryRun(["rev-list", "--count", `HEAD..origin/${base}`]);
+    return r.code === 0 ? Number(r.out.trim()) || 0 : 0;
+  }
   isDirty() {
     return this.run(["status", "--porcelain"]).trim().length > 0;
   }
   changedPathsStaged() {
     return this.lines(["diff", "--cached", "--name-only"]);
   }
+  /** The other parent of a merge in progress, or undefined when none is. */
+  mergeHead() {
+    const r = this.tryRun(["rev-parse", "-q", "--verify", "MERGE_HEAD"]);
+    return r.code === 0 ? r.out.trim() : void 0;
+  }
+  /** Staged paths whose index content differs from `ref` (so, authored here rather than taken from `ref`). */
+  stagedDifferingFrom(ref, paths) {
+    if (paths.length === 0) return [];
+    return this.lines(["diff", "--cached", "--name-only", "--no-renames", ref, "--", ...paths]);
+  }
   changedPaths(from, to) {
     return this.lines(["diff", "--name-only", "--no-renames", from, to]);
   }
@@ -202,18 +234,45 @@ var Git = class _Git {
     const conflicted = this.lines(["diff", "--name-only", "--diff-filter=U"]);
     return { kind: "conflict", before, after: before, conflicted };
   }
+  /** `origin/<branch>` after a fetch attempt, when the remote has it; the local copy may have been retired. */
+  remoteRef(branch) {
+    this.tryRun(["fetch", "-q", "origin", branch]);
+    const ref = `refs/remotes/origin/${branch}`;
+    return this.tryRun(["rev-parse", "--verify", "-q", ref]).code === 0 ? `origin/${branch}` : void 0;
+  }
+  /**
+   * Add a worktree on `branch`: the local branch if it exists, else a tracking
+   * branch from origin/<branch> if the remote has it (so retiring the local
+   * branch while its PR was open never recreates it from the base), else a
+   * new branch from `startPoint`.
+   */
   worktreeAdd(path, branch, startPoint) {
     mkdirSync(dirname(path), { recursive: true });
-    if (this.branchExists(branch)) this.run(["worktree", "add", "-q", path, branch]);
-    else
-      this.run(["worktree", "add", "-q", "--no-track", "-b", branch, path, startPoint ?? "HEAD"]);
+    if (this.branchExists(branch)) {
+      this.run(["worktree", "add", "-q", path, branch]);
+      return;
+    }
+    const remote = this.remoteRef(branch);
+    if (remote) {
+      this.run(["worktree", "add", "-q", "--track", "-b", branch, path, remote]);
+      return;
+    }
+    this.run(["worktree", "add", "-q", "--no-track", "-b", branch, path, startPoint ?? "HEAD"]);
   }
   worktreeRemove(path) {
     this.run(["worktree", "remove", "--force", path]);
   }
   checkout(branch, createFrom) {
-    if (this.branchExists(branch)) this.run(["checkout", "-q", branch]);
-    else this.run(["checkout", "-q", "--no-track", "-b", branch, createFrom ?? "HEAD"]);
+    if (this.branchExists(branch)) {
+      this.run(["checkout", "-q", branch]);
+      return;
+    }
+    const remote = this.remoteRef(branch);
+    if (remote) {
+      this.run(["checkout", "-q", "--track", "-b", branch, remote]);
+      return;
+    }
+    this.run(["checkout", "-q", "--no-track", "-b", branch, createFrom ?? "HEAD"]);
   }
   push(branch) {
     this.run(["push", "-q", "-u", "origin", branch]);
@@ -327,13 +386,14 @@ function slotVars(m, o) {
     BRANCH: o.branch ?? "",
     WORKTREE: o.worktree ?? "",
     LOG_DIR: o.logDir ?? "",
-    PORT_STORYBOOK: o.storybookPort === void 0 ? "" : String(o.storybookPort),
     STORYBROKR_HOST: storybookHostFor(m, o.worktree)
   };
   for (const service of Object.keys(m.ports.services)) {
     const p = o.ports[service];
     vars[`PORT_${service.toUpperCase()}`] = p === void 0 ? "" : String(p);
   }
+  if (o.storybookPort !== void 0) vars.PORT_STORYBOOK = String(o.storybookPort);
+  else if (vars.PORT_STORYBOOK === void 0) vars.PORT_STORYBOOK = "";
   return vars;
 }
 function ensureExcluded(worktree, patterns) {
@@ -558,8 +618,15 @@ function checkCommit(c) {
       `branch "${c.branch}" is protected (${c.m.protectedBranches.join(", ")}): work happens on <type>/<area> branches, never here`
     );
   }
+  const mergeHead = c.git.mergeHead();
+  const authored = mergeHead ? new Set(c.git.stagedDifferingFrom(mergeHead, c.stagedPaths)) : new Set(c.stagedPaths);
+  const ownPaths = c.stagedPaths.filter((p) => authored.has(p));
   const allEfforts = c.registry.efforts({ project: c.project });
   const efforts = new Map(allEfforts.map((e) => [e.id, e]));
+  const openEfforts = allEfforts.filter((e) => e.state === "active" || e.state === "starting");
+  const mine = openEfforts.find(
+    (e) => c.checkoutRoot && existsSync3(e.worktree) ? same(e.worktree, c.checkoutRoot) : e.branch === c.branch
+  );
   for (const lease of c.registry.leases({ project: c.project, kind: "commons" })) {
     const holder = efforts.get(lease.effort);
     const holderHasWorktree = Boolean(holder && existsSync3(holder.worktree));
@@ -568,34 +635,31 @@ function checkCommit(c) {
     } else if (lease.owner.session === c.ownerSession) {
       continue;
     }
+    if (holder && mine && holder.area === mine.area) continue;
     const globs = c.m.commons[String(lease.value)] ?? [];
-    const hit = pathsMatching(c.stagedPaths, globs);
+    const hit = pathsMatching(ownPaths, globs);
     if (hit.length > 0) {
       refusals.push(
         `commons "${lease.value}" is write-locked by ${lease.owner.session} (effort ${lease.effort}, since ${lease.touched}); staged: ${hit.join(", ")}`
       );
     }
   }
-  const openEfforts = allEfforts.filter((e) => e.state === "active" || e.state === "starting");
   for (const other of openEfforts) {
     if (c.checkoutRoot && existsSync3(other.worktree) && same(other.worktree, c.checkoutRoot)) {
       continue;
     }
     if (!c.checkoutRoot && other.branch === c.branch) continue;
-    const hit = pathsMatching(c.stagedPaths, other.scopes);
+    const hit = pathsMatching(ownPaths, other.scopes);
     if (hit.length > 0) {
       refusals.push(
         `path(s) ${hit.join(", ")} are inside the active scope of ${effortLabel(other)} (${other.branch}, owned by ${other.owner.session})`
       );
     }
   }
-  const mine = openEfforts.find(
-    (e) => c.checkoutRoot && existsSync3(e.worktree) ? same(e.worktree, c.checkoutRoot) : e.branch === c.branch
-  );
-  if (mine && c.stagedPaths.length > 0) {
+  if (mine && ownPaths.length > 0) {
     const allowed = allowedScopesForEffort(c.m, mine);
-    const inScope = new Set(pathsMatching(c.stagedPaths, allowed));
-    const outside = c.stagedPaths.filter((p) => !inScope.has(p));
+    const inScope = new Set(pathsMatching(ownPaths, allowed));
+    const outside = ownPaths.filter((p) => !inScope.has(p));
     if (outside.length > 0) {
       warnings.push(
         `${outside.length} staged path(s) are outside the effort's scope (${effortLabel(mine)}): ${outside.join(", ")}`
@@ -922,8 +986,19 @@ function rangesFor(m) {
 function rangesOverlap(a, b) {
   return a.base < b.base + b.count && b.base < a.base + a.count;
 }
+function ensureRanges(registry, m, repoRoot) {
+  const mine = rangesFor(m);
+  assertNoOverlap(registry, m, mine);
+  const current = registry.project(m.project);
+  if (current && JSON.stringify(current.ranges) === JSON.stringify(mine)) return;
+  registry.upsertProject(m.project, { root: repoRoot, ranges: mine });
+}
 function claimRanges(registry, m, repoRoot) {
   const mine = rangesFor(m);
+  assertNoOverlap(registry, m, mine);
+  registry.upsertProject(m.project, { root: repoRoot, ranges: mine });
+}
+function assertNoOverlap(registry, m, mine) {
   const others = Object.entries(registry.read().projects).filter(([name]) => name !== m.project);
   for (const [service, range] of Object.entries(mine)) {
     for (const [name, entry] of others) {
@@ -938,7 +1013,6 @@ function claimRanges(registry, m, repoRoot) {
       }
     }
   }
-  registry.upsertProject(m.project, { root: repoRoot, ranges: mine });
 }
 
 // src/core/refresh.ts
@@ -1070,8 +1144,8 @@ import {
 } from "fs";
 var newId = (prefix) => `${prefix}_${randomBytes(4).toString("hex")}`;
 var EMPTY = { version: 1, projects: {}, leases: [], efforts: [] };
-var LOCK_STALE_MS = 3e4;
-var LOCK_WAIT_MS = 5e3;
+var LOCK_STALE_MS = 1e4;
+var LOCK_WAIT_MS = 15e3;
 function sleep(ms) {
   Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
 }
@@ -1127,7 +1201,9 @@ var Registry = class _Registry {
       } catch {
         try {
           if (Date.now() - statSync2(lock).mtimeMs > LOCK_STALE_MS) {
-            rmSync2(lock, { recursive: true, force: true });
+            const claimed = `${lock}.stale.${process.pid}.${Date.now()}`;
+            renameSync(lock, claimed);
+            rmSync2(claimed, { recursive: true, force: true });
             continue;
           }
         } catch {
@@ -1237,7 +1313,7 @@ var Registry = class _Registry {
       if (slot < 0) {
         throw new WorkkitError(
           "NO_FREE_SLOT",
-          `no free slot in ${project} (0..${m.slots.count - 1}, reserved ${[...reserved].join(",")})`
+          `no free slot in ${project} (0..${m.slots.count - 1}, reserved ${[...reserved].join(",")}): \`work status\` lists the efforts holding them; \`work finish\` or \`work reap\` frees one`
         );
       }
       const lease = this.lease(
@@ -1480,10 +1556,14 @@ function currentOwner(env = process.env) {
   return { session: named ?? `${userInfo().username}@${hostname()}`, pid: process.pid };
 }
 
+// src/lib/pritty.ts
+import { spawnSync as spawnSync5 } from "child_process";
+
 // src/lib/storybrokr.ts
 import { spawnSync as spawnSync4 } from "child_process";
 var MIN_STORYBROKR_VERSION = "0.3.0";
 var versionChecked = false;
+var versionFound = "";
 function compareSemver(a, b) {
   const pa = a.trim().replace(/^v/, "").split(".").map((n) => Number.parseInt(n, 10) || 0);
   const pb = b.trim().replace(/^v/, "").split(".").map((n) => Number.parseInt(n, 10) || 0);
@@ -1514,12 +1594,14 @@ function assertStorybrokrVersion() {
     );
   }
   versionChecked = true;
+  versionFound = found;
 }
 var storybrokrCli = {
   async up(story, hostRoot, opts) {
     assertStorybrokrVersion();
     const args = ["up", story, "--host", hostRoot, "--json"];
     if (opts?.ttlMinutes !== void 0) args.push("--ttl", String(opts.ttlMinutes));
+    if (opts?.includeChildren) args.push("--include-children");
     const r = run(args);
     if (r.code !== 0) {
       throw new WorkkitError(
@@ -1536,8 +1618,26 @@ var storybrokrCli = {
       throw new WorkkitError("STORYBROKR_FAILED", `storybrokr down ${id} failed: ${r.err.trim()}`);
   },
   async downHost(hostRoot) {
-    const r = spawnSync4("storybrokr", ["down", "--host", hostRoot, "--json"], { encoding: "utf8" });
-    void r;
+    const r = spawnSync4("storybrokr", ["down", "--host", hostRoot, "--if-running", "--json"], {
+      encoding: "utf8"
+    });
+    if (r.error) return [];
+    if (r.status !== 0) {
+      throw new WorkkitError(
+        "STORYBROKR_FAILED",
+        `storybrokr down --host ${hostRoot} failed: ${(r.stderr || r.stdout || "").trim()}`
+      );
+    }
+    try {
+      const parsed = JSON.parse(r.stdout);
+      return parsed.stopped ?? [];
+    } catch {
+      return [];
+    }
+  },
+  version() {
+    assertStorybrokrVersion();
+    return versionFound;
   },
   async touch(id) {
     const r = spawnSync4("storybrokr", ["touch", id], { encoding: "utf8" });
@@ -1545,6 +1645,81 @@ var storybrokrCli = {
   }
 };
 
+// src/lib/pritty.ts
+var MIN_PRITTY_VERSION = "0.1.2";
+function assertPrittyVersion(client) {
+  const found = client.version();
+  if (compareSemver(found, MIN_PRITTY_VERSION) < 0) {
+    throw new WorkkitError(
+      "PRITTY_FAILED",
+      `pritty >= ${MIN_PRITTY_VERSION} required (found ${found || "unknown"}); npm i -g @helmsmith/pritty`
+    );
+  }
+}
+function run2(args, cwd) {
+  const r = spawnSync5("pritty", args, { cwd, encoding: "utf8", env: process.env });
+  if (r.error) {
+    throw new WorkkitError(
+      "PRITTY_FAILED",
+      `pritty is not installed (npm i -g @helmsmith/pritty): ${r.error.message}`
+    );
+  }
+  return { code: r.status ?? 1, out: r.stdout ?? "", err: r.stderr ?? "" };
+}
+function lastJsonLine(out, what) {
+  const line = out.trim().split("\n").filter(Boolean).pop() ?? "";
+  try {
+    return JSON.parse(line);
+  } catch {
+    throw new WorkkitError("PRITTY_FAILED", `pritty ${what} printed no JSON: ${out.trim()}`);
+  }
+}
+var versionFound2;
+var prittyCli = {
+  version() {
+    if (versionFound2 === void 0) {
+      const r = run2(["--version"]);
+      versionFound2 = r.code === 0 ? r.out.trim() : "";
+    }
+    return versionFound2;
+  },
+  async pr(o) {
+    const args = ["pr", "--base", o.base, "--no-push", "--auto-approve", "--json"];
+    if (o.draft) args.push("--draft");
+    if (o.title !== void 0) args.push("--title", o.title);
+    if (o.body !== void 0) args.push("--body", o.body);
+    if (o.bodyFile !== void 0) args.push("--body-file", o.bodyFile);
+    const r = run2(args, o.cwd);
+    if (r.code !== 0) {
+      throw new WorkkitError("PRITTY_FAILED", `pritty pr failed: ${(r.err || r.out).trim()}`, {
+        stderr: r.err
+      });
+    }
+    const j = lastJsonLine(
+      r.out,
+      "pr"
+    );
+    return { number: j.number, url: j.url, draft: Boolean(j.draft), created: Boolean(j.created) };
+  },
+  async check(o) {
+    const r = run2(["pr", "--check", "--base", o.base], o.cwd);
+    if (r.code !== 0) {
+      throw new WorkkitError(
+        "PRITTY_FAILED",
+        `pritty pr --check failed: ${(r.err || r.out).trim()}`,
+        {
+          stderr: r.err
+        }
+      );
+    }
+    const j = lastJsonLine(r.out, "pr --check");
+    return {
+      open: j.open ? { number: j.open.number, url: j.open.url, draft: Boolean(j.open.draft) } : null,
+      last: j.last ?? null
+    };
+  }
+};
+
 // src/lib/context.ts
 function resolveRepoRoot(cwd, override) {
   if (override) return override;
@@ -1555,7 +1730,7 @@ async function buildCtx(opts = {}) {
   const manifest = await loadManifest(repoRoot);
   const home = homeDir();
   const registry = Registry.open(home);
-  if (!registry.project(manifest.project)) claimRanges(registry, manifest, repoRoot);
+  ensureRanges(registry, manifest, repoRoot);
   return {
     home,
     repoRoot,
@@ -1564,6 +1739,7 @@ async function buildCtx(opts = {}) {
     owner: currentOwner(),
     runner: { start: startServices, stop: stopServices },
     storybrokr: storybrokrCli,
+    pritty: prittyCli,
     log: opts.quiet ? () => {
     } : (line) => console.error(chalk.gray(line))
   };
@@ -1576,9 +1752,11 @@ import {
   existsSync as existsSync7,
   mkdirSync as mkdirSync6,
   readdirSync,
+  readFileSync as readFileSync5,
   realpathSync as realpathSync4,
   rmSync as rmSync3,
-  statSync as statSync3
+  statSync as statSync3,
+  writeFileSync as writeFileSync5
 } from "fs";
 import { connect, createServer } from "net";
 import { dirname as dirname3, join as join8 } from "path";
@@ -1623,22 +1801,26 @@ function touchEffort(ctx, effort) {
   }
   ctx.registry.updateEffort(effort.id, { lastActivity: now() });
 }
-function portBusy(port) {
+function bindFails(port, host) {
   return new Promise((resolve4) => {
     const srv = createServer();
-    srv.once("error", () => resolve4(true));
-    srv.listen(port, "127.0.0.1", () => srv.close(() => resolve4(false)));
+    srv.once("error", (err) => resolve4(err.code === "EADDRINUSE"));
+    srv.listen(port, host, () => srv.close(() => resolve4(false)));
   });
 }
+async function portBusy(port) {
+  for (const host of ["127.0.0.1", "0.0.0.0", "::"]) if (await bindFails(port, host)) return true;
+  return false;
+}
 async function busyPorts(ports) {
   const out = [];
   for (const [service, port] of Object.entries(ports))
     if (await portBusy(port)) out.push(`${service}=${port}`);
   return out;
 }
-function portAnswers(port) {
+function portAnswersOn(port, host) {
   return new Promise((resolve4) => {
-    const sock = connect({ port, host: "127.0.0.1" });
+    const sock = connect({ port, host });
     const done = (v) => {
       sock.destroy();
       resolve4(v);
@@ -1648,6 +1830,9 @@ function portAnswers(port) {
     sock.once("error", () => done(false));
   });
 }
+async function portAnswers(port) {
+  return await portAnswersOn(port, "127.0.0.1") || await portAnswersOn(port, "::1");
+}
 async function anyPortAnswers(ports) {
   for (const port of Object.values(ports ?? {})) if (await portAnswers(port)) return true;
   return false;
@@ -1764,6 +1949,15 @@ function reserveEffort(ctx, o, branch, scopes, commons) {
   });
   return effort;
 }
+function areaBranchFor(ctx, area, preferredType) {
+  const main = new Git(ctx.repoRoot);
+  const types = [preferredType, ...ctx.manifest.branch.types.filter((t) => t !== preferredType)];
+  for (const type of types) {
+    const b = branchFor(type, area);
+    if (main.branchExists(b) || main.remoteRef(b)) return b;
+  }
+  return branchFor(preferredType, area);
+}
 function ensureWorktree(ctx, area, branch, task) {
   const m = ctx.manifest;
   const path = worktreePathFor(ctx, area, task);
@@ -1815,8 +2009,25 @@ function appendLog(file, line) {
   appendFileSync2(file, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `);
 }
+var PENDING_MARKS = ".pending-marks.json";
+function readPendingMarks(logDir) {
+  try {
+    const raw = JSON.parse(readFileSync5(join8(logDir, PENDING_MARKS), "utf8"));
+    return Array.isArray(raw) ? raw.filter((x) => typeof x === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function writePendingMarks(logDir, marks) {
+  mkdirSync6(logDir, { recursive: true });
+  writeFileSync5(join8(logDir, PENDING_MARKS), `${JSON.stringify(marks)}
+`);
+}
 async function startEffort(ctx, o) {
   const m = ctx.manifest;
+  await reapLeases(ctx).catch(
+    (err) => ctx.log(`pre-flight reap: ${err instanceof Error ? err.message : String(err)}`)
+  );
   fetchBaseOnce(ctx);
   const { branch, scopes, commons, warnings } = guardStart(ctx, o);
   const notices = ctx.registry.notices(m.project, o.area);
@@ -1960,6 +2171,9 @@ async function startEffort(ctx, o) {
       }
     );
     const baseSha = wg.rev("HEAD");
+    if (o.mode === "frontend" && sel.marks.length > 0) {
+      writePendingMarks(logDir, [.../* @__PURE__ */ new Set([...readPendingMarks(logDir), ...sel.marks])]);
+    }
     for (const name of commons)
       leases.push(
         ctx.registry.addLease(
@@ -1983,8 +2197,13 @@ async function startEffort(ctx, o) {
         branch
       });
       const env = { ...process.env, ...cfg.vars };
-      if (sel.marks.includes("db-reset") && m.services.postgres?.reset) {
+      const owedMarks = [.../* @__PURE__ */ new Set([...sel.marks, ...readPendingMarks(logDir)])];
+      if (owedMarks.includes("db-reset") && m.services.postgres?.reset) {
         runRefresh([m.services.postgres.reset], worktree, (l) => appendLog(refreshLog, l), env);
+        writePendingMarks(
+          logDir,
+          owedMarks.filter((x) => x !== "db-reset")
+        );
       }
       const pids = {};
       const signatures = {};
@@ -2073,7 +2292,7 @@ async function promoteEffort(ctx, o) {
   }
   const modeScopes = expandScopes(m, o.area, o.mode);
   const nextScopes = open.task ? [.../* @__PURE__ */ new Set([...open.scopes, ...modeScopes])] : modeScopes;
-  ctx.registry.update((r) => {
+  const refuseOverlap = (r) => {
     const others = r.efforts.filter(
       (e) => e.project === m.project && e.id !== open.id && (e.state === "active" || e.state === "starting")
     );
@@ -2088,17 +2307,49 @@ async function promoteEffort(ctx, o) {
         );
       }
     }
-    const idx = r.efforts.findIndex((e) => e.id === open.id);
-    if (idx >= 0) {
-      r.efforts[idx] = { ...r.efforts[idx], mode: o.mode, scopes: nextScopes, lastActivity: now() };
-    }
-  });
+  };
+  ctx.registry.update(refuseOverlap);
   const warnings = [];
   let slot = ctx.registry.leases({ effort: open.id, kind: "slot" })[0];
   const sb = ctx.registry.leases({ effort: open.id, kind: "storybook" })[0];
-  if (!slot) {
-    slot = await claimFreeSlot(ctx, open.id, warnings);
-    ctx.registry.updateEffort(open.id, { leases: [...open.leases, slot.id] });
+  const claimed = !slot;
+  if (!slot) slot = await claimFreeSlot(ctx, open.id, warnings);
+  try {
+    ctx.registry.update((r) => {
+      refuseOverlap(r);
+      const idx = r.efforts.findIndex((e) => e.id === open.id);
+      if (idx >= 0) {
+        r.efforts[idx] = {
+          ...r.efforts[idx],
+          mode: o.mode,
+          scopes: nextScopes,
+          leases: claimed ? [...open.leases, slot.id] : r.efforts[idx].leases,
+          lastActivity: now()
+        };
+      }
+    });
+  } catch (err) {
+    if (claimed) ctx.registry.release(slot.id);
+    throw err;
+  }
+  const owed = readPendingMarks(join8(open.worktree, m.logs.dir));
+  if (owed.includes("db-reset") && m.services.postgres?.reset) {
+    const cfgForReset = emitWorktreeConfig({
+      m,
+      worktree: open.worktree,
+      slot: slot.value,
+      ports: slot.ports ?? {},
+      area: o.area,
+      branch: open.branch
+    });
+    runRefresh([m.services.postgres.reset], open.worktree, ctx.log, {
+      ...process.env,
+      ...cfgForReset.vars
+    });
+    writePendingMarks(
+      join8(open.worktree, m.logs.dir),
+      owed.filter((x) => x !== "db-reset")
+    );
   }
   const cfg = emitWorktreeConfig({
     m,
@@ -2149,9 +2400,7 @@ async function promoteEffort(ctx, o) {
 }
 function behindBase(ctx, worktree) {
   if (!existsSync7(worktree)) return 0;
-  const g = new Git(worktree);
-  const r = g.tryRun(["rev-list", "--count", `HEAD..origin/${ctx.manifest.baseBranch}`]);
-  return r.code === 0 ? Number(r.out.trim()) || 0 : 0;
+  return new Git(worktree).behindCount(ctx.manifest.baseBranch);
 }
 function statusFor(ctx, area, task) {
   const m = ctx.manifest;
@@ -2233,6 +2482,15 @@ async function releaseLease(ctx, effort, lease) {
   }
   ctx.registry.release(lease.id);
 }
+async function sweepStorybook(ctx, effort) {
+  if (effort.mode === "backend" || !ctx.storybrokr.downHost) return;
+  try {
+    const stopped = await ctx.storybrokr.downHost(storybookHostFor(ctx.manifest, effort.worktree));
+    if (stopped.length > 0) ctx.log(`storybrokr: stopped ${stopped.join(", ")}`);
+  } catch (err) {
+    ctx.log(`storybrokr sweep failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
 function leaveNotices(ctx, effort, commons) {
   if (commons.length === 0) return 0;
   const notice = {
@@ -2301,7 +2559,7 @@ async function finishEffort(ctx, o) {
       );
     }
     fetchBaseOnce(ctx);
-    const parentBranch = branchFor(effort.type, effort.area);
+    const parentBranch = areaBranchFor(ctx, effort.area, effort.type);
     const { wg: areaGit } = ensureWorktree(ctx, effort.area, parentBranch);
     if (areaGit.isDirty()) {
       throw new WorkkitError(
@@ -2321,14 +2579,24 @@ async function finishEffort(ctx, o) {
       );
     }
   }
+  fetchBaseOnce(ctx);
+  const shouldPush = !o.intoArea && (g.ownCommitCount(m.baseBranch) > 0 || g.remoteBranchExists(effort.branch));
+  if (shouldPush) {
+    try {
+      g.push(effort.branch);
+    } catch (err) {
+      throw new WorkkitError(
+        "PUSH_REJECTED",
+        `push of ${effort.branch} was rejected (${err instanceof Error ? err.message : String(err)}); nothing was stopped or released. Merge origin/${effort.branch} into the worktree and run \`work finish\` again.`,
+        { branch: effort.branch, worktree: effort.worktree }
+      );
+    }
+  }
   for (const lease of ctx.registry.leases({ effort: effort.id }))
     await releaseLease(ctx, effort, lease);
-  await Promise.resolve(ctx.storybrokr.downHost?.(storybookHostFor(m, effort.worktree))).catch(
-    () => void 0
-  );
+  await sweepStorybook(ctx, effort);
   let notices = 0;
   if (!o.intoArea) {
-    g.push(effort.branch);
     if (g.commitsNotOn(m.baseBranch).length > 0 && !g.isEquivalentToBase(m.baseBranch)) {
       const since = g.changedSince(m.baseBranch);
       const sinceSet = new Set(since);
@@ -2347,14 +2615,14 @@ async function finishEffort(ctx, o) {
     ctx.registry.removeEfforts((e) => e.id === effort.id);
     return {
       effort: finished2,
-      pushed: !o.intoArea,
+      pushed: shouldPush,
       parked,
       mergedIntoArea: Boolean(o.intoArea),
       notices
     };
   }
   const finished = ctx.registry.updateEffort(effort.id, { state: "finished", lastActivity: now() });
-  return { effort: finished, pushed: true, parked, notices };
+  return { effort: finished, pushed: shouldPush, parked, notices };
 }
 async function reapLeases(ctx, o = {}) {
   const m = ctx.manifest;
@@ -2371,19 +2639,24 @@ async function reapLeases(ctx, o = {}) {
     const garbage = orphaned && !await anyPortAnswers(l.ports);
     if (expired || garbage) doomed.add(l.effort);
   }
+  for (const e of efforts.values()) {
+    if (e.state !== "starting" || doomed.has(e.id)) continue;
+    if (leases.some((l) => l.effort === e.id)) continue;
+    if (Date.now() - Date.parse(e.started) < STARTING_GRACE_MS) continue;
+    doomed.add(e.id);
+  }
   const reaped = leases.filter((l) => doomed.has(l.effort));
   if (o.dryRun) return { reaped };
   for (const lease of reaped) await releaseLease(ctx, efforts.get(lease.effort), lease);
   for (const id of doomed) {
     const effort = efforts.get(id);
     if (effort) {
-      await Promise.resolve(ctx.storybrokr.downHost?.(storybookHostFor(m, effort.worktree))).catch(
-        () => void 0
-      );
+      await sweepStorybook(ctx, effort);
       if (effort.state === "active" || effort.state === "starting") {
+        const hadLease = leases.some((l) => l.effort === effort.id);
         ctx.registry.updateEffort(effort.id, {
           state: "parked",
-          parkedReason: `idle: a lease expired by ${at.toISOString()}`,
+          parkedReason: hadLease ? `idle: a lease expired by ${at.toISOString()}` : `start died before its first lease (started ${effort.started})`,
           lastActivity: now()
         });
       }
@@ -2441,9 +2714,6 @@ async function retireArea(ctx, o) {
   const worktree = realpathOr2(worktreePathFor(ctx, o.area));
   const main = new Git(ctx.repoRoot);
   let archived = [];
-  await Promise.resolve(ctx.storybrokr.downHost?.(storybookHostFor(m, worktree))).catch(
-    () => void 0
-  );
   if (existsSync7(worktree)) {
     const g = new Git(worktree);
     if (g.isDirty())
@@ -2459,16 +2729,20 @@ async function retireArea(ctx, o) {
         `${g.currentBranch()} has ${unpushed} commit(s) not on origin; push before retiring`,
         { worktree, unpushed }
       );
+    const hadStorybook = ctx.registry.efforts({ project: m.project, area: o.area }).some((e) => e.mode !== "backend");
+    if (hadStorybook) await sweepStorybook(ctx, { worktree, mode: "frontend" });
     archived = archiveWorktree(ctx, o.area, worktree);
     main.worktreeRemove(worktree);
   }
   const branchesDeleted = [];
   const branchesKept = [];
   const allAreaBranches = m.branch.types.map((type) => `${type}/${o.area}`);
+  fetchBaseOnce(ctx);
   for (const branch of allAreaBranches) {
     if (!main.branchExists(branch)) continue;
     const onOrigin = main.remoteBranchExists(branch) && main.tryRun(["rev-list", "--count", `origin/${branch}..${branch}`]).out.trim() === "0";
-    if (onOrigin) {
+    const mergedIntoBase = !onOrigin && main.branchMergedInto(branch, m.baseBranch);
+    if (onOrigin || mergedIntoBase) {
       main.deleteLocalBranch(branch);
       branchesDeleted.push(branch);
     } else branchesKept.push(branch);
@@ -2478,6 +2752,94 @@ async function retireArea(ctx, o) {
   ctx.registry.clearNoticesFrom(m.project, allAreaBranches);
   return { archived, removed: worktree, branchesDeleted, branchesKept };
 }
+function effortAt(ctx, cwd) {
+  const top = new Git(cwd).tryRun(["rev-parse", "--show-toplevel"]);
+  if (top.code !== 0) return void 0;
+  const root = realpathOr2(top.out.trim());
+  return ctx.registry.efforts({ project: ctx.manifest.project }).filter((e) => e.state === "active" || e.state === "starting" || e.state === "parked").sort((a, b) => b.lastActivity.localeCompare(a.lastActivity)).find((e) => realpathOr2(e.worktree) === root);
+}
+async function prEffort(ctx, o) {
+  const m = ctx.manifest;
+  assertPrittyVersion(ctx.pritty);
+  const effort = o.area ? ctx.registry.openEffortFor(m.project, o.area, o.task) ?? ctx.registry.efforts({ project: m.project, area: o.area, state: "parked" }).filter((e) => (e.task ?? void 0) === (o.task ?? void 0)).sort((a, b) => b.started.localeCompare(a.started))[0] : effortAt(ctx, o.cwd ?? process.cwd());
+  if (!effort) {
+    throw new WorkkitError(
+      "EFFORT_NOT_FOUND",
+      o.area ? `no open or parked effort on ${effortLabel2(o.area, o.task)}` : `${o.cwd ?? process.cwd()} is not inside an effort's worktree; pass the area`,
+      { area: o.area, task: o.task }
+    );
+  }
+  const label = effortLabel2(effort.area, effort.task);
+  const g = new Git(effort.worktree);
+  if (g.isDirty()) {
+    throw new WorkkitError(
+      "DIRTY_WORKTREE",
+      `${effort.worktree} has uncommitted changes: commit them, or \`work finish --park\` to commit them as wip(${label}) and push`,
+      { worktree: effort.worktree }
+    );
+  }
+  fetchBaseOnce(ctx);
+  const warnings = [];
+  if (!g.hasUpstream() || g.unpushedCount(m.baseBranch) > 0) {
+    try {
+      g.push(effort.branch);
+    } catch (err) {
+      throw new WorkkitError(
+        "PUSH_REJECTED",
+        `push of ${effort.branch} was rejected (${err instanceof Error ? err.message : String(err)}); merge origin/${effort.branch} into the worktree and run \`work pr\` again`,
+        { branch: effort.branch, worktree: effort.worktree }
+      );
+    }
+  }
+  const behind = g.behindCount(m.baseBranch);
+  if (behind > BEHIND_LIMIT) {
+    warnings.push(
+      `${effort.branch} is ${behind} commits behind ${m.baseBranch}; consider merging origin/${m.baseBranch} before review`
+    );
+  }
+  const given = o.title !== void 0 || o.body !== void 0 || o.bodyFile !== void 0;
+  const store = (pr2) => {
+    const updated = ctx.registry.updateEffort(effort.id, { pr: pr2, lastActivity: now() });
+    touchEffort(ctx, updated);
+    return updated;
+  };
+  if (effort.pr) {
+    const { open, last } = await ctx.pritty.check({ cwd: effort.worktree, base: m.baseBranch });
+    if (open) {
+      if (!given) {
+        return { effort: store(open), pr: open, created: false, behindBase: behind, warnings };
+      }
+      const updated = await ctx.pritty.pr({
+        cwd: effort.worktree,
+        base: m.baseBranch,
+        draft: o.draft,
+        title: o.title,
+        body: o.body,
+        bodyFile: o.bodyFile
+      });
+      const pr2 = { number: updated.number, url: updated.url, draft: updated.draft };
+      return { effort: store(pr2), pr: pr2, created: false, behindBase: behind, warnings };
+    }
+    if (!o.force) {
+      const fate = last?.number === effort.pr.number ? last.state === "MERGED" ? "was merged" : "was closed without merging" : "is no longer open";
+      throw new WorkkitError(
+        "PR_CLOSED",
+        `PR #${effort.pr.number} for ${label} ${fate} (${effort.pr.url}); pass --force to open a new one`,
+        { pr: effort.pr, state: last?.state }
+      );
+    }
+  }
+  const res = await ctx.pritty.pr({
+    cwd: effort.worktree,
+    base: m.baseBranch,
+    draft: o.draft,
+    title: o.title,
+    body: o.body,
+    bodyFile: o.bodyFile
+  });
+  const pr = { number: res.number, url: res.url, draft: res.draft };
+  return { effort: store(pr), pr, created: res.created, behindBase: behind, warnings };
+}
 var BEHIND_LIMIT = 20;
 var NOTICE_STALE_MS = 7 * 864e5;
 var ARCHIVE_LIMIT_BYTES = 5 * 1024 ** 3;
@@ -2665,7 +3027,7 @@ function registerFinish(program2) {
 }
 
 // src/commands/hook.ts
-import { readFileSync as readFileSync5, realpathSync as realpathSync5 } from "fs";
+import { readFileSync as readFileSync6, realpathSync as realpathSync5 } from "fs";
 import { resolve as resolve2 } from "path";
 import chalk5 from "chalk";
 var ZEROS = /^0+$/;
@@ -2763,7 +3125,7 @@ function registerHook(program2) {
     "Refuse pushes to protected branches; warn when paths leave the effort scope or touch commons"
   ).argument("[remote]", "passed by git, unused").argument("[url]", "passed by git, unused").action(async () => {
     try {
-      const stdin = process.stdin.isTTY ? "" : readFileSync5(0, "utf8");
+      const stdin = process.stdin.isTTY ? "" : readFileSync6(0, "utf8");
       process.exit(await runPrePush(process.cwd(), stdin));
     } catch (err) {
       fail(err, false);
@@ -2786,7 +3148,7 @@ function registerHook(program2) {
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync8, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync8, writeFileSync as writeFileSync6 } from "fs";
 import { join as join9, resolve as resolve3 } from "path";
 var STORYBOOK_BASE = 6100;
 function defaultService(name) {
@@ -2862,7 +3224,7 @@ function runInit(o) {
   }
   const manifest = buildStarterManifest(o);
   const manifestPath = join9(repoRoot, "helmsmith.config.mjs");
-  writeFileSync5(manifestPath, `${HEADER}export default ${JSON.stringify(manifest, null, 2)};
+  writeFileSync6(manifestPath, `${HEADER}export default ${JSON.stringify(manifest, null, 2)};
 `);
   claimRanges(Registry.open(o.home), validateManifest(manifest), repoRoot);
   const hooks = o.hooks ? installHooks(repoRoot, { protectedBranches: [o.baseBranch] }).files : [];
@@ -2930,7 +3292,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z as z2 } from "zod";
 
 // src/version.ts
-import { existsSync as existsSync9, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
 import { dirname as dirname4, join as join10 } from "path";
 import { fileURLToPath } from "url";
 function findPackageJson(startDir) {
@@ -2944,7 +3306,7 @@ function findPackageJson(startDir) {
   }
 }
 var pkgFile = findPackageJson(dirname4(fileURLToPath(import.meta.url)));
-var VERSION = JSON.parse(readFileSync6(pkgFile, "utf8")).version;
+var VERSION = JSON.parse(readFileSync7(pkgFile, "utf8")).version;
 
 // src/mcp/server.ts
 var ok = (value) => ({
@@ -2969,7 +3331,9 @@ function buildMcpServer(ctxFactory) {
       description: "Start an effort on an area (or intra-area task): its worktree on <type>/<area> (or <type>/<area>--<task>), synced from the base branch, refreshed, leased (a slot for fullstack/backend, a storybrokr instance for frontend with a story) and running. Refuses with EFFORT_OPEN (another effort is open; join=true to share it), SCOPE_CONFLICT, SYNC_CONFLICT (resolve in the worktree, rerun with sync=false).",
       inputSchema: {
         area: z2.string().describe("a leaf area from helmsmith.config (e.g. org/applications)"),
-        task: z2.string().optional().describe("optional intra-area task slug for parallel sub-efforts (<type>/<area>--<task>)"),
+        task: z2.string().optional().describe(
+          "optional intra-area task slug for parallel sub-efforts (<type>/<area>--<task>)"
+        ),
         type: z2.string().describe("feature | chore | fix"),
         mode: z2.enum(["frontend", "backend", "fullstack"]),
         scopes: z2.array(z2.string()).optional().describe("optional narrowed scope globs for a task sub-effort"),
@@ -3002,11 +3366,38 @@ function buildMcpServer(ctxFactory) {
         area: z2.string().describe("the area of the open effort"),
         task: z2.string().optional().describe("optional intra-area task slug"),
         mode: z2.enum(["backend", "fullstack"]).describe("target mode to promote into"),
-        story: z2.string().optional().describe("optional story path"),
         projectRoot: z2.string().optional().describe("optional repository root path override")
       }
     },
-    async ({ area, task, mode, story, projectRoot }) => guard(async () => promoteEffort(await ctxFactory(projectRoot), { area, task, mode, story }))
+    async ({ area, task, mode, projectRoot }) => guard(async () => promoteEffort(await ctxFactory(projectRoot), { area, task, mode }))
+  );
+  server.registerTool(
+    "work_pr",
+    {
+      description: "Open the effort's pull request through pritty: pushes the branch first, reuses a stored PR that is still open (updating its title/body when given), refuses with PR_CLOSED when it was merged or closed unless force, and stores { number, url, draft } on the effort. Pass title and body: the agent writes the words, pritty's AI path is only the fallback.",
+      inputSchema: {
+        area: z2.string().optional().describe("the area of the effort (default: the effort of the cwd worktree)"),
+        task: z2.string().optional().describe("optional intra-area task slug"),
+        draft: z2.boolean().optional().describe("open a draft PR"),
+        title: z2.string().optional().describe("PR title"),
+        // body text only: a file path here would let any MCP caller have pritty read an
+        // arbitrary file and publish it as a PR body; read the file yourself and pass the text
+        body: z2.string().optional().describe("PR body text (read your body file and pass its text)"),
+        force: z2.boolean().optional().describe("open a new PR when the stored one was closed"),
+        projectRoot: z2.string().optional().describe("optional repository root path override")
+      }
+    },
+    async ({ area, task, draft, title, body, force, projectRoot }) => guard(
+      async () => prEffort(await ctxFactory(projectRoot), {
+        area,
+        task,
+        cwd: process.cwd(),
+        draft,
+        title,
+        body,
+        force
+      })
+    )
   );
   server.registerTool(
     "work_status",
@@ -3084,24 +3475,56 @@ function registerMcp(program2) {
   });
 }
 
-// src/commands/promote.ts
+// src/commands/pr.ts
 import chalk6 from "chalk";
+function registerPr(program2) {
+  program2.command("pr [area]").description(
+    "Open the effort's pull request through pritty (push first, reuse an open PR, store it on the effort). No area: the effort of the cwd's worktree."
+  ).option("--task <slug>", "intra-area task slug").option("--draft", "open a draft PR").option("--title <title>", "PR title (with --body or --body-file: no AI involved)").option("--body <text>", "PR body text").option("--body-file <path>", "PR body from a file").option("--force", "open a new PR when the stored one was merged or closed").option("--project-root <dir>", "repository root (default: the main checkout of the cwd)").option("--json", "print the result as JSON").action(
+    async (area, o) => {
+      try {
+        const ctx = await buildCtx({ projectRoot: o.projectRoot, quiet: Boolean(o.json) });
+        const r = await prEffort(ctx, {
+          area,
+          task: o.task,
+          cwd: process.cwd(),
+          draft: o.draft,
+          title: o.title,
+          body: o.body,
+          bodyFile: o.bodyFile,
+          force: o.force
+        });
+        if (o.json) printJson(r);
+        else {
+          for (const w of r.warnings) console.error(chalk6.yellow(w));
+          console.log(
+            `${r.created ? "opened" : "open"} PR #${r.pr.number}${r.pr.draft ? " (draft)" : ""} for ${r.effort.branch}: ${r.pr.url}`
+          );
+        }
+      } catch (err) {
+        fail(err, Boolean(o.json));
+      }
+    }
+  );
+}
+
+// src/commands/promote.ts
+import chalk7 from "chalk";
 function registerPromote(program2) {
-  program2.command("promote").description("Promote an open effort in place to backend or fullstack mode").requiredOption("--area <area>", "the area of the open effort").option("--task <slug>", "intra-area task slug if promoting a task sub-effort").requiredOption("--mode <mode>", "target mode: backend | fullstack").option("--story <path>", "optional story path to attach via storybrokr").option("--project-root <dir>", "repository root (default: the main checkout of the cwd)").option("--json", "print the result as JSON").action(
+  program2.command("promote").description("Promote an open effort in place to backend or fullstack mode").requiredOption("--area <area>", "the area of the open effort").option("--task <slug>", "intra-area task slug if promoting a task sub-effort").requiredOption("--mode <mode>", "target mode: backend | fullstack").option("--project-root <dir>", "repository root (default: the main checkout of the cwd)").option("--json", "print the result as JSON").action(
     async (o) => {
       try {
         const ctx = await buildCtx({ projectRoot: o.projectRoot, quiet: Boolean(o.json) });
         const r = await promoteEffort(ctx, {
           area: o.area,
           task: o.task,
-          mode: o.mode,
-          story: o.story
+          mode: o.mode
         });
         if (o.json) printJson(r);
         else {
           const label = r.effort.task ? `${r.effort.area}--${r.effort.task}` : r.effort.area;
           console.log(
-            `${chalk6.bold(label)} promoted to ${r.effort.mode}${r.startedServices.length ? ` (started: ${r.startedServices.join(", ")})` : ""}`
+            `${chalk7.bold(label)} promoted to ${r.effort.mode}${r.startedServices.length ? ` (started: ${r.startedServices.join(", ")})` : ""}`
           );
           for (const w of r.warnings) warn(w);
         }
@@ -3113,7 +3536,7 @@ function registerPromote(program2) {
 }
 
 // src/commands/reap.ts
-import chalk7 from "chalk";
+import chalk8 from "chalk";
 function registerReap(program2) {
   program2.command("reap").description(
     "Expire idle leases: stop only what they started, release them, park their efforts"
@@ -3122,7 +3545,7 @@ function registerReap(program2) {
       const ctx = await buildCtx({ projectRoot: o.projectRoot, quiet: Boolean(o.json) });
       const r = await reapLeases(ctx, { dryRun: o.dryRun });
       if (o.json) printJson(r);
-      else if (r.reaped.length === 0) console.log(chalk7.gray("nothing to reap"));
+      else if (r.reaped.length === 0) console.log(chalk8.gray("nothing to reap"));
       else
         for (const l of r.reaped)
           console.log(
@@ -3135,7 +3558,7 @@ function registerReap(program2) {
 }
 
 // src/commands/retire.ts
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 function registerRetire(program2) {
   program2.command("retire").description(
     "Archive an area's evidence, remove its worktree and its local branches that are on origin (the only destructive verb)"
@@ -3145,11 +3568,11 @@ function registerRetire(program2) {
       const r = await retireArea(ctx, { area: o.area });
       if (o.json) printJson(r);
       else {
-        console.log(`${chalk8.bold(o.area)} retired: removed ${r.removed}`);
+        console.log(`${chalk9.bold(o.area)} retired: removed ${r.removed}`);
         for (const a of r.archived) console.log(`  archived ${a}`);
         for (const b of r.branchesDeleted) console.log(`  deleted local branch ${b}`);
         for (const b of r.branchesKept)
-          console.log(chalk8.yellow(`  kept ${b}: not fully on origin`));
+          console.log(chalk9.yellow(`  kept ${b}: not fully on origin`));
       }
     } catch (err) {
       fail(err, Boolean(o.json));
@@ -3158,12 +3581,12 @@ function registerRetire(program2) {
 }
 
 // src/commands/start.ts
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 function printStart(r) {
   const e = r.effort;
   const label = e.task ? `${e.area}--${e.task}` : e.area;
   console.log(
-    `${chalk9.bold(label)}  ${e.type}/${e.mode}  ${e.branch}${r.joined ? chalk9.yellow("  (joined)") : ""}`
+    `${chalk10.bold(label)}  ${e.type}/${e.mode}  ${e.branch}${r.joined ? chalk10.yellow("  (joined)") : ""}`
   );
   console.log(`  worktree  ${e.worktree}`);
   console.log(
@@ -3174,7 +3597,7 @@ function printStart(r) {
     console.log(`  lease     ${l.kind} ${l.value}${ports}  expires ${l.expires}`);
   }
   for (const w of r.warnings) warn(w);
-  for (const n of r.notices) console.log(chalk9.yellow(`  notice    ${n.text} (${n.at})`));
+  for (const n of r.notices) console.log(chalk10.yellow(`  notice    ${n.text} (${n.at})`));
 }
 function registerStart(program2) {
   program2.command("start").description(
@@ -3206,36 +3629,47 @@ function registerStart(program2) {
 }
 
 // src/commands/status.ts
-import chalk10 from "chalk";
+import chalk11 from "chalk";
 var age = (iso) => {
   const mins = Math.max(0, Math.round((Date.now() - Date.parse(iso)) / 6e4));
   return mins < 60 ? `${mins}m` : mins < 1440 ? `${Math.round(mins / 60)}h` : `${Math.round(mins / 1440)}d`;
 };
 var expiresIn = (iso) => {
   const mins = Math.round((Date.parse(iso) - Date.now()) / 6e4);
-  return mins <= 0 ? chalk10.red("expired") : mins < 60 ? `${mins}m` : `${Math.round(mins / 60)}h`;
+  return mins <= 0 ? chalk11.red("expired") : mins < 60 ? `${mins}m` : `${Math.round(mins / 60)}h`;
 };
 function printStatus(r) {
-  console.log(chalk10.bold(`${r.project}`));
-  const cols = ["AREA", "TYPE/MODE", "BRANCH", "OWNER", "STARTED", "LEASES", "BEHIND", "NOTICES"];
+  console.log(chalk11.bold(`${r.project}`));
+  const cols = [
+    "AREA",
+    "TYPE/MODE",
+    "BRANCH",
+    "OWNER",
+    "STARTED",
+    "LEASES",
+    "PR",
+    "BEHIND",
+    "NOTICES"
+  ];
   const rows = r.areas.map((a) => [
     a.area,
-    a.effort ? `${a.effort.type}/${a.effort.mode}` : chalk10.gray("-"),
-    a.effort?.branch ?? chalk10.gray("-"),
-    a.effort?.owner.session ?? chalk10.gray("-"),
-    a.effort ? age(a.effort.started) : chalk10.gray("-"),
-    a.leases.length ? a.leases.map((l) => `${l.kind}:${l.value}`).join(",") : chalk10.gray("-"),
-    a.behindBase > 0 ? chalk10.yellow(String(a.behindBase)) : "0",
-    a.notices.length ? chalk10.yellow(String(a.notices.length)) : "0"
+    a.effort ? `${a.effort.type}/${a.effort.mode}` : chalk11.gray("-"),
+    a.effort?.branch ?? chalk11.gray("-"),
+    a.effort?.owner.session ?? chalk11.gray("-"),
+    a.effort ? age(a.effort.started) : chalk11.gray("-"),
+    a.leases.length ? a.leases.map((l) => `${l.kind}:${l.value}`).join(",") : chalk11.gray("-"),
+    a.effort?.pr ? `#${a.effort.pr.number}${a.effort.pr.draft ? " draft" : ""}` : chalk11.gray("-"),
+    a.behindBase > 0 ? chalk11.yellow(String(a.behindBase)) : "0",
+    a.notices.length ? chalk11.yellow(String(a.notices.length)) : "0"
   ]);
   const plain = (s) => s.replace(/\u001b\[[0-9;]*m/g, "");
   const widths = cols.map((c, i) => Math.max(c.length, ...rows.map((row) => plain(row[i]).length)));
   const line = (cells) => cells.map((c, i) => c + " ".repeat(widths[i] - plain(c).length)).join("  ");
-  console.log(chalk10.bold(line(cols)));
+  console.log(chalk11.bold(line(cols)));
   for (const row of rows) console.log(line(row));
   if (r.leases.length) {
     console.log("");
-    console.log(chalk10.bold("KIND       VALUE        OWNER                 AGE   EXPIRES-IN"));
+    console.log(chalk11.bold("KIND       VALUE        OWNER                 AGE   EXPIRES-IN"));
     for (const l of r.leases) {
       console.log(
         `${l.kind.padEnd(10)} ${String(l.value).padEnd(12)} ${l.owner.session.padEnd(21)} ${age(l.created).padEnd(5)} ${expiresIn(l.expires)}`
@@ -3260,13 +3694,14 @@ function registerStatus(program2) {
 var { program } = createCli({
   name: "work",
   version: VERSION,
-  description: "Area-based work: start, promote, status, finish, reap, retire, audit."
+  description: "Area-based work: start, promote, status, pr, finish, reap, retire, audit."
 });
 registerInit(program);
 registerStart(program);
 registerPromote(program);
 registerStatus(program);
 registerEnv(program);
+registerPr(program);
 registerFinish(program);
 registerReap(program);
 registerRetire(program);