@dylanpiercey/work 0.2.27 → 0.2.29

package/README.md

@@ -222,7 +222,9 @@ targeting that branch.
 
 The usage panel (and `work usage`) reads plan/quota windows straight from each
 agent CLI's own credentials on disk — Claude, Codex, Cursor, Grok, and Copilot
-(via `gh`'s token). Providers you are not signed into simply say so.
+(via `gh`'s token). Providers you are not signed into simply say so. A script
+that waits for room in a window reads `work usage --json`, whose shape (and
+what each field means when a reading is stale) `work help usage` spells out.
 
 Running more than one `work` (a laptop and a desk box, say)? Settings →
 Appearance gives each a name and an accent colour: the tab title, home-screen

package/bin/cli/branches.mjs

@@ -61,10 +61,10 @@ export const commands = [
             unpushed: s.unpushed || 0,
             edits: s.edits || 0,
             merged: !!s.contained && !s.pr,
-            // A PR's GitHub page beside its review: the link an agent
-            // hands on for a PR names both.
+            // A PR's name is its GitHub page, its review beside it: the
+            // link an agent hands on for a PR names both.
             link: s.pr?.url
-              ? `[${label}](${href}) ([GitHub](${s.pr.url}))`
+              ? `[${label}](${s.pr.url}) ([review](${href}))`
               : `[${label}](${href})`,
             href,
           };

package/bin/cli/session.mjs

@@ -89,20 +89,28 @@ async function textOf(value) {
 /** What became of a message, for the sender. */
 function sentText(id, r) {
   const lines = [
-    r.delivered
-      ? `sent to ${id}`
-      : `queued for ${id} (${r.queued}): typed in once it is at its prompt`,
+    `${r.reopened ? `reopened ${id} on its conversation; ` : ""}${
+      r.delivered
+        ? `sent to ${id}`
+        : `queued for ${id} (${r.queued}): typed in once it is at its prompt`
+    }`,
   ];
   if (r.wantsReply)
     lines.push(
       `Its last message, as that turn ends, comes back to you as a prompt: end your turn to wait for it, or run \`work session wait ${id}\`.`,
     );
+  if (r.wantsReply && !r.delivered)
+    lines.push(
+      "A reply it sends before then answers what it is on now: each reply names the message of yours it answers.",
+    );
   return lines.join("\n");
 }
 
 function printReply(r) {
   const head =
-    r.kind === "reply" ? `${r.label} replied:` : `${r.label}: ${r.text}`;
+    r.kind === "reply"
+      ? `${r.label} replied${r.answers ? ` to ${r.answers}` : ""}:`
+      : `${r.label}: ${r.text}`;
   console.log(head);
   if (r.kind === "reply") console.log(`${r.text}\n`);
 }
@@ -167,7 +175,7 @@ export const commands = [
   {
     name: "session",
     summary:
-      "this session and the workspace's others: new, fanout, send, wait, team, kill",
+      "this session and the workspace's others: new, fanout, send, wait, keep, team, kill",
     help: `work session [--json]
   This session (WORK_SESSION_ID): its id, agent, name, state, and the
   workspace it is in (id, name, path) — what a link names (/w/<id>/…).
@@ -184,8 +192,11 @@ work session new [--agent <id>] [--title "<name>"] [--prompt "<text>"|-] [--no-r
   and the prompt is a message from it (below). --topic starts it in a
   topic branch of its own (\`work topic new\`). It closes once it has
   answered and is done with — when your job finishes, or after ten idle
-  minutes — unless --keep, it is on the user's screen, or they have typed
-  into it. Past ${SESSION_CAP} running sessions in the workspace it wants --force.
+  minutes — unless --keep (or \`work session keep\` since), it is on the
+  user's screen, or they have typed into it; a message to it then reopens
+  it on its own conversation, where its CLI can resume one (Claude,
+  Codex). Each reply from it says when it closes and what then. Past
+  ${SESSION_CAP} running sessions in the workspace it wants --force.
 work session fanout --agent <id> [--agent <id>…] [--count <n>] --prompt "<text>"|- [<item>…] [--title "<name>"] [--parallel <n>] [--stream] [--close-done|--keep] [--topic <name> [--repo <repo>…] [--install]]
   Start a group of sessions from this one: each --agent once (or --count
   times), or once for each <item> with {} in the prompt replaced by it
@@ -193,10 +204,10 @@ work session fanout --agent <id> [--agent <id>…] [--count <n>] --prompt "<text
   (4), however many there are. Their replies come back to you as one
   prompt once every member has answered (--stream: each as it comes); end
   your turn to wait, or \`work session wait <group>\`. A member's session
-  closes once done with, as \`new\`'s does (its result is kept);
-  --close-done closes it as soon as it answers, --keep never;
-  --topic gives each member a topic branch of its own (<name>-1, -2, …),
-  side by side in Review. For a quick sweep inside your own CLI, its own
+  closes once done with, as \`new\`'s does (its result is kept, and a
+  message reopens it); --close-done closes it as soon as it answers,
+  --keep never; --topic gives each member a topic branch of its own
+  (<name>-1, -2, …), side by side in Review. For a quick sweep inside your own CLI, its own
   subagents are cheaper: this is for other vendors, long work, or work the
   user may want to watch.
 work session team [--json]
@@ -214,7 +225,12 @@ work session send <id> "<text>"|- [--no-reply]
   or a draft someone is typing. From an agent's session it wants a reply
   unless --no-reply: the recipient's last message as that turn ends,
   typed into this session as a prompt of its own. End your turn to wait
-  for it. A file's path says more than its text pasted in. An agent in
+  for it. One sent mid-turn is answered a turn later: the reply that
+  comes first answers what it was on, and each reply names the message
+  of yours it answers and those still queued. A session closed for being
+  done is reopened on its own conversation first, where its CLI can
+  resume one (Claude, Codex); otherwise the send says to start a new one.
+  A file's path says more than its text pasted in. An agent in
   another workspace (\`work session list <workspace>\`) can be messaged
   when the user asks, and only while it runs; everything else here an
   agent does in its own workspace only.
@@ -224,13 +240,17 @@ work session wait [<id>|<group>...] [--any] [--timeout <seconds>]
   typed in too. A group's come once all its members have answered, unless
   --any: then whatever is in, as soon as anything is. Exits 124 if some
   are still working after --timeout (${WAIT_S} s).
+work session keep <id>
+  Keep a session this one started open for follow-ups, as \`new --keep\`
+  would have: it is never closed for being done.
 work session kill <id> [--keep-children] --yes
   Close a session and the process in it, and the sessions it started
   with theirs, unless --keep-children (they then stand on their own).
   Whoever waits on a reply from one is told.
 work session kill --done
   Close now the sessions this one started that are done with (answered,
-  idle, not the user's): fan-out results stay in \`work session team\`.`,
+  idle, not the user's): fan-out results stay in \`work session team\`,
+  and a message to one reopens it, as \`send\` says.`,
     async run(ctx) {
       const [verb, ...rest] = ctx.parse([
         "--agent",
@@ -480,6 +500,14 @@ work session kill --done
             );
           return;
         }
+        case "keep": {
+          const [id] = rest;
+          if (!id) ctx.die("usage: work session keep <id>");
+          await ctx.api.post(`/api/sessions/${id}/keep${by()}`);
+          return ctx.out({ id, kept: true }, () =>
+            console.log(`kept ${id}: it is not closed for being done`),
+          );
+        }
         case "kill": {
           if (ctx.has("--done")) {
             const me = sessionId(ctx);

package/bin/cli/topic.mjs

@@ -56,6 +56,56 @@ function owns(ref, branch, foreign) {
   return of(ref, branch) && !foreign.some((x) => of(x, branch) && of(ref, x));
 }
 
+/** The branch `ref` names here (`HEAD` is the one the checkout has out,
+ * `origin/<b>` is `<b>`), or null for a commit or a tag. */
+function branchOf(dir, ref) {
+  const full = git(dir, ["rev-parse", "--symbolic-full-name", ref], {
+    allowFail: true,
+  }).out;
+  return /^refs\/(?:heads|remotes\/origin)\/(.+)$/.exec(full)?.[1] ?? null;
+}
+
+/** Each branch's recorded base (`branch.<b>.gh-merge-base`), in one read. */
+function mergeBases(dir) {
+  const out = git(
+    dir,
+    ["config", "--get-regexp", "^branch\\..*\\.gh-merge-base$"],
+    { allowFail: true },
+  ).out;
+  const map = new Map();
+  for (const line of out.split("\n")) {
+    const m = /^branch\.(.+)\.gh-merge-base (.+)$/.exec(line.trim());
+    if (m) map.set(m[1], m[2]);
+  }
+  return map;
+}
+
+/** The ref a base branch is counted against here, or null with neither
+ * copy. This workspace's own branches (it, and the topics one stacks on)
+ * go by the local one: they may never be pushed, and here is where they
+ * move. Any other (the repo's base) goes by origin's: a bare cache's local
+ * copy of it is as old as the clone, or as gh-stack's trunk. */
+function baseRef(dir, name, ws, foreign) {
+  const local = has(dir, `refs/heads/${name}`) ? name : null;
+  const remote = has(dir, `refs/remotes/origin/${name}`)
+    ? `origin/${name}`
+    : null;
+  return owns(name, ws.branch, foreign) ? local || remote : remote || local;
+}
+
+/** Commits `tip` has that `base` lacks, and the reverse. */
+function aheadBehind(dir, base, tip) {
+  const [behind, ahead] = git(dir, [
+    "rev-list",
+    "--left-right",
+    "--count",
+    `${base}...${tip}`,
+  ])
+    .out.split(/\s+/)
+    .map(Number);
+  return { ahead, behind };
+}
+
 /** Where the workspace and its repos are, and the other workspaces'
  * branches (whose topics are not this one's). */
 async function context(ctx, fresh) {
@@ -219,13 +269,16 @@ export function makeTopics(
     // --no-track: its upstream is set by the first push, to its own name on
     // origin, never to the base it was cut from.
     git(repo.dir, ["worktree", "add", "--no-track", "-b", branch, dest, start]);
-    const stacked = from && from !== `origin/${repo.base_branch}` ? from : null;
     // Its PR's base, said as gh reads it (branch.<b>.gh-merge-base): the
-    // branch it stacks on, else the base it was cut from.
-    const prBase = (stacked ?? repo.base_branch).replace(/^origin\//, "");
+    // branch it stacks on, else the base it was cut from. A commit or a tag
+    // names no branch, and leaves it unrecorded.
+    const prBase = from ? branchOf(repo.dir, from) : repo.base_branch;
+    const stacked =
+      from && prBase !== repo.base_branch ? (prBase ?? from) : null;
     if (
-      has(repo.dir, `refs/heads/${prBase}`) ||
-      has(repo.dir, `refs/remotes/origin/${prBase}`)
+      prBase &&
+      (has(repo.dir, `refs/heads/${prBase}`) ||
+        has(repo.dir, `refs/remotes/origin/${prBase}`))
     )
       git(repo.dir, ["config", `branch.${branch}.gh-merge-base`, prBase], {
         allowFail: true,
@@ -238,6 +291,7 @@ export function makeTopics(
       base: repo.base_branch,
       from: start,
       stacked,
+      prBase,
       install: installFor(dest),
       link: link(ws, repo, name),
     });
@@ -282,7 +336,9 @@ async function topicNew(ctx) {
       console.log(`  from:    ${m.from}`);
       if (m.stacked)
         console.log(
-          `  stacked: on ${m.stacked}, not origin/${m.base} — its PR's base is that branch, and it rebases when that one merges`,
+          m.prBase
+            ? `  stacked: on ${m.stacked}, not origin/${m.base} — its PR's base is that branch, and it rebases when that one merges`
+            : `  stacked: on ${m.stacked}, which is no branch — its base stays origin/${m.base}`,
         );
       if (m.install)
         console.log(
@@ -298,7 +354,7 @@ async function topicNew(ctx) {
 
 /** Every topic of the workspace in one repo: local branches and origin's,
  * this workspace's (not a longer-named workspace's), with where each
- * stands against origin/<base>. */
+ * stands against its base: the branch it stacks on, else the repo's. */
 function topicsIn(ws, repo, foreign) {
   const prefix = `${ws.branch}-`;
   const refs = git(repo.dir, [
@@ -313,32 +369,32 @@ function topicsIn(ws, repo, foreign) {
     if (b && owns(b, ws.branch, foreign)) branches.add(b);
   }
   const trees = worktreesOf(repo.dir);
-  const base = `origin/${repo.base_branch}`;
-  const haveBase = has(repo.dir, base);
+  // What `topic new` recorded for gh: the branch it stacks on, else the
+  // repo's base.
+  const recorded = mergeBases(repo.dir);
+  const bases = new Map();
   return [...branches].sort().map((branch) => {
     const name = branch.slice(prefix.length);
     const local = oid(repo.dir, `refs/heads/${branch}`);
     const remote = oid(repo.dir, `refs/remotes/origin/${branch}`);
     const tip = local || remote;
-    let ahead = null;
-    let behind = null;
-    if (haveBase) {
-      const [b, a] = git(repo.dir, [
-        "rev-list",
-        "--left-right",
-        "--count",
-        `${base}...${tip}`,
-      ]).out.split(/\s+/);
-      ahead = Number(a);
-      behind = Number(b);
-    }
+    const baseBranch = recorded.get(branch) || repo.base_branch;
+    if (!bases.has(baseBranch))
+      bases.set(baseBranch, baseRef(repo.dir, baseBranch, ws, foreign));
+    const base = bases.get(baseBranch);
+    const { ahead, behind } = base
+      ? aheadBehind(repo.dir, base, tip)
+      : { ahead: null, behind: null };
     const worktree = trees.get(branch) || null;
     const pr = prFor(repo, branch);
     return {
       topic: name,
       repo: repo.worktree,
       branch,
+      // The ref it is counted against (`origin/main`, or a branch of this
+      // workspace's as it is here), null with no copy of `baseBranch`.
       base,
+      baseBranch,
       worktree,
       ahead,
       behind,
@@ -366,7 +422,7 @@ 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: haveBase && ahead === 0,
+      contained: !!base && ahead === 0,
       link: link(ws, repo, name),
     };
   });
@@ -388,9 +444,11 @@ async function topicList(ctx) {
     for (const t of list) {
       const state = t.merged
         ? "merged"
-        : t.contained
-          ? `nothing past ${t.base}`
-          : `${t.ahead} ahead, ${t.behind} behind`;
+        : !t.base
+          ? `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}`;
       const flags = [
         t.dirty ? `${t.dirty} uncommitted` : null,
         t.local && !t.onOrigin && t.ahead ? "not pushed" : null,
@@ -457,6 +515,7 @@ async function topicDone(ctx) {
     removed: [],
     kept: [],
     refused: [],
+    restacked: [],
     rebase: [],
   };
   const touched = repos.filter(
@@ -472,9 +531,14 @@ async function topicDone(ctx) {
     if (!t) continue;
     const pr = prFor(repo, branch);
     if (!t.merged && !t.contained) {
+      const prState = t.pr
+        ? ` (#${t.pr.number} is ${t.pr.state.toLowerCase()})`
+        : "";
       result.refused.push({
         repo: repo.worktree,
-        why: `${branch} is not merged${t.pr ? ` (#${t.pr.number} is ${t.pr.state.toLowerCase()})` : ""} and has ${t.ahead} commit(s) its base does not`,
+        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`,
       });
       continue;
     }
@@ -501,24 +565,65 @@ async function topicDone(ctx) {
     } else {
       result.kept.push({ repo: repo.worktree, why: "no worktree to remove" });
     }
-    // The other open topics a squash-merge left on the old fork point.
+    // The other open topics the merge left behind their bases, each moved
+    // onto its own. Bases come before what stacks on them, and each is
+    // counted only as its turn comes, so a stack moves bottom first.
     const mergedTip = oid(repo.dir, `refs/heads/${branch}`);
-    for (const other of topicsIn(ws, repo, foreign)) {
-      if (other.branch === branch || other.merged || other.contained) continue;
-      if (!other.local || !other.behind) continue;
-      // Cut from the merged topic (a stack): only its own commits move.
+    // Each branch's tip before it moved (the merged topic's, which its base
+    // may hold only as a squash): past it, what was cut from it is its own.
+    const moved = new Map(mergedTip ? [[branch, mergedTip]] : []);
+    const others = topicsIn(ws, repo, foreign).filter(
+      (o) => o.branch !== branch && !o.merged,
+    );
+    const byBranch = new Map(others.map((o) => [o.branch, o]));
+    const depth = (o, seen = new Set([o.branch])) => {
+      const under = byBranch.get(o.baseBranch);
+      if (!under || seen.has(under.branch)) return 0;
+      seen.add(under.branch);
+      return 1 + depth(under, seen);
+    };
+    others.sort((a, b) => depth(a) - depth(b));
+    for (const other of others) {
+      // Stacked on the merged topic: it now stacks on what that one did,
+      // and its PR's base is that too, as gh reads it.
+      const restack = other.baseBranch === branch;
+      if (restack) {
+        git(repo.dir, [
+          "config",
+          `branch.${other.branch}.gh-merge-base`,
+          t.baseBranch,
+        ]);
+        result.restacked.push({
+          repo: repo.worktree,
+          branch: other.branch,
+          base: t.baseBranch,
+        });
+      }
+      // 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;
+      const base = restack ? t.base : other.base;
+      if (!other.local || !base) continue;
+      const { behind } = aheadBehind(repo.dir, base, other.branch);
+      if (!behind) continue;
+      // Cut from a tip its base now holds only as copies (a squash-merge,
+      // or a rebase just now): only its own commits move.
+      const cut = moved.get(other.baseBranch) ?? mergedTip;
       const onto =
-        mergedTip && contains(repo.dir, other.branch, mergedTip) && !t.contained
-          ? mergedTip
+        cut &&
+        contains(repo.dir, other.branch, cut) &&
+        !contains(repo.dir, base, cut)
+          ? cut
           : null;
       const entry = {
         repo: repo.worktree,
         branch: other.branch,
         worktree: other.worktree,
-        behind: other.behind,
+        base,
+        behind,
         command: onto
-          ? `git rebase --onto origin/${repo.base_branch} ${onto.slice(0, 12)}`
-          : `git rebase origin/${repo.base_branch}`,
+          ? `git rebase --onto ${base} ${onto.slice(0, 12)}`
+          : `git rebase ${base}`,
         state: "needs rebase",
       };
       if (ctx.has("--rebase")) {
@@ -527,11 +632,14 @@ async function topicDone(ctx) {
           entry.state = "skipped: uncommitted changes";
         else {
           const args = onto
-            ? ["rebase", "--onto", `origin/${repo.base_branch}`, onto]
-            : ["rebase", `origin/${repo.base_branch}`];
+            ? ["rebase", "--onto", base, onto]
+            : ["rebase", base];
+          const before = oid(repo.dir, `refs/heads/${other.branch}`);
           const r = git(other.worktree, args, { allowFail: true });
-          if (r.ok) entry.state = "rebased";
-          else {
+          if (r.ok) {
+            entry.state = "rebased";
+            moved.set(other.branch, before);
+          } else {
             // A rebase that stopped part-way is put back as it was; one that
             // never started (no identity to commit as, a lock) says why.
             const conflicted = /CONFLICT|could not apply/i.test(
@@ -559,9 +667,11 @@ async function topicDone(ctx) {
     for (const x of r.kept) console.log(`${x.repo}: ${x.why}`);
     for (const x of r.refused)
       console.log(`${x.repo}: left as it was — ${x.why}`);
+    for (const x of r.restacked)
+      console.log(`${x.repo}: ${x.branch} now stacks on ${x.base}`);
     for (const x of r.rebase)
       console.log(
-        `${x.repo}: ${x.branch} ${x.behind} behind — ${x.state}${x.state === "needs rebase" ? ` (in ${x.worktree || "its checkout"}: ${x.command}, or work topic done ${name} --rebase)` : ""}`,
+        `${x.repo}: ${x.branch} ${x.behind} behind ${x.base} — ${x.state}${x.state === "needs rebase" ? ` (in ${x.worktree || "its checkout"}: ${x.command}, or work topic done ${name} --rebase)` : ""}`,
       );
   });
   if (
@@ -575,22 +685,27 @@ async function topicDone(ctx) {
 
 const HELP = `work topic new <name> [--repo <repo>]… [--from <ref>] [--install]
     start a topic branch, <ws-branch>-<name>, in its own worktree at
-    <ws>/.worktrees/<name>/<repo>, from origin/<base> (or <ref>: a stack).
-    The repo is the one the cwd is in, else the workspace's only one, else
-    --repo (repeat it for several). Prints each path, the install command
-    its lockfile wants (--install runs it) and the review link.
-    \`<group>.<topic>\` folds topics into one review chip.
+    <ws>/.worktrees/<name>/<repo>, from origin/<base> (or <ref>: a stack,
+    whose branch becomes its base). The repo is the one the cwd is in,
+    else the workspace's only one, else --repo (repeat it for several).
+    Prints each path, the install command its lockfile wants (--install
+    runs it) and the review link. \`<group>.<topic>\` folds topics into one
+    review chip.
 work topic list [--all] [--fresh] [--json]
-    this workspace's open topic branches: worktree, ahead/behind its base,
-    uncommitted and unpushed work, PR, merged, review link. --all adds
-    the ones put away (merged, worktree removed); --fresh asks GitHub
-    for PRs again rather than the last minutes' answer.
+    this workspace's open topic branches: worktree, ahead/behind its base
+    (the branch it stacks on, which may be local only, else
+    origin/<base>), uncommitted and unpushed work, PR, merged, review
+    link. --all adds the ones put away (merged, worktree removed);
+    --fresh asks GitHub for PRs again rather than the last minutes'
+    answer.
 work topic done <name> [--rebase] [--json]
-    after its PR merged (or with nothing past its base): 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
-    onto origin/<base> — --rebase does it where the worktree is clean,
-    aborting on conflict. Never touches the workspace's own checkout.`;
+    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.`;
 
 export const commands = [
   {

package/bin/work.mjs

@@ -13,14 +13,27 @@
 //   work doctor   report machine readiness (--json, --fix to install what's missing)
 //   work start    run the server in the foreground
 //   work update   upgrade the npm package and refresh the service (--yes, --json as setup's)
-//   work usage    print agent plan/quota usage
+//   work usage    print agent plan/quota usage, a row per signed-in account. Providers are
+//                 asked at most once a minute, a reading over five minutes old is waited for,
+//                 and a changed sign-in (a login, a token its CLI renewed) is read at once;
+//                 --refresh asks again past two minutes. --json prints {agents: [{agent, plan,
+//                 account, windows, absent, stale_seconds?, note?}]}:
+//                   windows        [{window, used_percent, resets_at}], one per window the plan
+//                                  has (5h, 7d or month, fable; resets_at can be null), kept
+//                                  once read: stale: true (stale_seconds, their age, where
+//                                  known) when its numbers are last-known, reset_passed: true
+//                                  once resets_at is past (used_percent is the last window's)
+//                   absent         windows the plan does not have; one in neither is unknown
+//                   stale_seconds  the row's numbers are last-known: how old they are
+//                   note           why a row is stale or empty, and what brings it back
 //   work workspaces           list workspaces (name, branch, sessions, ports)
 //   work workspace [id|name]  one workspace: repos, PRs, sessions, procs (default: the current one;
 //                             --fresh asks GitHub again rather than the PR cache, ~2 min old)
 //   work repos [id|name]      a workspace's repos with base branch and open PRs
 //   work procs [id|name]      a workspace's running processes and ports, each port with
 //                             the link that opens it from the user's browser (through the
-//                             address it last reached work by)
+//                             address it last reached work by); an agent CLI a script runs
+//                             once (`grok -p`, `codex exec`) is marked a background run
 //   work review [id|name]     pending review comments as markdown (--json for rows;
 //                             --take also clears exactly those from the review, as its
 //                             Send does, once acted on, so a later Send cannot repeat them)
@@ -247,12 +260,25 @@ async function usage() {
       .join("  ·  ");
     console.log(`\n${head}`);
     for (const win of agent.windows || []) {
+      // Turned over since it was read: not as full as it was.
+      if (win.reset_passed) {
+        console.log(
+          `  ${win.window.padEnd(5)} ${"░".repeat(10)} reset  ${pctText(win.used_percent)} before it, not read since`,
+        );
+        continue;
+      }
       const pct = Math.max(0, Math.min(100, win.used_percent));
       const filled = Math.round(pct / 10);
       const bar = "█".repeat(filled) + "░".repeat(10 - filled);
       const resets = until(win.resets_at);
+      // A stale row says how old below; a window kept from an earlier
+      // reading of a live one says it here.
+      const old =
+        win.stale_seconds != null && agent.stale_seconds == null
+          ? `  (${duration(win.stale_seconds * 1000)} old)`
+          : "";
       console.log(
-        `  ${win.window.padEnd(5)} ${bar} ${pctText(win.used_percent).padStart(5)}${resets ? `  ↻ ${resets}` : ""}`,
+        `  ${win.window.padEnd(5)} ${bar} ${pctText(win.used_percent).padStart(5)}${resets ? `  ↻ ${resets}` : ""}${old}`,
       );
     }
     // Only reason a row can be empty or wrong, so it goes last and unindented
@@ -440,7 +466,7 @@ async function workspaceCmd() {
   if (procs.length) {
     console.log(`  running:`);
     for (const p of out.procs)
-      console.log(`    ${pad(p.pid, 7)} ${p.cmd}${portsText(p)}`);
+      console.log(`    ${pad(p.pid, 7)} ${p.cmd}${runText(p)}${portsText(p)}`);
   }
 }
 
@@ -474,6 +500,12 @@ function withUrls(p, linkPort) {
   };
 }
 
+/** An agent CLI a script runs once (`grok -p`, `codex exec`): a job of
+ * what started it, not a session (server/procs.ts `run`). */
+function runText(p) {
+  return p.run ? "  (background run)" : "";
+}
+
 /** A process's ports for a line of text, each with where it opens. */
 function portsText(p) {
   if (!p.ports?.length) return "";
@@ -517,7 +549,7 @@ async function procsCmd() {
   if (jsonOut) return console.log(JSON.stringify(procs, null, 2));
   if (!procs.length) return console.log("nothing running");
   for (const p of procs)
-    console.log(`${pad(p.pid, 7)} ${p.cmd}${portsText(p)}`);
+    console.log(`${pad(p.pid, 7)} ${p.cmd}${runText(p)}${portsText(p)}`);
 }
 
 /** Comments left on the review page but not yet sent: an agent can pull

package/dist/_Cg63x2E_.js

@@ -0,0 +1,2 @@
+import { f as teamsOf } from "./_cvaVxDgR.js";
+export { teamsOf };

package/dist/_CkGqrA7b.js

@@ -0,0 +1,2 @@
+import { q as notifySessionsChanged } from "./_DQbVrULO.js";
+export { notifySessionsChanged };