@retasc/cli 1.40.0 → 1.41.0

package/CHANGELOG.md

@@ -6,6 +6,19 @@ release commits and the issues they reference.
 
 Dates are the npm publish date. Each entry names the RTSC issue behind it.
 
+## 1.41.0 (2026-09-04)
+
+- **RTSC-825** — every workspace now carries the name of the folder it is bound to. The
+  server never receives a path, so the name can only come from the machine that has one:
+  `retasc bind` sends it when the key is minted, and the watchdog proxy re-sends it at
+  every session start, so a folder bound before this existed is named the next time an
+  agent runs there. Only the folder's own name travels, never the path above it, and it
+  is the folder the BINDING names — a session opened in a subdirectory still reports the
+  bound folder rather than renaming the row to whatever directory it started in. The
+  Dash shows it as `workspace` on the Agents page and on the Connect page, and shows
+  nothing at all where a workspace has not reported one; a key retired before this
+  shipped can never report one, so it stays blank.
+
 ## 1.40.0 (2026-09-04)
 
 - **RTSC-820** — every session now tells Retasc which conversation it is. `retasc setup`

package/dist/commands/bind.js

@@ -521,6 +521,9 @@ export async function completeWorkspaceSetup(args) {
             // The server cleans the name and falls back to the project's own when the
             // leaf is empty.
             keyName: basename(cwd),
+            // RTSC-825 — and as the WORKSPACE, which is the field the Dash reads. `keyName`
+            // stays for the legacy label; nothing reads it as a folder any more.
+            workspace: basename(cwd),
         }));
     // The key is named in the receipt card below, not here — one mention, in the place
     // that says where it went (RTSC-673).
