@retasc/cli 1.2.4 → 1.3.1

package/dist/api.js

@@ -1,6 +1,7 @@
 import { ConvexHttpClient } from "convex/browser";
 import { makeFunctionReference } from "convex/server";
 import { loadConfig } from "./config.js";
+import { refreshSession, deviceLogin } from "./auth.js";
 // Typed-ish references to the public management functions in convex/manage.ts.
 // The CLI is a standalone package, so we reference functions by name rather than
 // importing the parent's generated api.
@@ -26,18 +27,69 @@ function client() {
         c.setAuth(cfg.token);
     return c;
 }
+// Does this error mean "the access token is missing/expired", i.e. a refresh
+// might fix it? The access-token JWT lives ~1h, so any long-lived login trips
+// this. Two shapes surface: our server functions throw `UNAUTHENTICATED …`
+// (requireUser), and the Convex platform rejects a stale JWT with "Could not
+// verify OIDC token"/"Unauthenticated". Match either, case-insensitively.
+export function isAuthError(e) {
+    const msg = String(e?.message ?? e);
+    return /unauthenticated|could not verify oidc|oidc token/i.test(msg);
+}
+/**
+ * Run an authed management call, transparently recovering from an expired
+ * access token. The two-token design (short access JWT + long refresh token) is
+ * the point: the CLI silently rides the refresh token across the hourly access
+ * boundary instead of forcing `retasc login` every hour (RTSC-165).
+ *
+ * On an auth error we try ONE recovery, then retry the call ONCE:
+ *   1. If there is no stored token at all, the user was never signed in — this
+ *      isn't an expiry, so rethrow the clean "sign in first" error rather than
+ *      launching a surprise device flow under a misleading "session expired".
+ *   2. `refreshSession()` — swap the refresh token for a fresh access token. A
+ *      transient backend failure here (network/5xx/masked "Server Error") is
+ *      rethrown by `refreshSession`, so it propagates out as a retryable error
+ *      instead of forcing a device-flow re-login on a valid session (RTSC-178).
+ *   3. If the refresh token is genuinely expired/invalid (a clean `false`, not a
+ *      throw), fall back to a full `deviceLogin()` — but only when stdout is a
+ *      TTY, since the device flow prints a code to stdout for a human to
+ *      authorize; in a captured/piped context we surface a clear "run `retasc
+ *      login`" error instead of hanging or spilling the prompt into someone's
+ *      `$(retasc …)` capture.
+ * A second auth failure after recovery is real (rethrown) — we never loop.
+ */
+async function withAuth(call) {
+    try {
+        return await call();
+    }
+    catch (e) {
+        if (!isAuthError(e))
+            throw e;
+        // No session to recover — never signed in. Surface the original error.
+        if (!loadConfig().token)
+            throw e;
+        if (await refreshSession())
+            return await call();
+        if (!process.stdout.isTTY) {
+            throw new Error("Session expired and could not refresh. Run `retasc login`.");
+        }
+        console.error("Session expired — re-authenticating with GitHub…");
+        await deviceLogin();
+        return await call();
+    }
+}
 export const api = {
-    me: () => client().query(fns.me, {}),
-    listProjects: (args) => client().query(fns.listProjects, args),
-    createOrg: (args) => client().mutation(fns.createOrg, args),
-    createProject: (args) => client().mutation(fns.createProject, args),
-    renameProjectPrefix: (args) => client().mutation(fns.renameProjectPrefix, args),
-    listKeys: (args) => client().query(fns.listKeys, args),
-    mintKey: (args) => client().action(fns.mintKey, args),
-    rotateKey: (args) => client().action(fns.rotateKey, args),
-    revokeKey: (args) => client().mutation(fns.revokeKey, args),
-    createInvite: (args) => client().action(fns.createInvite, args),
-    acceptInvite: (args) => client().mutation(fns.acceptInvite, args),
-    listInvites: (args) => client().query(fns.listInvites, args),
-    revokeInvite: (args) => client().mutation(fns.revokeInvite, args),
+    me: () => withAuth(() => client().query(fns.me, {})),
+    listProjects: (args) => withAuth(() => client().query(fns.listProjects, args)),
+    createOrg: (args) => withAuth(() => client().mutation(fns.createOrg, args)),
+    createProject: (args) => withAuth(() => client().mutation(fns.createProject, args)),
+    renameProjectPrefix: (args) => withAuth(() => client().mutation(fns.renameProjectPrefix, args)),
+    listKeys: (args) => withAuth(() => client().query(fns.listKeys, args)),
+    mintKey: (args) => withAuth(() => client().action(fns.mintKey, args)),
+    rotateKey: (args) => withAuth(() => client().action(fns.rotateKey, args)),
+    revokeKey: (args) => withAuth(() => client().mutation(fns.revokeKey, args)),
+    createInvite: (args) => withAuth(() => client().action(fns.createInvite, args)),
+    acceptInvite: (args) => withAuth(() => client().mutation(fns.acceptInvite, args)),
+    listInvites: (args) => withAuth(() => client().query(fns.listInvites, args)),
+    revokeInvite: (args) => withAuth(() => client().mutation(fns.revokeInvite, args)),
 };

