feat(cli): /agents opens the engine's native agent view when it has one

`/agents <engine>` (and `moshcode agents <engine>`) previously always ran the
engine's autonomous-session bypass flag — so `/agents claude` dropped you into a
`claude --dangerously-skip-permissions` session, never your agent list.

Engines can now declare an `agentsView` (the exact argv that opens their native
agent list). Agent-mode launches use it when present, else fall back to the
autonomous bypass flags as before:

  claude   -> claude agents --dangerously-skip-permissions   (agent view)
  opencode -> opencode agent list                            (agent view)
  codex    -> codex --dangerously-bypass-approvals-and-sandbox (autonomous)
  gemini   -> gemini --approval-mode=yolo                      (autonomous)
  aider    -> aider --yes-always                               (autonomous)

Only engines whose CLI actually has an agents subcommand get a view; codex has
bypass flags but no agents subcommand, so it (and gemini/aider) keep the old
autonomous behavior. Updated the agent-mode banner + README + engine tests.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: ralyodio

README.md

@@ -25,16 +25,17 @@ moshcode install codex      # npm i -g @openai/codex
 
 ### Autonomous agents versus raw starts
 
-`agents` intentionally starts an autonomous session by injecting each engine's
-native bypass or auto-approval mode. Use this only in an isolated container, VM,
-or workspace you trust:
+`agents` opens the engine's native **agent view** when it has one, so you land on
+your agent list. Engines without an agents view instead start an autonomous
+session by injecting the engine's native bypass or auto-approval mode. Either way,
+use this only in an isolated container, VM, or workspace you trust:
 
 ```sh
-moshcode agents claude      # claude --dangerously-skip-permissions
-moshcode agents codex       # codex --dangerously-bypass-approvals-and-sandbox
-moshcode agents gemini      # gemini --approval-mode=yolo
-moshcode agents aider       # aider --yes-always
-moshcode agents opencode    # opencode --auto
+moshcode agents claude      # claude agents --dangerously-skip-permissions  (agent view)
+moshcode agents opencode    # opencode agent list                          (agent view)
+moshcode agents codex       # codex --dangerously-bypass-approvals-and-sandbox  (autonomous)
+moshcode agents gemini      # gemini --approval-mode=yolo                       (autonomous)
+moshcode agents aider       # aider --yes-always                                (autonomous)
 ```
 
 `start` is the explicit raw path. It injects nothing, so the native engine keeps

bin/moshcode.mjs

