@viraatdas/rudder 3.9.13 → 4.0.0-alpha.2

package/README.md

@@ -12,11 +12,18 @@
 [![Website](https://img.shields.io/badge/site-rudder.exla.ai-111111.svg)](https://rudder.exla.ai)
 
 Rudder is a TUI for managing coding agents. Run Claude Code, Codex and opencode
-side by side in one native dashboard: every task you type gets its own isolated
-jj workspace, so agents never step on each other. See which agent needs you,
+side by side in one native dashboard. Implementation workers get isolated
+jj workspaces. See which agent needs you,
 approve prompts, steer any agent mid-turn, and merge the results back with one
-key. `/main` puts an agent in the main checkout when you want one there, and
-`/plan` turns a bigger goal into a reviewed multi-agent DAG.
+key. Type a goal and Rudder chooses discussion, one worker, or a proposed
+multi-agent plan. `/main` explicitly selects the main checkout.
+
+The [v4 architecture and rollout](https://github.com/exla-ai/rudder/blob/main/PLAN.md) covers the distributed workspace,
+build-cache and persistent-engine rewrite. Early milestones do not imply that
+the complete storage/engine migration has shipped.
+
+This branch contains v4 alpha foundations. Install the prerelease with
+`npm install -g @exla/rudder@next`; the stable package remains on `latest`.
 
 > **AI agents and contributors:** this README is for using Rudder. If you are
 > an AI agent (or a human) working on the Rudder codebase itself, read
@@ -76,12 +83,19 @@ rudder
 ```
 
 With no arguments, `rudder` opens the dashboard. Type a task in the bottom input
-and press `Enter`: Rudder starts one worker for it in its own jj workspace. It
-lands in Review when done and merges back with `m`. Use `/main <task>` for an
-agent that works directly in the main checkout (for release, push and deploy
-work), `/gam <task>` to pair a builder with a reviewer from another model,
-`/plan <task>` when you want a reviewed multi-agent DAG, or `/swarm [n] <task>`
-to run many competing experiments at one goal and keep the ones that work.
+and press `Enter`. A narrow implementation starts one isolated worker; a broad
+architectural implementation proposes a plan for approval. Questions and
+plan-only requests open one discussion session without implementation workers.
+An isolated worker lands in Review and merges back with `m`. Use `/main <task>`
+for an agent working directly in the checkout, including release work.
+`/swarm [n] <task>` remains available for competing experiments.
+
+Routing works locally without an API key. To opt into bounded model-assisted
+routing, set `RUDDER_TASK_ROUTING=decisions` and `OPENAI_API_KEY`; a failed or
+slow classifier falls back to local rules. The classifier chooses a workflow;
+your selected agent still writes the plan. `/plan` remains a compatibility
+shortcut. Standalone `/gam` and `/nudge` have been retired; send a follow-up to
+the agent's pane and resume a stopped agent explicitly.
 
 If a task needs shared local context like API tokens, private URLs, account ids,
 or environment values, save it with `/share <text>` in the task input. Rudder
@@ -121,7 +135,7 @@ to `~/.rudder/config.json`.
 │ task list     │ live Claude Code or Codex terminal           │
 │ status/model  │ DAG-over-orchestrator, scrollback, review    │
 ├───────────────┴────────────────────────────────────────────┤
-│ task input: main owner by default, /plan DAG, /run isolated   │
+│ task input: discuss, work, or propose a plan automatically   │
 └──────────────────────────────────────────────────────────────┘
 ```
 
@@ -179,8 +193,8 @@ your browser. The board is a second control surface, not just a monitor: open a
 task to send an update while it runs, or request changes from Review to resume
 the same agent in the same workspace. The task's update thread records your
 directions alongside the latest worker activity. `+ Task` follows the same
-end-to-end main-owner path as typing in the dashboard task pane; use `/plan` in
-the native dashboard for an explicit DAG.
+task routing as the native dashboard when that dashboard owns the project.
+The standalone board retains its detached-worker workflow.
 
 The board also works on its own with `rudder board`: in that mode updates
 redirect or resume the detached worker directly and move revised work back
@@ -309,9 +323,7 @@ running, Rudder also exposes matching project skills; the orchestrator can write
 | --- | --- |
 | `/model` | Pick provider, then model, then effort |
 | `/fast` | Fast mode for new agents: flagship model at low effort (Claude opus / Codex gpt-6.1-sol); `/model` switches back |
-| `/plan <text>` | Start the orchestrator / DAG planner |
 | `/swarm [n] <task>` | Run `n` competing experiments at one goal (leave `n` out and the swarm decides). A conversational planner proposes the experiment list; talk to it to change the list, then press `Enter` to launch. Every experiment runs on the current model in its own workspace, at most 18 at a time (`swarm.maxParallel`), and none merges on its own |
-| `/gam [main] [<model>] <task>` | Generator + adversarial reviewer pair: split panes, the reviewer questions every round, steers the generator mid-turn, and can stop the run; only the generator edits. `^W t` shows the dialogue between them |
 | `/share <text>` | Save gitignored shared context for all agents in `RUDDER_SHARED.md` |
 | `/main [task]` or `/m` | Start an agent in the main checkout instead of its own workspace |
 | `/review-all` | Combine completed workspaces and start a Codex review-all agent |
@@ -360,17 +372,17 @@ disable both capabilities so planning cannot cause external side effects.
 
 ## One-Off and Planning
 
-Type a task in the bottom input and Rudder starts one worker for it in its own
-jj workspace. The same thing happens no matter what else is on screen: a
-standalone worker that touches nothing but its workspace, lands in Review when
-done, and merges back with `m` or `/merge-all`. A slash command Rudder does not
+Type a task in the bottom input. Rudder chooses discussion, one isolated worker
+or a proposed plan from the request. A standalone implementation worker touches
+its workspace, lands in Review and merges back with `m` or `/merge-all`.
+A slash command Rudder does not
 know is reported as unknown instead of being sent to an agent as a task.
 
 Use `/main <task>` for an agent in the main checkout itself, for work that has to
 happen there (release, push, deploy). Several may run there at once; they edit
 the same tree, so they can overwrite each other, and Rudder says so in the
-activity log rather than stopping you. Use `/plan <text>` when you want the
-orchestrator / DAG path: the read-only planner decomposes the task, then separate
+activity log rather than stopping you. Larger implementation goals can select
+the DAG path automatically: the read-only planner decomposes the task, then separate
 isolated workers implement its nodes. To change a running plan, talk to that
 orchestrator's own pane.
 
@@ -448,7 +460,7 @@ session, main checkout) instead of forking it into a worker.
 
 ## Worktrees and merging
 
-**Who merges what:** planned `/plan` DAG nodes integrate into your checkout
+**Who merges what:** approved DAG nodes integrate into your checkout
 **automatically** as soon as they finish — no per-node confirmation — so
 dependent nodes unblock and the chain keeps flowing (their row shows
 `done · auto-merging`, then `merged locally`; the final gate runs the repo's
@@ -577,11 +589,21 @@ reach an agent (a menu is open in its pane) says so instead of vanishing. Claude
 panes in the cloud also run with Remote Control, so they appear in the Claude
 app too.
 
-**Previews.** Put a Tailscale auth key in the vault
-(`rudder cloud secrets set TS_AUTHKEY`) and the home machine joins your tailnet
-as `rudder-home`. Any dev server an agent starts there shows up as an HTTPS link
-(`https://rudder-home.<tailnet>.ts.net:<port>`) in `rudder cloud home` and the
-phone app.
+**Previews.** Enroll the home machine with a Tailscale auth key in the vault
+(`rudder cloud secrets set TS_AUTHKEY`). It reuses its persisted login on later
+boots. Connect your laptop to the same tailnet and run `rudder cloud preview`
+from the project to open its ready dev server, or `rudder cloud preview --list`
+to inspect the links. Pass a port when several servers are running.
+
+Ready project previews also appear in the app. Rudder checks the listener and
+tailnet state before advertising it, removes stale links and prefers private
+HTTPS Serve. If tailnet certificates are unavailable, the link identifies a
+private HTTP fallback. This does not create a public Funnel. Discovery polls
+every five seconds; first-time enrollment/certificate setup can take longer.
+
+Home project tasks in the web/phone app use automatic planning. Legacy task
+sails retain direct execution in this initial v4 track; they refuse discussion
+or decomposition requests and point you to the home dashboard instead.
 
 Inside the dashboard, `/login` starts browser auth and `/cloud` toggles cloud
 mode: while it is on, tasks you type start as workers in Rudder Cloud and keep

package/dist/cloud.js

@@ -14,6 +14,7 @@ import { runLaptopOnboarding } from "./onboarding.js";
 import { renderQrForTerminal } from "./qr.js";
 import { describeSync, exportWork, importWork, syncCheckout } from "./checkout-sync.js";
 import { pullFromHome } from "./cloud-pull.js";
+import { cloudPreviews, localTailnetStatus, previewAccess, previewReachable } from "./tailscale-preview.js";
 import { ensureDir, commandExists, expandHome, isTty, newRunId, nowIso, pathExists, promptConfirm, promptText, promptSelect, promptSecret, readJson, runCommand, shortenHome, shellQuote, writeJson, } from "./util.js";
 const DEFAULT_LOGIN_INTERVAL_MS = 2000;
 const DEFAULT_LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
@@ -136,6 +137,9 @@ export async function runCloudCommand(command, args, options = {}) {
         case "home":
             await homeCommand(rest, options);
             return;
+        case "preview":
+            await cloudPreviewCommand(rest, options);
+            return;
         case "doctor":
             await cloudDoctor(options);
             return;
@@ -3734,6 +3738,8 @@ Usage:
       holds every repo) and attach to its dashboard. --snapshot uploads this
       folder to its own machine instead.
   rudder cloud home [status|start|stop|open <owner/repo>]
+  rudder cloud preview [port] [--list] [--json]
+      open this repo's private Tailscale preview; list ready URLs with --list
   rudder cloud move [runId...] [--yes]
       move this repo's unfinished agents (or just the named ones) to the
       home machine: their jj changes and conversations go along, nothing is
@@ -4700,6 +4706,71 @@ async function homeAgentsCommand(client, sub, args, options) {
         ? "The home machine is asleep; it deletes them as soon as it is back."
         : "Deleted on the home machine.");
 }
+async function cloudPreviewCommand(args, options) {
+    const listOnly = options.json || args.includes("--list");
+    const positional = args.filter((arg) => arg !== "--list");
+    if (positional.length > 1 || (positional[0] && !/^\d{2,5}$/.test(positional[0]))) {
+        throw new Error("Usage: rudder cloud preview [port] [--list] [--json]");
+    }
+    const requestedPort = positional[0] ? Number(positional[0]) : null;
+    if (requestedPort !== null && (requestedPort < 1024 || requestedPort > 65535)) {
+        throw new Error("Preview port must be between 1024 and 65535.");
+    }
+    const root = findRepoRoot();
+    const repo = await githubSlugFromOrigin(root).catch(() => null);
+    const project = repo ? { repo } : { name: path.basename(root) };
+    const client = await cloudClient({ requireToken: true });
+    let state = await client.request("/api/rudder/home", { method: "GET" });
+    if (!listOnly && state.home && (!state.home.connected || state.home.stateLive === false)) {
+        process.stderr.write("Waking the cloud machine for its private preview...\n");
+        await client.request("/api/rudder/home/start", { method: "POST", body: {} });
+        const deadline = Date.now() + 90_000;
+        while ((!state.home?.connected || state.home.stateLive === false) && Date.now() < deadline) {
+            await sleep(1500);
+            state = await client.request("/api/rudder/home", { method: "GET" });
+        }
+    }
+    const ready = () => cloudPreviews(state, project).filter((entry) => requestedPort === null || entry.port === requestedPort);
+    let previews = ready();
+    if (!listOnly && !previews.length && state.home?.connected) {
+        const deadline = Date.now() + 20_000;
+        process.stderr.write("Waiting for this project's private preview...\n");
+        while (!previews.length && state.home?.connected && Date.now() < deadline) {
+            const tailnet = state.home.tailnet;
+            if (tailnet && typeof tailnet === "object" && !Array.isArray(tailnet) && tailnet.error)
+                break;
+            await sleep(1000);
+            state = await client.request("/api/rudder/home", { method: "GET" });
+            previews = ready();
+        }
+    }
+    if (options.json) {
+        printJson({ previews, connected: state.home?.connected === true, access: "tailnet", requiresTailscale: true });
+        return;
+    }
+    if (!previews.length) {
+        const tailnet = state.home?.tailnet;
+        const detail = tailnet && typeof tailnet === "object" && !Array.isArray(tailnet) && typeof tailnet.error === "string"
+            ? ` ${tailnet.error}.` : "";
+        throw new Error(`No ready private preview${requestedPort ? ` on port ${requestedPort}` : ""} for ${repo || project.name}.${detail} Start a dev server in that project's cloud workspace, then retry.`);
+    }
+    if (listOnly || previews.length > 1) {
+        for (const preview of previews)
+            console.log(`:${preview.port} ${preview.label} ${preview.url}`);
+        if (!listOnly)
+            console.log("Open one with: rudder cloud preview <port>");
+        return;
+    }
+    const preview = previews[0];
+    const access = previewAccess(await localTailnetStatus(), new URL(preview.url).hostname);
+    if (!access.ok)
+        throw new Error(`${access.error} Preview: ${preview.url}`);
+    if (!(await previewReachable(preview.url))) {
+        throw new Error(`The preview is not reachable from this computer. Check the dev server and your existing Tailscale access rules. Preview: ${preview.url}`);
+    }
+    console.log(preview.url);
+    openBrowser(preview.url);
+}
 async function homeCommand(args, options) {
     const client = await cloudClient({ requireToken: true });
     const sub = args[0] ?? "status";