@retasc/cli 1.32.0 → 1.34.0

package/CHANGELOG.md

@@ -6,6 +6,36 @@ release commits and the issues they reference.
 
 Dates are the npm publish date. Each entry names the RTSC issue behind it.
 
+## 1.34.0 (2026-08-24)
+
+- **RTSC-731** — `bind` stops asking whether you want to join an org you are already in.
+  A teammate given access to a second project was shown "Join Retasc, or start your own
+  workspace?", with the second option one keystroke away from creating a duplicate
+  organization that cannot be deleted from the terminal. Invites that only add projects
+  to a membership you already have are no longer treated as onboarding, and no longer
+  suppress the single-org shortcut. Your agent still hears about them, and
+  `setup_status` now asks about them in its own words, naming the project and the
+  organization so "Retasc the org" and "Retasc the project" can't be confused.
+- **RTSC-731** — the invite questions hand back a value your agent can actually use.
+  Both onboarding questions told the agent to pass the chosen answer to `accept_invite`'s
+  `org` flag, then offered "join" as that answer — so an agent doing exactly what it was
+  told got "no invite to join is waiting for you", while one that ignored the instruction
+  and read the prose succeeded. The accept option now carries the organization itself.
+
+## 1.33.0 (2026-08-23)
+
+- **RTSC-722** — the setup questions arrive as a matrix your agent can actually render.
+  1.32.0 sent three of the four as free text, and a picker cannot draw a question with no
+  options, so the whole set collapsed back into the numbered list in prose that RTSC-720
+  existed to remove. They now carry defaults derived from the folder you are standing in:
+  in `~/the egg` you get `The Egg`, `The Egg`, `EGG`, and the folder confirm, four clicks
+  instead of three typed answers. Every question keeps a "Something else" escape.
+  Folders that name nothing about the work (`/Users`, your home directory, `src`, a
+  dotfile, anything too long for the server to accept) suggest nothing and fall back to
+  text, because a plausible wrong default is worse than no default when what you are
+  confirming is which folder gets connected. Picking a project in an org that has more
+  than four is a picker too now, instead of an unrenderable list of every project.
+
 ## 1.32.0 (2026-08-23)
 
 - **RTSC-720** — when `bind --json` stops to ask, it hands your agent the exact questions

package/dist/commands/bind.js