@@ -78,7 +78,7 @@ function printEngineStatus() {
 
 async function launchEngine(key, engine, args, { agentMode = false } = {}) {
   if (agentMode) {
-    console.error(`⚠ agent mode: ${key} ${engine.agentArgs.join(" ")} — native approvals/permissions are bypassed or auto-approved.`);
+    console.error(`⚠ agent mode: ${key} ${agentLaunchArgs(engine).join(" ")}${engine.agentsView ? " — opening its agent view" : " — native approvals/permissions are bypassed or auto-approved"}.`);
   }
   const result = await openSession(engine, agentMode ? agentLaunchArgs(engine, args) : args);
   if (!result.ok) {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "moshcode",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "type": "module",
   "description": "moshcode — a metal wrapper for coding engines and native UGig/CoinPay workflow CLIs, with OpenPRD and moshscript",
   "bin": {

src/engines.mjs

@@ -2,6 +2,14 @@
 // runs the engine's official installer; `/agents <name>` (or `moshcode <name>`)
 // opens a passthrough session on it. moshcode itself stays lean (no vendored
 // fork). Add engines here.
+//
+// `agentsView` (optional) is the exact argv that opens the engine's native
+// agent list/view — used by `/agents <name>` when the engine actually has one
+// (claude, opencode). It's the FULL leading args (subcommand + any flags that
+// subcommand accepts), because not every agents-subcommand takes the engine's
+// bypass flag (e.g. `opencode agent list` takes none). Engines without an
+// `agentsView` fall back to `agentArgs` — an autonomous session with native
+// approvals bypassed/auto-approved.
 import { spawn } from "node:child_process";
 import { existsSync, statSync } from "node:fs";
 import path from "node:path";
@@ -11,13 +19,15 @@ export const ENGINES = {
     desc: "opencode — the open-source coding agent (SST/anomalyco)",
     bin: "opencode",
     agentArgs: ["--auto"],
+    agentsView: ["agent", "list"], // `opencode agent list` — lists agents; the `agent` subcommand takes no bypass flag
     install: { cmd: "bash", args: ["-c", "curl -fsSL https://opencode.ai/install | bash"] },
     upgrade: { cmd: "opencode", args: ["upgrade"] },
   },
   claude: {
     desc: "Claude Code — Anthropic's agentic CLI",
     bin: "claude",
     agentArgs: ["--dangerously-skip-permissions"],
+    agentsView: ["agents", "--dangerously-skip-permissions"], // `claude agents …` — the background-agents view; accepts the skip flag
     install: { cmd: "npm", args: ["install", "-g", "@anthropic-ai/claude-code"] },
     // Claude Code authenticates via its own stored login (~/.claude). An
     // inherited ANTHROPIC_API_KEY hijacks that subscription auth — and if the
@@ -92,9 +102,14 @@ export function engineList() {
   return Object.entries(ENGINES).map(([k, v]) => `  ${k.padEnd(10)} ${v.desc}`).join("\n");
 }
 
-/** Prepend an engine's autonomous-mode flags to caller-supplied arguments. */
+/**
+ * Args for an agent-mode launch (`/agents <engine>` / `moshcode agents <engine>`):
+ * the engine's native agents-view invocation when it has one (so you land on your
+ * agent list), else its autonomous bypass flags. Caller-supplied args follow.
+ */
 export function agentLaunchArgs(engine, args = []) {
-  return [...(engine.agentArgs || []), ...args];
+  const lead = engine.agentsView || engine.agentArgs || [];
+  return [...lead, ...args];
 }
 
 /**

src/tui.mjs

@@ -154,7 +154,7 @@ async function openEngine(key, engine, args, { agentMode = false } = {}) {
     console.log(info(`${key} isn't installed — try ${acid("/install " + key)} first.`));
   }
   if (agentMode) {
-    console.log(err(`agent mode: ${key} ${engine.agentArgs.join(" ")} — native approvals/permissions are bypassed or auto-approved.`));
+    console.log(err(`agent mode: ${key} ${agentLaunchArgs(engine).join(" ")}${engine.agentsView ? " — opening its agent view" : " — native approvals/permissions are bypassed or auto-approved"}.`));
   }
   console.log(info(`opening ${bone(key)}${agentMode ? " autonomously" : " raw"} — hand-off to its CLI, exit it to come back…`));
   console.log(hr());

test/engines.test.mjs

@@ -17,6 +17,7 @@ import test from "node:test";
 import { ENGINES, agentLaunchArgs } from "../src/engines.mjs";
 
 const BIN = fileURLToPath(new URL("../bin/moshcode.mjs", import.meta.url));
+// The autonomous-session bypass flags each engine declares (engine.agentArgs).
 const EXPECTED_AGENT_ARGS = {
   opencode: ["--auto"],
   claude: ["--dangerously-skip-permissions"],
@@ -25,6 +26,16 @@ const EXPECTED_AGENT_ARGS = {
   aider: ["--yes-always"],
 };
 
+// What an agent-mode launch actually runs (agentLaunchArgs): the engine's native
+// agents-view invocation where it has one, else its autonomous bypass flags.
+const EXPECTED_LAUNCH_ARGS = {
+  opencode: ["agent", "list"],
+  claude: ["agents", "--dangerously-skip-permissions"],
+  codex: ["--dangerously-bypass-approvals-and-sandbox"],
+  gemini: ["--approval-mode=yolo"],
+  aider: ["--yes-always"],
+};
+
 function tempDir(prefix = "moshcode-engines-") {
   return mkdtempSync(path.join(tmpdir(), prefix));
 }
@@ -75,15 +86,15 @@ test("every engine declares its reviewed autonomous-mode arguments", () => {
   );
   for (const [key, engine] of Object.entries(ENGINES)) {
     assert.deepEqual(agentLaunchArgs(engine, ["--user-arg", "two words"]), [
-      ...EXPECTED_AGENT_ARGS[key],
+      ...EXPECTED_LAUNCH_ARGS[key],
       "--user-arg",
       "two words",
     ]);
   }
 });
 
-for (const [key, expected] of Object.entries(EXPECTED_AGENT_ARGS)) {
-  test(`agents ${key} injects autonomous flags before user arguments`, async () => {
+for (const [key, expected] of Object.entries(EXPECTED_LAUNCH_ARGS)) {
+  test(`agents ${key} injects its agent-launch args before user arguments`, async () => {
     const nativeBin = tempDir();
     mkdirSync(nativeBin, { recursive: true });
     writeEngine(nativeBin, key);