@retasc/cli 1.11.0 → 1.12.0

package/dist/commands/bind.js

@@ -277,7 +277,33 @@ export async function completeWorkspaceSetup(args) {
     catch {
         /* binding written; whoami confirmation is best-effort */
     }
+    // RTSC-519 — say that setup FINISHED, and what to do with it.
+    //
+    // Here rather than in either command, because it is true of both and this is the tail
+    // they share. `join` said it and `bind` did not, so the person who set up their own org
+    // was left reading a status line and guessing whether anything else was required — while
+    // the invited teammate, who arrived through the other command, was told. A line in one
+    // caller is a line the other has to remember; a line here is one neither can lose.
+    //
+    // AFTER the confirmation, and after everything that can throw, so it is only ever
+    // printed by a run that actually finished. Nothing below it can fail.
+    if (isInteractive())
+        console.log(`\n${NEXT_STEP}`);
 }
+/**
+ * What to do with a workspace that is now set up.
+ *
+ * "or restart it if it's already open" is the load-bearing half. `.mcp.json` is read when
+ * an MCP client starts, so an agent already running on this folder will not see Retasc
+ * until it restarts — the same trap RTSC-496 records for the Dash's version of this
+ * handover, where the screen otherwise waits forever on an agent that can never call in.
+ * It bites harder here: `bind` is routinely run from inside a session already open on the
+ * folder being bound.
+ *
+ * Deliberately NOT "run `retasc next`". The agent pulls work over MCP; the CLI's claim
+ * commands are a human convenience, and naming one here would teach the wrong first move.
+ */
+export const NEXT_STEP = "Start your agent in this folder, or restart it if it's already open, and it'll pull from the queue.";
 /**
  * Sign in first when there is no session at all (RTSC-481, extended to `join` by RTSC-492).
  *

package/dist/commands/identity.js

@@ -50,15 +50,19 @@ function report(outcome, orgLabel) {
             console.log("Run this again after a migration — each import brings its own people across.");
             return;
         case "answered":
-            // The permanent decline. Worth its own wording: from in here it is indistinguishable
-            // from "none", and someone who declined during an earlier import and now has a real
-            // placeholder from a NEW one would otherwise read "nothing waiting" as the truth.
-            console.log(`You've already said none of the imported people in ${orgLabel} are you.`);
-            console.log("That answer covers the whole org, including later migrations.");
-            console.log("If a newer import did carry you across, an owner can link it from the Team page.");
+            // They have answered here before, and nothing is left from a tool they haven't
+            // answered about. It differs from "none" only in being able to say what already
+            // happened; the advice is identical, because it is now TRUE for both.
+            //
+            // RTSC-507 rewrote this. It used to read "that answer covers the whole org,
+            // including later migrations" and send them to an owner — because one decline really
+            // did shut them out of every future import. That sentence existed only to describe a
+            // bug, and it goes in the same release the bug does.
+            console.log(`You've answered about every tool imported into ${orgLabel} so far.`);
+            console.log("Run this again after the next migration — each one is asked about separately.");
             return;
         case "declined":
-            console.log("Noted — you won't be asked again.");
+            console.log("Noted. That covers those tools only, so a later import will ask again.");
             return;
         case "left":
             console.log("Nothing linked. Run `retasc identity` again whenever you want to look.");

package/dist/commands/join.js

@@ -16,6 +16,24 @@ const UNKNOWN_SOURCE = "another tool";
  * number of migrated tools.
  */
 const MAX_IDENTITY_ROUNDS = 10;
