@helmsmith/workbrokr 0.1.0 → 0.3.0

package/dist/cli.js

@@ -25,23 +25,30 @@ function createCli(opts) {
 // src/commands/audit.ts
 import chalk3 from "chalk";
 
-// ../../platform/core/workkit-lib/src/config.ts
+// src/lib/context.ts
+import chalk from "chalk";
+
+// src/core/config.ts
 import {
   appendFileSync,
-  existsSync,
+  existsSync as existsSync2,
   mkdirSync as mkdirSync2,
   readFileSync,
   realpathSync as realpathSync2,
   writeFileSync
 } from "fs";
-import { join } from "path";
+import { join as join2 } from "path";
 
-// ../../platform/core/workkit-lib/src/errors.ts
+// src/core/errors.ts
 var REFUSALS = /* @__PURE__ */ new Set([
   "MANIFEST_INVALID",
   "AREA_UNKNOWN",
+  "TASK_INVALID",
   "TYPE_UNKNOWN",
   "MODE_UNKNOWN",
+  "MODE_MISMATCH",
+  "SCOPE_REQUIRES_TASK",
+  "SCOPE_OUTSIDE_AREA",
   "MAIN_CHECKOUT",
   "WORKTREE_INVALID",
   "PROTECTED_BRANCH",
@@ -54,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;
@@ -76,11 +84,19 @@ function toErrorBody(err) {
   return { code: "INTERNAL", message: err instanceof Error ? err.message : String(err) };
 }
 
-// ../../platform/core/workkit-lib/src/git.ts
+// src/core/git.ts
 import { spawnSync } from "child_process";
-import { mkdirSync, realpathSync } from "fs";
-import { dirname } from "path";
-var Git = class {
+import { existsSync, mkdirSync, realpathSync, rmSync, statSync } from "fs";
+import { dirname, join, resolve, sep } from "path";
+var realpathOr = (p) => {
+  try {
+    return realpathSync(p);
+  } catch {
+    return p;
+  }
+};
+var SAFE_SUBMODULE_NAME = /^[^\p{Cc}\s=]+$/u;
+var Git = class _Git {
   constructor(cwd) {
     this.cwd = cwd;
   }
@@ -149,12 +165,27 @@ var Git = class {
     else if (this.remoteBranchExists(this.currentBranch())) ref = `origin/${this.currentBranch()}`;
     return this.lines(["rev-list", `${ref}..HEAD`]).length;
   }
+  /** 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]);
   }
@@ -187,18 +218,45 @@ var Git = class {
     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]);
@@ -206,9 +264,89 @@ var Git = class {
   deleteLocalBranch(branch) {
     this.run(["branch", "-q", "-D", branch]);
   }
+  isAncestor(ancestor, descendant) {
+    return this.tryRun(["merge-base", "--is-ancestor", ancestor, descendant]).code === 0;
+  }
+  /** True when HEAD's tree matches origin/<base>, or every commit on HEAD is patch-equivalent to origin/<base> (squash-merged). */
+  isEquivalentToBase(base) {
+    const target = `origin/${base}`;
+    if (this.tryRun(["diff", "--quiet", target, "HEAD"]).code === 0) return true;
+    const cherry = this.tryRun(["cherry", target, "HEAD"]);
+    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("- "));
+  }
+  /**
+   * Give a linked worktree its own clone of every submodule the main checkout has initialized,
+   * cloned locally from the main checkout's module directory (no network) and then re-pointed at
+   * the real URL. `git worktree add` under submodule.recurse leaves a gitfile aimed at a module
+   * directory that was never cloned; a gitfile aimed at the MAIN checkout's module directory is
+   * worse, because that module's core.worktree is the main checkout's submodule, so any git
+   * command in the worktree's submodule (checkout -f, reset, merge) rewrites the human's files.
+   * Both shapes are replaced; a submodule that is already its own working tree is left alone.
+   */
+  repairSubmodules(mainRoot, log = () => {
+  }) {
+    const gitmodules = join(this.cwd, ".gitmodules");
+    if (!existsSync(gitmodules)) return;
+    const cfg = this.tryRun([
+      "config",
+      "-f",
+      ".gitmodules",
+      "--get-regexp",
+      "^submodule\\..*\\.path$"
+    ]);
+    if (cfg.code !== 0) return;
+    const wtGitDir = this.run(["rev-parse", "--path-format=absolute", "--git-dir"]).trim();
+    for (const line of cfg.out.split("\n").filter(Boolean)) {
+      const m = /^submodule\.(.+)\.path\s+(.+)$/.exec(line.trim());
+      if (!m) continue;
+      const [, name, subPath] = m;
+      const modulesDir = resolve(wtGitDir, "modules");
+      const moduleDir = resolve(modulesDir, name);
+      if (!SAFE_SUBMODULE_NAME.test(name) || name.split(/[\\/]/).some((seg) => seg === "" || seg === "." || seg === "..") || !moduleDir.startsWith(modulesDir + sep)) {
+        log(`submodule ${subPath}: refusing name ${JSON.stringify(name)}; not repaired`);
+        continue;
+      }
+      const wtSub = join(this.cwd, subPath);
+      const wtGit = join(wtSub, ".git");
+      if (this.isOwnSubmodule(wtSub, wtGit)) continue;
+      const mainSub = join(mainRoot, subPath);
+      if (!existsSync(join(mainSub, ".git"))) continue;
+      const src = new _Git(mainSub).tryRun(["rev-parse", "--path-format=absolute", "--git-dir"]);
+      if (src.code !== 0 || !src.out.trim()) continue;
+      if (existsSync(wtGit) && statSync(wtGit).isFile()) rmSync(wtGit);
+      rmSync(moduleDir, { recursive: true, force: true });
+      const r = this.tryRun([
+        "-c",
+        "protocol.file.allow=always",
+        "-c",
+        `submodule.${name}.url=${src.out.trim()}`,
+        "submodule",
+        "update",
+        "--init",
+        "--",
+        subPath
+      ]);
+      if (r.code !== 0) {
+        log(
+          `submodule ${subPath}: not repaired (${(r.err || r.out).trim()}); the project's refresh steps may still set it up`
+        );
+        continue;
+      }
+      this.tryRun(["submodule", "sync", "-q", "--", subPath]);
+    }
+  }
+  /** A submodule is the worktree's own when git, run inside it, says its top level IS that directory. */
+  isOwnSubmodule(wtSub, wtGit) {
+    if (!existsSync(wtGit)) return false;
+    const top = new _Git(wtSub).tryRun(["rev-parse", "--show-toplevel"]);
+    if (top.code !== 0) return false;
+    return realpathOr(top.out.trim()) === realpathOr(wtSub);
+  }
 };
 
-// ../../platform/core/workkit-lib/src/config.ts
+// src/core/config.ts
 function renderTemplate(s, vars) {
   return s.replace(/\$\{([A-Z0-9_]+)\}/g, (_, name) => {
     if (!(name in vars)) {
@@ -220,6 +358,10 @@ function renderTemplate(s, vars) {
     return vars[name];
   });
 }
+function storybookHostFor(m, worktree) {
+  if (!worktree) return "";
+  return m.storybook?.hostRoot ? join2(worktree, m.storybook.hostRoot) : worktree;
+}
 function slotVars(m, o) {
   const vars = {
     SLOT: o.slot === void 0 ? "" : String(o.slot),
@@ -228,28 +370,30 @@ 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) {
   const r = new Git(worktree).tryRun(["rev-parse", "--path-format=absolute", "--git-common-dir"]);
   if (r.code !== 0) return;
   const common = realpathSync2(r.out.trim());
-  const file = join(common, "info", "exclude");
-  mkdirSync2(join(common, "info"), { recursive: true });
+  const file = join2(common, "info", "exclude");
+  mkdirSync2(join2(common, "info"), { recursive: true });
   const present = new Set(
-    existsSync(file) ? readFileSync(file, "utf8").split("\n").map((l) => l.trim()) : []
+    existsSync2(file) ? readFileSync(file, "utf8").split("\n").map((l) => l.trim()) : []
   );
   const missing = patterns.filter((p) => !present.has(p));
   if (missing.length === 0) return;
   appendFileSync(
     file,
-    `${present.size ? "\n" : ""}# written by @helmsmith/workkit: per-worktree config and logs
+    `${present.size ? "\n" : ""}# written by @helmsmith/workbrokr: per-worktree config and logs
 ${missing.join("\n")}
 `
   );
@@ -261,26 +405,26 @@ function emitWorktreeConfig(a) {
     `${a.m.logs.dir.replace(/\/+$/, "")}/`,
     `${a.m.worktreeRoot.replace(/\/+$/, "")}/`
   ]);
-  const logDir = join(a.worktree, a.m.logs.dir);
+  const logDir = join2(a.worktree, a.m.logs.dir);
   mkdirSync2(logDir, { recursive: true });
   const vars = slotVars(a.m, { ...a, logDir });
-  const envFile = join(a.worktree, a.m.env.file);
+  const envFile = join2(a.worktree, a.m.env.file);
   const lines = Object.entries(a.m.env.template).map(([k, v]) => `${k}=${renderTemplate(v, vars)}`);
   writeFileSync(envFile, `${lines.join("\n")}
 `);
   let slotFile;
   if (a.slot !== void 0) {
-    slotFile = join(a.worktree, ".slot");
+    slotFile = join2(a.worktree, ".slot");
     writeFileSync(slotFile, `${a.slot}
 `);
   }
   return slotFile ? { envFile, slotFile, logDir, vars } : { envFile, logDir, vars };
 }
 
-// ../../platform/core/workkit-lib/src/guards.ts
-import { existsSync as existsSync2, realpathSync as realpathSync3 } from "fs";
+// src/core/guards.ts
+import { existsSync as existsSync3, realpathSync as realpathSync3 } from "fs";
 
-// ../../platform/core/workkit-lib/src/scopes.ts
+// src/core/scopes.ts
 import picomatch from "picomatch";
 function areaVars(area) {
   const parts = area.split("/");
@@ -298,7 +442,42 @@ function fill(template, vars) {
   });
   return missing ? null : out;
 }
-function expandScopes(m, area, mode) {
+function extraScopesForMode(spec, mode) {
+  if (!spec.extraScopes) return [];
+  if (Array.isArray(spec.extraScopes)) {
+    return mode === "frontend" || mode === "fullstack" ? spec.extraScopes : [];
+  }
+  const out = [];
+  if (mode === "frontend" || mode === "fullstack") out.push(...spec.extraScopes.frontend ?? []);
+  if (mode === "backend" || mode === "fullstack") out.push(...spec.extraScopes.backend ?? []);
+  return out;
+}
+var normalizeGlob = (g) => g.replace(/^\.\//, "").replace(/\/+$/, "");
+var hasWildcard = (s) => /[*?[{]/.test(s);
+function isSubGlob(child, parent) {
+  const c = normalizeGlob(child);
+  const p = normalizeGlob(parent);
+  if (c === p) return true;
+  const cSegs = c.split("/");
+  const pSegs = p.split("/");
+  for (let i = 0; i < pSegs.length; i++) {
+    const ps = pSegs[i];
+    if (ps === "**") return true;
+    const cs = cSegs[i];
+    if (cs === void 0 || cs === "**") return false;
+    if (!hasWildcard(ps) && !hasWildcard(cs)) {
+      if (ps !== cs) return false;
+      continue;
+    }
+    if (!hasWildcard(cs) && hasWildcard(ps)) {
+      if (!picomatch.isMatch(cs, ps, { dot: true })) return false;
+      continue;
+    }
+    if (cs !== ps) return false;
+  }
+  return cSegs.length === pSegs.length;
+}
+function expandScopes(m, area, mode, narrowedScopes, hasTask = false) {
   const spec = m.areas[area];
   if (!spec)
     throw new WorkkitError(
@@ -307,15 +486,17 @@ function expandScopes(m, area, mode) {
     );
   const vars = { ...areaVars(area), module: spec.module };
   const out = [];
-  for (const t of m.scopes.frontend) {
-    const g = fill(t, vars);
-    if (g) out.push(g);
+  if (mode === "frontend" || mode === "fullstack") {
+    for (const t of m.scopes.frontend) {
+      const g = fill(t, vars);
+      if (g) out.push(g);
+    }
   }
-  if (mode === "fullstack") {
+  if (mode === "backend" || mode === "fullstack") {
     if (!spec.module) {
       throw new WorkkitError(
         "MANIFEST_INVALID",
-        `area "${area}" has no module, so a fullstack effort cannot hold a backend scope; add areas["${area}"].module or use --mode frontend`
+        `area "${area}" has no module, so a ${mode} effort cannot hold a backend scope; add areas["${area}"].module or use --mode frontend`
       );
     }
     for (const t of m.scopes.backend) {
@@ -323,20 +504,65 @@ function expandScopes(m, area, mode) {
       if (g) out.push(g);
     }
   }
-  out.push(...spec.extraScopes ?? []);
-  return out;
-}
-function literalPrefix(glob) {
-  const i = glob.search(/[*?[{]/);
-  return i < 0 ? glob : glob.slice(0, i);
+  out.push(...extraScopesForMode(spec, mode));
+  if (!narrowedScopes || narrowedScopes.length === 0) return out;
+  if (!hasTask) {
+    throw new WorkkitError(
+      "SCOPE_REQUIRES_TASK",
+      "--scope narrowing requires --task <slug> so primary area efforts always protect the full area"
+    );
+  }
+  const allowed = [...out, ...spec.sharedScopes ?? []];
+  for (const g of narrowedScopes) {
+    if (!allowed.some((base) => isSubGlob(g, base))) {
+      throw new WorkkitError(
+        "SCOPE_OUTSIDE_AREA",
+        `narrowed scope "${g}" is outside ${area}'s ${mode} scopes (${allowed.join(", ")})`,
+        { area, mode, scope: g, allowed }
+      );
+    }
+  }
+  return narrowedScopes;
+}
+function allowedScopesForEffort(m, effort) {
+  const shared = m.areas[effort.area]?.sharedScopes ?? [];
+  const allCommons = Object.values(m.commons).flat();
+  return [...effort.scopes, ...shared, ...allCommons];
+}
+function segmentsOverlap(sx, sy) {
+  if (sx === sy) return true;
+  const wx = hasWildcard(sx);
+  const wy = hasWildcard(sy);
+  if (!wx && !wy) return false;
+  if (!wx && wy) return picomatch.isMatch(sx, sy, { dot: true });
+  if (wx && !wy) return picomatch.isMatch(sy, sx, { dot: true });
+  const starToken = /^\*([^*?[{]+)\*$/;
+  const mx = starToken.exec(sx);
+  const my = starToken.exec(sy);
+  if (mx && my) {
+    const tx = mx[1];
+    const ty = my[1];
+    return tx.includes(ty) || ty.includes(tx);
+  }
+  return true;
+}
+function twoGlobsOverlap(x, y) {
+  const xs = normalizeGlob(x).split("/");
+  const ys = normalizeGlob(y).split("/");
+  const len = Math.min(xs.length, ys.length);
+  for (let i = 0; i < len; i++) {
+    if (xs[i] === "**" || ys[i] === "**") return true;
+    if (!segmentsOverlap(xs[i], ys[i])) return false;
+  }
+  if (xs.length === ys.length) return true;
+  const longer = xs.length > ys.length ? xs : ys;
+  return longer[len] === "**";
 }
 function globsOverlap(a, b) {
   const pairs = [];
   for (const x of a) {
-    const px = literalPrefix(x);
     for (const y of b) {
-      const py = literalPrefix(y);
-      if (px.startsWith(py) || py.startsWith(px)) pairs.push(`${x} ~ ${y}`);
+      if (twoGlobsOverlap(x, y)) pairs.push(`${x} ~ ${y}`);
     }
   }
   return pairs;
@@ -350,7 +576,7 @@ function commonsTouched(m, paths) {
   return Object.entries(m.commons).filter(([, globs]) => pathsMatching(paths, globs).length > 0).map(([name]) => name);
 }
 
-// ../../platform/core/workkit-lib/src/guards.ts
+// src/core/guards.ts
 function assertNotProtected(m, branch) {
   if (m.protectedBranches.includes(branch)) {
     throw new WorkkitError(
@@ -367,28 +593,64 @@ var same = (a, b) => {
     return a === b;
   }
 };
+var effortLabel = (e) => e.task ? `${e.area}--${e.task}` : e.area;
 function checkCommit(c) {
   const refusals = [];
+  const warnings = [];
   if (c.m.protectedBranches.includes(c.branch)) {
     refusals.push(
       `branch "${c.branch}" is protected (${c.m.protectedBranches.join(", ")}): work happens on <type>/<area> branches, never here`
     );
   }
-  const efforts = new Map(c.registry.efforts({ project: c.project }).map((e) => [e.id, e]));
+  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" })) {
-    if (lease.owner.session === c.ownerSession) continue;
     const holder = efforts.get(lease.effort);
-    if (holder && c.checkoutRoot && existsSync2(holder.worktree) && same(holder.worktree, c.checkoutRoot))
+    const holderHasWorktree = Boolean(holder && existsSync3(holder.worktree));
+    if (holder && holderHasWorktree && c.checkoutRoot) {
+      if (same(holder.worktree, c.checkoutRoot)) continue;
+    } 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(", ")}`
       );
     }
   }
-  return { refusals };
+  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(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})`
+      );
+    }
+  }
+  if (mine && ownPaths.length > 0) {
+    const allowed = allowedScopesForEffort(c.m, mine);
+    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(", ")}`
+      );
+    }
+  }
+  return { refusals, warnings };
 }
 function checkPush(c) {
   const refusals = [];
@@ -401,15 +663,15 @@ function checkPush(c) {
     return { refusals, warnings };
   }
   if (c.isDelete) return { refusals, warnings };
-  const effort = c.registry.efforts({ project: c.project, state: "active" }).find((e) => e.branch === c.branch);
+  const effort = c.registry.efforts({ project: c.project }).find((e) => (e.state === "active" || e.state === "parked") && e.branch === c.branch);
   const commons = commonsTouched(c.m, c.changedPaths);
   if (effort) {
-    const allCommonsGlobs = Object.values(c.m.commons).flat();
-    const inScope = new Set(pathsMatching(c.changedPaths, [...effort.scopes, ...allCommonsGlobs]));
+    const allowed = allowedScopesForEffort(c.m, effort);
+    const inScope = new Set(pathsMatching(c.changedPaths, allowed));
     const outside = c.changedPaths.filter((p) => !inScope.has(p));
     if (outside.length > 0) {
       warnings.push(
-        `${outside.length} changed path(s) are outside the effort's scope (${effort.area}): ${outside.join(", ")} \u2014 add a scope template or expect a merge collision`
+        `${outside.length} changed path(s) are outside the effort's scope (${effortLabel(effort)}): ${outside.join(", ")} \u2014 add a scope template or expect a merge collision`
       );
     }
   }
@@ -418,13 +680,13 @@ function checkPush(c) {
   return { refusals, warnings };
 }
 
-// ../../platform/core/workkit-lib/src/hooks.ts
+// src/core/hooks.ts
 import { chmodSync, lstatSync, mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 
-// ../../platform/core/workkit-lib/src/manifest.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
+// src/core/manifest.ts
+import { existsSync as existsSync4, readFileSync as readFileSync2 } from "fs";
+import { join as join3 } from "path";
 import { pathToFileURL } from "url";
 import { z } from "zod";
 var MANIFEST_FILES = [
@@ -434,14 +696,23 @@ var MANIFEST_FILES = [
 ];
 var BRANCH_NAME = /^[A-Za-z0-9][A-Za-z0-9._/-]*$/;
 var BRANCH_NAME_HINT = 'must be a plain ref name: letters, digits, ".", "_", "/", "-"';
+var TASK_SLUG = /^(?!.*--)[a-z0-9][a-z0-9_-]{0,47}$/;
 var Service = z.object({
   start: z.string().min(1),
   stop: z.string().min(1),
   health: z.string().min(1),
   healthyCodes: z.array(z.number().int()).optional(),
   reset: z.string().optional(),
-  healthTimeoutMs: z.number().int().positive().optional()
+  healthTimeoutMs: z.number().int().positive().optional(),
+  modes: z.array(z.enum(["backend", "fullstack"])).optional()
 });
+var ExtraScopes = z.union([
+  z.array(z.string()),
+  z.object({
+    frontend: z.array(z.string()).optional(),
+    backend: z.array(z.string()).optional()
+  })
+]);
 var Schema = z.object({
   project: z.string().regex(/^[a-z0-9][a-z0-9-]*$/),
   baseBranch: z.string().regex(BRANCH_NAME, BRANCH_NAME_HINT),
@@ -459,21 +730,24 @@ var Schema = z.object({
   storybook: z.object({ hostRoot: z.string() }).optional(),
   logs: z.object({ dir: z.string() }).default({ dir: ".logs" }),
   env: z.object({ file: z.string(), template: z.record(z.string(), z.string()) }).optional(),
+  seed: z.array(z.string().min(1)).optional(),
   refresh: z.array(
     z.object({
       when: z.string().optional(),
       always: z.boolean().optional(),
       run: z.string().optional(),
-      mark: z.string().optional()
+      mark: z.string().optional(),
+      restoreWhenIfClean: z.boolean().optional()
     })
   ).default([]),
   scopes: z.object({ frontend: z.array(z.string()), backend: z.array(z.string()) }),
   areas: z.record(
-    z.string().regex(/^[a-z0-9-]+(\/[a-z0-9-]+)*$/),
+    z.string().regex(/^(?!.*--)[a-z0-9-]+(\/[a-z0-9-]+)*$/),
     z.object({
       module: z.string().optional(),
       commons: z.array(z.string()).optional(),
-      extraScopes: z.array(z.string()).optional()
+      extraScopes: ExtraScopes.optional(),
+      sharedScopes: z.array(z.string()).optional()
     })
   ),
   commons: z.record(z.string(), z.array(z.string())).default({}),
@@ -496,13 +770,21 @@ function templateVariables(m) {
     "AREA",
     "BRANCH",
     "WORKTREE",
-    "PORT_STORYBOOK"
+    "PORT_STORYBOOK",
+    "STORYBROKR_HOST"
   ]);
   for (const s of Object.keys(m.ports.services)) vars.add(`PORT_${s.toUpperCase()}`);
   return vars;
 }
 function defaultEnv(services) {
-  const template = { SLOT: "${SLOT}", LOG_DIR: "${LOG_DIR}" };
+  const template = {
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: manifest template placeholder
+    SLOT: "${SLOT}",
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: manifest template placeholder
+    LOG_DIR: "${LOG_DIR}",
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: manifest template placeholder
+    STORYBROKR_HOST: "${STORYBROKR_HOST}"
+  };
   for (const s of services) template[`PORT_${s.toUpperCase()}`] = `\${PORT_${s.toUpperCase()}}`;
   return { file: ".env.slot", template };
 }
@@ -555,8 +837,8 @@ function validateManifest(raw) {
 }
 async function loadManifest(repoRoot) {
   for (const name of MANIFEST_FILES) {
-    const file = join2(repoRoot, name);
-    if (!existsSync3(file)) continue;
+    const file = join3(repoRoot, name);
+    if (!existsSync4(file)) continue;
     if (name.endsWith(".json")) return validateManifest(JSON.parse(readFileSync2(file, "utf8")));
     const mod = await import(`${pathToFileURL(file).href}?t=${Date.now()}`);
     return validateManifest(mod.default);
@@ -567,7 +849,7 @@ async function loadManifest(repoRoot) {
   );
 }
 
-// ../../platform/core/workkit-lib/src/hooks.ts
+// src/core/hooks.ts
 var HOOKS_DIR = ".helmsmith/hooks";
 function preCommitScript(protectedBranches) {
   return `#!/bin/sh
@@ -580,11 +862,21 @@ for p in $PROTECTED; do
     exit 2
   fi
 done
-if ! command -v workbrokr >/dev/null 2>&1; then
+if command -v workbrokr >/dev/null 2>&1; then
+  workbrokr hook pre-commit "$@" || exit $?
+else
   echo "work: workbrokr is not on PATH; commons and scope checks skipped (npm i -g @helmsmith/workbrokr)" >&2
-  exit 0
 fi
-exec workbrokr hook pre-commit "$@"
+COMMON_DIR=$(git rev-parse --path-format=absolute --git-common-dir 2>/dev/null)
+LEGACY="$COMMON_DIR/hooks/pre-commit"
+if [ -n "$COMMON_DIR" ] && [ -x "$LEGACY" ]; then
+  SELF_DIR=$(cd "$(dirname "$0")" && pwd)
+  LEGACY_DIR=$(cd "$(dirname "$LEGACY")" && pwd)
+  if [ "$SELF_DIR" != "$LEGACY_DIR" ]; then
+    exec "$LEGACY" "$@"
+  fi
+fi
+exit 0
 `;
 }
 function prePushScript(protectedBranches) {
@@ -602,11 +894,21 @@ printf '%s\\n' "$input" | while read -r lref lsha rref rsha; do
     fi
   done
 done || exit 2
-if ! command -v workbrokr >/dev/null 2>&1; then
+if command -v workbrokr >/dev/null 2>&1; then
+  printf '%s\\n' "$input" | workbrokr hook pre-push "$@" || exit $?
+else
   echo "work: workbrokr is not on PATH; scope and commons warnings skipped" >&2
-  exit 0
 fi
-printf '%s\\n' "$input" | exec workbrokr hook pre-push "$@"
+COMMON_DIR=$(git rev-parse --path-format=absolute --git-common-dir 2>/dev/null)
+LEGACY="$COMMON_DIR/hooks/pre-push"
+if [ -n "$COMMON_DIR" ] && [ -x "$LEGACY" ]; then
+  SELF_DIR=$(cd "$(dirname "$0")" && pwd)
+  LEGACY_DIR=$(cd "$(dirname "$LEGACY")" && pwd)
+  if [ "$SELF_DIR" != "$LEGACY_DIR" ]; then
+    printf '%s\\n' "$input" | exec "$LEGACY" "$@"
+  fi
+fi
+exit 0
 `;
 }
 function installHooks(repoRoot, opts) {
@@ -614,7 +916,7 @@ function installHooks(repoRoot, opts) {
     if (!BRANCH_NAME.test(b))
       throw new WorkkitError("MANIFEST_INVALID", `protected branch "${b}" is not a plain ref name`);
   }
-  const hooksDir = join3(repoRoot, HOOKS_DIR);
+  const hooksDir = join4(repoRoot, HOOKS_DIR);
   mkdirSync3(hooksDir, { recursive: true });
   const files = [];
   const scripts = [
@@ -622,7 +924,7 @@ function installHooks(repoRoot, opts) {
     ["pre-push", prePushScript(opts.protectedBranches)]
   ];
   for (const [name, body] of scripts) {
-    const file = join3(hooksDir, name);
+    const file = join4(hooksDir, name);
     let existing;
     try {
       existing = lstatSync(file);
@@ -642,16 +944,16 @@ function installHooks(repoRoot, opts) {
   return { hooksDir, files };
 }
 
-// ../../platform/core/workkit-lib/src/paths.ts
+// src/core/paths.ts
 import { homedir } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 function homeDir(env = process.env) {
-  return env.HELMSMITH_HOME && env.HELMSMITH_HOME.length > 0 ? env.HELMSMITH_HOME : join4(homedir(), ".cache", "helmsmith");
+  return env.HELMSMITH_HOME && env.HELMSMITH_HOME.length > 0 ? env.HELMSMITH_HOME : join5(homedir(), ".cache", "helmsmith");
 }
-var registryFile = (home) => join4(home, "registry.json");
-var lockDir = (home) => join4(home, "registry.lock");
+var registryFile = (home) => join5(home, "registry.json");
+var lockDir = (home) => join5(home, "registry.lock");
 
-// ../../platform/core/workkit-lib/src/ports.ts
+// src/core/ports.ts
 function portsForSlot(m, slot) {
   return Object.fromEntries(
     Object.entries(m.ports.services).map(([service, { base }]) => [service, base + slot])
@@ -668,8 +970,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) {
@@ -684,28 +997,100 @@ function claimRanges(registry, m, repoRoot) {
       }
     }
   }
-  registry.upsertProject(m.project, { root: repoRoot, ranges: mine });
 }
 
-// ../../platform/core/workkit-lib/src/refresh.ts
+// src/core/refresh.ts
 import { spawnSync as spawnSync2 } from "child_process";
+import { createHash } from "crypto";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname2, join as join6 } from "path";
 import picomatch2 from "picomatch";
 function matchesWhen(glob) {
   const isMatch = picomatch2(glob, { dot: true });
   return (p) => isMatch(p);
 }
-function selectRefresh(entries, changedPaths) {
+function readStamps(stampFile) {
+  if (!stampFile || !existsSync5(stampFile)) return {};
+  try {
+    return JSON.parse(readFileSync3(stampFile, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeStamps(stampFile, stamps) {
+  mkdirSync4(dirname2(stampFile), { recursive: true });
+  writeFileSync3(stampFile, `${JSON.stringify(stamps, null, 2)}
+`);
+}
+function matchedFilesInWorktree(worktree, whenGlob) {
+  if (!/[*?[{]/.test(whenGlob)) {
+    return existsSync5(join6(worktree, whenGlob)) ? [whenGlob] : [];
+  }
+  const r = spawnSync2("git", ["ls-files"], { cwd: worktree, encoding: "utf8" });
+  if (r.status !== 0) return [];
+  const isMatch = matchesWhen(whenGlob);
+  return (r.stdout ?? "").split("\n").map((l) => l.trim()).filter((l) => l.length > 0 && isMatch(l) && existsSync5(join6(worktree, l)));
+}
+function hashFiles(worktree, relPaths) {
+  if (relPaths.length === 0) return null;
+  const h = createHash("sha256");
+  for (const rel of [...relPaths].sort()) {
+    const abs = join6(worktree, rel);
+    if (!existsSync5(abs)) continue;
+    h.update(`${rel}\0`);
+    h.update(readFileSync3(abs));
+    h.update("\0");
+  }
+  return h.digest("hex");
+}
+function isFileCleanInGit(worktree, relPath) {
+  const r = spawnSync2("git", ["status", "--porcelain", "--", relPath], {
+    cwd: worktree,
+    encoding: "utf8"
+  });
+  return r.status === 0 && (r.stdout ?? "").trim().length === 0;
+}
+function selectRefresh(entries, changedPaths, opts) {
   const runs = [];
   const marks = [];
+  const stored = readStamps(opts?.stampFile);
+  const pendingStamps = { ...stored };
+  const cleanWhenFiles = /* @__PURE__ */ new Set();
   for (const e of entries) {
-    const hit = e.always === true || e.when !== void 0 && changedPaths.some(matchesWhen(e.when));
+    let hit = e.always === true;
+    let matchedFiles = [];
+    if (e.when !== void 0) {
+      const byChanged = changedPaths.some(matchesWhen(e.when));
+      if (opts?.worktree) {
+        matchedFiles = matchedFilesInWorktree(opts.worktree, e.when);
+        const digest = hashFiles(opts.worktree, matchedFiles);
+        if (digest !== null) {
+          if (stored[e.when] !== digest) hit = true;
+          pendingStamps[e.when] = digest;
+        }
+      }
+      if (byChanged) hit = true;
+    }
     if (!hit) continue;
-    if (e.run) runs.push(e.run);
+    if (e.run) {
+      runs.push(e.run);
+      if (opts?.worktree && e.when && e.restoreWhenIfClean !== false) {
+        for (const f of matchedFiles) {
+          if (isFileCleanInGit(opts.worktree, f)) cleanWhenFiles.add(f);
+        }
+      }
+    }
     if (e.mark) marks.push(e.mark);
   }
-  return { runs, marks };
+  if (!opts?.worktree) return { runs, marks };
+  return {
+    runs,
+    marks,
+    pendingStamps,
+    cleanWhenFiles: [...cleanWhenFiles]
+  };
 }
-function runRefresh(runs, cwd, log, env = process.env) {
+function runRefresh(runs, cwd, log, env = process.env, opts) {
   for (const cmd of runs) {
     log(`$ ${cmd}`);
     const r = spawnSync2("sh", ["-c", cmd], { cwd, env, encoding: "utf8" });
@@ -718,23 +1103,33 @@ function runRefresh(runs, cwd, log, env = process.env) {
       });
     }
   }
+  if (opts?.restoreFiles && opts.restoreFiles.length > 0) {
+    for (const rel of opts.restoreFiles) {
+      if (!isFileCleanInGit(cwd, rel)) {
+        spawnSync2("git", ["checkout", "--", rel], { cwd, encoding: "utf8" });
+      }
+    }
+  }
+  if (opts?.stampFile && opts.pendingStamps) {
+    writeStamps(opts.stampFile, opts.pendingStamps);
+  }
 }
 
-// ../../platform/core/workkit-lib/src/registry.ts
+// src/core/registry.ts
 import { randomBytes } from "crypto";
 import {
-  existsSync as existsSync4,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync3,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync4,
   renameSync,
-  rmSync,
-  statSync,
-  writeFileSync as writeFileSync3
+  rmSync as rmSync2,
+  statSync as statSync2,
+  writeFileSync as writeFileSync4
 } 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);
 }
@@ -746,16 +1141,16 @@ var Registry = class _Registry {
   home;
   now;
   static open(home, now2 = () => /* @__PURE__ */ new Date()) {
-    mkdirSync4(home, { recursive: true });
+    mkdirSync5(home, { recursive: true });
     return new _Registry(home, now2);
   }
   /** The registry as it is on disk. A file that does not parse is refused, never replaced. */
   read() {
     const file = registryFile(this.home);
-    if (!existsSync4(file)) return structuredClone(EMPTY);
+    if (!existsSync6(file)) return structuredClone(EMPTY);
     let parsed;
     try {
-      parsed = JSON.parse(readFileSync3(file, "utf8"));
+      parsed = JSON.parse(readFileSync4(file, "utf8"));
     } catch (err) {
       throw new WorkkitError(
         "INTERNAL",
@@ -785,12 +1180,14 @@ var Registry = class _Registry {
     const started = Date.now();
     for (; ; ) {
       try {
-        mkdirSync4(lock);
+        mkdirSync5(lock);
         break;
       } catch {
         try {
-          if (Date.now() - statSync(lock).mtimeMs > LOCK_STALE_MS) {
-            rmSync(lock, { recursive: true, force: true });
+          if (Date.now() - statSync2(lock).mtimeMs > LOCK_STALE_MS) {
+            const claimed = `${lock}.stale.${process.pid}.${Date.now()}`;
+            renameSync(lock, claimed);
+            rmSync2(claimed, { recursive: true, force: true });
             continue;
           }
         } catch {
@@ -810,12 +1207,12 @@ var Registry = class _Registry {
       const out = fn(r);
       const file = registryFile(this.home);
       const tmp = `${file}.${process.pid}.tmp`;
-      writeFileSync3(tmp, `${JSON.stringify(r, null, 2)}
+      writeFileSync4(tmp, `${JSON.stringify(r, null, 2)}
 `);
       renameSync(tmp, file);
       return out;
     } finally {
-      rmSync(lock, { recursive: true, force: true });
+      rmSync2(lock, { recursive: true, force: true });
     }
   }
   project(name) {
@@ -836,18 +1233,29 @@ var Registry = class _Registry {
       (e) => Object.entries(filter).every(([k, v]) => e[k] === v)
     );
   }
-  activeEffortFor(project, area) {
-    return this.efforts({ project, area, state: "active" })[0];
+  activeEffortFor(project, area, task) {
+    return this.efforts({ project, area, state: "active" }).find(
+      (e) => (e.task ?? void 0) === (task ?? void 0)
+    );
   }
-  /** An effort that is being started counts as open: nobody else may start on the area meanwhile. */
-  openEffortFor(project, area) {
+  /** An effort that is being started counts as open: nobody else may start on the same (area, task) meanwhile. */
+  openEffortFor(project, area, task) {
     return this.efforts({ project, area }).find(
-      (e) => e.state === "starting" || e.state === "active"
+      (e) => (e.state === "starting" || e.state === "active") && (e.task ?? void 0) === (task ?? void 0)
     );
   }
   addNotice(project, area, notice) {
     this.update((r) => {
-      r.notices = [...r.notices ?? [], { project, area, notice }];
+      const existing = r.notices ?? [];
+      const dup = existing.findIndex(
+        (n) => n.project === project && n.area === area && n.notice.from === notice.from && n.notice.text === notice.text
+      );
+      if (dup >= 0) {
+        existing[dup] = { project, area, notice };
+        r.notices = existing;
+      } else {
+        r.notices = [...existing, { project, area, notice }];
+      }
     });
   }
   notices(project, area) {
@@ -858,6 +1266,21 @@ var Registry = class _Registry {
       r.notices = (r.notices ?? []).filter((n) => !(n.project === project && n.area === area));
     });
   }
+  clearNoticesFrom(project, branches) {
+    const set = new Set(branches);
+    this.update((r) => {
+      r.notices = (r.notices ?? []).filter(
+        (n) => !(n.project === project && set.has(n.notice.from))
+      );
+    });
+  }
+  pruneNoticesWhere(project, area, remove) {
+    this.update((r) => {
+      r.notices = (r.notices ?? []).filter(
+        (n) => !(n.project === project && n.area === area && remove(n.notice))
+      );
+    });
+  }
   allocateSlot(project, m, owner, effort, exclude = /* @__PURE__ */ new Set()) {
     return this.update((r) => {
       const taken = new Set(
@@ -874,7 +1297,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(
@@ -958,10 +1381,10 @@ var Registry = class _Registry {
   }
 };
 
-// ../../platform/core/workkit-lib/src/runner.ts
+// src/core/runner.ts
 import { spawn, spawnSync as spawnSync3 } from "child_process";
 import { closeSync, openSync } from "fs";
-import { join as join5 } from "path";
+import { join as join7 } from "path";
 var DEFAULT_HEALTH_TIMEOUT_MS = 18e4;
 var HEALTH_POLL_MS = 1e3;
 var PROBE_CAP_MS = 1e4;
@@ -980,6 +1403,10 @@ function pidSignature(pid) {
   const r = spawnSync3("ps", ["-o", "lstart=", "-p", String(pid)], { encoding: "utf8" });
   return r.status === 0 ? (r.stdout ?? "").trim() : "";
 }
+function serviceModes(name, spec) {
+  if (spec.modes && spec.modes.length > 0) return spec.modes;
+  return name === "frontend" ? ["fullstack"] : ["backend", "fullstack"];
+}
 function probe(spec, cwd, env, timeoutMs = PROBE_CAP_MS) {
   const r = spawnSync3("sh", ["-c", spec.health], {
     cwd,
@@ -1013,7 +1440,7 @@ async function waitHealthy(o) {
   );
 }
 function spawnService(name, spec, a) {
-  const fd = openSync(join5(a.logDir, `${name}.log`), "a");
+  const fd = openSync(join7(a.logDir, `${name}.log`), "a");
   try {
     const child = spawn("sh", ["-c", spec.start], {
       cwd: a.cwd,
@@ -1035,7 +1462,12 @@ function spawnService(name, spec, a) {
 async function startServices(a) {
   const pids = {};
   const signatures = {};
-  for (const [name, spec] of Object.entries(a.m.services)) {
+  const targetMode = a.mode ?? "fullstack";
+  const entries = Object.entries(a.m.services).filter(([name, spec]) => {
+    if (a.onlyServices) return a.onlyServices.includes(name);
+    return serviceModes(name, spec).includes(targetMode);
+  });
+  for (const [name, spec] of entries) {
     a.onLog?.(`starting ${name}: ${spec.start}`);
     pids[name] = spawnService(name, spec, a);
     signatures[name] = pidSignature(pids[name]);
@@ -1099,7 +1531,7 @@ async function stopServices(o) {
   while (alive().length > 0 && Date.now() < hardDeadline) await sleep2(100);
 }
 
-// ../../platform/core/workkit-lib/src/session.ts
+// src/core/session.ts
 import { hostname, userInfo } from "os";
 function currentOwner(env = process.env) {
   const named = [env.WORK_SESSION, env.CLAUDE_SESSION_NAME, env.CLAUDE_CODE_SESSION_ID].find(
@@ -1108,11 +1540,23 @@ function currentOwner(env = process.env) {
   return { session: named ?? `${userInfo().username}@${hostname()}`, pid: process.pid };
 }
 
-// src/lib/context.ts
-import chalk from "chalk";
+// 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);
+  for (let i = 0; i < 3; i++) {
+    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
 function run(args) {
   const r = spawnSync4("storybrokr", args, { encoding: "utf8" });
   if (r.error) {
@@ -1123,9 +1567,26 @@ function run(args) {
   }
   return { code: r.status ?? 1, out: r.stdout ?? "", err: r.stderr ?? "" };
 }
+function assertStorybrokrVersion() {
+  if (versionChecked) return;
+  const r = run(["--version"]);
+  const found = r.out.trim();
+  if (r.code !== 0 || compareSemver(found, MIN_STORYBROKR_VERSION) < 0) {
+    throw new WorkkitError(
+      "STORYBROKR_FAILED",
+      `storybrokr >= ${MIN_STORYBROKR_VERSION} required (found ${found || "unknown"}); upgrade @helmsmith/storybrokr`
+    );
+  }
+  versionChecked = true;
+  versionFound = found;
+}
 var storybrokrCli = {
-  async up(story, hostRoot) {
-    const r = run(["up", story, "--host", hostRoot, "--json"]);
+  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(
         "STORYBROKR_FAILED",
@@ -1139,6 +1600,107 @@ var storybrokrCli = {
     const r = run(["down", id]);
     if (r.code !== 0)
       throw new WorkkitError("STORYBROKR_FAILED", `storybrokr down ${id} failed: ${r.err.trim()}`);
+  },
+  async downHost(hostRoot) {
+    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" });
+    void r;
+  }
+};
+
+// src/lib/pritty.ts
+var MIN_PRITTY_VERSION = "0.1.1";
+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 j.open ? { number: j.open.number, url: j.open.url, draft: Boolean(j.open.draft) } : null;
   }
 };
 
@@ -1152,7 +1714,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,
@@ -1161,6 +1723,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))
   };
@@ -1170,26 +1733,34 @@ async function buildCtx(opts = {}) {
 import {
   appendFileSync as appendFileSync2,
   cpSync,
-  existsSync as existsSync5,
-  mkdirSync as mkdirSync5,
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync6,
   readdirSync,
+  readFileSync as readFileSync5,
   realpathSync as realpathSync4,
-  rmSync as rmSync2,
-  statSync as statSync2
+  rmSync as rmSync3,
+  statSync as statSync3,
+  writeFileSync as writeFileSync5
 } from "fs";
 import { connect, createServer } from "net";
-import { dirname as dirname2, join as join6 } from "path";
-var worktreePathFor = (ctx, area) => join6(ctx.repoRoot, ctx.manifest.worktreeRoot, area);
-var branchFor = (type, area) => `${type}/${area}`;
+import { dirname as dirname3, join as join8 } from "path";
+var worktreePathFor = (ctx, area, task) => task ? join8(ctx.repoRoot, ctx.manifest.worktreeRoot, "_tasks", `${area}--${task}`) : join8(ctx.repoRoot, ctx.manifest.worktreeRoot, area);
+var branchFor = (type, area, task) => task ? `${type}/${area}--${task}` : `${type}/${area}`;
+var effortLabel2 = (area, task) => task ? `${area}--${task}` : area;
 var now = () => (/* @__PURE__ */ new Date()).toISOString();
 var STARTING_GRACE_MS = 30 * 6e4;
-var realpathOr = (p) => {
+var JOIN_WAIT_MS = 6e4;
+var sleep3 = (ms) => new Promise((r) => setTimeout(r, ms));
+var realpathOr2 = (p) => {
   try {
     return realpathSync4(p);
   } catch {
     return p;
   }
 };
+function fetchBaseOnce(ctx) {
+  new Git(ctx.repoRoot).tryRun(["fetch", "-q", "origin", ctx.manifest.baseBranch]);
+}
 function hoursFor(m, kind) {
   return {
     slot: m.expiry.slotHours,
@@ -1197,40 +1768,76 @@ function hoursFor(m, kind) {
     commons: m.expiry.commonsHours
   }[kind];
 }
+function modeCovers(existing, requested) {
+  if (existing === "fullstack") return true;
+  return existing === requested;
+}
+var STORYBROKR_TOUCH_THROTTLE_MS = 6e4;
 function touchEffort(ctx, effort) {
-  for (const l of ctx.registry.leases({ effort: effort.id }))
+  const prevMs = Date.parse(effort.lastActivity);
+  const shouldTouchStorybrokr = Number.isNaN(prevMs) || Date.now() - prevMs >= STORYBROKR_TOUCH_THROTTLE_MS;
+  for (const l of ctx.registry.leases({ effort: effort.id })) {
     ctx.registry.touch(l.id, hoursFor(ctx.manifest, l.kind));
+    if (l.kind === "storybook" && shouldTouchStorybrokr) {
+      void Promise.resolve(ctx.storybrokr.touch?.(String(l.value))).catch(() => {
+      });
+    }
+  }
   ctx.registry.updateEffort(effort.id, { lastActivity: now() });
 }
-function portBusy(port) {
-  return new Promise((resolve3) => {
+function bindFails(port, host) {
+  return new Promise((resolve4) => {
     const srv = createServer();
-    srv.once("error", () => resolve3(true));
-    srv.listen(port, "127.0.0.1", () => srv.close(() => resolve3(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) {
-  return new Promise((resolve3) => {
-    const sock = connect({ port, host: "127.0.0.1" });
+function portAnswersOn(port, host) {
+  return new Promise((resolve4) => {
+    const sock = connect({ port, host });
     const done = (v) => {
       sock.destroy();
-      resolve3(v);
+      resolve4(v);
     };
     sock.setTimeout(300, () => done(false));
     sock.once("connect", () => done(true));
     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;
 }
+async function claimFreeSlot(ctx, effortId, warnings) {
+  const m = ctx.manifest;
+  const exclude = /* @__PURE__ */ new Set();
+  const busyNotes = [];
+  for (; ; ) {
+    const candidate = ctx.registry.allocateSlot(m.project, m, ctx.owner, effortId, exclude);
+    const busy = await busyPorts(candidate.ports ?? {});
+    if (busy.length === 0) {
+      if (busyNotes.length) warnings.push(...busyNotes);
+      return candidate;
+    }
+    ctx.registry.release(candidate.id);
+    exclude.add(candidate.value);
+    busyNotes.push(`slot ${candidate.value}: ${busy.join(", ")} already in use`);
+    ctx.log(busyNotes[busyNotes.length - 1]);
+  }
+}
 function guardStart(ctx, o) {
   const m = ctx.manifest;
   const spec = m.areas[o.area];
@@ -1240,28 +1847,37 @@ function guardStart(ctx, o) {
       `unknown area "${o.area}" (known: ${Object.keys(m.areas).join(", ")})`,
       { area: o.area }
     );
+  if (o.task !== void 0 && !TASK_SLUG.test(o.task))
+    throw new WorkkitError(
+      "TASK_INVALID",
+      `invalid task slug "${o.task}" (must match /^[a-z0-9][a-z0-9_-]{0,47}$/ with no "--")`,
+      { task: o.task }
+    );
   if (!m.branch.types.includes(o.type))
     throw new WorkkitError(
       "TYPE_UNKNOWN",
       `unknown type "${o.type}" (allowed: ${m.branch.types.join(", ")})`,
       { type: o.type }
     );
-  if (o.mode !== "frontend" && o.mode !== "fullstack")
-    throw new WorkkitError("MODE_UNKNOWN", `unknown mode "${o.mode}" (frontend | fullstack)`);
-  const branch = branchFor(o.type, o.area);
+  if (o.mode !== "frontend" && o.mode !== "backend" && o.mode !== "fullstack")
+    throw new WorkkitError(
+      "MODE_UNKNOWN",
+      `unknown mode "${o.mode}" (frontend | backend | fullstack)`
+    );
+  const branch = branchFor(o.type, o.area, o.task);
   assertNotProtected(m, branch);
-  const scopes = expandScopes(m, o.area, o.mode);
+  const scopes = expandScopes(m, o.area, o.mode, o.scopes, Boolean(o.task));
   const commons = spec.commons ?? [];
   const warnings = [];
   if (commons.length > 0) {
     for (const e of ctx.registry.efforts({ project: m.project })) {
-      if (e.area === o.area || e.state !== "active" && e.state !== "starting" || !existsSync5(e.worktree))
+      if (e.area === o.area && (e.task ?? void 0) === (o.task ?? void 0) || e.state !== "active" && e.state !== "starting" || !existsSync7(e.worktree))
         continue;
       const changed = new Git(e.worktree).tryRun(["diff", "--name-only", "--no-renames", `origin/${m.baseBranch}...HEAD`]).out.split("\n").filter(Boolean);
       const hit = commonsTouched(m, changed).filter((c) => commons.includes(c));
       if (hit.length > 0)
         warnings.push(
-          `${e.area} (${e.branch}, ${e.owner.session}) already has commits under commons ${hit.join(", ")}: coordinate or wait for its merge`
+          `${effortLabel2(e.area, e.task)} (${e.branch}, ${e.owner.session}) already has commits under commons ${hit.join(", ")}: coordinate or wait for its merge`
         );
     }
   }
@@ -1273,10 +1889,11 @@ function reserveEffort(ctx, o, branch, scopes, commons) {
     id: newId("eff"),
     project: m.project,
     area: o.area,
+    ...o.task ? { task: o.task } : {},
     type: o.type,
     mode: o.mode,
     branch,
-    worktree: worktreePathFor(ctx, o.area),
+    worktree: worktreePathFor(ctx, o.area, o.task),
     owner: ctx.owner,
     state: "starting",
     scopes,
@@ -1290,21 +1907,25 @@ function reserveEffort(ctx, o, branch, scopes, commons) {
     const open = r.efforts.filter(
       (e) => e.project === m.project && (e.state === "active" || e.state === "starting")
     );
-    const onArea = open.find((e) => e.area === o.area);
-    if (onArea) {
+    const onTarget = open.find(
+      (e) => e.area === o.area && (e.task ?? void 0) === (o.task ?? void 0)
+    );
+    if (onTarget) {
+      const label = effortLabel2(o.area, o.task);
       throw new WorkkitError(
         "EFFORT_OPEN",
-        `an effort is open on ${o.area} (${onArea.branch}, ${onArea.mode}) owned by ${onArea.owner.session} since ${onArea.started}; finish it, or pass --join to work in the same checkout`,
-        { owner: onArea.owner.session, effort: onArea.id, branch: onArea.branch }
+        `an effort is open on ${label} (${onTarget.branch}, ${onTarget.mode}) owned by ${onTarget.owner.session} since ${onTarget.started}; finish it, or pass --join to work in the same checkout`,
+        { owner: onTarget.owner.session, effort: onTarget.id, branch: onTarget.branch }
       );
     }
     for (const e of open) {
       const pairs = globsOverlap(scopes, e.scopes);
       if (pairs.length > 0) {
+        const otherLabel = effortLabel2(e.area, e.task);
         throw new WorkkitError(
           "SCOPE_CONFLICT",
-          `scope overlaps the open effort on ${e.area} (${e.branch}, owner ${e.owner.session}): ${pairs.join("; ")}`,
-          { with: e.area, owner: e.owner.session, effort: e.id, pairs }
+          `scope overlaps the open effort on ${otherLabel} (${e.branch}, owner ${e.owner.session}): ${pairs.join("; ")}`,
+          { with: otherLabel, owner: e.owner.session, effort: e.id, pairs }
         );
       }
     }
@@ -1312,55 +1933,136 @@ function reserveEffort(ctx, o, branch, scopes, commons) {
   });
   return effort;
 }
-function ensureWorktree(ctx, area, branch) {
+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);
+  const path = worktreePathFor(ctx, area, task);
   const main = new Git(ctx.repoRoot);
-  main.fetch(m.baseBranch);
-  if (!existsSync5(path)) {
+  if (!existsSync7(path)) {
     main.worktreeAdd(path, branch, `origin/${m.baseBranch}`);
-    return new Git(path);
+    const wg2 = new Git(path);
+    wg2.repairSubmodules(ctx.repoRoot, ctx.log);
+    return { wg: wg2, created: true };
   }
-  const registered = main.run(["worktree", "list", "--porcelain"]).split("\n").filter((l) => l.startsWith("worktree ")).map((l) => realpathOr(l.slice(9)));
-  const real = realpathOr(path);
+  const registered = main.run(["worktree", "list", "--porcelain"]).split("\n").filter((l) => l.startsWith("worktree ")).map((l) => realpathOr2(l.slice(9)));
+  const real = realpathOr2(path);
   const wg = new Git(path);
   const topLevel = wg.tryRun(["rev-parse", "--show-toplevel"]);
-  if (!registered.includes(real) || topLevel.code !== 0 || realpathOr(topLevel.out.trim()) !== real || wg.isMainCheckout()) {
+  if (!registered.includes(real) || topLevel.code !== 0 || realpathOr2(topLevel.out.trim()) !== real || wg.isMainCheckout()) {
     throw new WorkkitError(
       "WORKTREE_INVALID",
-      `${path} exists but is not this repository's worktree for ${area} (a leftover directory?); move it away, or \`git worktree prune\` and retry`,
+      `${path} exists but is not this repository's worktree for ${effortLabel2(area, task)} (a leftover directory?); move it away, or \`git worktree prune\` and retry`,
       { worktree: path }
     );
   }
+  wg.repairSubmodules(ctx.repoRoot, ctx.log);
   const current = wg.currentBranch();
   if (current !== branch) {
-    if (current.endsWith(`/${area}`) && wg.commitsNotOn(m.baseBranch).length > 0) {
-      throw new WorkkitError(
-        "EFFORT_OPEN",
-        `${current} holds ${wg.commitsNotOn(m.baseBranch).length} commit(s) not yet on ${m.baseBranch}: ship or finish it first, or --join it`,
-        { branch: current, area }
-      );
-    }
     if (wg.isDirty())
       throw new WorkkitError(
         "DIRTY_WORKTREE",
         `${path} has uncommitted changes on ${current}; commit or park them before switching to ${branch}`,
         { worktree: path }
       );
+    const unshipped = wg.commitsNotOn(m.baseBranch);
+    if (unshipped.length > 0 && !wg.isEquivalentToBase(m.baseBranch)) {
+      throw new WorkkitError(
+        "EFFORT_OPEN",
+        `${current} holds ${unshipped.length} commit(s) not yet on ${m.baseBranch}: ship or finish it first, or --join it`,
+        { branch: current, area }
+      );
+    }
     wg.checkout(branch, `origin/${m.baseBranch}`);
+    if (!wg.isDirty() && wg.commitsNotOn(m.baseBranch).length > 0 && wg.isEquivalentToBase(m.baseBranch)) {
+      wg.run(["reset", "--hard", `origin/${m.baseBranch}`]);
+    }
+  } else if (!wg.isDirty() && wg.commitsNotOn(m.baseBranch).length > 0 && wg.isEquivalentToBase(m.baseBranch)) {
+    wg.run(["reset", "--hard", `origin/${m.baseBranch}`]);
   }
-  return wg;
+  return { wg, created: false };
 }
 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);
-  const open = ctx.registry.openEffortFor(m.project, o.area);
+  let open = ctx.registry.openEffortFor(m.project, o.area, o.task);
   if (open && o.join) {
+    const deadline = Date.now() + JOIN_WAIT_MS;
+    while (open && open.state === "starting" && Date.now() < deadline) {
+      await sleep3(200);
+      open = ctx.registry.openEffortFor(m.project, o.area, o.task);
+    }
+    if (!open || open.state !== "active") {
+      throw new WorkkitError(
+        "EFFORT_NOT_FOUND",
+        `effort on ${effortLabel2(o.area, o.task)} did not become active in time to join`,
+        { area: o.area, task: o.task }
+      );
+    }
+    if (!modeCovers(open.mode, o.mode)) {
+      const label = effortLabel2(o.area, o.task);
+      throw new WorkkitError(
+        "MODE_MISMATCH",
+        `open effort on ${label} is in ${open.mode} mode, which does not cover ${o.mode}; run \`work promote --area ${o.area}${o.task ? ` --task ${o.task}` : ""} --mode fullstack\` first`,
+        { area: o.area, task: o.task, openMode: open.mode, requestedMode: o.mode }
+      );
+    }
+    const currentLeases = ctx.registry.leases({ effort: open.id });
+    if (o.story && !currentLeases.some((l) => l.kind === "storybook")) {
+      const hostRoot = storybookHostFor(m, open.worktree);
+      const inst = await ctx.storybrokr.up(o.story, hostRoot, {
+        ttlMinutes: Math.ceil(m.expiry.storybookHours * 60)
+      });
+      const sbLease = ctx.registry.addLease(
+        "storybook",
+        m.project,
+        inst.id,
+        ctx.owner,
+        open.id,
+        m.expiry.storybookHours,
+        { ports: { storybook: inst.port } }
+      );
+      open = ctx.registry.updateEffort(open.id, {
+        leases: [...open.leases, sbLease.id]
+      });
+    }
+    const existingParticipants = open.participants ?? [];
+    const isAlreadyMember = open.owner.session === ctx.owner.session || existingParticipants.some((p) => p.session === ctx.owner.session);
+    if (!isAlreadyMember) {
+      open = ctx.registry.updateEffort(open.id, {
+        participants: [...existingParticipants, ctx.owner]
+      });
+    }
     touchEffort(ctx, open);
     return {
       effort: open,
@@ -1386,6 +2088,8 @@ async function startEffort(ctx, o) {
           signatures: l.signatures,
           onLog: ctx.log
         }).catch(() => void 0);
+      } else if (stopPids && l.kind === "storybook") {
+        await ctx.storybrokr.down(String(l.value)).catch(() => void 0);
       }
       ctx.registry.release(l.id);
     }
@@ -1397,17 +2101,28 @@ async function startEffort(ctx, o) {
   process.once("SIGINT", onSignal);
   process.once("SIGTERM", onSignal);
   try {
-    const wg = ensureWorktree(ctx, o.area, branch);
+    const { wg, created } = ensureWorktree(ctx, o.area, branch, o.task);
     const worktree = wg.root();
     ctx.registry.updateEffort(effort.id, { worktree });
     effort.worktree = worktree;
-    const logDir = join6(worktree, m.logs.dir);
-    mkdirSync5(logDir, { recursive: true });
-    const refreshLog = join6(logDir, "refresh.log");
+    const logDir = join8(worktree, m.logs.dir);
+    mkdirSync6(logDir, { recursive: true });
+    const refreshLog = join8(logDir, "refresh.log");
+    const stampFile = join8(logDir, ".refresh-stamps.json");
+    if (created && m.seed && m.seed.length > 0) {
+      runRefresh(
+        m.seed,
+        worktree,
+        (l) => {
+          appendLog(refreshLog, l);
+          ctx.log(l);
+        },
+        { ...process.env, WORKTREE: worktree, MAIN_ROOT: ctx.repoRoot }
+      );
+    }
     let sync = "skipped";
     let changed = [];
     if (o.sync !== false) {
-      wg.fetch(m.baseBranch);
       const r = wg.syncFrom(m.baseBranch);
       if (r.kind === "conflict") {
         throw new WorkkitError(
@@ -1418,12 +2133,31 @@ async function startEffort(ctx, o) {
       }
       sync = r.kind;
       if (r.kind === "ff" || r.kind === "merge") changed = wg.changedPaths(r.before, r.after);
+      ctx.registry.pruneNoticesWhere(
+        m.project,
+        o.area,
+        (n) => wg.isAncestor(`origin/${n.from}`, "HEAD") || wg.isAncestor(n.from, "HEAD")
+      );
+    }
+    const sel = selectRefresh(m.refresh, changed, { worktree, stampFile });
+    runRefresh(
+      sel.runs,
+      worktree,
+      (l) => {
+        appendLog(refreshLog, l);
+        ctx.log(l);
+      },
+      process.env,
+      {
+        stampFile,
+        pendingStamps: sel.pendingStamps,
+        restoreFiles: sel.cleanWhenFiles
+      }
+    );
+    const baseSha = wg.rev("HEAD");
+    if (o.mode === "frontend" && sel.marks.length > 0) {
+      writePendingMarks(logDir, [.../* @__PURE__ */ new Set([...readPendingMarks(logDir), ...sel.marks])]);
     }
-    const sel = selectRefresh(m.refresh, changed);
-    runRefresh(sel.runs, worktree, (l) => {
-      appendLog(refreshLog, l);
-      ctx.log(l);
-    });
     for (const name of commons)
       leases.push(
         ctx.registry.addLease(
@@ -1435,25 +2169,9 @@ async function startEffort(ctx, o) {
           m.expiry.commonsHours
         )
       );
-    if (o.mode === "fullstack") {
-      const exclude = /* @__PURE__ */ new Set();
-      let slot;
-      const busyNotes = [];
-      for (; ; ) {
-        const candidate = ctx.registry.allocateSlot(m.project, m, ctx.owner, effort.id, exclude);
-        const busy = await busyPorts(candidate.ports ?? {});
-        if (busy.length === 0) {
-          slot = candidate;
-          break;
-        }
-        ctx.registry.release(candidate.id);
-        exclude.add(candidate.value);
-        busyNotes.push(`slot ${candidate.value}: ${busy.join(", ")} already in use`);
-        ctx.log(busyNotes[busyNotes.length - 1]);
-      }
-      if (!slot) throw new WorkkitError("NO_FREE_SLOT", busyNotes.join("; "));
+    if (o.mode === "fullstack" || o.mode === "backend") {
+      const slot = await claimFreeSlot(ctx, effort.id, warnings);
       leases.push(slot);
-      if (busyNotes.length) warnings.push(...busyNotes);
       const cfg = emitWorktreeConfig({
         m,
         worktree,
@@ -1463,8 +2181,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 = {};
@@ -1473,6 +2196,7 @@ async function startEffort(ctx, o) {
         cwd: worktree,
         env,
         logDir,
+        mode: o.mode,
         onLog: ctx.log,
         onSpawn: (service, pid, signature) => {
           pids[service] = pid;
@@ -1487,8 +2211,10 @@ async function startEffort(ctx, o) {
     } else {
       let storybookPort;
       if (o.story) {
-        const hostRoot = m.storybook ? join6(worktree, m.storybook.hostRoot) : worktree;
-        const inst = await ctx.storybrokr.up(o.story, hostRoot);
+        const hostRoot = storybookHostFor(m, worktree);
+        const inst = await ctx.storybrokr.up(o.story, hostRoot, {
+          ttlMinutes: Math.ceil(m.expiry.storybookHours * 60)
+        });
         storybookPort = inst.port;
         leases.push(
           ctx.registry.addLease(
@@ -1506,6 +2232,7 @@ async function startEffort(ctx, o) {
     }
     const active = ctx.registry.updateEffort(effort.id, {
       state: "active",
+      baseSha,
       leases: leases.map((l) => l.id),
       lastActivity: now()
     });
@@ -1527,28 +2254,154 @@ async function startEffort(ctx, o) {
     process.off("SIGTERM", onSignal);
   }
 }
+async function promoteEffort(ctx, o) {
+  const m = ctx.manifest;
+  if (o.mode !== "backend" && o.mode !== "fullstack") {
+    throw new WorkkitError("MODE_UNKNOWN", `promote target mode must be backend or fullstack`);
+  }
+  const open = ctx.registry.openEffortFor(m.project, o.area, o.task);
+  if (!open) {
+    throw new WorkkitError(
+      "EFFORT_NOT_FOUND",
+      `no open effort on ${effortLabel2(o.area, o.task)} to promote`,
+      { area: o.area, task: o.task }
+    );
+  }
+  if (open.mode === "fullstack" && o.mode === "backend" || open.mode === "frontend" && o.mode === "backend") {
+    throw new WorkkitError(
+      "MODE_MISMATCH",
+      `cannot transition effort on ${effortLabel2(o.area, o.task)} from ${open.mode} to ${o.mode}`,
+      { from: open.mode, to: o.mode }
+    );
+  }
+  const modeScopes = expandScopes(m, o.area, o.mode);
+  const nextScopes = open.task ? [.../* @__PURE__ */ new Set([...open.scopes, ...modeScopes])] : modeScopes;
+  const refuseOverlap = (r) => {
+    const others = r.efforts.filter(
+      (e) => e.project === m.project && e.id !== open.id && (e.state === "active" || e.state === "starting")
+    );
+    for (const e of others) {
+      const pairs = globsOverlap(nextScopes, e.scopes);
+      if (pairs.length > 0) {
+        const otherLabel = effortLabel2(e.area, e.task);
+        throw new WorkkitError(
+          "SCOPE_CONFLICT",
+          `promoting ${effortLabel2(o.area, o.task)} to ${o.mode} overlaps ${otherLabel} (${e.branch}): ${pairs.join("; ")}`,
+          { with: otherLabel, owner: e.owner.session, effort: e.id, pairs }
+        );
+      }
+    }
+  };
+  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];
+  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,
+    worktree: open.worktree,
+    slot: slot.value,
+    ports: slot.ports ?? {},
+    storybookPort: sb?.ports?.storybook,
+    area: o.area,
+    branch: open.branch
+  });
+  const env = { ...process.env, ...cfg.vars };
+  const logDir = join8(open.worktree, m.logs.dir);
+  mkdirSync6(logDir, { recursive: true });
+  const existingPids = { ...slot.pids ?? {} };
+  const existingSigs = { ...slot.signatures ?? {} };
+  const missingServices = Object.entries(m.services).filter(([name, spec]) => serviceModes(name, spec).includes(o.mode) && !existingPids[name]).map(([name]) => name);
+  if (missingServices.length > 0) {
+    const result = await ctx.runner.start({
+      m,
+      cwd: open.worktree,
+      env,
+      logDir,
+      mode: o.mode,
+      onlyServices: missingServices,
+      onLog: ctx.log,
+      onSpawn: (service, pid, signature) => {
+        existingPids[service] = pid;
+        existingSigs[service] = signature;
+        ctx.registry.patchLease(slot.id, {
+          pids: { ...existingPids },
+          signatures: { ...existingSigs }
+        });
+      }
+    });
+    ctx.registry.patchLease(slot.id, {
+      pids: { ...existingPids, ...result.pids },
+      signatures: { ...existingSigs, ...result.signatures ?? {} }
+    });
+  }
+  const updated = ctx.registry.updateEffort(open.id, { lastActivity: now() });
+  touchEffort(ctx, updated);
+  return {
+    effort: updated,
+    leases: ctx.registry.leases({ effort: open.id }),
+    startedServices: missingServices,
+    warnings
+  };
+}
 function behindBase(ctx, worktree) {
-  if (!existsSync5(worktree)) return 0;
-  const g = new Git(worktree);
-  g.tryRun(["fetch", "-q", "origin", ctx.manifest.baseBranch]);
-  const r = g.tryRun(["rev-list", "--count", `HEAD..origin/${ctx.manifest.baseBranch}`]);
-  return r.code === 0 ? Number(r.out.trim()) || 0 : 0;
+  if (!existsSync7(worktree)) return 0;
+  return new Git(worktree).behindCount(ctx.manifest.baseBranch);
 }
-function statusFor(ctx, area) {
+function statusFor(ctx, area, task) {
   const m = ctx.manifest;
+  fetchBaseOnce(ctx);
   const names = (area ? [area] : Object.keys(m.areas)).sort();
   const areas = names.map((name) => {
-    const effort = ctx.registry.openEffortFor(m.project, name);
+    const effort = ctx.registry.openEffortFor(m.project, name, area ? task : void 0);
     if (effort && area) touchEffort(ctx, effort);
-    const worktree = worktreePathFor(ctx, name);
+    const worktree = worktreePathFor(ctx, name, area ? task : void 0);
     const out = {
-      area: name,
+      area: area && task ? `${name}--${task}` : name,
       leases: effort ? ctx.registry.leases({ effort: effort.id }) : [],
       behindBase: behindBase(ctx, worktree),
       notices: ctx.registry.notices(m.project, name)
     };
     if (effort) out.effort = effort;
-    if (existsSync5(worktree)) out.worktree = worktree;
+    if (existsSync7(worktree)) out.worktree = worktree;
     return out;
   });
   return { project: m.project, areas, leases: ctx.registry.leases({ project: m.project }) };
@@ -1556,14 +2409,14 @@ function statusFor(ctx, area) {
 function slotEnv(m, slot) {
   return slotVars(m, { slot, ports: portsForSlot(m, slot) });
 }
-function effortEnv(ctx, area) {
+function effortEnv(ctx, area, task) {
   const m = ctx.manifest;
-  const effort = ctx.registry.openEffortFor(m.project, area);
+  const effort = ctx.registry.openEffortFor(m.project, area, task);
   if (!effort)
     throw new WorkkitError(
       "EFFORT_NOT_FOUND",
-      `no open effort on ${area}; \`work start --area ${area} \u2026\` first`,
-      { area }
+      `no open effort on ${effortLabel2(area, task)}; \`work start --area ${area} \u2026\` first`,
+      { area, task }
     );
   touchEffort(ctx, effort);
   const slot = ctx.registry.leases({ effort: effort.id, kind: "slot" })[0];
@@ -1575,7 +2428,7 @@ function effortEnv(ctx, area) {
     area,
     branch: effort.branch,
     worktree: effort.worktree,
-    logDir: join6(effort.worktree, m.logs.dir)
+    logDir: join8(effort.worktree, m.logs.dir)
   });
   return { ...vars, MODE: effort.mode };
 }
@@ -1586,14 +2439,14 @@ function leaseEnv(ctx, effort, lease) {
     area: effort.area,
     branch: effort.branch,
     worktree: effort.worktree,
-    logDir: join6(effort.worktree, ctx.manifest.logs.dir)
+    logDir: join8(effort.worktree, ctx.manifest.logs.dir)
   });
   return { ...process.env, ...vars };
 }
 async function releaseLease(ctx, effort, lease) {
   try {
     if (lease.kind === "slot" && lease.pids && Object.keys(lease.pids).length > 0) {
-      const hasWorktree = effort !== void 0 && existsSync5(effort.worktree);
+      const hasWorktree = effort !== void 0 && existsSync7(effort.worktree);
       await ctx.runner.stop({
         m: ctx.manifest,
         cwd: hasWorktree && effort ? effort.worktree : ctx.repoRoot,
@@ -1613,6 +2466,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 = {
@@ -1630,29 +2492,117 @@ function leaveNotices(ctx, effort, commons) {
 }
 async function finishEffort(ctx, o) {
   const m = ctx.manifest;
-  const effort = ctx.registry.openEffortFor(m.project, o.area) ?? ctx.registry.efforts({ project: m.project, area: o.area, state: "parked" }).sort((a, b) => b.started.localeCompare(a.started))[0];
+  const effort = 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];
   if (!effort)
-    throw new WorkkitError("EFFORT_NOT_FOUND", `no open or parked effort on ${o.area}`, {
-      area: o.area
-    });
+    throw new WorkkitError(
+      "EFFORT_NOT_FOUND",
+      `no open or parked effort on ${effortLabel2(o.area, o.task)}`,
+      { area: o.area, task: o.task }
+    );
+  if (!o.force && effort.participants && effort.participants.length > 0) {
+    if (ctx.owner.session === effort.owner.session) {
+      const [nextOwner, ...rest] = effort.participants;
+      const updated = ctx.registry.updateEffort(effort.id, {
+        owner: nextOwner,
+        participants: rest,
+        lastActivity: now()
+      });
+      touchEffort(ctx, updated);
+      return { effort: updated, pushed: false, parked: false, left: true, notices: 0 };
+    }
+    if (effort.participants.some((p) => p.session === ctx.owner.session)) {
+      const updated = ctx.registry.updateEffort(effort.id, {
+        participants: effort.participants.filter((p) => p.session !== ctx.owner.session),
+        lastActivity: now()
+      });
+      touchEffort(ctx, updated);
+      return { effort: updated, pushed: false, parked: false, left: true, notices: 0 };
+    }
+  }
+  const label = effortLabel2(effort.area, effort.task);
   const g = new Git(effort.worktree);
   let parked = false;
   if (g.isDirty()) {
     if (!o.park) {
       throw new WorkkitError(
         "DIRTY_WORKTREE",
-        `${effort.worktree} has uncommitted changes: commit them, or \`work finish --park\` to commit them as wip(${effort.area}) and push`,
+        `${effort.worktree} has uncommitted changes: commit them, or \`work finish --park\` to commit them as wip(${label}) and push`,
         { worktree: effort.worktree }
       );
     }
     g.run(["add", "-A"]);
-    g.run(["commit", "-q", "-m", `wip(${effort.area}): parked ${now()}`]);
+    g.run(["commit", "-q", "-m", `wip(${label}): parked ${now()}`]);
     parked = true;
   }
+  if (o.intoArea) {
+    if (!effort.task) {
+      throw new WorkkitError(
+        "MANIFEST_INVALID",
+        "--into-area requires a task sub-effort (--task <slug>)",
+        { area: effort.area }
+      );
+    }
+    fetchBaseOnce(ctx);
+    const parentBranch = areaBranchFor(ctx, effort.area, effort.type);
+    const { wg: areaGit } = ensureWorktree(ctx, effort.area, parentBranch);
+    if (areaGit.isDirty()) {
+      throw new WorkkitError(
+        "DIRTY_WORKTREE",
+        `parent area worktree ${areaGit.cwd} has uncommitted changes; commit or clean it before merging task ${effort.branch} --into-area`,
+        { worktree: areaGit.cwd }
+      );
+    }
+    const merged = areaGit.tryRun(["merge", "--no-edit", "-q", effort.branch]);
+    if (merged.code !== 0) {
+      const conflicted = areaGit.tryRun(["diff", "--name-only", "--diff-filter=U"]).out.split("\n").map((l) => l.trim()).filter(Boolean);
+      areaGit.tryRun(["merge", "--abort"]);
+      throw new WorkkitError(
+        "SYNC_CONFLICT",
+        `merging ${effort.branch} into ${parentBranch} conflicts in ${conflicted.join(", ")}; resolve in ${effort.worktree} before retrying \`work finish --into-area\``,
+        { conflicted, worktree: areaGit.cwd }
+      );
+    }
+  }
+  if (!o.intoArea) {
+    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);
-  g.push(effort.branch);
-  const notices = leaveNotices(ctx, effort, commonsTouched(m, g.changedSince(m.baseBranch)));
+  await sweepStorybook(ctx, effort);
+  let notices = 0;
+  if (!o.intoArea) {
+    if (g.commitsNotOn(m.baseBranch).length > 0 && !g.isEquivalentToBase(m.baseBranch)) {
+      const since = g.changedSince(m.baseBranch);
+      const sinceSet = new Set(since);
+      const changed = effort.baseSha ? g.changedPaths(effort.baseSha, "HEAD").filter((p) => sinceSet.has(p)) : since;
+      notices = leaveNotices(ctx, effort, commonsTouched(m, changed));
+    }
+  }
+  if (effort.task) {
+    archiveWorktree(ctx, label, effort.worktree);
+    const main = new Git(ctx.repoRoot);
+    main.worktreeRemove(effort.worktree);
+    if (o.intoArea) {
+      main.deleteLocalBranch(effort.branch);
+    }
+    const finished2 = { ...effort, state: "finished", lastActivity: now() };
+    ctx.registry.removeEfforts((e) => e.id === effort.id);
+    return {
+      effort: finished2,
+      pushed: !o.intoArea,
+      parked,
+      mergedIntoArea: Boolean(o.intoArea),
+      notices
+    };
+  }
   const finished = ctx.registry.updateEffort(effort.id, { state: "finished", lastActivity: now() });
   return { effort: finished, pushed: true, parked, notices };
 }
@@ -1667,57 +2617,67 @@ async function reapLeases(ctx, o = {}) {
     if (effort?.state === "starting" && Date.now() - Date.parse(effort.started) < STARTING_GRACE_MS)
       continue;
     const expired = Date.parse(l.expires) < at.getTime();
-    const orphaned = !effort || !existsSync5(effort.worktree);
+    const orphaned = !effort || !existsSync7(effort.worktree);
     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 && (effort.state === "active" || effort.state === "starting")) {
-      ctx.registry.updateEffort(effort.id, {
-        state: "parked",
-        parkedReason: `idle: a lease expired by ${at.toISOString()}`,
-        lastActivity: now()
-      });
+    if (effort) {
+      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: hadLease ? `idle: a lease expired by ${at.toISOString()}` : `start died before its first lease (started ${effort.started})`,
+          lastActivity: now()
+        });
+      }
     }
   }
   return { reaped };
 }
 var ARCHIVE_DIR = ".slot-archive";
 function dirSize(path) {
-  if (!existsSync5(path)) return 0;
+  if (!existsSync7(path)) return 0;
   let total = 0;
   for (const entry of readdirSync(path, { withFileTypes: true })) {
-    const p = join6(path, entry.name);
-    total += entry.isDirectory() ? dirSize(p) : statSync2(p).size;
+    const p = join8(path, entry.name);
+    total += entry.isDirectory() ? dirSize(p) : statSync3(p).size;
   }
   return total;
 }
 function archiveWorktree(ctx, area, worktree) {
   const m = ctx.manifest;
-  const areaRoot = join6(ctx.repoRoot, ARCHIVE_DIR, area);
+  const areaRoot = join8(ctx.repoRoot, ARCHIVE_DIR, area);
   const stamp = now().replace(/[-:]/g, "").replace("T", "-").slice(0, 15);
-  const target = join6(areaRoot, stamp);
+  const target = join8(areaRoot, stamp);
   const archived = [];
   for (const rel of m.archive.paths) {
-    const src = join6(worktree, rel);
-    if (!existsSync5(src)) continue;
-    const dst = join6(target, rel);
-    mkdirSync5(dirname2(dst), { recursive: true });
+    const src = join8(worktree, rel);
+    if (!existsSync7(src)) continue;
+    const dst = join8(target, rel);
+    mkdirSync6(dirname3(dst), { recursive: true });
     cpSync(src, dst, { recursive: true });
     archived.push(dst);
   }
   if (archived.length > 0) ensureExcluded(ctx.repoRoot, [`${ARCHIVE_DIR}/`]);
-  if (existsSync5(areaRoot)) {
+  if (existsSync7(areaRoot)) {
     const stamps = readdirSync(areaRoot, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
     const cutoff = Date.now() - m.archive.keepDays * 864e5;
     stamps.forEach((d, i) => {
-      const t = statSync2(join6(areaRoot, d)).mtimeMs;
+      const t = statSync3(join8(areaRoot, d)).mtimeMs;
       if (i >= m.archive.keepPerArea || t < cutoff)
-        rmSync2(join6(areaRoot, d), { recursive: true, force: true });
+        rmSync3(join8(areaRoot, d), { recursive: true, force: true });
     });
   }
   return archived;
@@ -1726,17 +2686,17 @@ async function retireArea(ctx, o) {
   const m = ctx.manifest;
   if (!m.areas[o.area])
     throw new WorkkitError("AREA_UNKNOWN", `unknown area "${o.area}"`, { area: o.area });
-  const open = ctx.registry.openEffortFor(m.project, o.area);
+  const open = ctx.registry.efforts({ project: m.project, area: o.area }).find((e) => e.state === "starting" || e.state === "active");
   if (open)
     throw new WorkkitError(
       "EFFORT_OPEN",
-      `an effort is open on ${o.area} (${open.owner.session}); \`work finish\` it first`,
+      `an effort is open on ${effortLabel2(open.area, open.task)} (${open.owner.session}); \`work finish\` it first`,
       { owner: open.owner.session }
     );
-  const worktree = worktreePathFor(ctx, o.area);
+  const worktree = realpathOr2(worktreePathFor(ctx, o.area));
   const main = new Git(ctx.repoRoot);
   let archived = [];
-  if (existsSync5(worktree)) {
+  if (existsSync7(worktree)) {
     const g = new Git(worktree);
     if (g.isDirty())
       throw new WorkkitError(
@@ -1751,13 +2711,15 @@ 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 = [];
-  for (const type of m.branch.types) {
-    const branch = `${type}/${o.area}`;
+  const allAreaBranches = m.branch.types.map((type) => `${type}/${o.area}`);
+  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) {
@@ -1767,8 +2729,96 @@ async function retireArea(ctx, o) {
   }
   ctx.registry.removeEfforts((e) => e.project === m.project && e.area === o.area);
   ctx.registry.clearNotices(m.project, o.area);
+  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 = 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) {
+      throw new WorkkitError(
+        "PR_CLOSED",
+        `PR #${effort.pr.number} for ${label} is no longer open (${effort.pr.url}); pass --force to open a new one`,
+        { pr: effort.pr }
+      );
+    }
+  }
+  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;
@@ -1786,15 +2836,16 @@ function registeredWorktrees(ctx) {
     }
   }
   if (current) out.push(current);
-  const wtRoot = join6(realpathOr(ctx.repoRoot), ctx.manifest.worktreeRoot);
-  return out.filter((w) => existsSync5(w.path) && realpathOr(w.path).startsWith(wtRoot));
+  const wtRoot = join8(realpathOr2(ctx.repoRoot), ctx.manifest.worktreeRoot);
+  return out.filter((w) => existsSync7(w.path) && realpathOr2(w.path).startsWith(wtRoot));
 }
 async function auditProject(ctx) {
   const m = ctx.manifest;
+  fetchBaseOnce(ctx);
   const findings = [];
   const types = m.branch.types.join("|");
   const areaOf = (branch) => {
-    const match = new RegExp(`^(${types})/(.+)$`).exec(branch);
+    const match = new RegExp(`^(${types})/(.+?)(?:--([a-z0-9][a-z0-9_-]*))?$`).exec(branch);
     return match && m.areas[match[2]] ? match[2] : null;
   };
   for (const w of registeredWorktrees(ctx)) {
@@ -1843,7 +2894,7 @@ async function auditProject(ctx) {
         findings.push({ kind: "notice-stale", area, detail: `${n.text} (since ${n.at})` });
     }
   }
-  const bytes = dirSize(join6(ctx.repoRoot, ARCHIVE_DIR));
+  const bytes = dirSize(join8(ctx.repoRoot, ARCHIVE_DIR));
   if (bytes > ARCHIVE_LIMIT_BYTES)
     findings.push({
       kind: "archive-size",
@@ -1893,51 +2944,70 @@ function registerAudit(program2) {
 
 // src/commands/env.ts
 function registerEnv(program2) {
-  program2.command("env").description("The slot-derived variables of an area's open effort, or of a slot number alone").option("--area <area>", "the area whose open effort to read").option(
+  program2.command("env").description("The slot-derived variables of an area's open effort, or of a slot number alone").option("--area <area>", "the area whose open effort to read").option("--task <slug>", "intra-area task slug").option(
     "--slot <n>",
     "compute the variables for this slot from the manifest alone",
     (v) => Number(v)
-  ).option("--project-root <dir>", "repository root (default: the main checkout of the cwd)").option("--json", "print as JSON (default: KEY=value lines)").option("--sh", "print KEY=value lines (the default)").action(async (o) => {
-    try {
-      const ctx = await buildCtx({ projectRoot: o.projectRoot, quiet: true });
-      let vars;
-      if (o.area) vars = effortEnv(ctx, o.area);
-      else if (o.slot !== void 0 && Number.isInteger(o.slot))
-        vars = slotEnv(ctx.manifest, o.slot);
-      else throw new WorkkitError("EFFORT_NOT_FOUND", "pass --area <area> or --slot <n>");
-      if (o.json) printJson(vars);
-      else for (const [k, v] of Object.entries(vars)) console.log(`${k}=${v}`);
-    } catch (err) {
-      fail(err, Boolean(o.json));
+  ).option("--project-root <dir>", "repository root (default: the main checkout of the cwd)").option("--json", "print as JSON (default: KEY=value lines)").option("--sh", "print KEY=value lines (the default)").action(
+    async (o) => {
+      try {
+        const ctx = await buildCtx({ projectRoot: o.projectRoot, quiet: true });
+        let vars;
+        if (o.area) vars = effortEnv(ctx, o.area, o.task);
+        else if (o.slot !== void 0 && Number.isInteger(o.slot))
+          vars = slotEnv(ctx.manifest, o.slot);
+        else throw new WorkkitError("EFFORT_NOT_FOUND", "pass --area <area> or --slot <n>");
+        if (o.json) printJson(vars);
+        else for (const [k, v] of Object.entries(vars)) console.log(`${k}=${v}`);
+      } catch (err) {
+        fail(err, Boolean(o.json));
+      }
     }
-  });
+  );
 }
 
 // src/commands/finish.ts
 import chalk4 from "chalk";
 function registerFinish(program2) {
   program2.command("finish").description(
-    "Stop the effort's runner, release its leases, push its branch; the worktree and branch stay"
-  ).requiredOption("--area <area>", "the area whose open effort to finish").option("--park", "commit uncommitted changes as wip(<area>) instead of refusing").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 finishEffort(ctx, { area: o.area, park: o.park });
-      if (o.json) printJson(r);
-      else {
-        console.log(
-          `${chalk4.bold(r.effort.area)} finished: ${r.effort.branch} pushed${r.parked ? " (uncommitted changes parked as wip)" : ""}`
-        );
-        if (r.notices) console.log(`  ${r.notices} area(s) told about commons changes`);
+    "Stop the effort's runner, release its leases, push its branch (or merge --into-area); area worktrees stay, task worktrees are cleaned up"
+  ).requiredOption("--area <area>", "the area whose open effort to finish").option("--task <slug>", "finish an intra-area task sub-effort").option("--park", "commit uncommitted changes as wip(<area>) instead of refusing").option("--into-area", "merge task branch into <type>/<area> instead of pushing to origin").option("--force", "stop and finish even if other joined participants remain").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 finishEffort(ctx, {
+          area: o.area,
+          task: o.task,
+          park: o.park,
+          intoArea: o.intoArea,
+          force: o.force
+        });
+        if (o.json) printJson(r);
+        else {
+          const label = r.effort.task ? `${r.effort.area}--${r.effort.task}` : r.effort.area;
+          if (r.left) {
+            console.log(`${chalk4.bold(label)}: left shared effort (other participants remain)`);
+          } else if (r.mergedIntoArea) {
+            console.log(
+              `${chalk4.bold(label)} finished: ${r.effort.branch} merged into ${r.effort.type}/${r.effort.area}`
+            );
+          } else {
+            console.log(
+              `${chalk4.bold(label)} finished: ${r.effort.branch} pushed${r.parked ? " (uncommitted changes parked as wip)" : ""}`
+            );
+          }
+          if (r.notices) console.log(`  ${r.notices} area(s) told about commons changes`);
+        }
+      } catch (err) {
+        fail(err, Boolean(o.json));
       }
-    } catch (err) {
-      fail(err, Boolean(o.json));
     }
-  });
+  );
 }
 
 // src/commands/hook.ts
-import { readFileSync as readFileSync4, realpathSync as realpathSync5 } from "fs";
-import { resolve } from "path";
+import { readFileSync as readFileSync6, realpathSync as realpathSync5 } from "fs";
+import { resolve as resolve2 } from "path";
 import chalk5 from "chalk";
 var ZEROS = /^0+$/;
 async function hookContext(cwd) {
@@ -1956,7 +3026,7 @@ async function runPreCommit(cwd) {
   if (!c) return 0;
   const root = c.git.root();
   touchByWorktree(c.registry, c.manifest, root);
-  const { refusals } = checkCommit({
+  const { refusals, warnings } = checkCommit({
     m: c.manifest,
     registry: c.registry,
     git: c.git,
@@ -1966,6 +3036,7 @@ async function runPreCommit(cwd) {
     ownerSession: currentOwner().session,
     checkoutRoot: root
   });
+  for (const w of warnings) console.error(chalk5.yellow(`work: ${w}`));
   for (const r of refusals) console.error(chalk5.red(`work: ${r}`));
   return refusals.length ? 2 : 0;
 }
@@ -2033,7 +3104,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 ? "" : readFileSync4(0, "utf8");
+      const stdin = process.stdin.isTTY ? "" : readFileSync6(0, "utf8");
       process.exit(await runPrePush(process.cwd(), stdin));
     } catch (err) {
       fail(err, false);
@@ -2044,7 +3115,7 @@ function registerHook(program2) {
     "Write .helmsmith/hooks and point this clone's core.hooksPath at them (for a repo whose manifest already exists)"
   ).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 repoRoot = o.projectRoot ? resolve(o.projectRoot) : new Git(process.cwd()).mainRoot();
+      const repoRoot = o.projectRoot ? resolve2(o.projectRoot) : new Git(process.cwd()).mainRoot();
       const manifest = await loadManifest(repoRoot);
       const out = installHooks(repoRoot, { protectedBranches: manifest.protectedBranches });
       if (o.json) printJson(out);
@@ -2056,8 +3127,8 @@ function registerHook(program2) {
 }
 
 // src/commands/init.ts
-import { existsSync as existsSync6, writeFileSync as writeFileSync4 } from "fs";
-import { join as join7, resolve as resolve2 } from "path";
+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) {
   const PORT = `\${PORT_${name.toUpperCase()}}`;
@@ -2121,9 +3192,9 @@ var HEADER = `// biome-ignore-all lint/suspicious/noTemplateCurlyInString: \${PO
 // each with its backend module) and the commons. Nothing here is read by the application.
 `;
 function runInit(o) {
-  const repoRoot = resolve2(o.repoRoot);
+  const repoRoot = resolve3(o.repoRoot);
   for (const name of MANIFEST_FILES) {
-    if (existsSync6(join7(repoRoot, name)) && !o.force) {
+    if (existsSync8(join9(repoRoot, name)) && !o.force) {
       throw new WorkkitError(
         "MANIFEST_INVALID",
         `${name} already exists in ${repoRoot}; pass --force to overwrite`
@@ -2131,8 +3202,8 @@ function runInit(o) {
     }
   }
   const manifest = buildStarterManifest(o);
-  const manifestPath = join7(repoRoot, "helmsmith.config.mjs");
-  writeFileSync4(manifestPath, `${HEADER}export default ${JSON.stringify(manifest, null, 2)};
+  const manifestPath = join9(repoRoot, "helmsmith.config.mjs");
+  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 : [];
@@ -2162,7 +3233,7 @@ function registerInit(program2) {
   ).option("--storybook-host <dir>", "the package whose .storybook storybrokr boots from").option("--worktree-root <dir>", "where area worktrees live (default .claude/worktrees)").option("--repo-root <dir>", "repository root (default: the main checkout of the cwd)").option("--no-hooks", "do not install the git hooks").option("--force", "overwrite an existing manifest").option("--json", "print the result as JSON").action(
     (o) => {
       try {
-        const repoRoot = o.repoRoot ? resolve2(o.repoRoot) : defaultRepoRoot();
+        const repoRoot = o.repoRoot ? resolve3(o.repoRoot) : defaultRepoRoot();
         if (o.service.length === 0)
           throw new WorkkitError(
             "MANIFEST_INVALID",
@@ -2200,21 +3271,21 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z as z2 } from "zod";
 
 // src/version.ts
-import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname3, join as join8 } from "path";
+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) {
   let dir = startDir;
   for (; ; ) {
-    const candidate = join8(dir, "package.json");
-    if (existsSync7(candidate)) return candidate;
-    const parent = dirname3(dir);
+    const candidate = join10(dir, "package.json");
+    if (existsSync9(candidate)) return candidate;
+    const parent = dirname4(dir);
     if (parent === dir) throw new Error(`package.json not found above ${startDir}`);
     dir = parent;
   }
 }
-var pkgFile = findPackageJson(dirname3(fileURLToPath(import.meta.url)));
-var VERSION = JSON.parse(readFileSync5(pkgFile, "utf8")).version;
+var pkgFile = findPackageJson(dirname4(fileURLToPath(import.meta.url)));
+var VERSION = JSON.parse(readFileSync7(pkgFile, "utf8")).version;
 
 // src/mcp/server.ts
 var ok = (value) => ({
@@ -2236,64 +3307,143 @@ function buildMcpServer(ctxFactory) {
   server.registerTool(
     "work_start",
     {
-      description: "Start an effort on an area: its worktree on <type>/<area>, synced from the base branch, refreshed, leased (a slot for fullstack, 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).",
+      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>)"
+        ),
         type: z2.string().describe("feature | chore | fix"),
-        mode: z2.enum(["frontend", "fullstack"]),
+        mode: z2.enum(["frontend", "backend", "fullstack"]),
+        scopes: z2.array(z2.string()).optional().describe("optional narrowed scope globs for a task sub-effort"),
         story: z2.string().optional().describe(
           "frontend: story file or component folder for storybrokr, relative to its host"
         ),
         join: z2.boolean().optional().describe("work in the already-open effort instead of refusing"),
-        sync: z2.boolean().optional().describe("fetch and merge the base branch first (default true)")
+        sync: z2.boolean().optional().describe("fetch and merge the base branch first (default true)"),
+        projectRoot: z2.string().optional().describe("optional repository root path override")
+      }
+    },
+    async ({ area, task, type, mode, scopes, story, join: join11, sync, projectRoot }) => guard(
+      async () => startEffort(await ctxFactory(projectRoot), {
+        area,
+        task,
+        type,
+        mode,
+        scopes,
+        story,
+        join: join11,
+        sync
+      })
+    )
+  );
+  server.registerTool(
+    "work_promote",
+    {
+      description: "Promote an open effort in place to backend or fullstack mode, claiming a slot if needed and starting only newly required services.",
+      inputSchema: {
+        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"),
+        projectRoot: z2.string().optional().describe("optional repository root path override")
       }
     },
-    async ({ area, type, mode, story, join: join9, sync }) => guard(async () => startEffort(await ctxFactory(), { area, type, mode, story, join: join9, sync }))
+    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",
     {
       description: "Per area: the open effort, its leases, how far behind the base branch it is, pending notices; plus every lease of the project.",
-      inputSchema: { area: z2.string().optional() }
+      inputSchema: {
+        area: z2.string().optional(),
+        task: z2.string().optional(),
+        projectRoot: z2.string().optional().describe("optional repository root path override")
+      }
     },
-    async ({ area }) => guard(async () => statusFor(await ctxFactory(), area))
+    async ({ area, task, projectRoot }) => guard(async () => statusFor(await ctxFactory(projectRoot), area, task))
   );
   server.registerTool(
     "work_finish",
     {
-      description: "Stop the effort's runner, release its leases, push its branch, leave commons notices. The worktree and branch stay. Refuses DIRTY_WORKTREE unless park=true (commits as wip).",
-      inputSchema: { area: z2.string(), park: z2.boolean().optional() }
+      description: "Stop the effort's runner, release its leases, push its branch (or merge --into-area for task sub-efforts), leave commons notices. Refuses DIRTY_WORKTREE unless park=true (commits as wip).",
+      inputSchema: {
+        area: z2.string(),
+        task: z2.string().optional().describe("optional intra-area task slug"),
+        park: z2.boolean().optional(),
+        intoArea: z2.boolean().optional().describe("merge task branch into <type>/<area> instead of pushing to origin"),
+        force: z2.boolean().optional().describe("stop and finish even if other joined participants remain"),
+        projectRoot: z2.string().optional().describe("optional repository root path override")
+      }
     },
-    async ({ area, park }) => guard(async () => finishEffort(await ctxFactory(), { area, park }))
+    async ({ area, task, park, intoArea, force, projectRoot }) => guard(
+      async () => finishEffort(await ctxFactory(projectRoot), { area, task, park, intoArea, force })
+    )
   );
   server.registerTool(
     "work_reap",
     {
       description: "Expire idle leases: stop only what they started, release them, park their efforts. dryRun lists without touching.",
-      inputSchema: { dryRun: z2.boolean().optional() }
+      inputSchema: {
+        dryRun: z2.boolean().optional(),
+        projectRoot: z2.string().optional().describe("optional repository root path override")
+      }
     },
-    async ({ dryRun }) => guard(async () => reapLeases(await ctxFactory(), { dryRun }))
+    async ({ dryRun, projectRoot }) => guard(async () => reapLeases(await ctxFactory(projectRoot), { dryRun }))
   );
   server.registerTool(
     "work_audit",
     {
       description: "Findings: dirty or unpushed area worktrees, foreign worktrees, aging leases, drift from the base branch, stale notices, archive size.",
-      inputSchema: {}
+      inputSchema: {
+        projectRoot: z2.string().optional().describe("optional repository root path override")
+      }
     },
-    async () => guard(async () => auditProject(await ctxFactory()))
+    async ({ projectRoot }) => guard(async () => auditProject(await ctxFactory(projectRoot)))
   );
   server.registerTool(
     "work_env",
     {
       description: "The slot-derived variables of an area's open effort (PORT_*, SLOT, LOG_DIR, WORKTREE, BRANCH, MODE).",
-      inputSchema: { area: z2.string() }
+      inputSchema: {
+        area: z2.string(),
+        task: z2.string().optional(),
+        projectRoot: z2.string().optional().describe("optional repository root path override")
+      }
     },
-    async ({ area }) => guard(async () => effortEnv(await ctxFactory(), area))
+    async ({ area, task, projectRoot }) => guard(async () => effortEnv(await ctxFactory(projectRoot), area, task))
   );
   return server;
 }
 async function runStdio() {
-  const server = buildMcpServer(() => buildCtx({ quiet: true }));
+  const server = buildMcpServer((projectRoot) => buildCtx({ projectRoot, quiet: true }));
   await server.connect(new StdioServerTransport());
 }
 
@@ -2304,8 +3454,68 @@ function registerMcp(program2) {
   });
 }
 
-// src/commands/reap.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("--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
+        });
+        if (o.json) printJson(r);
+        else {
+          const label = r.effort.task ? `${r.effort.area}--${r.effort.task}` : r.effort.area;
+          console.log(
+            `${chalk7.bold(label)} promoted to ${r.effort.mode}${r.startedServices.length ? ` (started: ${r.startedServices.join(", ")})` : ""}`
+          );
+          for (const w of r.warnings) warn(w);
+        }
+      } catch (err) {
+        fail(err, Boolean(o.json));
+      }
+    }
+  );
+}
+
+// src/commands/reap.ts
+import chalk8 from "chalk";
 function registerReap(program2) {
   program2.command("reap").description(
     "Expire idle leases: stop only what they started, release them, park their efforts"
@@ -2314,7 +3524,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(chalk6.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(
@@ -2327,7 +3537,7 @@ function registerReap(program2) {
 }
 
 // src/commands/retire.ts
-import chalk7 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)"
@@ -2337,11 +3547,11 @@ function registerRetire(program2) {
       const r = await retireArea(ctx, { area: o.area });
       if (o.json) printJson(r);
       else {
-        console.log(`${chalk7.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(chalk7.yellow(`  kept ${b}: not fully on origin`));
+          console.log(chalk9.yellow(`  kept ${b}: not fully on origin`));
       }
     } catch (err) {
       fail(err, Boolean(o.json));
@@ -2350,11 +3560,12 @@ function registerRetire(program2) {
 }
 
 // src/commands/start.ts
-import chalk8 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(
-    `${chalk8.bold(e.area)}  ${e.type}/${e.mode}  ${e.branch}${r.joined ? chalk8.yellow("  (joined)") : ""}`
+    `${chalk10.bold(label)}  ${e.type}/${e.mode}  ${e.branch}${r.joined ? chalk10.yellow("  (joined)") : ""}`
   );
   console.log(`  worktree  ${e.worktree}`);
   console.log(
@@ -2365,12 +3576,12 @@ 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(chalk8.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(
-    "Start an effort: the area's worktree on <type>/<area>, synced from the base branch, leased and running"
-  ).requiredOption("--area <area>", "a leaf area from helmsmith.config (e.g. org/applications)").requiredOption("--type <type>", "feature | chore | fix (as the manifest allows)").requiredOption("--mode <mode>", "fullstack (a slot) | frontend (storybrokr)").option(
+    "Start an effort: the area's worktree on <type>/<area> (or <type>/<area>--<task>), synced from the base branch, leased and running"
+  ).requiredOption("--area <area>", "a leaf area from helmsmith.config (e.g. org/applications)").option("--task <slug>", "intra-area task slug for parallel sub-efforts (<type>/<area>--<slug>)").requiredOption("--type <type>", "feature | chore | fix (as the manifest allows)").requiredOption("--mode <mode>", "fullstack | backend (a slot) | frontend (storybrokr)").option("--scope <glob...>", "narrow exclusive scope globs for this task sub-effort").option(
     "--story <path>",
     "frontend: the story file or component folder storybrokr boots, relative to the Storybook host"
   ).option("--join", "work in the already-open effort on this area instead of refusing").option("--no-sync", "skip the fetch and merge from the base branch (reproducing something)").option("--project-root <dir>", "repository root (default: the main checkout of the cwd)").option("--json", "print the result as JSON").action(
@@ -2379,8 +3590,10 @@ function registerStart(program2) {
         const ctx = await buildCtx({ projectRoot: o.projectRoot, quiet: Boolean(o.json) });
         const r = await startEffort(ctx, {
           area: o.area,
+          task: o.task,
           type: o.type,
           mode: o.mode,
+          scopes: o.scope,
           story: o.story,
           join: o.join,
           sync: o.sync
@@ -2395,36 +3608,47 @@ function registerStart(program2) {
 }
 
 // src/commands/status.ts
-import chalk9 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 ? chalk9.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(chalk9.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}` : chalk9.gray("-"),
-    a.effort?.branch ?? chalk9.gray("-"),
-    a.effort?.owner.session ?? chalk9.gray("-"),
-    a.effort ? age(a.effort.started) : chalk9.gray("-"),
-    a.leases.length ? a.leases.map((l) => `${l.kind}:${l.value}`).join(",") : chalk9.gray("-"),
-    a.behindBase > 0 ? chalk9.yellow(String(a.behindBase)) : "0",
-    a.notices.length ? chalk9.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(chalk9.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(chalk9.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)}`
@@ -2433,10 +3657,10 @@ function printStatus(r) {
   }
 }
 function registerStatus(program2) {
-  program2.command("status").description("Open efforts, leases, drift from the base branch and notices, per area").option("--area <area>", "one area only").option("--project-root <dir>", "repository root (default: the main checkout of the cwd)").option("--json", "print the report as JSON").action(async (o) => {
+  program2.command("status").description("Open efforts, leases, drift from the base branch and notices, per area").option("--area <area>", "one area only").option("--task <slug>", "intra-area task slug").option("--project-root <dir>", "repository root (default: the main checkout of the cwd)").option("--json", "print the report as JSON").action(async (o) => {
     try {
       const ctx = await buildCtx({ projectRoot: o.projectRoot, quiet: true });
-      const r = statusFor(ctx, o.area);
+      const r = statusFor(ctx, o.area, o.task);
       if (o.json) printJson(r);
       else printStatus(r);
     } catch (err) {
@@ -2449,12 +3673,14 @@ function registerStatus(program2) {
 var { program } = createCli({
   name: "work",
   version: VERSION,
-  description: "Area-based work: start, 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);