package/dist/auth.js

@@ -76,3 +76,71 @@ export async function deviceLogin() {
     }
     patchConfig({ token: tokens.token, refreshToken: tokens.refreshToken });
 }
+/**
+ * Does this thrown error clearly mean "this refresh token can never mint a new
+ * session" — as opposed to a transient backend blip? RTSC-178.
+ *
+ * Note the asymmetry in how Convex Auth's refresh grant fails:
+ *   - A genuinely expired/invalid/reused refresh token does NOT throw — the
+ *     server returns `{ tokens: null }`, which `refreshSession` already reads as
+ *     `false` (no exception reaches here).
+ *   - The `catch` only sees *thrown* errors: network failures, 5xx, and the
+ *     opaque masked "Server Error" prod returns for any uncaught server-side
+ *     throw — all transient — plus the rare corrupt/unparseable stored token
+ *     (`parseRefreshToken` throws "Can't parse refresh token …").
+ *
+ * So we default to "transient" and only classify as unrefreshable when the
+ * message is unmistakably refresh-token-shaped. In prod a corrupt-token throw is
+ * itself masked to "Server Error" and so reads as transient — the deliberate,
+ * safe bias (RTSC-165 saw exactly this masking): never drag a user with a valid
+ * session through the whole device flow on a one-off hiccup. A truly dead
+ * refresh token still reaches `deviceLogin` via the `{ tokens: null }` → `false`
+ * path above, unaffected by this classifier.
+ */
+export function isUnrefreshableRefreshToken(err) {
+    const msg = String(err?.message ?? err);
+    return /can'?t parse refresh token|cannot parse refresh token|invalid refresh token|expired refresh token|refresh token (?:is |has )?(?:invalid|expired)/i.test(msg);
+}
+/**
+ * Silently mint a fresh access token from the stored refresh token and persist
+ * the rotated pair to ~/.retasc/config.json.
+ *
+ * Convex Auth access tokens (the JWT in `token`) live only ~1h; the refresh
+ * token is long-lived (session default ~30d) and exists precisely to swap for a
+ * new access token without re-running the device flow. Calling `auth:signIn`
+ * with `{ refreshToken }` (no provider/params) is Convex Auth's refresh grant —
+ * it returns `{ tokens: { token, refreshToken } }` with BOTH rotated (refresh
+ * tokens are single-use; the old one is invalidated), so we must write the new
+ * pair back immediately and never reuse the old refresh token.
+ *
+ * Returns true on success (config now holds a fresh session), false when there
+ * is no refresh token or the grant is cleanly rejected (expired/invalid/reused,
+ * which the server signals as `{ tokens: null }`) — the caller then falls back
+ * to a full `deviceLogin()`. A *transient* failure (network/5xx/opaque backend
+ * blip) is RE-THROWN so the caller can surface a retryable error instead of
+ * forcing a needless device-flow re-login (RTSC-178). Never prints token values.
+ */
+export async function refreshSession() {
+    const cfg = loadConfig();
+    if (!cfg.refreshToken)
+        return false;
+    try {
+        const convex = new ConvexHttpClient(cfg.deploymentUrl);
+        const res = await convex.action(signIn, { refreshToken: cfg.refreshToken });
+        const tokens = res?.tokens;
+        if (!tokens?.token)
+            return false;
+        patchConfig({ token: tokens.token, refreshToken: tokens.refreshToken });
+        return true;
+    }
+    catch (err) {
+        // A clearly refresh-token-shaped rejection means we genuinely cannot
+        // refresh — fall through to device login. Anything else (network, 5xx,
+        // masked prod "Server Error") is transient: rethrow so `withAuth` surfaces a
+        // retryable error rather than dragging a valid session through the device
+        // flow at an hourly access-token boundary.
+        if (isUnrefreshableRefreshToken(err))
+            return false;
+        throw err;
+    }
+}

