@dylanpiercey/work 0.2.69 → 0.2.71

package/bin/cli/session.mjs

@@ -382,7 +382,7 @@ work session send <id> "<text>"|- [--no-reply] [--now|--interrupt]
 work session unsend <id>
   Take back what this session queued for <id> that is not typed in yet:
   a message that went in stays in its turn (send a correction instead).
-work session reopen <id> [--agent <id>] [--now]
+work session reopen <id> [--agent <id>] [--now] [--team]
   Start a session again on its own conversation, where its CLI can resume
   one (Claude, Codex): one closed — by its lead's close, the user's, or
   for being done — back under the session that started it, or under this
@@ -392,8 +392,17 @@ work session reopen <id> [--agent <id>] [--now]
   where the two share their conversations. What is queued for it and what
   it owes you stay: send it a message to carry it on. A restart ends the
   turn under way and what its pane runs (a background job, a dev server),
-  so a running one mid-turn or with jobs is refused, saying what it is
-  on, unless --now.
+  so a running one mid-turn or with jobs moves once it is idle, saying
+  what it waits out, unless --now restarts it at once. On this session
+  itself (\`reopen $WORK_SESSION_ID --agent claude2\`, a lead moving to
+  another account) it always waits for this turn's end, --now or not:
+  finish the turn and it moves, its conversation, team and queue kept.
+  --team, for a closed lead, brings back with it the sessions closed in
+  the same close, each under its own parent again and on its own
+  conversation (as --agent too, where that is another instance of its
+  CLI), naming any that cannot be reopened; those under one come back
+  under the nearest above them that did. It needs no --force: it brings
+  back what ran, not more.
 work session wait [<id>|<group>...] [--any] [--timeout <seconds>]
   Wait for the replies owed to this session (by those sessions or groups,
   else by any), printing each as it comes; a reply printed here is not
@@ -777,16 +786,39 @@ work session kill --done
         case "reopen": {
           const [id] = rest;
           if (!id)
-            ctx.die("usage: work session reopen <id> [--agent <id>] [--now]");
+            ctx.die(
+              "usage: work session reopen <id> [--agent <id>] [--now] [--team]",
+            );
           const agent = ctx.flag("--agent");
           const r = await ctx.api.post(`/api/sessions/${id}/reopen${by()}`, {
             ...(agent ? { agent } : {}),
             ...(ctx.has("--now") ? { now: true } : {}),
+            ...(ctx.has("--team") ? { team: true } : {}),
           });
           return ctx.out(r, (r) => {
+            if (r.scheduled) {
+              const self = r.id === process.env.WORK_SESSION_ID;
+              console.log(
+                `${r.id} moves to ${r.scheduled} once ${self ? "this turn ends" : `it is idle (it waits out ${r.waits.join(", and ")})`}, on its own conversation, its team and queue kept.`,
+              );
+              if (self)
+                console.log(
+                  "Finish this turn: say what you were on, then stop. The move starts this conversation again as the new instance.",
+                );
+              return;
+            }
             console.log(
               `${r.restarted ? "restarted" : "reopened"} ${r.id} on its conversation as ${r.agent}${r.parent ? `, under ${r.parent}` : ""}`,
             );
+            if (r.team) {
+              console.log(
+                r.team.reopened.length
+                  ? `with its team: ${r.team.reopened.join(", ")}`
+                  : "nothing was closed with it to bring back",
+              );
+              for (const s of r.team.skipped)
+                console.log(`  not reopened ${s.id}: ${s.why}`);
+            }
             console.log(
               `It is at its prompt: \`work session send ${r.id} "…"\` carries it on.`,
             );

package/bin/cli/topic.mjs

