@dylanpiercey/work 0.2.54 → 0.2.56

package/bin/cli/session.mjs

@@ -111,12 +111,16 @@ function sentText(id, r, asked) {
       "A reply it sends before then answers what it is on now: each reply names the message of yours it answers.",
     );
   const reopened = r.reopened ? `reopened ${id} on its conversation; ` : "";
+  const what = r.promoted
+    ? `your ${r.promoted === 1 ? "queued message" : `${r.promoted} queued messages`}`
+    : "";
   const stopped = r.interrupted ? `stopped ${id}'s turn; ` : "";
   if (r.midTurn)
     lines.push(
-      `${stopped}typed into ${id}'s turn under way: it gets this at its next step, after the tool call it is on`,
+      `${stopped}typed ${what || "this"} into ${id}'s turn under way: it gets ${r.promoted > 1 ? "them" : "it"} at its next step, after the tool call it is on`,
     );
-  else if (r.delivered) lines.push(`${reopened}${stopped}sent to ${id}`);
+  else if (r.delivered)
+    lines.push(`${reopened}${stopped}sent ${what ? `${what} ` : ""}to ${id}`);
   else {
     const wait = [
       r.queued,
@@ -126,12 +130,12 @@ function sentText(id, r, asked) {
     const sooner = !r.queued.startsWith("it is working")
       ? ""
       : r.steers && !asked.now
-        ? ` To reach it sooner: \`work session send ${id} --now "…"\` (into the turn, at its next step) or --interrupt (stops the turn first).`
+        ? ` To reach it sooner: \`work session send ${id} --now\` with no text sends what you queued into the turn, at its next step (--interrupt stops the turn first); never send it again.`
         : !r.steers && r.interrupts && !asked.interrupt
-          ? ` Its CLI takes no message mid-turn: --interrupt stops the turn to send it now.`
+          ? ` Its CLI takes no message mid-turn: \`work session send ${id} --interrupt\` with no text stops the turn to send what you queued now.`
           : "";
     lines.push(
-      `${reopened}${stopped}queued for ${id} (${wait.join("; ")}): typed in once it is at its prompt${asked.now && r.steers ? ", or into its turn once nothing stands in the way" : ""}.${sooner}`,
+      `${reopened}${stopped}${what ? `${what} ${r.promoted === 1 ? "stays" : "stay"} ` : ""}queued for ${id} (${wait.join("; ")}): typed in once it is at its prompt${asked.now && r.steers ? ", or into its turn once nothing stands in the way" : ""}.${sooner}`,
     );
   }
   return lines.join("\n");
@@ -193,6 +197,47 @@ const STATUS_MARK = {
   closed: "✕",
 };
 
+/** A moment as the log shows it: the time today, else the date too. */
+function clockOf(at) {
+  const d = new Date(at);
+  const time = d.toLocaleTimeString("en-GB", {
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+  return d.toDateString() === new Date().toDateString()
+    ? time
+    : `${d.toLocaleDateString("en-CA")} ${time}`;
+}
+
+/** One message of `work session log`: who to whom, what, how it went,
+ * then its text (its first line, unless `full`). */
+function printLogged(m, full) {
+  const kind =
+    m.kind === "message"
+      ? m.wants_reply
+        ? "message, wants a reply"
+        : "message"
+      : m.kind;
+  const went = [
+    m.urgent && "to go now",
+    m.delivered_at
+      ? `${m.delivered === "into its turn" ? "typed into its turn" : m.delivered === "at its prompt" ? "typed in at its prompt" : m.delivered} ${clockOf(m.delivered_at)}`
+      : !m.done_at && "queued",
+    m.done_at
+      ? m.outcome === "delivered"
+        ? null
+        : `${m.outcome} ${clockOf(m.done_at)}`
+      : m.delivered_at && m.wants_reply && "reply owed",
+  ].filter(Boolean);
+  console.log(
+    `${clockOf(m.created_at)}  ${m.from_session ?? "user"} → ${m.to_session}  ${kind}${went.length ? `  (${went.join("; ")})` : ""}`,
+  );
+  const text = full
+    ? m.body
+    : (m.body.split("\n").find((l) => l.trim()) ?? "").slice(0, 160);
+  for (const line of text.split("\n")) console.log(`    ${line}`);
+}
+
 /** One group of `work session team`: its head, then a line a member. */
 function printGroup(ctx, g) {
   const c = g.counts;
@@ -218,13 +263,22 @@ export const commands = [
   {
     name: "session",
     summary:
-      "this session and the workspace's others: new, fanout, send, wait, hold, keep, team, kill",
+      "this session and the workspace's others: new, fanout, send, wait, hold, keep, reopen, log, 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>/…).
-work session list [id|name] [--json]
+work session list [<workspace>|<session>] [--json]
   The workspace's sessions, this one marked, with how long each has been
-  in the turn under way and how many messages are queued for it.
+  in the turn under way and how many messages are queued for it. Given a
+  session's id: that one and those it started, or, closed, how and when,
+  and whether \`work session reopen\` can start it again.
+work session log [<id>] [--all] [--full] [--limit <n>] [--json]
+  What went to and from a session (this one unless <id>; --all: between
+  every session of the workspace), the last week, oldest first: each
+  message, reply and notice, when it was sent, how it went in (at its
+  prompt, into its turn, taken by wait) and how it left the queue
+  (answered, closed before a reply…) or that it is still queued or owed.
+  The first line of each unless --full.
 work session title "<name>" [--session <id>]
   Name a session in the session list (empty clears it).
 work session new [--agent <id>] [--title "<name>"] [--prompt "<text>"|-] [--no-reply] [--keep] [--topic <name> [--repo <repo>…] [--install]] [--workspace <id|name>] [--force]
@@ -280,7 +334,10 @@ work session send <id> "<text>"|- [--no-reply] [--now|--interrupt]
   step (after the tool call it is on), and that turn's end answers it;
   --interrupt stops the turn first, for one the next step is too late
   for or whose CLI takes nothing mid-turn (Grok). What is queued for it
-  goes in with it. The last line printed says whether it went in, and
+  goes in with it, and --now or --interrupt with no text sends what you
+  queued so, rather than a second copy. One with --no-reply goes into the
+  turn under way at its next step by itself: nothing waits on its answer,
+  and the turn may need it before it ends. The last line printed says whether it went in, and
   if not, how long the turn it waits out has run. 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.
@@ -288,6 +345,15 @@ work session send <id> "<text>"|- [--no-reply] [--now|--interrupt]
   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.
+work session reopen <id> [--agent <id>]
+  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
+  one when that is gone; or one running, whose CLI is restarted. --agent
+  starts it as another instance of the same CLI (claude2 for claude):
+  one stuck because its account hit a limit goes on as another account's,
+  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.
 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
@@ -307,7 +373,8 @@ work session keep <id>
 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.
+  Whoever waits on a reply from one is told. Each that can resume its
+  conversation can be started again for a week: \`work session reopen\`.
 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\`,
@@ -324,6 +391,7 @@ work session kill --done
         "--repo",
         "--count",
         "--parallel",
+        "--limit",
       ]);
       switch (verb) {
         case undefined: {
@@ -351,11 +419,61 @@ work session kill --done
           });
         }
         case "list": {
-          const { ws } = await ctx.resolveWorkspace(rest[0]);
-          const list = await sessionsOf(ctx, ws.id);
+          const [arg] = rest;
+          // A session's id names that one; anything else a workspace.
+          const workspaces = arg ? await ctx.api.get("/api/workspaces") : [];
+          const isWs = workspaces.some((w) => w.id === arg || w.name === arg);
+          const one =
+            arg && !isWs
+              ? await ctx.api.get(
+                  `/api/sessions/${encodeURIComponent(arg)}?missing=null`,
+                )
+              : null;
+          if (arg && !isWs && !one)
+            ctx.die(
+              `no workspace or session named ${arg} (see: work workspaces, work session list)`,
+            );
+          if (one?.closed)
+            return ctx.out(one, (s) =>
+              console.log(
+                `${ctx.pad(s.id, 9)} ${ctx.pad(s.agent, 10)} closed   ${s.title || ""}  (${s.closed.how === "done" ? "closed for being done" : "closed"} ${clockOf(s.closed.at)}; ${!s.reopenable ? "its conversation went with it" : s.closed.how === "done" ? "a message reopens it on its conversation" : `\`work session reopen ${s.id}\` starts it again on its conversation`})`,
+              ),
+            );
+          const { ws } = await ctx.resolveWorkspace(one ? one.workspace : arg);
+          const all = await sessionsOf(ctx, ws.id);
+          // One session: it and those it started, under it.
+          const under = one ? [one.id] : null;
+          if (under)
+            for (const s of all)
+              if (s.parent && under.includes(s.parent) && !under.includes(s.id))
+                under.push(s.id);
+          const list = under ? all.filter((s) => under.includes(s.id)) : all;
+          const top = list[0]?.depth ?? 0;
           return ctx.out(list, (l) => {
             if (!l.length) return console.log("no sessions");
-            for (const s of l) console.log(sessionLine(ctx, s));
+            for (const s of l)
+              console.log(sessionLine(ctx, { ...s, depth: s.depth - top }));
+          });
+        }
+        case "log": {
+          const id = rest[0] ?? (ctx.has("--all") ? null : sessionId(ctx));
+          const limit = ctx.flag("--limit");
+          const q = `?limit=${encodeURIComponent(limit ?? 50)}${by("&")}`;
+          const r = id
+            ? await ctx.api.get(
+                `/api/sessions/${encodeURIComponent(id)}/log${q}`,
+              )
+            : await ctx.api.get(
+                `/api/workspaces/${(await ctx.resolveWorkspace(ctx.flag("--workspace"))).ws.id}/messages${q}`,
+              );
+          return ctx.out(r, (r) => {
+            if (!r.messages.length)
+              return console.log(
+                id
+                  ? `nothing went to or from ${id} in the last week`
+                  : "nothing went between this workspace's sessions in the last week",
+              );
+            for (const m of r.messages) printLogged(m, ctx.has("--full"));
           });
         }
         case "title": {
@@ -509,15 +627,16 @@ work session kill --done
         case "send": {
           const [id, ...words] = rest;
           const text = await textOf(words.join(" "));
-          if (!id || !text)
-            ctx.die(
-              'usage: work session send <id> "<text>"|- [--no-reply] [--now|--interrupt]',
-            );
-          const me = process.env.WORK_SESSION_ID;
           const asked = {
             now: ctx.has("--now"),
             interrupt: ctx.has("--interrupt"),
           };
+          // No text, to go now: what this session queued for it goes.
+          if (!id || (!text && !asked.now && !asked.interrupt))
+            ctx.die(
+              'usage: work session send <id> "<text>"|- [--no-reply] [--now|--interrupt]',
+            );
+          const me = process.env.WORK_SESSION_ID;
           const r = await ctx.api.post(`/api/sessions/${id}/messages`, {
             text,
             ...(me ? { from: me } : {}),
@@ -583,6 +702,22 @@ work session kill --done
             ),
           );
         }
+        case "reopen": {
+          const [id] = rest;
+          if (!id) ctx.die("usage: work session reopen <id> [--agent <id>]");
+          const agent = ctx.flag("--agent");
+          const r = await ctx.api.post(`/api/sessions/${id}/reopen${by()}`, {
+            ...(agent ? { agent } : {}),
+          });
+          return ctx.out(r, (r) => {
+            console.log(
+              `${r.restarted ? "restarted" : "reopened"} ${r.id} on its conversation as ${r.agent}${r.parent ? `, under ${r.parent}` : ""}`,
+            );
+            console.log(
+              `It is at its prompt: \`work session send ${r.id} "…"\` carries it on.`,
+            );
+          });
+        }
         case "keep": {
           const [id] = rest;
           if (!id) ctx.die("usage: work session keep <id>");

package/dist/_CVNGN2QO.js

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