package/dist/config.js

@@ -1,6 +1,7 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { mkdirSync, readFileSync, writeFileSync, existsSync, chmodSync } from "node:fs";
+import { mkdirSync, readFileSync, writeFileSync, renameSync, unlinkSync, existsSync, chmodSync, } from "node:fs";
+import { randomUUID } from "node:crypto";
 // Production defaults. Overridable via env for dev/testing.
 //   RETASC_DEPLOYMENT_URL — Convex deployment (.cloud) for management calls
 //   RETASC_MCP_URL        — the MCP endpoint agents connect to
@@ -8,20 +9,41 @@ export const DEFAULTS = {
     deploymentUrl: process.env.RETASC_DEPLOYMENT_URL ?? "https://unique-lyrebird-934.convex.cloud",
     mcpUrl: process.env.RETASC_MCP_URL ?? "https://mcp.retasc.com/mcp",
 };
-const DIR = join(homedir(), ".retasc");
-const FILE = join(DIR, "config.json");
+/** The dir config lives in. RETASC_DIR overrides it (tests, sandboxes) — same
+ *  knob the keystore reads, so the two stay co-located. */
+function configDir() {
+    return process.env.RETASC_DIR || join(homedir(), ".retasc");
+}
 export function configPath() {
-    return FILE;
+    return join(configDir(), "config.json");
 }
 export function loadConfig() {
+    const FILE = configPath();
     let stored = {};
     if (existsSync(FILE)) {
+        let raw;
         try {
-            stored = JSON.parse(readFileSync(FILE, "utf8"));
+            raw = readFileSync(FILE, "utf8");
         }
         catch {
-            // Corrupt config — start fresh rather than crash.
-            stored = {};
+            // A read that FAILS (file lock, EIO, EMFILE, stale NFS handle) is transient,
+            // not corruption. Leave the file untouched and fall back to defaults for this
+            // run — self-heal next time — rather than renaming a possibly-valid config
+            // aside and turning a blip into a permanent logout.
+            raw = undefined;
+        }
+        if (raw !== undefined) {
+            try {
+                stored = JSON.parse(raw);
+            }
+            catch {
+                // Read succeeded but the bytes aren't valid JSON → genuinely corrupt/
+                // truncated (e.g. an interrupted write). Preserve them under a backup name
+                // rather than silently discarding — the file may still hold the only copy
+                // of the user's tokens, recoverable by hand. Then start fresh.
+                backupCorruptConfig(FILE);
+                stored = {};
+            }
         }
     }
     // Defaults fill in; a saved value always wins.
@@ -35,19 +57,49 @@ export function loadConfig() {
         defaultProjectPrefix: stored.defaultProjectPrefix,
     };
 }