@@ -6,6 +6,7 @@
 // plus the server's workspace rows (bases) and status (PRs).
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 
 /** A topic's name: a word, or `<group>.<topic>` (folded into one review
@@ -24,11 +25,12 @@ const INSTALLERS = [
   ["Gemfile.lock", "bundle install"],
 ];
 
-function git(cwd, args, { allowFail = false } = {}) {
+function git(cwd, args, { allowFail = false, env = {}, input } = {}) {
   const r = spawnSync("git", args, {
     cwd,
     encoding: "utf8",
-    env: { ...process.env, GIT_TERMINAL_PROMPT: "0" },
+    env: { ...process.env, GIT_TERMINAL_PROMPT: "0", ...env },
+    input,
   });
   if (r.status !== 0 && !allowFail) {
     const why = (r.stderr || r.stdout || "").trim() || `exit ${r.status}`;
@@ -106,6 +108,27 @@ function aheadBehind(dir, base, tip) {
   return { ahead, behind };
 }
 
+/** Its changes are all in `base` already though its commits are not —
+ * squashed into another PR, cherry-picked, folded in by hand: merging it
+ * there would change nothing, or every one of its commits' patches is
+ * there. Either way nothing is lost by putting it away, where ancestry
+ * alone called it unmerged for good. */
+function landedIn(dir, base, tip) {
+  const merged = git(dir, ["merge-tree", "--write-tree", base, tip], {
+    allowFail: true,
+  });
+  // A clean merge prints its tree alone; one with conflicts exits 1.
+  if (merged.ok && merged.out === oid(dir, `${base}^{tree}`)) return true;
+  // Each commit's patch already there (`-`), even where the base has moved
+  // the same lines on since and the merge would conflict.
+  const cherry = git(dir, ["cherry", base, tip], { allowFail: true });
+  return (
+    cherry.ok &&
+    cherry.out !== "" &&
+    cherry.out.split("\n").every((l) => l.startsWith("- "))
+  );
+}
+
 /** Where the workspace and its repos are, the other workspaces' branches
  * (whose topics are not this one's), and each repo's PRs — dismissed ones
  * too: a merged chip the user dismissed is still the merge that lets
@@ -125,9 +148,56 @@ async function context(ctx, fresh) {
     dir: path.join(ws.path, r.worktree),
     prs: prsOf.get(r.full_name) || [],
   }));
+  await withOlderPrs(ctx, ws, repos, foreign);
   return { ws, repos, foreign };
 }
 
+/** The PRs the workspace's search no longer holds, for the topics that
+ * point at one. That search keeps only its latest finished PRs, so a topic
+ * squash-merged long ago read as unmerged work for good. Its tell: pushed
+ * once (an upstream recorded) and its copy on origin gone, which is how a
+ * merged PR's branch ends when GitHub deletes it, while a topic never
+ * pushed (most of a team's) asks nothing. Those few are asked for by name,
+ * in one request, and added to the repo's list. */
+async function withOlderPrs(ctx, ws, repos, foreign) {
+  const heads = new Set();
+  for (const repo of repos) {
+    if (!fs.existsSync(repo.dir)) continue;
+    const pushed = git(
+      repo.dir,
+      [
+        "config",
+        "--get-regexp",
+        `^branch\\.${ws.branch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}-.*\\.remote$`,
+      ],
+      { allowFail: true },
+    ).out;
+    for (const line of pushed.split("\n")) {
+      const branch = line.match(/^branch\.(.+)\.remote /)?.[1];
+      if (
+        branch &&
+        owns(branch, ws.branch, foreign) &&
+        !prFor(repo, branch) &&
+        oid(repo.dir, `refs/heads/${branch}`) &&
+        !oid(repo.dir, `refs/remotes/origin/${branch}`)
+      )
+        heads.add(branch);
+    }
+  }
+  if (!heads.size) return;
+  const found = await ctx.api
+    .get(
+      `/api/workspaces/${ws.id}/prs?heads=${encodeURIComponent([...heads].join(","))}`,
+    )
+    .catch(() => null);
+  for (const r of found?.repos || []) {
+    const repo = repos.find((x) => x.full_name === r.full_name);
+    if (!repo) continue;
+    const have = new Set(repo.prs.map((p) => p.number));
+    repo.prs.push(...(r.prs || []).filter((p) => !have.has(p.number)));
+  }
+}
+
 const topicDir = (ws, name, repo) =>
   path.join(ws.path, ".worktrees", name, repo.worktree);
 
