opencara 0.8.0 → 0.9.0

package/dist/index.js

@@ -131,6 +131,7 @@ function parseAgents(data) {
     const agent = { model: obj.model, tool: obj.tool };
     if (typeof obj.name === "string") agent.name = obj.name;
     if (typeof obj.command === "string") agent.command = obj.command;
+    if (obj.router === true) agent.router = true;
     const agentLimits = parseLimits(obj);
     if (agentLimits) agent.limits = agentLimits;
     const repoConfig = parseRepoConfig(obj, i);
@@ -408,28 +409,28 @@ var DEFAULT_REGISTRY = {
       name: "claude",
       displayName: "Claude",
       binary: "claude",
-      commandTemplate: "claude --model ${MODEL} -p ${PROMPT} --output-format text",
+      commandTemplate: "claude --model ${MODEL} --allowedTools '*' --print",
       tokenParser: "claude"
     },
     {
       name: "codex",
       displayName: "Codex",
       binary: "codex",
-      commandTemplate: "codex --model ${MODEL} -p ${PROMPT}",
+      commandTemplate: "codex --model ${MODEL} exec",
       tokenParser: "codex"
     },
     {
       name: "gemini",
       displayName: "Gemini",
       binary: "gemini",
-      commandTemplate: "gemini --model ${MODEL} -p ${PROMPT}",
+      commandTemplate: "gemini -m ${MODEL}",
       tokenParser: "gemini"
     },
     {
       name: "qwen",
       displayName: "Qwen",
       binary: "qwen",
-      commandTemplate: "qwen --model ${MODEL} -p ${PROMPT} -y",
+      commandTemplate: "qwen --model ${MODEL} -y",
       tokenParser: "qwen"
     }
   ],
