@retasc/cli 1.2.1 → 1.2.3

package/dist/commands/claim.js

@@ -1,7 +1,8 @@
 import { spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { basename, dirname, resolve, sep } from "node:path";
-import { resolveMcpConn, readMcpJson, mcpCall, parseClaimResult, planWorktree, isValidIssueId, } from "../lib/claim.js";
+import { resolveMcpConn, readMcpJson, mcpCall, parseClaimResult, planWorktree, isValidIssueId, normalizeIssueId, workspacePrefix, } from "../lib/claim.js";
+import { loadConfig } from "../config.js";
 function git(args, cwd) {
     return spawnSync("git", args, { encoding: "utf8", cwd });
 }
@@ -28,6 +29,50 @@ export async function claimAction(opts) {
         note("  (Looked at $RETASC_MCP_KEY and ./.mcp.json.)");
         process.exit(1);
     }
+    // RTSC-148: resolve the requested issue id up front — a positional (`claim 143`,
+    // `claim RTSC-143`) or --id, normalized to PREFIX-NN. An unresolvable reference
+    // fails HERE; it must never fall through to "claim whatever is next".
+    // A bare number expands against the WORKSPACE's prefix (whoami over this
+    // workspace's key — the key decides the org/project), falling back to the
+    // global config only if the server can't be asked.
+    let prefix;
+    let prefixResolved = false;
+    let requestedId;
+    for (const [label, raw] of [
+        ["issue", opts.issueArg],
+        ["--id", opts.id],
+    ]) {
+        // Only ABSENT skips — an empty string (e.g. `claim "$UNSET_VAR"`) must hit
+        // the loud-failure path below, not fall through to next_issue.
+        if (raw === undefined)
+            continue;
+        if (/^\d+$/.test(raw.trim()) && !prefixResolved) {
+            prefix = (await workspacePrefix(conn)) ?? loadConfig().defaultProjectPrefix;
+            prefixResolved = true;
+        }
+        const norm = normalizeIssueId(raw, prefix);
+        if (!norm) {
+            if (/^\d+$/.test(raw.trim()) && !prefix) {
+                note(`✗ "${raw}" is a bare number and the project prefix couldn't be resolved from this workspace.`);
+                note("  Use the full id (e.g. RTSC-" + raw.trim() + ").");
+            }
+            else {
+                note(`✗ "${raw}" doesn't look like an issue id (expected RTSC-NN or a bare number).`);
+            }
+            process.exit(1);
+        }
+        if (requestedId && requestedId !== norm) {
+            note(`✗ Conflicting issue ids: positional "${requestedId}" vs ${label} "${norm}". Pass just one.`);
+            process.exit(1);
+        }
+        requestedId = norm;
+    }
+    // --mine filters the next_issue pull; on a targeted claim it would be
+    // silently ignored — reject instead of letting the intent evaporate.
+    if (requestedId && opts.mine) {
+        note(`✗ --mine only applies when pulling the next issue; drop it to claim ${requestedId} directly.`);
+        process.exit(1);
+    }
     const makeWorktree = opts.worktree !== false;
     // Must be in a git repo to place the worktree. Resolve the *main* checkout so
     // worktrees are always siblings of it, even when claiming from another worktree.
@@ -52,8 +97,8 @@ export async function claimAction(opts) {
     // --- claim over MCP ------------------------------------------------------
     let claim;
     try {
-        const result = opts.id
-            ? await mcpCall(conn, "claim_issue", { identifier: opts.id })
+        const result = requestedId
+            ? await mcpCall(conn, "claim_issue", { identifier: requestedId })
             : await mcpCall(conn, "next_issue", opts.mine ? { mine: true } : {});
         claim = parseClaimResult(result);
     }
@@ -62,9 +107,9 @@ export async function claimAction(opts) {
         note(`✗ ${msg}`);
         // Re-claiming an issue you already hold is the "resume my own work" case —
         // point at the worktree instead of leaving the user stuck on the error.
-        if (opts.id && /ALREADY_CLAIMED/.test(msg) && makeWorktree) {
-            note(`  ${opts.id} is held. If it's your session, resume in ${parentDir}/${repoName}-${opts.id.toLowerCase()}`);
-            note(`  or \`retasc release ${opts.id}\` first.`);
+        if (requestedId && /ALREADY_CLAIMED/.test(msg) && makeWorktree) {
+            note(`  ${requestedId} is held. If it's your session, resume in ${parentDir}/${repoName}-${requestedId.toLowerCase()}`);
+            note(`  or \`retasc release ${requestedId}\` first.`);
         }
         process.exit(1);
     }

package/dist/index.js

@@ -414,12 +414,19 @@ function addClaimFlags(cmd) {
         .option("--print-path", "Print only the worktree path on stdout (for `cd \"$(…)\"`)")
         .option("--json", "Emit the claim + worktree as JSON");
 }
+// RTSC-148: `claim` takes the issue as a positional too (`retasc claim 143` /
+// `retasc claim RTSC-143`). Excess arguments are rejected loudly on both
+// commands — Commander otherwise silently drops an undeclared positional, which
+// turned "claim this specific issue" into "claim whatever is next".
 addClaimFlags(program
     .command("claim")
-    .description("Claim an issue (--id, or the next unblocked) and drop into a fresh worktree.")).action((opts) => claimAction(opts).catch(fail));
+    .description("Claim an issue (RTSC-NN, a bare number, --id, or the next unblocked) and drop into a fresh worktree.")
+    .argument("[issue]", "Issue to claim, e.g. RTSC-143 or 143 (defaults to the next unblocked)")
+    .allowExcessArguments(false)).action((issue, opts) => claimAction({ ...opts, issueArg: issue }).catch(fail));
 addClaimFlags(program
     .command("next")
-    .description("Claim the next unblocked issue and drop into a fresh worktree (alias of `claim`).")).action((opts) => claimAction(opts).catch(fail));
+    .description("Claim the next unblocked issue and drop into a fresh worktree (alias of `claim`).")
+    .allowExcessArguments(false)).action((opts) => claimAction(opts).catch(fail));
 // --- branch hygiene (close the worktree+branch claim opened) ----------------
 program
     .command("tidy")

package/dist/lib/claim.js

@@ -60,6 +60,36 @@ export function slugFromTitle(title, max = 50) {
 export function isValidIssueId(id) {
     return typeof id === "string" && /^[A-Za-z][A-Za-z0-9]*-\d+$/.test(id);
 }
+/**
+ * Normalize a user-typed issue reference (`143`, `rtsc-143`, `RTSC-143`) to the
+ * canonical `PREFIX-NN` form. A bare number needs `defaultPrefix` (from the
+ * logged-in project) to be resolvable. Returns null when the input can't be an
+ * issue id — the caller decides how to fail loudly (RTSC-148: a typo must never
+ * silently fall through to `next_issue`).
+ */
+/**
+ * The workspace's project prefix, asked of the server over the workspace's own
+ * key (`whoami`). Org/project routing IS the key — the global config's prefix
+ * may belong to a different workspace, so this is the authoritative source for
+ * expanding a bare issue number. Best-effort: undefined on any failure.
+ */
+export async function workspacePrefix(conn, fetchImpl = fetch) {
+    try {
+        const who = (await mcpCall(conn, "whoami", {}, fetchImpl));
+        const p = who?.project?.prefix;
+        return typeof p === "string" && p ? p : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function normalizeIssueId(input, defaultPrefix) {
+    const s = input.trim();
+    if (/^\d+$/.test(s)) {
+        return defaultPrefix ? `${defaultPrefix.toUpperCase()}-${s}` : null;
+    }
+    return isValidIssueId(s) ? s.toUpperCase() : null;
+}
 /**
  * Derive the branch + sibling worktree path from an issue, matching the CLAUDE.md
  * convention: branch `rtsc-NN/<slug>`, worktree dir `../<repo>-rtsc-NN`.

package/dist/lib/watchdog.js

@@ -57,10 +57,33 @@ export function heartbeatRequest(rpcId, issueId, claimToken) {
         params: { name: "heartbeat", arguments: { identifier: issueId, claimToken } },
     };
 }
-/** A heartbeat result of CLAIM_LOST means the lease is gone — stop tracking it. */
+/**
+ * A heartbeat CLAIM_LOST means the lease is gone — stop tracking it.
+ *
+ * The server throws `Error("CLAIM_LOST: …")` (convex/lib/claims.ts), and http.ts
+ * surfaces that as an MCP tool ERROR: `{ isError: true, content:[{text:"CLAIM_LOST: …"}] }`.
+ * Match ONLY that signal (or a top-level `error`/`code` field, for a future
+ * structured shape) — NEVER `JSON.stringify` the whole result and regex it, or a
+ * benign payload field that merely CONTAINS "CLAIM_LOST" (an issue title, a
+ * checkpoint note quoting an error, a comment body) would silently drop a live
+ * lease and let the reclaimer hand our work to someone else (RTSC-150).
+ */
 export function isClaimLost(result) {
     if (!result || typeof result !== "object")
         return false;
-    const text = JSON.stringify(result);
-    return /CLAIM_LOST/.test(text);
+    const r = result;
+    // A structured error signal on a top-level field (belt-and-suspenders; also the
+    // shape the older unit test asserts). Bounded to top-level scalars, not nested.
+    if (r.code === "CLAIM_LOST")
+        return true;
+    if (typeof r.error === "string" && /CLAIM_LOST/.test(r.error))
+        return true;
+    // The live shape: only an MCP error envelope, and only its text blocks — success
+    // payloads (isError absent/false) are never treated as a lost claim.
+    if (r.isError !== true || !Array.isArray(r.content))
+        return false;
+    return r.content.some((c) => c !== null &&
+        typeof c === "object" &&
+        typeof c.text === "string" &&
+        /CLAIM_LOST/.test(c.text));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@retasc/cli",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "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": {