@@ -646,7 +649,7 @@ export async function setupFromToken(token, opts, deps = {}) {
     const cwd = process.cwd();
     const guard = deps.guard ?? rebindGuard;
     const redeem = deps.redeem ??
-        ((t, label) => api.redeemSetupToken({ token: t, label }));
+        ((t, label, workspace) => api.redeemSetupToken({ token: t, label, workspace }));
     // BEFORE the redeem. `rebindGuard` prints its own explanation and, with no TTY,
     // refuses with exit 1 unless `--yes` — which is exactly the required behaviour, so it
     // is reused rather than restated. No org/project passed: its idempotent-converge
@@ -664,7 +667,12 @@ export async function setupFromToken(token, opts, deps = {}) {
     // RTSC-532 — the LEAF name, never the full path. It names the key in the Dash, so it
     // has to be recognisable ("client-a → ENG") without publishing where on her disk it
     // sits. `basename` of the cwd is exactly that.
-    const redeemed = await redeem(token.trim(), basename(cwd));
+    //
+    // RTSC-825 — sent TWICE, on purpose: once as the legacy `label` and once as the
+    // `workspace`. They happen to be the same string here and nowhere is that a rule —
+    // the label is a human field a future caller may set to anything, so the folder
+    // travels in its own argument rather than being read back out of it.
+    const redeemed = await redeem(token.trim(), basename(cwd), basename(cwd));
     const workspaceId = existing?.workspaceId ?? newWorkspaceId();
     (deps.bind ?? setBinding)(workspaceId, {
         orgId: redeemed.orgId,

package/dist/index.js

@@ -6,7 +6,7 @@ import { VERSION } from "./version.js";
 import { selfCommand, versionStamp } from "./lib/launcher.js";
 import { loadConfig, patchConfig, saveConfig, configPath, isLoggedIn } from "./config.js";
 import { installMcp, noteRuntimeIsALabel, normalizeScope } from "./commands/mcp.js";
-import { runSetup } from "./commands/setup.js";
+import { runSetup, printSetup } from "./commands/setup.js";
 import { installGate, resolveGatePrefix } from "./commands/gate.js";
 import { claimAction, releaseAction } from "./commands/claim.js";
 import { bindAction, completeWorkspaceSetup, rebindGuard, setupFromToken } from "./commands/bind.js";
@@ -576,7 +576,7 @@ program
     .option("--no-install", "Don't install `retasc` on this machine; wire the pinned npx launcher instead")
     .allowExcessArguments(false)
     .action((opts) => {
-    runSetup({ install: opts.install });
+    printSetup(runSetup({ install: opts.install, quiet: true }));
 });
 const mcp = program.command("mcp").description("Wire the Retasc MCP server into your agent.");
 mcp

package/dist/lib/keystore.js

@@ -202,6 +202,7 @@ export function resolveConn(opts) {
     // came from the keystore, so it travels only to the keystore's url. That is what
     // lets `auto` be written into a GLOBAL harness config: the entry is identical on
     // every machine and in every folder, and carries nothing worth stealing.
+    let boundPath = "";
     if (!key) {
         const wsId = env.RETASC_WORKSPACE || entry?.env?.RETASC_WORKSPACE;
         const b = wsId === AUTO_WORKSPACE
@@ -217,7 +218,8 @@ export function resolveConn(opts) {
             // url" is stated here outright rather than left resting on that invariant, so
             // restoring an unpaired url above cannot quietly resurrect the RTSC-800 redirect.
             url = b.url;
+            boundPath = b.boundPath ?? "";
         }
     }
-    return { key, url: url || opts.defaultUrl || "" };
+    return { key, url: url || opts.defaultUrl || "", boundPath };
 }

package/dist/lib/session.js

@@ -5,9 +5,17 @@
 // sessions collapse into one server-side identity and the per-session claim fence
 // (RTSC-49/50) is silently inert.
 import { toolResult } from "./toolresult.js";
-// Out-of-band ids are negative so they never collide with the harness's (the
-// same convention as the proxy's heartbeat ids; announceBinding uses -1001).
-const MINT_RPC_ID = -1000;
+// Out-of-band ids are negative so they never collide with the harness's (the same
+// convention as the proxy's heartbeat ids). One id per out-of-band call, named rather
+// than counted: the offsets these replaced had drifted into a collision, with
+// `announceBinding` and `record_session` both sending -1001.
+export const RPC_ID = {
+    mint: -1000,
+    announce: -1001,
+    recordSession: -1002,
+    nameWorkspace: -1003,
+};
+const MINT_RPC_ID = RPC_ID.mint;
 // The mint runs BEFORE the proxy serves `initialize`, so a hung server must not
 // stall startup past the harness's MCP timeout — that would turn "degraded
 // identity" into "no Retasc tools at all", the exact failure fail-soft exists
@@ -92,11 +100,17 @@ export function appendFallbackNotice(toolName, resp, degraded) {
     }
 }
 /**
- * Record the harness's transcript id on THIS session's key (RTSC-820). Best effort and
- * quiet: the worst case is the Dash saying "none recorded", which is what it said
- * before this existed. Returns true once the server has it (already-recorded counts).
+ * One out-of-band `tools/call` (RTSC-825). The proxy makes several of these around a
+ * session's start — mint the session key, announce the binding, record the transcript,
+ * name the folder — and they had been written out longhand each time, so a change to
+ * the transport (the auth header, the timeout, how a failure is surfaced) had to be
+ * made in three places and would have been made in one.
+ *
+ * Every caller here is best-effort: the session must serve MCP traffic whatever the
+ * server says, so this NEVER throws. `expect` is the field the tool returns on success;
+ * its presence is what separates a real result from an error envelope carrying prose.
  */
-export async function recordSession(opts) {
+async function callTool(opts) {
     const fetchImpl = opts.fetchImpl ?? fetch;
     const warn = opts.warn ?? ((msg) => process.stderr.write(`[retasc] ${msg}\n`));
     try {
@@ -109,25 +123,58 @@ export async function recordSession(opts) {
             },
             body: JSON.stringify({
                 jsonrpc: "2.0",
-                id: MINT_RPC_ID - 1,
+                id: opts.id,
                 method: "tools/call",
-                params: {
-                    name: "record_session",
-                    arguments: { transcriptId: opts.transcriptId, ...(opts.harness ? { harness: opts.harness } : {}) },
-                },
+                params: { name: opts.name, arguments: opts.args },
             }),
             signal: AbortSignal.timeout(MINT_TIMEOUT_MS),
         });
         const text = await res.text();
         if (!res.ok) {
-            warn(`record_session failed (HTTP ${res.status})`);
-            return false;
+            warn(`${opts.name} failed (HTTP ${res.status})`);
+            // 5xx is the server having a bad minute; anything else is it saying no.
+            return res.status >= 500 ? "unreachable" : "refused";
         }
         const r = toolResult(text ? JSON.parse(text) : null, warn);
-        return !!(r && typeof r === "object" && "transcriptId" in r);
+        if (r && typeof r === "object" && opts.expect in r)
+            return "ok";
+        // A 200 carrying an error result: an unknown tool on an older deployment, a
+        // revoked key, the wrong kind of key. All of them are answers, not outages.
+        return "refused";
     }
     catch (e) {
-        warn(`record_session failed: ${String(e?.message ?? e)}`);
-        return false;
+        warn(`${opts.name} failed: ${String(e?.message ?? e)}`);
+        return "unreachable";
     }
 }
+/**
+ * Record the harness's transcript id on THIS session's key (RTSC-820). Best effort and
+ * quiet: the worst case is the Dash saying "none recorded", which is what it said
+ * before this existed. Returns true once the server has it (already-recorded counts).
+ */
+export async function recordSession(opts) {
+    const out = await callTool({
+        ...opts,
+        id: RPC_ID.recordSession,
+        name: "record_session",
+        args: { transcriptId: opts.transcriptId, ...(opts.harness ? { harness: opts.harness } : {}) },
+        expect: "transcriptId",
+    });
+    return out === "ok";
+}
+/**
+ * Tell Retasc which folder a workspace key is bound to (RTSC-825). Best effort and
+ * quiet, like `recordSession`: the worst case is the Dash omitting the workspace, which
+ * is what it did before this existed. "named" once the server holds this folder
+ * (already-correct counts).
+ */
+export async function nameWorkspace(opts) {
+    const out = await callTool({
+        ...opts,
+        id: RPC_ID.nameWorkspace,
+        name: "name_workspace",
+        args: { workspace: opts.workspace },
+        expect: "workspace",
+    });
+    return out === "ok" ? "named" : out;
+}

package/dist/proxy.js

@@ -8,12 +8,12 @@
 import { createInterface } from "node:readline";
 import { hostname } from "node:os";
 import { spawn, spawnSync } from "node:child_process";
-import { dirname, resolve } from "node:path";
+import { basename, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { applyObservation, heartbeatRequest, isClaimLost, isUnauthorized, shouldReapOnClose, untrackedLeaseWarning, } from "./lib/watchdog.js";
 import { AUTO_WORKSPACE, resolveConn } from "./lib/keystore.js";
 import { toolResult as parseTool } from "./lib/toolresult.js";
-import { mintSessionKey, appendFallbackNotice, recordSession } from "./lib/session.js";
+import { mintSessionKey, appendFallbackNotice, recordSession, nameWorkspace, RPC_ID } from "./lib/session.js";
 import { readHookRecord, clearHookRecord } from "./lib/sessionHook.js";
 import { attachRoot, isLocalAttachCall, mergeAttachTool, readAttachFile, resolveAttachPath, uploadFailureMessage, uploadUrlWith, } from "./lib/attachFile.js";
 import { MAX_FETCH_BYTES, downloadFailureMessage, existingDownload, isLocalFetchCall, mergeFetchTool, resolveDownloadTarget, writeDownloadedFile, } from "./lib/fetchFile.js";
@@ -251,7 +251,7 @@ async function announceBinding() {
     try {
         const resp = await postRemote({
             jsonrpc: "2.0",
-            id: -1001,
+            id: RPC_ID.announce,
             method: "tools/call",
             params: { name: "whoami", arguments: {} },
         });
@@ -627,6 +627,20 @@ export async function runProxy() {
     // attributed to this session. stdin buffers in the OS pipe meanwhile.
     await adoptSessionKey();
     await announceBinding();
+    // RTSC-825 — the folder this session runs in IS its workspace, and this process is
+    // the only thing that knows it. Sent on the WORKSPACE key (not the session child just
+    // adopted), so a folder bound before the CLI reported one, or renamed since, corrects
+    // itself the next time an agent starts. A no-op server-side when it already matches.
+    //
+    // The BOUND folder, not the cwd. The `auto` marker resolves this key by walking up
+    // from wherever the harness was started, so a session opened in `retasc/dash` runs on
+    // `retasc`'s key — naming it `dash` would be wrong, and the next session from the root
+    // would rename it back, flapping the row on every start. Empty for a key that came
+    // from the environment rather than the keystore: that one names no folder.
+    const BOUND_FOLDER = resolved.boundPath ? basename(resolved.boundPath) : "";
+    if (KEY && BOUND_FOLDER) {
+        nameWorkspace({ url: MCP_URL, key: KEY, workspace: BOUND_FOLDER, warn: log }).catch((e) => log(`name_workspace: ${String(e?.message ?? e)}`));
+    }
     reportTranscript().catch((e) => log(`record_session: ${String(e?.message ?? e)}`));
     const timer = setInterval(() => void heartbeatAll(), HEARTBEAT_MS);
     timer.unref?.(); // the timer alone must not keep the process alive

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@retasc/cli",
-  "version": "1.40.0",
+  "version": "1.41.0",
   "description": "Retasc CLI — 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": {