@@ -898,6 +899,141 @@ ${userMessage}`;
   }
 }
 
+// src/router.ts
+import * as readline2 from "readline";
+var END_OF_RESPONSE = "<<<OPENCARA_END_RESPONSE>>>";
+var RouterRelay = class {
+  pending = null;
+  responseLines = [];
+  rl = null;
+  stdout;
+  stderr;
+  stdin;
+  stopped = false;
+  constructor(deps) {
+    this.stdin = deps?.stdin ?? process.stdin;
+    this.stdout = deps?.stdout ?? process.stdout;
+    this.stderr = deps?.stderr ?? process.stderr;
+  }
+  /** Start listening for stdin input */
+  start() {
+    this.stopped = false;
+    this.rl = readline2.createInterface({
+      input: this.stdin,
+      terminal: false
+    });
+    this.rl.on("line", (line) => {
+      this.handleLine(line);
+    });
+    this.rl.on("close", () => {
+      if (this.stopped) return;
+      if (this.pending) {
+        const response = this.responseLines.join("\n");
+        this.responseLines = [];
+        clearTimeout(this.pending.timer);
+        const task = this.pending;
+        this.pending = null;
+        if (response.trim()) {
+          task.resolve(response);
+        } else {
+          task.reject(new Error("stdin closed with no response"));
+        }
+      }
+    });
+  }
+  /** Stop listening and clean up */
+  stop() {
+    this.stopped = true;
+    if (this.rl) {
+      this.rl.close();
+      this.rl = null;
+    }
+    if (this.pending) {
+      clearTimeout(this.pending.timer);
+      this.pending.reject(new Error("Router relay stopped"));
+      this.pending = null;
+      this.responseLines = [];
+    }
+  }
+  /** Write the prompt as plain text to stdout */
+  writePrompt(prompt) {
+    this.stdout.write(prompt + "\n");
+  }
+  /** Write a status message to stderr (doesn't interfere with prompt/response on stdout/stdin) */
+  writeStatus(message) {
+    this.stderr.write(message + "\n");
+  }
+  /** Build the full prompt for a review request */
+  buildReviewPrompt(req) {
+    const systemPrompt = buildSystemPrompt(
+      req.owner,
+      req.repo,
+      req.reviewMode
+    );
+    const userMessage = buildUserMessage(req.prompt, req.diffContent);
+    return `${systemPrompt}
+
+${userMessage}`;
+  }
+  /** Build the full prompt for a summary request */
+  buildSummaryPrompt(req) {
+    const systemPrompt = buildSummarySystemPrompt(req.owner, req.repo, req.reviews.length);
+    const userMessage = buildSummaryUserMessage(req.prompt, req.reviews, req.diffContent);
+    return `${systemPrompt}
+
+${userMessage}`;
+  }
+  /**
+   * Send a prompt to the external agent via stdout (plain text)
+   * and wait for the response via stdin (plain text, terminated by END_OF_RESPONSE or EOF).
+   */
+  sendPrompt(_type, _taskId, prompt, timeoutSec) {
+    return new Promise((resolve2, reject) => {
+      if (this.pending) {
+        reject(new Error("Another prompt is already pending"));
+        return;
+      }
+      const timeoutMs = timeoutSec * 1e3;
+      this.responseLines = [];
+      const timer = setTimeout(() => {
+        this.pending = null;
+        this.responseLines = [];
+        reject(new RouterTimeoutError(`Response timeout (${timeoutSec}s)`));
+      }, timeoutMs);
+      this.pending = { resolve: resolve2, reject, timer };
+      this.writePrompt(prompt);
+    });
+  }
+  /** Parse a review response: extract verdict and review text */
+  parseReviewResponse(response) {
+    return extractVerdict(response);
+  }
+  /** Get whether a task is pending (for testing) */
+  get pendingCount() {
+    return this.pending ? 1 : 0;
+  }
+  /** Handle a single line from stdin */
+  handleLine(line) {
+    if (!this.pending) return;
+    if (line.trim() === END_OF_RESPONSE) {
+      const response = this.responseLines.join("\n");
+      this.responseLines = [];
+      clearTimeout(this.pending.timer);
+      const task = this.pending;
+      this.pending = null;
+      task.resolve(response);
+      return;
+    }
+    this.responseLines.push(line);
+  }
+};
+var RouterTimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RouterTimeoutError";
+  }
+};
+
 // src/consumption.ts
 async function checkConsumptionLimits(_agentId, _limits) {
   return { allowed: true };
@@ -956,6 +1092,7 @@ function startAgent(agentId, platformUrl, apiKey, reviewDeps, consumptionDeps, o
   const stabilityThreshold = options?.stabilityThresholdMs ?? CONNECTION_STABILITY_THRESHOLD_MS;
   const repoConfig = options?.repoConfig;
   const displayName = options?.displayName;
+  const routerRelay = options?.routerRelay;
   const prefix = options?.label ? `[${options.label}]` : "";
   const log = (...args) => console.log(...prefix ? [prefix, ...args] : args);
   const logError = (...args) => console.error(...prefix ? [prefix, ...args] : args);
@@ -1048,7 +1185,8 @@ function startAgent(agentId, platformUrl, apiKey, reviewDeps, consumptionDeps, o
         verbose,
         repoConfig,
         displayName,
-        prefix
+        prefix,
+        routerRelay
       );
     });
     ws.on("close", (code, reason) => {
@@ -1128,7 +1266,7 @@ async function logPostReviewStats(type, verdict, tokensUsed, tokensEstimated, co
     `${pfx}${formatPostReviewStats(tokensUsed, consumptionDeps.session, consumptionDeps.limits)}`
   );
 }
-function handleMessage(ws, msg, resetHeartbeat, reviewDeps, consumptionDeps, verbose, repoConfig, displayName, logPrefix) {
+function handleMessage(ws, msg, resetHeartbeat, reviewDeps, consumptionDeps, verbose, repoConfig, displayName, logPrefix, routerRelay) {
   const pfx = logPrefix ? `${logPrefix} ` : "";
   switch (msg.type) {
     case "connected":
@@ -1140,6 +1278,9 @@ function handleMessage(ws, msg, resetHeartbeat, reviewDeps, consumptionDeps, ver
         ...displayName ? { displayName } : {},
         repoConfig: repoConfig ?? { mode: "all" }
       });
+      if (routerRelay) {
+        routerRelay.writeStatus("Waiting for review requests...");
+      }
       break;
     case "heartbeat_ping":
       ws.send(JSON.stringify({ type: "heartbeat_pong", timestamp: Date.now() }));
@@ -1155,6 +1296,81 @@ function handleMessage(ws, msg, resetHeartbeat, reviewDeps, consumptionDeps, ver
       console.log(
         `${pfx}Review request: task ${request.taskId} for ${request.project.owner}/${request.project.repo}#${request.pr.number}`
       );