@@ -374,6 +444,7 @@ function topicsIn(ws, repo, foreign) {
   // What `topic new` recorded for gh: the branch it stacks on, else the
   // repo's base.
   const recorded = mergeBases(repo.dir);
+  const dropped = droppedBranches(repo.dir);
   const bases = new Map();
   return [...branches].sort().map((branch) => {
     const name = branch.slice(prefix.length);
@@ -389,6 +460,7 @@ function topicsIn(ws, repo, foreign) {
       : { ahead: null, behind: null };
     const worktree = trees.get(branch) || null;
     const pr = prFor(repo, branch);
+    const contained = !!base && ahead === 0;
     return {
       topic: name,
       repo: repo.worktree,
@@ -424,7 +496,12 @@ function topicsIn(ws, repo, foreign) {
       // Nothing of its own past the base: either merged as it was, or a
       // topic with no commits yet. Either way, nothing is lost by
       // putting its worktree away.
-      contained: !!base && ahead === 0,
+      contained,
+      // Commits of its own, but none of its changes the base lacks.
+      landed: !!base && !contained && landedIn(repo.dir, base, tip),
+      // Dropped here (`topic drop`), its local branch gone: what is left is
+      // origin's copy, which drop leaves alone.
+      dropped: !local && dropped.has(branch),
       link: link(ws, repo, name),
     };
   });
@@ -433,9 +510,11 @@ function topicsIn(ws, repo, foreign) {
 async function topicList(ctx) {
   const { ws, repos, foreign } = await context(ctx, ctx.has("--fresh"));
   const all = repos.flatMap((repo) => topicsIn(ws, repo, foreign));
-  // Put away: merged (or nothing past its base) with no worktree left —
-  // its branch kept, as the after-merge chores leave it. Listed on asking.
-  const away = (t) => !t.worktree && (t.merged || t.contained);
+  // Put away: merged (or nothing of it its base lacks) with no worktree
+  // left — its branch kept, as the after-merge chores leave it — or dropped
+  // here. Listed on asking.
+  const away = (t) =>
+    t.dropped || (!t.worktree && (t.merged || t.contained || t.landed));
   const rows = ctx.has("--all") ? all : all.filter((t) => !away(t));
   const hidden = all.length - rows.length;
   ctx.out(rows, (list) => {
@@ -450,7 +529,9 @@ async function topicList(ctx) {
           ? `no ${t.baseBranch} or origin/${t.baseBranch} here to count against`
           : t.contained
             ? `nothing past ${t.base}`
-            : `${t.ahead} ahead, ${t.behind} behind ${t.base}`;
+            : t.landed
+              ? `landed in ${t.base} (by other commits: ${t.ahead} of its own, none of its changes missing there)`
+              : `${t.ahead} ahead, ${t.behind} behind ${t.base}`;
       const flags = [
         t.dirty ? `${t.dirty} uncommitted` : null,
         t.local && !t.onOrigin && t.ahead ? "not pushed" : null,
@@ -458,7 +539,8 @@ async function topicList(ctx) {
         t.local && t.onOrigin && !t.unpushed && !t.pushed
           ? "origin has newer"
           : null,
-        !t.local ? "only on origin" : null,
+        t.dropped ? "dropped here, origin keeps it" : null,
+        !t.local && !t.dropped ? "only on origin" : null,
       ].filter(Boolean);
       const pr = t.pr
         ? `  #${t.pr.number} ${t.pr.state === "OPEN" ? (t.pr.draft ? "draft" : "open") : t.pr.state.toLowerCase()}`
@@ -471,7 +553,7 @@ async function topicList(ctx) {
     }
     if (hidden)
       console.log(
-        `${hidden} put away (merged, worktree removed): --all lists them`,
+        `${hidden} put away (merged or landed with its worktree removed, or dropped): --all lists them`,
       );
   });
 }
@@ -483,7 +565,7 @@ async function topicList(ctx) {
  * PR's head, or past what origin has of it. */
 function leftover(repo, t, pr) {
   const local = oid(repo.dir, `refs/heads/${t.branch}`);
-  if (!local || t.contained) return null;
+  if (!local || t.contained || t.landed) return null;
   let head = pr?.headRefOid || null;
   if (head && !has(repo.dir, `${head}^{commit}`)) {
     // A squash-merged PR's head lives on in GitHub's pull ref.
@@ -532,15 +614,18 @@ async function topicDone(ctx) {
     const t = topicsIn(ws, repo, foreign).find((x) => x.branch === branch);
     if (!t) continue;
     const pr = prFor(repo, branch);
-    if (!t.merged && !t.contained) {
+    if (!t.merged && !t.contained && !t.landed) {
       const prState = t.pr
         ? ` (#${t.pr.number} is ${t.pr.state.toLowerCase()})`
         : "";
+      // An abandoned topic is never merged: say how it goes instead.
       result.refused.push({
         repo: repo.worktree,
-        why: t.base
-          ? `${branch} is not merged${prState} and has ${t.ahead} commit(s) ${t.base} does not`
-          : `${branch} is not merged${prState}, and there is no ${t.baseBranch} or origin/${t.baseBranch} here to check it against`,
+        why: `${
+          t.base
+            ? `${branch} is not merged${prState} and has changes in ${t.ahead} commit(s) ${t.base} lacks`
+            : `${branch} is not merged${prState}, and there is no ${t.baseBranch} or origin/${t.baseBranch} here to check it against`
+        } (to abandon it: work topic drop ${name})`,
       });
       continue;
     }
@@ -603,7 +688,8 @@ async function topicDone(ctx) {
       }
       // Nothing of its own: left where it is, unless what it stacks on
       // moved out from under it.
-      if (other.contained && !moved.has(other.baseBranch)) continue;
+      if ((other.contained || other.landed) && !moved.has(other.baseBranch))
+        continue;
       const base = restack ? t.base : other.base;
       if (!other.local || !base) continue;
       const { behind } = aheadBehind(repo.dir, base, other.branch);
@@ -684,6 +770,307 @@ async function topicDone(ctx) {
     process.exitCode = 1;
 }
 
+// -- drop --------------------------------------------------------------------
+
+/** Where a dropped topic's last tip is kept, a ref per drop
+ * (`<branch>/<UTC stamp>`): outside `refs/work/<workspace>/`, whose
+ * snapshots the server prunes, and in no push. */
+const DROPPED = "refs/work-dropped/";
+/** How long a dropped topic can be brought back. */
+const KEEP_DROPPED_DAYS = 30;
+const DAY = 86_400_000;
+
+const stampOf = (d) =>
+  d
+    .toISOString()
+    .replace(/[-:]/g, "")
+    .replace(/\.\d+Z$/, "Z");
+
+function stampTime(stamp) {
+  const m = /^(\d{4})(\d\d)(\d\d)T(\d\d)(\d\d)(\d\d)Z$/.exec(stamp);
+  return m ? Date.UTC(+m[1], +m[2] - 1, +m[3], +m[4], +m[5], +m[6]) : null;
+}
+
+/** Each dropped ref: its branch, the time of its drop. */
+function droppedRefs(dir) {
+  return git(dir, ["for-each-ref", "--format=%(refname)", DROPPED], {
+    allowFail: true,
+  })
+    .out.split("\n")
+    .filter(Boolean)
+    .map((ref) => {
+      const rest = ref.slice(DROPPED.length);
+      const cut = rest.lastIndexOf("/");
+      return {
+        ref,
+        branch: rest.slice(0, cut),
+        at: stampTime(rest.slice(cut + 1)),
+      };
+    })
+    .filter((r) => r.branch && r.at !== null);
+}
+
+/** The branches dropped here (within their keep). */
+function droppedBranches(dir) {
+  return new Set(droppedRefs(dir).map((r) => r.branch));
+}
+
+/** Dropped refs past their keep, gone: every workspace's on this repo,
+ * since its cache is shared and a deleted workspace drops nothing again. */
+function pruneDropped(dir, now = Date.now()) {
+  const gone = droppedRefs(dir).filter(
+    (r) => r.at < now - KEEP_DROPPED_DAYS * DAY,
+  );
+  if (gone.length)
+    git(dir, ["update-ref", "--stdin"], {
+      allowFail: true,
+      input: gone.map((r) => `delete ${r.ref}\n`).join(""),
+    });
+  return gone.length;
+}
+
+/** A worktree as it is — uncommitted and untracked files too — as a commit
+ * on its HEAD, made through an index of its own so the worktree and its
+ * index are untouched: a forced drop keeps what it discards. */
+function snapshotOf(worktree, message) {
+  const index = path.join(
+    os.tmpdir(),
+    `work-topic-drop-${process.pid}-${Date.now()}.index`,
+  );
+  // An identity of its own (a machine with none set still drops) and no
+  // signing (a key's passphrase prompt would hang a script).
+  const env = {
+    GIT_INDEX_FILE: index,
+    GIT_AUTHOR_NAME: "work",
+    GIT_AUTHOR_EMAIL: "work@localhost",
+    GIT_COMMITTER_NAME: "work",
+    GIT_COMMITTER_EMAIL: "work@localhost",
+  };
+  try {
+    git(worktree, ["read-tree", "HEAD"], { env });
+    git(worktree, ["add", "-A"], { env });
+    const tree = git(worktree, ["write-tree"], { env }).out;
+    return git(
+      worktree,
+      ["commit-tree", "--no-gpg-sign", tree, "-p", "HEAD", "-m", message],
+      { env },
+    ).out;
+  } finally {
+    fs.rmSync(index, { force: true });
+  }
+}
+
+const real = (p) => {
+  try {
+    return fs.realpathSync(p);
+  } catch {
+    return path.resolve(p);
+  }
+};
+const within = (dir, root) => dir === root || dir.startsWith(root + path.sep);
+
+/** Everything about dropping the topic in one repo, before any of it is
+ * done: what goes, what would be lost, and what stands in the way —
+ * `blocks` give way to --yes, `stops` never do. */
+function planDrop(ctx, ws, repo, t, sessions, topics) {
+  const plan = { repo, t, lost: [], blocks: [], stops: [], dirty: [] };
+  plan.local = oid(repo.dir, `refs/heads/${t.branch}`);
+  if (!plan.local) return plan;
+  if (t.worktree && real(t.worktree) === real(repo.dir))
+    plan.stops.push(
+      `${t.branch} is checked out in the workspace's own checkout (${repo.dir}): switch that off it first`,
+    );
+  if (t.worktree) {
+    plan.dirty = dirtyIn(t.worktree);
+    if (plan.dirty.length)
+      plan.blocks.push(
+        `${t.worktree} has ${plan.dirty.length} uncommitted change(s):\n    ${plan.dirty.slice(0, 10).join("\n    ")}`,
+      );
+    const here = real(t.worktree);
+    for (const s of sessions)
+      if (
+        s.state?.alive &&
+        s.launch_dir &&
+        within(real(path.resolve(ws.path, s.launch_dir)), here)
+      )
+        plan.blocks.push(
+          `session ${s.id}${s.title ? ` ("${s.title}")` : ""} is working in ${t.worktree}`,
+        );
+  }
+  // What the drop discards: none of it when its base holds every change.
+  const merged = t.merged && !leftover(repo, t, prFor(repo, t.branch));
+  if (!t.contained && !t.landed && !merged) {
+    if (!t.base)
+      plan.blocks.push(
+        `there is no ${t.baseBranch} or origin/${t.baseBranch} here to tell what of ${t.branch} would be lost`,
+      );
+    else {
+      plan.lost = git(repo.dir, [
+        "log",
+        "--format=%h %s",
+        `${t.base}..${plan.local}`,
+      ]).out.split("\n");
+      plan.blocks.push(
+        `${t.branch} has ${plan.lost.length} commit(s) whose changes ${t.base} lacks${
+          t.unpushed
+            ? `, ${t.onOrigin ? t.unpushed : "all"} of them on no remote`
+            : ""
+        }:\n    ${plan.lost.slice(0, 10).join("\n    ")}`,
+      );
+    }
+  }
+  if (t.pr?.state === "OPEN")
+    plan.blocks.push(
+      `#${t.pr.number} is open (the drop leaves the PR and origin's copy as they are)`,
+    );
+  plan.stacked = topics.filter(
+    (o) => o.branch !== t.branch && o.local && o.baseBranch === t.branch,
+  );
+  for (const o of plan.stacked)
+    plan.blocks.push(
+      `${o.branch} stacks on it (with --yes it is counted against ${t.baseBranch} instead, still carrying ${t.branch}'s commits)`,
+    );
+  return plan;
+}
+
+async function topicDrop(ctx) {
+  const [name] = ctx.parse([]);
+  if (!name) ctx.die("usage: work topic drop <name> [--yes] [--json]");
+  const { ws, repos, foreign } = await context(ctx, false);
+  const branch = `${ws.branch}-${name}`;
+  const touched = repos.filter(
+    (r) =>
+      has(r.dir, `refs/heads/${branch}`) ||
+      has(r.dir, `refs/remotes/origin/${branch}`),
+  );
+  if (!touched.length)
+    ctx.die(`no topic ${name} in ${ws.name} (see: work topic list)`);
+  const sessions = await ctx.api
+    .get(`/api/workspaces/${ws.id}/sessions`)
+    .catch(() => []);
+  // Every repo is planned before any is touched: half a topic dropped is
+  // worse than none.
+  const plans = [];
+  for (const repo of touched) {
+    // A fetch that fails (offline) only leaves the base older, which can
+    // only find more to lose.
+    ctx.log(`fetching ${repo.full_name}…`);
+    if (
+      !git(repo.dir, ["fetch", "--prune", "--quiet", "origin"], {
+        allowFail: true,
+      }).ok
+    )
+      ctx.warn(
+        `${repo.worktree}: could not fetch origin; counting against what is here`,
+      );
+    const topics = topicsIn(ws, repo, foreign);
+    const t = topics.find((x) => x.branch === branch);
+    if (t) plans.push(planDrop(ctx, ws, repo, t, sessions, topics));
+  }
+  const result = {
+    topic: name,
+    dropped: [],
+    skipped: [],
+    refused: [],
+    restacked: [],
+  };
+  for (const p of plans) {
+    for (const why of p.stops)
+      result.refused.push({ repo: p.repo.worktree, why });
+    if (!ctx.yes)
+      for (const why of p.blocks)
+        result.refused.push({ repo: p.repo.worktree, why });
+  }
+  if (!result.refused.length) {
+    const at = new Date();
+    for (const p of plans) {
+      const { repo, t } = p;
+      if (!p.local) {
+        result.skipped.push({
+          repo: repo.worktree,
+          why: `${branch} is only on origin: nothing here to drop (git push origin --delete ${branch} removes it there)`,
+        });
+        continue;
+      }
+      pruneDropped(repo.dir, at.getTime());
+      const keep = p.dirty.length
+        ? snapshotOf(
+            t.worktree,
+            `work topic drop: ${branch} with its uncommitted changes`,
+          )
+        : p.local;
+      const ref = `${DROPPED}${branch}/${stampOf(at)}`;
+      git(repo.dir, ["update-ref", ref, keep]);
+      if (t.worktree) {
+        git(repo.dir, [
+          "worktree",
+          "remove",
+          ...(p.dirty.length ? ["--force"] : []),
+          t.worktree,
+        ]);
+        // The topic's own folder, once its last repo's worktree is gone.
+        try {
+          fs.rmdirSync(path.dirname(t.worktree));
+        } catch {}
+      }
+      for (const o of p.stacked) {
+        git(repo.dir, [
+          "config",
+          `branch.${o.branch}.gh-merge-base`,
+          t.baseBranch,
+        ]);
+        result.restacked.push({
+          repo: repo.worktree,
+          branch: o.branch,
+          base: t.baseBranch,
+        });
+      }
+      // Its config (the recorded base) goes with it.
+      git(repo.dir, ["branch", "-D", branch]);
+      result.dropped.push({
+        repo: repo.worktree,
+        branch,
+        worktree: t.worktree,
+        commits: p.lost.filter(Boolean).length,
+        unpushed: p.lost.length ? t.unpushed : 0,
+        uncommitted: p.dirty.length,
+        kept: ref,
+        keptDays: KEEP_DROPPED_DAYS,
+        restore: `git -C ${repo.dir} branch ${branch} ${ref}`,
+        onOrigin: t.onOrigin,
+      });
+    }
+  }
+  ctx.out(result, (r) => {
+    for (const x of r.dropped) {
+      const lost = [
+        x.commits ? `${x.commits} commit(s) its base lacks` : null,
+        x.uncommitted ? `${x.uncommitted} uncommitted change(s)` : null,
+      ].filter(Boolean);
+      console.log(
+        `${x.repo}: dropped ${x.branch}${lost.length ? ` (${lost.join(", ")})` : ""}`,
+      );
+      if (x.worktree) console.log(`  removed ${x.worktree}`);
+      console.log(
+        `  kept as ${x.kept} for ${x.keptDays} days; to bring it back: ${x.restore}${x.uncommitted ? " (its top commit holds the uncommitted changes)" : ""}`,
+      );
+      if (x.onOrigin)
+        console.log(
+          `  origin/${x.branch} is still on origin (git push origin --delete ${x.branch} removes it)`,
+        );
+    }
+    for (const x of r.skipped) console.log(`${x.repo}: ${x.why}`);
+    for (const x of r.restacked)
+      console.log(`${x.repo}: ${x.branch} now counts against ${x.base}`);
+    for (const x of r.refused) console.log(`${x.repo}: ${x.why}`);
+    if (r.refused.length)
+      console.log(
+        `nothing dropped${ctx.yes ? "" : `: pass --yes to drop it anyway (its tip and uncommitted changes are kept ${KEEP_DROPPED_DAYS} days)`}`,
+      );
+  });
+  if (result.refused.length) process.exitCode = 1;
+}
+
 // -- command -----------------------------------------------------------------
 
 const HELP = `work topic new <name> [--repo <repo>]… [--from <ref>] [--install]
@@ -703,17 +1090,27 @@ work topic list [--all] [--fresh] [--json]
     answer.
 work topic done <name> [--rebase] [--json]
     after its PR merged, or once its base holds all of it (merged there
-    by hand, say): fetch --prune, remove its worktree (only if clean, and
-    only if the merge took every commit), keep the branch, and list the
-    other open topics to rebase, each onto its own base — one stacked on
-    this topic onto this one's, which becomes its base. --rebase does it
-    where the worktree is clean, aborting on conflict. Never touches the
-    workspace's own checkout.`;
+    by hand, say) or all of its changes by other commits (squashed into
+    another PR, cherry-picked): fetch --prune, remove its worktree (only
+    if clean, and only if the merge took every commit), keep the branch,
+    and list the other open topics to rebase, each onto its own base — one
+    stacked on this topic onto this one's, which becomes its base.
+    --rebase does it where the worktree is clean, aborting on conflict.
+    Never touches the workspace's own checkout.
+work topic drop <name> [--yes] [--json]
+    abandon a topic: remove its worktree and delete its local branch,
+    keeping its tip (with any uncommitted changes) as
+    refs/work-dropped/<branch>/<when> for ${KEEP_DROPPED_DAYS} days; the output says how to
+    bring it back. Refuses, unless --yes, whatever would discard work:
+    commits whose changes its base lacks (and which of them no remote has),
+    uncommitted changes, a session working in it, a topic stacked on it, an
+    open PR. Origin's copy and any PR are left as they are. Never touches
+    the workspace's own checkout.`;
 
 export const commands = [
   {
     name: "topic",
-    summary: "start, list and put away topic branches (work help topic)",
+    summary: "start, list, put away and drop topic branches (work help topic)",
     help: HELP,
     async run(ctx) {
       const [verb] = ctx.positional;
@@ -725,11 +1122,12 @@ export const commands = [
         if (verb === "list" || verb === "ls" || !verb)
           return await topicList(sub);
         if (verb === "done") return await topicDone(sub);
+        if (verb === "drop") return await topicDrop(sub);
       } catch (err) {
         ctx.die(err instanceof Error ? err.message : String(err));
       }
       ctx.die(
-        `no \`work topic ${verb}\`: new, list or done (see: work help topic)`,
+        `no \`work topic ${verb}\`: new, list, done or drop (see: work help topic)`,
       );
     },
   },