+/**
+ * The tools on screen, named the way they'd be read aloud (RTSC-507).
+ *
+ * The twin of `sourcePhrase` in `dash/src/lib/ghostPrompt.ts`, duplicated rather than
+ * shared because the two live in separate packages with no common build — the same reason
+ * `UNKNOWN_SOURCE` above is a second copy of the Dash's constant. Keep the two in step:
+ * they answer the same question in front of the same irreversible decision.
+ */
+export function sourcePhrase(ghosts) {
+    const names = [...new Set(ghosts.map((g) => clean(g.sourceLabel ?? UNKNOWN_SOURCE)))].sort((a, b) => 
+    // Keep the vague fallback last, so a known tool always leads.
+    a === UNKNOWN_SOURCE ? 1 : b === UNKNOWN_SOURCE ? -1 : a.localeCompare(b));
+    if (names.length <= 1)
+        return names[0] ?? UNKNOWN_SOURCE;
+    if (names.length === 2)
+        return `${names[0]} and ${names[1]}`;
+    return `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`;
+}
 /** How one row reads: the person, and the tool they were carried in from. */
 function ghostRow(g) {
     // BOTH fields are third-party text: the name was typed by someone in ClickUp/Jira/Asana
@@ -62,13 +80,16 @@ deps = {}) {
         let ghosts;
         try {
             const res = await d.claimableGhosts({ orgId });
-            // Two different endings the server returns on one shape. "Answered" is this human's
-            // permanent org-wide decline; "none" is simply an empty list, and they can be asked
-            // again after the next migration. `join` treats both as silence; `identity` does not.
-            if (res.asked)
-                return claimedAny ? "claimed" : "answered";
-            if (!res.ghosts.length)
-                return claimedAny ? "claimed" : "none";
+            // An empty list is the only ending now (RTSC-507). `asked` no longer gates anything
+            // — it used to mean "declined, permanently", and branching on it FIRST is exactly
+            // what hid a later migration's placeholders for good. It now only picks the wording:
+            // "you've answered everything so far" reads differently from "nothing was ever
+            // imported here", and both are empty. `join` treats them alike; `identity` does not.
+            if (!res.ghosts.length) {
+                if (claimedAny)
+                    return "claimed";
+                return res.asked ? "answered" : "none";
+            }
             ghosts = res.ghosts;
         }
         catch (e) {
@@ -80,14 +101,18 @@ deps = {}) {
             ? `\nWhen ${orgLabel ?? "this org"} migrated, some people were carried across.\n` +
                 "One of them may be you:"
             : "\nAnything else here you recognise?");
-        // "Don't ask again" is not decoration. Declining writes `ghostPromptDismissedAt` on the
-        // member row and `claimGhost` refuses for good afterwards, org-wide — so a bare "none
-        // of these are me" would read as "none of these ClickUp ones" and quietly close the
-        // door on a second tool's placeholder too.
+        // RTSC-507 — the row says what the answer COVERS, because that is what changed.
+        // Declining used to write one org-wide flag that shut the person out of every later
+        // migration, so the row had to carry the warning "don't ask again". It now records
+        // only the tools on screen, so a bare "none of these are me" is finally the literal
+        // truth, and naming the tools is what makes the answer safe to give.
         // Compared by REFERENCE below, not by a magic id value: a sentinel that is merely a
-        // row with an empty id would let any future ghost with a falsy id read as a decline —
-        // and a decline is permanent.
-        const NONE = { id: "", name: "None of these are me (don't ask again)", sourceLabel: null };
+        // row with an empty id would let any future ghost with a falsy id read as a decline.
+        const NONE = {
+            id: "",
+            name: `None of these are me (covers ${sourcePhrase(ghosts)} only)`,
+            sourceLabel: null,
+        };
         // No label: the heading above is the prompt, and `choose` would print a second one.
         const chosen = await pickExisting("", [...ghosts, NONE], (g) => (g === NONE ? g.name : ghostRow(g)), d.askFn);
         if (chosen === NONE) {
@@ -96,10 +121,10 @@ deps = {}) {
             }
             catch (e) {
                 console.error(`  ! ${formatError(e).message}`);
-                // NOT "declined". A caller answers that with "you won't be asked again", and the
-                // write is the only thing that makes it true — the flag never landed, so they WILL
-                // be asked again. The error is already on stderr; `unavailable` adds no second
-                // sentence on top of it rather than a reassuring false one.
+                // NOT "declined". A caller answers that with "noted", and the write is the only
+                // thing that makes it true — nothing landed, so these tools WILL be offered again.
+                // The error is already on stderr; `unavailable` adds no second sentence on top of
+                // it rather than a reassuring false one.
                 return "unavailable";
             }
             return "declined";
@@ -212,7 +237,6 @@ export async function joinAction(link, opts) {
         console.error(`  Resume with:  ${resume}`);
         throw e;
     }
-    if (isInteractive()) {
-        console.log("\nStart your agent in this folder and it'll pull from the queue.");
-    }
+    // RTSC-519 — the closing line moved into `completeWorkspaceSetup`, the tail both commands
+    // already share, so `bind` gets it too. Saying it here as well would say it twice.
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@retasc/cli",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "Retasc CLI — sign in with GitHub, create projects, mint agent API keys, and wire your agent to the Retasc MCP server in one command.",
   "type": "module",
   "bin": {