+      if (routerRelay) {
+        void (async () => {
+          if (consumptionDeps) {
+            const limitResult = await checkConsumptionLimits(
+              consumptionDeps.agentId,
+              consumptionDeps.limits
+            );
+            if (!limitResult.allowed) {
+              trySend(ws, {
+                type: "review_rejected",
+                id: crypto2.randomUUID(),
+                timestamp: Date.now(),
+                taskId: request.taskId,
+                reason: limitResult.reason ?? "consumption_limit_exceeded"
+              });
+              console.log(`${pfx}Review rejected: ${limitResult.reason}`);
+              return;
+            }
+          }
+          try {
+            const prompt = routerRelay.buildReviewPrompt({
+              owner: request.project.owner,
+              repo: request.project.repo,
+              reviewMode: request.reviewMode ?? "full",
+              prompt: request.project.prompt,
+              diffContent: request.diffContent
+            });
+            const response = await routerRelay.sendPrompt(
+              "review_request",
+              request.taskId,
+              prompt,
+              request.timeout
+            );
+            const { verdict, review } = routerRelay.parseReviewResponse(response);
+            const tokensUsed = estimateTokens(prompt) + estimateTokens(response);
+            trySend(ws, {
+              type: "review_complete",
+              id: crypto2.randomUUID(),
+              timestamp: Date.now(),
+              taskId: request.taskId,
+              review,
+              verdict,
+              tokensUsed
+            });
+            await logPostReviewStats(
+              "Review",
+              verdict,
+              tokensUsed,
+              true,
+              consumptionDeps,
+              logPrefix
+            );
+          } catch (err) {
+            if (err instanceof RouterTimeoutError) {
+              trySend(ws, {
+                type: "review_error",
+                id: crypto2.randomUUID(),
+                timestamp: Date.now(),
+                taskId: request.taskId,
+                error: err.message
+              });
+            } else {
+              trySend(ws, {
+                type: "review_error",
+                id: crypto2.randomUUID(),
+                timestamp: Date.now(),
+                taskId: request.taskId,
+                error: err instanceof Error ? err.message : "Unknown error"
+              });
+            }
+            console.error(`${pfx}Review failed:`, err);
+          }
+        })();
+        break;
+      }
       if (!reviewDeps) {
         ws.send(
           JSON.stringify({
@@ -1244,6 +1460,79 @@ function handleMessage(ws, msg, resetHeartbeat, reviewDeps, consumptionDeps, ver
       console.log(
         `${pfx}Summary request: task ${summaryRequest.taskId} for ${summaryRequest.project.owner}/${summaryRequest.project.repo}#${summaryRequest.pr.number} (${summaryRequest.reviews.length} reviews)`
       );
+      if (routerRelay) {
+        void (async () => {
+          if (consumptionDeps) {
+            const limitResult = await checkConsumptionLimits(
+              consumptionDeps.agentId,
+              consumptionDeps.limits
+            );
+            if (!limitResult.allowed) {
+              trySend(ws, {
+                type: "review_rejected",
+                id: crypto2.randomUUID(),
+                timestamp: Date.now(),
+                taskId: summaryRequest.taskId,
+                reason: limitResult.reason ?? "consumption_limit_exceeded"
+              });
+              console.log(`${pfx}Summary rejected: ${limitResult.reason}`);
+              return;
+            }
+          }
+          try {
+            const prompt = routerRelay.buildSummaryPrompt({
+              owner: summaryRequest.project.owner,
+              repo: summaryRequest.project.repo,
+              prompt: summaryRequest.project.prompt,
+              reviews: summaryRequest.reviews,
+              diffContent: summaryRequest.diffContent ?? ""
+            });
+            const response = await routerRelay.sendPrompt(
+              "summary_request",
+              summaryRequest.taskId,
+              prompt,
+              summaryRequest.timeout
+            );
+            const tokensUsed = estimateTokens(prompt) + estimateTokens(response);
+            trySend(ws, {
+              type: "summary_complete",
+              id: crypto2.randomUUID(),
+              timestamp: Date.now(),
+              taskId: summaryRequest.taskId,
+              summary: response,
+              tokensUsed
+            });
+            await logPostReviewStats(
+              "Summary",
+              void 0,
+              tokensUsed,
+              true,
+              consumptionDeps,
+              logPrefix
+            );
+          } catch (err) {
+            if (err instanceof RouterTimeoutError) {
+              trySend(ws, {
+                type: "review_error",
+                id: crypto2.randomUUID(),
+                timestamp: Date.now(),
+                taskId: summaryRequest.taskId,
+                error: err.message
+              });
+            } else {
+              trySend(ws, {
+                type: "review_error",
+                id: crypto2.randomUUID(),
+                timestamp: Date.now(),
+                taskId: summaryRequest.taskId,
+                error: err instanceof Error ? err.message : "Summary failed"
+              });
+            }
+            console.error(`${pfx}Summary failed:`, err);
+          }
+        })();
+        break;
+      }
       if (!reviewDeps) {
         trySend(ws, {
           type: "review_rejected",
@@ -1354,6 +1643,12 @@ function resolveLocalAgentCommand(localAgent, globalAgentCommand) {
   const effectiveCommand = localAgent.command ?? globalAgentCommand;
   return resolveCommandTemplate(effectiveCommand);
 }
+function startAgentRouter() {
+  void agentCommand.parseAsync(
+    ["start", "--router", "--anonymous", "--model", "router", "--tool", "opencara"],
+    { from: "user" }
+  );
+}
 var agentCommand = new Command2("agent").description("Manage review agents");
 agentCommand.command("create").description("Add an agent to local config (interactive or via flags)").option("--model <model>", "AI model name (e.g., claude-opus-4-6)").option("--tool <tool>", "Review tool name (e.g., claude-code)").option("--command <cmd>", "Custom command template (bypasses registry lookup)").action(async (opts) => {
   const config = loadConfig();
@@ -1433,7 +1728,7 @@ agentCommand.command("create").description("Add an agent to local config (intera
         break;
       }
       const toolEntry = registry.tools.find((t) => t.name === tool);
-      const defaultCommand = toolEntry ? toolEntry.commandTemplate.replaceAll("${MODEL}", model) : `${tool} --model ${model} -p \${PROMPT}`;
+      const defaultCommand = toolEntry ? toolEntry.commandTemplate.replaceAll("${MODEL}", model) : `${tool} --model ${model}`;
       command = await input({
         message: "Command:",
         default: defaultCommand,
@@ -1573,7 +1868,7 @@ async function resolveAnonymousAgent(config, model, tool) {
   );
   return { entry, command };
 }
-agentCommand.command("start [agentIdOrModel]").description("Connect agent to platform via WebSocket").option("--all", "Start all agents from local config concurrently").option("-a, --anonymous", "Start an anonymous agent (no login required)").option("--model <model>", "AI model name (used with --anonymous)").option("--tool <tool>", "Review tool name (used with --anonymous)").option("--verbose", "Enable detailed WebSocket diagnostic logging").option(
+agentCommand.command("start [agentIdOrModel]").description("Connect agent to platform via WebSocket").option("--all", "Start all agents from local config concurrently").option("-a, --anonymous", "Start an anonymous agent (no login required)").option("--model <model>", "AI model name (used with --anonymous)").option("--tool <tool>", "Review tool name (used with --anonymous)").option("--verbose", "Enable detailed WebSocket diagnostic logging").option("--router", "Router mode: relay prompts to stdout, read responses from stdin").option(
   "--stability-threshold <ms>",
   `Connection stability threshold in ms (${STABILITY_THRESHOLD_MIN_MS}\u2013${STABILITY_THRESHOLD_MAX_MS}, default: ${CONNECTION_STABILITY_THRESHOLD_MS})`
 ).action(
@@ -1595,24 +1890,57 @@ agentCommand.command("start [agentIdOrModel]").description("Connect agent to pla
         console.error("Both --model and --tool are required with --anonymous.");
         process.exit(1);
       }
-      let resolved;
-      try {
-        resolved = await resolveAnonymousAgent(config, opts.model, opts.tool);
-      } catch (err) {
-        console.error(
-          "Failed to register anonymous agent:",
-          err instanceof Error ? err.message : err
-        );
-        process.exit(1);
-      }
-      const { entry, command } = resolved;
+      let entry;
       let reviewDeps2;
-      if (validateCommandBinary(command)) {
-        reviewDeps2 = { commandTemplate: command, maxDiffSizeKb: config.maxDiffSizeKb };
-      } else {
-        console.warn(
-          `Warning: binary "${command.split(" ")[0]}" not found. Reviews will be rejected.`
+      let relay2;
+      if (opts.router) {
+        const existing = config.anonymousAgents.find(
+          (a) => a.model === opts.model && a.tool === opts.tool
         );
+        if (existing) {
+          console.log(
+            `Reusing stored anonymous agent ${existing.agentId} (${opts.model} / ${opts.tool})`
+          );
+          entry = existing;
+        } else {
+          console.log("Registering anonymous agent...");
+          const client2 = new ApiClient(config.platformUrl);
+          const res = await client2.post("/api/agents/anonymous", {
+            model: opts.model,
+            tool: opts.tool
+          });
+          entry = {
+            agentId: res.agentId,
+            apiKey: res.apiKey,
+            model: opts.model,
+            tool: opts.tool
+          };
+          config.anonymousAgents.push(entry);
+          saveConfig(config);
+          console.log(`Agent registered: ${res.agentId} (${opts.model} / ${opts.tool})`);
+        }
+        relay2 = new RouterRelay();
+        relay2.start();
+      } else {
+        let resolved;
+        try {
+          resolved = await resolveAnonymousAgent(config, opts.model, opts.tool);
+        } catch (err) {
+          console.error(
+            "Failed to register anonymous agent:",
+            err instanceof Error ? err.message : err
+          );
+          process.exit(1);
+        }
+        entry = resolved.entry;
+        const command = resolved.command;
+        if (validateCommandBinary(command)) {
+          reviewDeps2 = { commandTemplate: command, maxDiffSizeKb: config.maxDiffSizeKb };
+        } else {
+          console.warn(
+            `Warning: binary "${command.split(" ")[0]}" not found. Reviews will be rejected.`
+          );
+        }
       }
       const consumptionDeps2 = {
         agentId: entry.agentId,
@@ -1624,13 +1952,19 @@ agentCommand.command("start [agentIdOrModel]").description("Connect agent to pla
         verbose: opts.verbose,
         stabilityThresholdMs,
         displayName: entry.name,
-        repoConfig: entry.repoConfig
+        repoConfig: entry.repoConfig,
+        routerRelay: relay2
       });
       return;
     }
     if (config.agents !== null) {
+      const routerAgents = [];
       const validAgents = [];
       for (const local of config.agents) {
+        if (opts.router || local.router) {
+          routerAgents.push(local);
+          continue;
+        }
         let cmd;
         try {
           cmd = resolveLocalAgentCommand(local, config.agentCommand);
@@ -1648,30 +1982,45 @@ agentCommand.command("start [agentIdOrModel]").description("Connect agent to pla
         }
         validAgents.push({ local, command: cmd });
       }
-      if (validAgents.length === 0 && config.anonymousAgents.length === 0) {
+      const totalValid = validAgents.length + routerAgents.length;
+      if (totalValid === 0 && config.anonymousAgents.length === 0) {
         console.error("No valid agents in config. Check that tool binaries are installed.");
         process.exit(1);
       }
       let agentsToStart;
+      let routerAgentsToStart;
       const anonAgentsToStart = [];
       if (opts.all) {
         agentsToStart = validAgents;
+        routerAgentsToStart = routerAgents;
         anonAgentsToStart.push(...config.anonymousAgents);
       } else if (agentIdOrModel) {
-        const match = validAgents.find((a) => a.local.model === agentIdOrModel);
-        if (!match) {
+        const cmdMatch = validAgents.find((a) => a.local.model === agentIdOrModel);
+        const routerMatch = routerAgents.find((a) => a.model === agentIdOrModel);
+        if (!cmdMatch && !routerMatch) {
           console.error(`No agent with model "${agentIdOrModel}" found in local config.`);
           console.error("Available agents:");
           for (const a of validAgents) {
             console.error(`  ${a.local.model}  (${a.local.tool})`);
           }
+          for (const a of routerAgents) {
+            console.error(`  ${a.model}  (${a.tool}) [router]`);
+          }
           process.exit(1);
         }
-        agentsToStart = [match];
-      } else if (validAgents.length === 1) {
-        agentsToStart = [validAgents[0]];
-        console.log(`Using agent ${validAgents[0].local.model} (${validAgents[0].local.tool})`);
-      } else if (validAgents.length === 0) {
+        agentsToStart = cmdMatch ? [cmdMatch] : [];
+        routerAgentsToStart = routerMatch ? [routerMatch] : [];
+      } else if (totalValid === 1) {
+        if (validAgents.length === 1) {
+          agentsToStart = [validAgents[0]];
+          routerAgentsToStart = [];
+          console.log(`Using agent ${validAgents[0].local.model} (${validAgents[0].local.tool})`);
+        } else {
+          agentsToStart = [];
+          routerAgentsToStart = [routerAgents[0]];
+          console.log(`Using router agent ${routerAgents[0].model} (${routerAgents[0].tool})`);
+        }
+      } else if (totalValid === 0) {
         console.error("No valid authenticated agents in config. Use --anonymous or --all.");
         process.exit(1);
       } else {
@@ -1679,9 +2028,12 @@ agentCommand.command("start [agentIdOrModel]").description("Connect agent to pla
         for (const a of validAgents) {
           console.error(`  ${a.local.model}  (${a.local.tool})`);
         }
+        for (const a of routerAgents) {
+          console.error(`  ${a.model}  (${a.tool}) [router]`);
+        }
         process.exit(1);
       }
-      const totalAgents = agentsToStart.length + anonAgentsToStart.length;
+      const totalAgents = agentsToStart.length + routerAgentsToStart.length + anonAgentsToStart.length;
       if (totalAgents > 1) {
         process.setMaxListeners(process.getMaxListeners() + totalAgents * 2);
       }
@@ -1689,7 +2041,7 @@ agentCommand.command("start [agentIdOrModel]").description("Connect agent to pla
       let apiKey2;
       let client2;
       let serverAgents;
-      if (agentsToStart.length > 0) {
+      if (agentsToStart.length > 0 || routerAgentsToStart.length > 0) {
         apiKey2 = requireApiKey(config);
         client2 = new ApiClient(config.platformUrl, apiKey2);
         try {
@@ -1743,6 +2095,48 @@ agentCommand.command("start [agentIdOrModel]").description("Connect agent to pla
         });
         startedCount++;
       }
+      for (const local of routerAgentsToStart) {
+        let agentId2;
+        try {
+          const sync = await syncAgentToServer(client2, serverAgents, local);
+          agentId2 = sync.agentId;
+          if (sync.created) {
+            console.log(`Registered new agent ${agentId2} on platform`);
+            serverAgents.push({
+              id: agentId2,
+              model: local.model,
+              tool: local.tool,
+              isAnonymous: false,
+              status: "offline",
+              repoConfig: null,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        } catch (err) {
+          console.error(
+            `Failed to sync router agent ${local.model} to server:`,
+            err instanceof Error ? err.message : err
+          );
+          continue;
+        }
+        const relay2 = new RouterRelay();
+        relay2.start();
+        const consumptionDeps2 = {
+          agentId: agentId2,
+          limits: resolveAgentLimits(local.limits, config.limits),
+          session: createSessionTracker()
+        };
+        const label = local.name || local.model || "unnamed";
+        console.log(`Starting router agent ${label} (${agentId2})...`);
+        startAgent(agentId2, config.platformUrl, apiKey2, void 0, consumptionDeps2, {
+          verbose: opts.verbose,
+          stabilityThresholdMs,
+          repoConfig: local.repos,
+          label,
+          routerRelay: relay2
+        });
+        startedCount++;
+      }
       for (const anon of anonAgentsToStart) {
         let command;
         try {
@@ -1815,16 +2209,22 @@ agentCommand.command("start [agentIdOrModel]").description("Connect agent to pla
       }
     }
     let reviewDeps;
-    try {
-      const commandTemplate = resolveCommandTemplate(config.agentCommand);
-      reviewDeps = {
-        commandTemplate,
-        maxDiffSizeKb: config.maxDiffSizeKb
-      };
-    } catch (err) {
-      console.warn(
-        `Warning: ${err instanceof Error ? err.message : "Could not determine agent command."} Reviews will be rejected.`
-      );
+    let relay;
+    if (opts.router) {
+      relay = new RouterRelay();
+      relay.start();
+    } else {
+      try {
+        const commandTemplate = resolveCommandTemplate(config.agentCommand);
+        reviewDeps = {
+          commandTemplate,
+          maxDiffSizeKb: config.maxDiffSizeKb
+        };
+      } catch (err) {
+        console.warn(
+          `Warning: ${err instanceof Error ? err.message : "Could not determine agent command."} Reviews will be rejected.`
+        );
+      }
     }
     const consumptionDeps = {
       agentId,
@@ -1835,7 +2235,8 @@ agentCommand.command("start [agentIdOrModel]").description("Connect agent to pla
     startAgent(agentId, config.platformUrl, apiKey, reviewDeps, consumptionDeps, {
       verbose: opts.verbose,
       stabilityThresholdMs,
-      label: agentId
+      label: agentId,
+      routerRelay: relay
     });
   }
 );
@@ -2016,8 +2417,11 @@ var statsCommand = new Command3("stats").description("Display agent dashboard: t
 });
 
 // src/index.ts
-var program = new Command4().name("opencara").description("OpenCara \u2014 distributed AI code review agent").version("0.8.0");
+var program = new Command4().name("opencara").description("OpenCara \u2014 distributed AI code review agent").version("0.9.0");
 program.addCommand(loginCommand);
 program.addCommand(agentCommand);
 program.addCommand(statsCommand);
+program.action(() => {
+  startAgentRouter();
+});
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencara",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "type": "module",
   "repository": {
     "type": "git",