@@ -9,7 +9,7 @@ import { resolveLauncher, launcherNote, onDurablePath, selfCommand, versionStamp
 import { ask, confirm, isInteractive } from "../lib/prompt.js";
 import { clean } from "../lib/text.js";
 import { card, DOT } from "../lib/card.js";
-import { emit, orgQuestions, projectQuestions } from "../lib/outcome.js";
+import { answeredElsewhere, ELSEWHERE_VALUE, emit, orgQuestions, projectQuestions, } from "../lib/outcome.js";
 import { VERSION } from "../version.js";
 // RTSC-508: `ask`/`confirm`/`isInteractive` now live in lib/prompt.ts so `auth.ts`
 // can use them without closing an import cycle (bind → auth → bind). Re-exported
@@ -640,6 +640,31 @@ export async function bindAction(opts) {
         ? { onUrl: (url) => emit({ event: "approve_url", url }) }
         : undefined;
     const folder = process.cwd();
+    // RTSC-722 — the escape option's value is a sentinel, and this is where it stops being
+    // an answer. Every suggested question offers "Something else", and the agent is told to
+    // put the chosen value in the named flag; without this a human declining the suggestion
+    // creates a workspace literally called `__ask_me__`. Strip it here, at the boundary, so
+    // no downstream site has to know: the flag reads as unanswered, and the re-ask drops
+    // the suggestion this human just declined instead of offering it again.
+    const declined = answeredElsewhere(opts);
+    if (declined.size) {
+        opts = {
+            ...opts,
+            orgName: opts.orgName === ELSEWHERE_VALUE ? undefined : opts.orgName,
+            project: opts.project === ELSEWHERE_VALUE ? undefined : opts.project,
+            prefix: opts.prefix === ELSEWHERE_VALUE ? undefined : opts.prefix,
+            projectId: opts.projectId === ELSEWHERE_VALUE ? undefined : opts.projectId,
+        };
+    }
+    // What the agent has ALREADY collected, so the re-ask asks only for the rest. Computed
+    // after the strip: a sentinel is a decline, never an answer.
+    const answered = new Set();
+    if (opts.orgName)
+        answered.add("org.name");
+    if (opts.project)
+        answered.add("project.name");
+    if (opts.prefix)
+        answered.add("project.prefix");
     /** Continuable: say what is missing, exit 0. See lib/outcome.ts for why 0. */
     const pause = (o) => {
         if (agent)
@@ -703,7 +728,17 @@ export async function bindAction(opts) {
     if (!orgId) {
         const me = (await api.me());
         const orgs = me.orgs ?? [];
-        const pendingInvites = me.pendingInvites ?? [];
+        // RTSC-731 — JOIN invites only. RTSC-730 widened what `me.pendingInvites` returns to
+        // include invites that merely add projects to a membership somebody already has, and
+        // this block asks "join this org, or start your own workspace?" — a question whose
+        // premise is false for an existing member, and whose second option creates a SECOND
+        // org on the billing rail with no CLI-callable delete (RTSC-297). A widening also
+        // must not suppress the single-org shortcut below.
+        //
+        // Widenings are NOT dropped from the product, only from THIS question: the notice
+        // rider still relays them, `whoami` still lists them, `setup_status` asks about them
+        // with its own wording, and `accept_invite` still takes them.
+        const pendingInvites = (me.pendingInvites ?? []).filter((i) => !i.widensExisting);
         if (isInteractive()) {
             const chosen = await pick("Select an org", orgs, (o) => `${o.name} (${o.slug})`);
             if (chosen) {
@@ -766,7 +801,7 @@ export async function bindAction(opts) {
                             resume: { tool: "join" },
                         },
                     ]
-                    : orgQuestions(signedInAs, folder),
+                    : orgQuestions(signedInAs, folder, declined, answered),
                 next: pendingInvites.length
                     ? `Signed in as ${signedInAs}. They have been invited to ` +
                         `${pendingInvites.map((i) => `"${i.org}"`).join(", ")}. ASK whether they want to join ` +
@@ -814,16 +849,31 @@ export async function bindAction(opts) {
                 state: "NEEDS_PROJECT",
                 org: { id: orgId, name: opts.orgName ?? orgId },
                 projects: list,
-                missing: list.length ? ["--project-id"] : ["--project", "--prefix"],
-                askHuman: projectQuestions(folder, list),
-                next: list.length
-                    ? `That organization has ${list.length} projects. Ask which one THIS FOLDER is ` +
-                        `for, then re-run with --project-id. Confirm the folder with them: this will ` +
-                        `connect ${folder}.`
-                    : `That organization has no projects yet. Ask what they are working on, and ` +
-                        `whether they want to bring a backlog across from Linear, Jira, Asana, ClickUp ` +
-                        `or Shortcut rather than start empty. Then re-run with --project and --prefix. ` +
-                        `Confirm the folder with them: this will connect ${folder}.`,
+                // RTSC-722 — once THIS run created the org, `--org-name` is a trap: the obvious
+                // agent move is to replay the previous argv with the missing flag added, which
+                // re-enters createOrg, hits `CONFLICT: org slug is taken` and exits 1. The
+                // instructions say a non-zero exit means stop, so the run dies one flag from
+                // working, with a stranded org. Naming --org-id here is what makes the retry
+                // survivable. The REFUSED branch below already warns about this; this pause is
+                // the one that reaches it, and did not.
+                missing: [
+                    ...(createdOrgThisRun ? [`--org-id ${orgId}`] : []),
+                    ...(list.length ? ["--project-id"] : ["--project", "--prefix"]),
+                ],
+                askHuman: projectQuestions(folder, list, declined),
+                next: (createdOrgThisRun
+                    ? `The organization "${opts.orgName}" now EXISTS — it was created by this run. ` +
+                        `Every retry from here must pass --org-id ${orgId} and must NOT pass ` +
+                        `--org-name again, which would try to create a second one and fail. `
+                    : "") +
+                    (list.length
+                        ? `That organization has ${list.length} projects. Ask which one THIS FOLDER is ` +
+                            `for, then re-run with --project-id. Confirm the folder with them: this will ` +
+                            `connect ${folder}.`
+                        : `That organization has no projects yet. Ask what they are working on, and ` +
+                            `whether they want to bring a backlog across from Linear, Jira, Asana, ClickUp ` +
+                            `or Shortcut rather than start empty. Then re-run with --project and --prefix. ` +
+                            `Confirm the folder with them: this will connect ${folder}.`),
             });
             return;
         }

package/dist/lib/outcome.js

@@ -47,6 +47,7 @@
  * There is a test that greps for these code strings under `convex/`. If one ever appears
  * there, the split has been broken.
  */
+import { homedir } from "node:os";
 /**
  * Every terminal outcome of an agent-driven `bind`, in two classes.
  *
@@ -100,14 +101,137 @@ export function isContinuable(state) {
  * The questions each continuable state asks, as pure builders so they are testable
  * without a network. bindAction attaches their output to the outcome it emits.
  */
-export function orgQuestions(signedInAs, folder) {
+/**
+ * Names suggested from the folder, or null when the folder does not name anything
+ * (RTSC-722).
+ *
+ * Every question in the setup matrix needs OPTIONS, because a picker cannot render a
+ * question that has none — which is exactly why RTSC-720's three free-text questions
+ * came out as prose. The folder is where the defaults come from: somebody working in
+ * `~/the egg` almost certainly wants a workspace called The Egg, and the common case
+ * becomes a click rather than three typed answers.
+ *
+ * NULL for a folder that names nothing, and this guard is load-bearing rather than
+ * tidy. The run before this one had a human standing in `/Users` — suggesting "Users"
+ * as their workspace name would have made a WRONG binding easier to accept, which is
+ * the opposite of what the folder confirmation exists for. Home, root, a dotfile and
+ * the usual meaningless container directories all decline to suggest, and those
+ * questions fall back to text.
+ */
+const UNHELPFUL = new Set([
+    "users", "home", "root", "src", "lib", "tmp", "temp", "var", "opt", "etc", "desktop",
+    "documents", "downloads", "projects", "project", "code", "dev", "developer", "repos",
+    "repo", "workspace", "work", "apps", "app", "api", "web", "www", "site", "server",
+    "client", "backend", "frontend", "main", "new", "new folder", "untitled folder", "untitled",
+    "node modules", "git", "github", "test", "tests", "build", "dist",
+]);
+/** Longest suggestion worth offering. The server caps an org name at 120 (manage.ts
+ *  MAX_ORG_NAME), but a picker option is read at a glance and a folder whose basename
+ *  runs past this is not a workspace name anyway. */
+const MAX_SUGGESTED_NAME = 48;
+/** Case-folded, trailing-separator-free, for comparing two paths for sameness. */
+const samePath = (a, b) => a.replace(/[/\\]+$/, "").toLowerCase() === b.replace(/[/\\]+$/, "").toLowerCase();
+export function suggestNames(folder, home = homedir()) {
+    const trimmed = folder.replace(/[/\\]+$/, "");
+    // The home directory names the HUMAN, not the work. It is the likeliest wrong folder
+    // after `/Users` itself, and "Kim" as a workspace name is plausible enough to click
+    // past — which is exactly the wrong-folder binding the confirm exists to catch. The
+    // basename check below cannot see this: "kim" is not a generic container word.
+    // Case-insensitively, because macOS and Windows filesystems are: `/users/kim` and
+    // `/Users/kim` are the same directory and only one of them would match an exact compare.
+    if (home && samePath(trimmed, home))
+        return null;
+    const raw0 = trimmed.split(/[/\\]/).pop() ?? "";
+    // Fold accents to their ASCII base BEFORE splitting. The split treats every character
+    // outside [A-Za-z0-9] as a SEPARATOR, so without this `café-api` silently becomes
+    // "Caf Api" and `résumé` becomes "R Sum" — a confident, wrong, pre-filled default,
+    // which is the one thing this function's null-return exists to avoid. A basename that
+    // is entirely non-Latin already returns null (no words survive); it is the MIXED case
+    // that mangles.
+    const base = raw0.normalize("NFD").replace(/\p{Diacritic}/gu, "");
+    // Anything still outside ASCII after folding (CJK, Cyrillic, emoji) cannot be
+    // transliterated honestly, so decline rather than drop characters.
+    if (/[^\x20-\x7E]/.test(base))
+        return null;
+    // A dotfile directory, an empty basename (root), or a generic container names nothing
+    // about the work. `-2`/` 2` suffixes are stripped first, so "New Folder 2" and
+    // "project-3" decline the same way their unsuffixed forms do.
+    const generic = base.toLowerCase().replace(/[\s._-]+\d+$/, "").replace(/[_-]+/g, " ").trim();
+    if (!base || base.startsWith(".") || UNHELPFUL.has(generic))
+        return null;
+    const words = base.split(/[^A-Za-z0-9]+/).filter(Boolean);
+    if (!words.length)
+        return null;
+    const name = words.map((w) => w[0].toUpperCase() + w.slice(1)).join(" ");
+    // Do not offer a default the server will reject, or one a picker cannot show.
+    if (name.length > MAX_SUGGESTED_NAME)
+        return null;
+    // Must satisfy the server's own rule — /^[A-Z][A-Z0-9]{1,9}$/ (manage.ts). A suggested
+    // default the server then rejects is worse than no suggestion, because the human
+    // accepted it and the failure arrives afterwards, attributed to nothing they did.
+    const joined = words.join("").toUpperCase().replace(/[^A-Z0-9]/g, "");
+    // A mid-word truncation reads as a typo, and the prefix then appears in EVERY issue id
+    // in the project (renaming one is owner-gated and Dash-only). `a-very-long-project-name`
+    // as AVERYLONGP is worse than no suggestion; its initials, AVLPN, is a real prefix.
+    const prefix = joined.length <= 10
+        ? joined
+        : words.map((w) => w[0]).join("").toUpperCase().replace(/[^A-Z0-9]/g, "");
+    if (!/^[A-Z][A-Z0-9]{1,9}$/.test(prefix))
+        return null;
+    return { name, prefix };
+}
+/**
+ * The escape every suggested question carries, so the matrix never traps anyone.
+ *
+ * The value is a SENTINEL, not a word. `toElicitation` turns the option list into a JSON
+ * schema `enum`, and the instructions tell the agent to put the chosen value in the named
+ * flag — so a human-readable escape value like "other" arrives as `--org-name other` and
+ * names the workspace "other". `bind` rejects this exact string on every answer flag
+ * (`answeredElsewhere` below), so a mistake costs one more question rather than a wrongly
+ * named workspace. Enforced in the command, not in the wording: an instruction the agent
+ * can misread is not a guard.
+ */
+export const ELSEWHERE_VALUE = "__ask_me__";
+/** A picker renders at most four options (AskUserQuestion caps there, and a longer list
+ *  stops being scannable anyway). Emitting more is the RTSC-722 defect. */
+export const MAX_OPTIONS = 4;
+const ELSEWHERE = { value: ELSEWHERE_VALUE, label: "Something else — I'll tell you" };
+/**
+ * Which answers came back as the escape, so the re-ask does NOT re-offer the suggestion
+ * the human just declined. Without this the same matrix comes back unchanged and the
+ * exchange loops: suggestion, "something else", same suggestion.
+ */
+export function answeredElsewhere(opts) {
+    const out = new Set();
+    if (opts.orgName === ELSEWHERE_VALUE)
+        out.add("org.name");
+    if (opts.project === ELSEWHERE_VALUE)
+        out.add("project.name");
+    if (opts.prefix === ELSEWHERE_VALUE)
+        out.add("project.prefix");
+    return out;
+}
+export function orgQuestions(signedInAs, folder, declined = new Set(), answered = new Set()) {
     const context = (signedInAs ? `Signed in as ${signedInAs}. ` : "") +
         `These three answers create the workspace; the folder question is what connects ` +
         `THIS folder to it.`;
-    return [
-        { id: "org.name", question: "What should your workspace (organization) be called?", context, input: "text", resume: { tool: "bind", arg: "--org-name" } },
-        { id: "project.name", question: "And the first project?", input: "text", resume: { tool: "bind", arg: "--project" } },
-        { id: "project.prefix", question: "A short prefix for issue ids?", input: "text", hint: "e.g. ACME", resume: { tool: "bind", arg: "--prefix" } },
+    const g = suggestNames(folder);
+    // With a usable folder name every question carries options, so all four render as ONE
+    // matrix and the common case is four clicks on pre-filled defaults. Without one they
+    // stay text — a wrong suggestion is worse than a typed answer.
+    // `hint` is documented on BOTH sides of the mirror (here and convex/lib/askHuman.ts) as
+    // meaningful only with `input: "text"`, so it rides the text branch only. A question
+    // showing THEEGG does not also need "e.g. ACME".
+    const suggested = (value, arg, id, question, hint) => g && !declined.has(id)
+        ? { id, question, options: [{ value, label: value }, ELSEWHERE], resume: { tool: "bind", arg } }
+        : { id, question, input: "text", ...(hint ? { hint } : {}), resume: { tool: "bind", arg } };
+    // An answer already in hand is not a question. Declining ONE of the three used to
+    // re-emit all three, so a human who had already named their project was asked for it a
+    // second time, and could answer differently the second time.
+    const all = [
+        { ...suggested(g?.name ?? "", "--org-name", "org.name", "What should your workspace (organization) be called?"), context },
+        suggested(g?.name ?? "", "--project", "project.name", "And the first project?"),
+        suggested(g?.prefix ?? "", "--prefix", "project.prefix", "A short prefix for issue ids?", "e.g. ACME"),
         {
             // The folder rides IN the exchange, not after it. It earned this on the run that
             // shaped RTSC-720: the human was standing in /Users, the outcome named the path,
@@ -122,24 +246,46 @@ export function orgQuestions(signedInAs, folder) {
             resume: { tool: "bind" },
         },
     ];
+    return all.filter((q) => !answered.has(q.id));
 }
-export function projectQuestions(folder, projects) {
+export function projectQuestions(folder, projects, declined = new Set()) {
     if (projects.length) {
+        // RTSC-722 again, on the path the first pass missed. A picker renders at most FOUR
+        // options, so an org with five projects reproduced the exact failure this issue is
+        // about: unrenderable, so the question degrades to prose. Show three and an escape;
+        // the outcome carries the FULL list in `projects`, so "none of these" means the agent
+        // reads that list out and passes the id the human picks — an escape, not a dead end.
+        const shown = projects.length <= MAX_OPTIONS ? projects : projects.slice(0, MAX_OPTIONS - 1);
+        const options = shown.map((p) => ({
+            value: p.id,
+            label: `${p.prefix ?? ""} — ${p.name ?? p.id}`.trim(),
+        }));
+        if (shown.length < projects.length) {
+            options.push({
+                value: ELSEWHERE_VALUE,
+                label: `None of these — show me all ${projects.length}`,
+            });
+        }
         return [
             {
                 id: "project.pick",
                 question: `Which project is ${folder} for?`,
-                options: projects.map((p) => ({
-                    value: p.id,
-                    label: `${p.prefix ?? ""} — ${p.name ?? p.id}`.trim(),
-                })),
+                options,
                 resume: { tool: "bind", arg: "--project-id" },
             },
         ];
     }
+    // Same rule as orgQuestions: options where the folder names something, text where it
+    // does not. This path is reached with an org already chosen and no projects in it.
+    const g = suggestNames(folder);
+    const pick = (id) => g && !declined.has(id);
     return [
-        { id: "project.name", question: "What is the first project called?", input: "text", resume: { tool: "bind", arg: "--project" } },
-        { id: "project.prefix", question: "A short prefix for issue ids?", input: "text", hint: "e.g. ACME", resume: { tool: "bind", arg: "--prefix" } },
+        pick("project.name")
+            ? { id: "project.name", question: "What is the first project called?", options: [{ value: g.name, label: g.name }, ELSEWHERE], resume: { tool: "bind", arg: "--project" } }
+            : { id: "project.name", question: "What is the first project called?", input: "text", resume: { tool: "bind", arg: "--project" } },
+        pick("project.prefix")
+            ? { id: "project.prefix", question: "A short prefix for issue ids?", options: [{ value: g.prefix, label: g.prefix }, ELSEWHERE], resume: { tool: "bind", arg: "--prefix" } }
+            : { id: "project.prefix", question: "A short prefix for issue ids?", input: "text", hint: "e.g. ACME", resume: { tool: "bind", arg: "--prefix" } },
     ];
 }
 /** stdout, one line, no trailing prose. Never stderr: see the module header. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@retasc/cli",
-  "version": "1.32.0",
+  "version": "1.34.0",
   "description": "Retasc CLI \u2014 the issue tracker AI agents pull work from. Sign in with GitHub or Google, create projects, mint agent API keys, and wire your agent to the Retasc MCP server in one command.",
   "type": "module",
   "bin": {