-export function saveConfig(cfg) {
-    // Create the dir user-only and the file 0600 on the initial write, so tokens
-    // never exist world-readable even briefly (the chmod below only closes a
-    // pre-existing 0644 file — it can't undo a world-readable creation window).
-    mkdirSync(DIR, { recursive: true, mode: 0o700 });
-    writeFileSync(FILE, JSON.stringify(cfg, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
-    // Tokens live here — keep it user-only readable (covers overwriting an
-    // existing 0644 file, where the write mode above doesn't apply).
+/** Move a corrupt config aside to a unique sibling so a human can recover any
+ *  tokens it still holds. Best effort — never throw from the load path. */
+function backupCorruptConfig(file) {
     try {
-        chmodSync(FILE, 0o600);
+        renameSync(file, `${file}.corrupt-${randomUUID()}`);
     }
     catch {
-        /* best effort (e.g. Windows) */
+        /* best effort — if we can't back it up, saveConfig will overwrite it */
+    }
+}
+export function saveConfig(cfg) {
+    const dir = configDir();
+    const FILE = configPath();
+    // Create the dir user-only and the temp file 0600, so tokens never exist
+    // world-readable even briefly (the chmod below only closes a pre-existing
+    // 0644 file — it can't undo a world-readable creation window).
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    // Atomic write: fully write a sibling temp file, then rename it over the real
+    // one. rename(2) is atomic on POSIX, so a crash or an interleaved write leaves
+    // either the old complete config or the new one — never a truncated file that
+    // loadConfig would read as "logged out". The temp lives in the same dir so the
+    // rename stays on one filesystem (a cross-device rename is not atomic).
+    const tmp = join(dir, `.config.json.${randomUUID()}.tmp`);
+    const body = JSON.stringify(cfg, null, 2) + "\n";
+    try {
+        writeFileSync(tmp, body, { encoding: "utf8", mode: 0o600 });
+        try {
+            chmodSync(tmp, 0o600); // keep user-only if a umask/prior file loosened it
+        }
+        catch {
+            /* best effort (e.g. Windows) */
+        }
+        renameSync(tmp, FILE);
+    }
+    catch (err) {
+        // Don't leave a stray temp file behind on failure.
+        try {
+            unlinkSync(tmp);
+        }
+        catch {
+            /* already gone */
+        }
+        throw err;
     }
 }
 export function patchConfig(patch) {

package/dist/index.js

@@ -434,7 +434,11 @@ program
     .option("--prune", "Delete reapable branches + worktrees (default: dry-run, just report)")
     .option("--force", "Also delete orphans (issue done but branch unmerged)")
     .option("--json", "Emit the reconciled branch table as JSON")
-    .action((opts) => tidyAction(opts).catch(fail));
+    .option("--only <RTSC-NN>", "Scope the sweep to a single issue's branch (used by the MCP auto-reap)")
+    .action((opts) => 
+// Normalize --only to the canonical uppercase id so it matches the branch ids
+// scan() derives (rtsc-181/… → RTSC-181), same as `done` does for --id.
+tidyAction({ ...opts, only: opts.only ? String(opts.only).toUpperCase() : undefined }).catch(fail));
 program
     .command("done")
     .description("Mark the current issue (rtsc-NN/ branch, or --id) done and tear down its worktree+branch.")

package/dist/lib/watchdog.js

@@ -38,15 +38,59 @@ export function applyObservation(leases, o) {
     }
     // Releases / terminal status drop the lease — the issue is named in the REQUEST.
     const id = typeof o.args?.identifier === "string" ? o.args.identifier : undefined;
-    if (id) {
-        if (o.toolName === "release_issue")
-            leases.delete(id);
-        if (o.toolName === "save_issue") {
-            const status = o.args?.status;
-            if (status === "done" || status === "canceled")
-                leases.delete(id);
-        }
-    }
+    if (id && o.toolName === "release_issue")
+        leases.delete(id);
+    const closeId = terminalCloseId(o);
+    if (closeId)
+        leases.delete(closeId);
+}
+/**
+ * The issue id to reap if this observation is a terminal close (done|canceled) via
+ * `save_issue`, else undefined. This is the SAME rule applyObservation uses to drop
+ * the lease — factored out so "which calls end an issue" lives in one place and the
+ * proxy's auto-reap (RTSC-181) can't drift from the lease bookkeeping. The caller
+ * decides whether it actually held the lease and whether the call succeeded
+ * (`isToolError`) before acting — this only classifies the request shape.
+ */
+export function terminalCloseId(o) {
+    if (o.toolName !== "save_issue")
+        return undefined;
+    const id = typeof o.args?.identifier === "string" ? o.args.identifier : undefined;
+    if (!id)
+        return undefined;
+    const status = o.args?.status;
+    return status === "done" || status === "canceled" ? id : undefined;
+}
+/**
+ * Did a tools/call result come back as an MCP error envelope (`{ isError: true }`)?
+ * Used to gate side effects — the proxy must never reap a branch off a `save_issue`
+ * that actually FAILED server-side. Distinct from isClaimLost (which matches a
+ * specific error string); this is the generic "did the tool error at all" check.
+ */
+export function isToolError(result) {
+    return (!!result && typeof result === "object" && result.isError === true);
+}
+/**
+ * The full RTSC-181 reap gate as ONE pure decision: given an observed tool call and
+ * the leases this session holds, return the issue id to reap — or undefined. Reap ONLY
+ * when ALL hold:
+ *   1. it's a terminal close (save_issue done|canceled),
+ *   2. of an issue THIS session actually claimed (in `leases` — never someone else's),
+ *   3. and the call genuinely succeeded — a truthy payload that is not an error
+ *      envelope. A transport-level failure yields an undefined result (no envelope to
+ *      catch); requiring a truthy payload means we never reap off a failed close.
+ * This is the security-critical check — keeping it pure makes every branch testable
+ * (the proxy just spawns on a non-undefined return).
+ */
+export function shouldReapOnClose(o, leases) {
+    const id = terminalCloseId(o);
+    if (!id)
+        return undefined;
+    if (!leases.has(id))
+        return undefined;
+    if (!o.result || isToolError(o.result))
+        return undefined;
+    return id;
 }
 /** A JSON-RPC `heartbeat` tool call for one lease (the proxy's timer sends these). */
 export function heartbeatRequest(rpcId, issueId, claimToken) {

package/dist/proxy.js

@@ -7,7 +7,10 @@
 // no watchdog. Self-enforcing: no proxy → no Retasc tools → can't orphan a lease.
 import { createInterface } from "node:readline";
 import { hostname } from "node:os";
-import { applyObservation, heartbeatRequest, isClaimLost, } from "./lib/watchdog.js";
+import { spawn, spawnSync } from "node:child_process";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { applyObservation, heartbeatRequest, isClaimLost, shouldReapOnClose, } from "./lib/watchdog.js";
 import { resolveConn } from "./lib/keystore.js";
 import { toolResult as parseTool } from "./lib/toolresult.js";
 import { mintSessionKey, appendFallbackNotice } from "./lib/session.js";
@@ -30,6 +33,87 @@ let sessionKeyFallback = false;
 function log(msg) {
     process.stderr.write(`[retasc-watchdog] ${msg}\n`);
 }
+// RTSC-181: closing an issue over MCP (save_issue status:done) marks it done on the
+// control plane but the server never touches git — so the branch/worktree orphans.
+// The proxy is the local hands: when it sees a session's own claim close terminally,
+// it reaps that issue's branch out-of-band via the CLI's existing `tidy --prune`,
+// which reuses every safety guard (skips dirty/unmerged/current-branch). Resolved
+// once at startup; null if we're not in a git repo (nothing to reap).
+const MAIN_CHECKOUT = resolveMainCheckout();
+// The compiled CLI entrypoint (dist/index.js) — resolved relative to this module so
+// it's correct however the proxy was launched (not process.argv, which a wrapper
+// could rewrite). Reaps re-invoke it as `retasc tidy`.
+const CLI_ENTRY = fileURLToPath(new URL("./index.js", import.meta.url));
+// Issues whose reap child is in flight — so a duplicate/retried close doesn't spawn
+// two concurrent teardowns racing on the same branch.
+const reaping = new Set();
+// Reaps are SERIALIZED through this chain: concurrent `tidy` children mutating the
+// same main checkout contend on `.git` locks (index.lock, ref locks) — a wave-close
+// (next_batch → N × save_issue done) would otherwise fire N parallel worktree/branch
+// deletes and hit "cannot lock ref" errors + partial teardown. One at a time avoids it.
+let reapChain = Promise.resolve();
+const REAP_TIMEOUT_MS = 60_000; // a stuck git (e.g. a credential prompt) must not wedge the queue
+/** The main checkout root (worktree/branch ops always target it), or null if not in
+ *  a git repo. `--git-common-dir` resolves to the MAIN `.git` even from a worktree. */
+function resolveMainCheckout() {
+    const r = spawnSync("git", ["rev-parse", "--git-common-dir"], { encoding: "utf8" });
+    if (r.status !== 0)
+        return null;
+    const commonDir = (r.stdout ?? "").trim();
+    return commonDir ? dirname(resolve(commonDir)) : null;
+}
+/**
+ * Reap a terminally-closed issue's branch/worktree, out-of-band (RTSC-181). Enqueues
+ * a `retasc tidy --prune --only <id>` run (serialized — see `reapChain`) as a SEPARATE
+ * process rooted at the main checkout so (a) blocking git never stalls the proxy's
+ * stdio loop, and (b) cwd is the main checkout, not the agent's worktree — so `tidy`'s
+ * "you're inside its worktree" guard doesn't skip the very tree we mean to remove.
+ * `tidy` still enforces every safety check: an unmerged (or dirty) branch is left as an
+ * orphan, never force-deleted — so only a clean, merged worktree is ever removed.
+ */
+function reapClosedIssue(issueId) {
+    if (!MAIN_CHECKOUT)
+        return; // not in a git repo — nothing local to reap
+    if (reaping.has(issueId))
+        return; // a teardown for this issue is already queued/running
+    reaping.add(issueId);
+    // Chain after any in-flight reap so git ops on the shared checkout never overlap.
+    reapChain = reapChain.then(() => runReap(issueId));
+}
+/** Run one `tidy --prune --only` child to completion (resolve on exit/error/timeout).
+ *  Never rejects — a failed reap is best-effort cleanup, logged, never fatal. */
+function runReap(issueId) {
+    return new Promise((resolve) => {
+        log(`${issueId} closed → reaping its branch/worktree…`);
+        const child = spawn(process.execPath, [CLI_ENTRY, "tidy", "--prune", "--only", issueId], {
+            cwd: MAIN_CHECKOUT,
+            env: process.env,
+            // stdout is ignored (tidy reports on stderr); stderr inherits so its reap log
+            // lands in the same MCP stderr stream as the rest of the watchdog's output.
+            stdio: ["ignore", "ignore", "inherit"],
+        });
+        let settled = false;
+        const finish = () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reaping.delete(issueId);
+            resolve();
+        };
+        const timer = setTimeout(() => {
+            log(`reap of ${issueId} timed out — killing it`);
+            child.kill("SIGKILL"); // 'exit' still fires → finish() runs
+        }, REAP_TIMEOUT_MS);
+        timer.unref?.();
+        child.on("error", (e) => {
+            log(`reap of ${issueId} couldn't start: ${String(e?.message ?? e)}`);
+            finish();
+        });
+        child.on("exit", finish);
+        child.unref?.(); // a pending reap must not keep the proxy alive
+    });
+}
 async function postRemote(body) {
     const res = await fetch(MCP_URL, {
         method: "POST",
@@ -120,18 +204,25 @@ async function handleLine(line) {
     // Watch tools/call traffic for claims/releases (request args + result), and
     // flag the workspace-key fallback on whoami so the AGENT sees the degraded
     // state (RTSC-143) — the startup stderr warning only reaches the MCP logs.
+    let reapId;
     if (msg.method === "tools/call" && resp) {
-        applyObservation(leases, {
-            toolName: msg.params?.name,
-            args: msg.params?.arguments,
-            result: toolResult(resp, msg.params?.name),
-        });
+        const result = toolResult(resp, msg.params?.name);
+        const obs = { toolName: msg.params?.name, args: msg.params?.arguments, result };
+        // Decide the reap BEFORE applyObservation drops the lease (the gate checks lease
+        // ownership). Pure decision — see shouldReapOnClose. We act on it AFTER relaying
+        // the response, below (RTSC-181).
+        reapId = shouldReapOnClose(obs, leases);
+        applyObservation(leases, obs);
         appendFallbackNotice(msg.params?.name, resp, sessionKeyFallback);
     }
     // Relay the response (requests have an id; notifications don't).
     if (resp != null && msg.id !== undefined) {
         process.stdout.write(JSON.stringify(resp) + "\n");
     }
+    // Reap only after the tool result is on the wire — spawns its own process, so git
+    // never delays the response the agent is blocked on (RTSC-181).
+    if (reapId)
+        reapClosedIssue(reapId);
 }
 async function heartbeatAll() {
     for (const [issueId, token] of [...leases]) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@retasc/cli",
-  "version": "1.2.4",
+  "version": "1.3.1",
   "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": {
@@ -46,7 +46,7 @@
     "convex": "^1.41.0"
   },
   "devDependencies": {
-    "@types/node": "^22.0.0",
+    "@types/node": "^26.1.0",
     "typescript": "^5.6.0"
   }
 }