agent-yes 1.72.4 → 1.73.2

package/ts/index.ts

@@ -4,7 +4,7 @@ import { mkdir, readFile, writeFile } from "fs/promises";
 import path from "path";
 import DIE from "phpdie";
 import sflow from "sflow";
-import { TerminalRenderStream } from "terminal-render";
+import { XtermProxy } from "./xterm-proxy.ts";
 import {
   extractSessionId,
   getSessionForCwd,
@@ -16,7 +16,6 @@ import { acquireLock, releaseLock, shouldUseLock } from "./runningLock.ts";
 import { logger } from "./logger.ts";
 import { createFifoStream } from "./beta/fifo.ts";
 import { PidStore } from "./pidStore.ts";
-import { SUPPORTED_CLIS } from "./SUPPORTED_CLIS.ts";
 import { sendEnter, sendMessage } from "./core/messaging.ts";
 import {
   initializeLogPaths,
@@ -41,11 +40,16 @@ export type AgentCliConfig = {
   version?: string; // hint user for version command to check if installed
   binary?: string; // actual binary name if different from cli, e.g. cursor -> cursor-agent
   defaultArgs?: string[]; // function to ensure certain args are present
+  help?: string; // documentation/help URL for the CLI
+  bunx?: boolean; // metadata for bunx-based launches
+  systemPrompt?: string; // flag name for system prompt injection
+  system?: string; // system prompt content to inject
 
   // status detect, and actions
   ready?: RegExp[]; // regex matcher for stdin ready, or line index for gemini. Set to empty array [] to disable ready check entirely.
   fatal?: RegExp[]; // array of regex to match for fatal errors
   working?: RegExp[]; // regex matcher for working status
+  updateAvailable?: RegExp[]; // regex matcher for update available banners
   exitCommands?: string[]; // commands to exit the cli gracefully
   promptArg?: (string & {}) | "first-arg" | "last-arg"; // argument name to pass the prompt, e.g. --prompt, or first-arg for positional arg
 
@@ -121,7 +125,7 @@ export default async function agentYes({
   autoYes = true,
   idleAction,
 }: {
-  cli: SUPPORTED_CLIS;
+  cli: keyof typeof CLIS_CONFIG;
   cliArgs?: string[];
   prompt?: string;
   robust?: boolean;
@@ -185,9 +189,14 @@ export default async function agentYes({
   process.stdin.setRawMode?.(true); // must be called any stdout/stdin usage
   if (verbose) logger.debug(`[stdin] Raw mode set, isRaw: ${(process.stdin as any).isRaw}`);
 
-  const terminalStream = new TerminalRenderStream({ mode: "raw" });
-  const terminalRender = terminalStream.getRenderer();
-  const outputWriter = terminalStream.writable.getWriter();
+  // XtermProxy: headless xterm emulator that auto-responds to all terminal
+  // queries (DSR, DA, etc.) so the spawned CLI never blocks waiting for replies.
+  // writeToPty is set after shell spawn (see below).
+  let shellWrite: (data: string) => void = () => {};
+  const xtermProxy = new XtermProxy({
+    ...getTerminalDimensions(),
+    writeToPty: (data) => shellWrite(data),
+  });
 
   logger.debug(`Using ${ptyPackage} for pseudo terminal management.`);
 
@@ -329,11 +338,14 @@ export default async function agentYes({
     ptyOptions,
   });
 
+  // Wire up the xterm proxy to write back to the PTY
+  shellWrite = (data: string) => shell.write(data);
+
   // Attach data handler IMMEDIATELY after spawn to avoid losing early PTY output.
   // node-pty emits 'data' events eagerly — if no listener is attached, events are lost.
   function onData(data: string) {
     const currentPid = shell.pid;
-    outputWriter.write(data);
+    xtermProxy.write(data);
     globalAgentRegistry.appendStdout(currentPid, data);
   }
   shell.onData(onData);
@@ -348,7 +360,7 @@ export default async function agentYes({
 
   // Initialize log paths (independent of registration)
   const logPaths = await initializeLogPaths(pidStore, shell.pid);
-  setupDebugLogging(logPaths.debuggingLogsPath);
+  await setupDebugLogging(logPaths.debuggingLogsPath);
 
   // Create agent context
   const ctx = new AgentContext({
@@ -447,6 +459,7 @@ export default async function agentYes({
         env: ptyEnv,
       };
       shell = pty.spawn(bin!, args, restartPtyOptions);
+      shellWrite = (data: string) => shell.write(data);
       // Register process in pidStore (non-blocking)
       try {
         await pidStore.registerProcess({ pid: shell.pid, cli, args, prompt, cwd: workingDir });
@@ -548,6 +561,7 @@ export default async function agentYes({
         env: ptyEnv,
       };
       shell = pty.spawn(cli, restoreArgs, restorePtyOptions);
+      shellWrite = (data: string) => shell.write(data);
       // Register process in pidStore (non-blocking)
       try {
         await pidStore.registerProcess({
@@ -601,14 +615,15 @@ export default async function agentYes({
     return pendingExitCode.resolve(exitCode);
   });
 
-  // when current tty resized, resize the pty too
+  // when current tty resized, resize both pty and xterm proxy
   process.stdout.on("resize", () => {
     const { cols, rows } = getTerminalDimensions();
     shell.resize(cols, rows);
+    xtermProxy.resize(cols, rows);
   });
 
   const isStillWorkingQ = () => {
-    const rendered = terminalRender.tail(24).replace(/\s+/g, " ");
+    const rendered = xtermProxy.tail(24).replace(/\s+/g, " ");
     return conf.working?.some((rgx) => rgx.test(rendered));
   };
 
@@ -617,7 +632,7 @@ export default async function agentYes({
   let lastHeartbeatRendered = "";
   const heartbeatInterval = setInterval(async () => {
     try {
-      const rendered = removeControlCharacters(terminalRender.tail(12));
+      const rendered = removeControlCharacters(xtermProxy.tail(12));
 
       // Skip if output hasn't changed since last heartbeat
       if (rendered === lastHeartbeatRendered) return;
@@ -895,7 +910,7 @@ export default async function agentYes({
           shell.write(data);
         },
       }),
-      readable: terminalStream.readable,
+      readable: xtermProxy.readable,
     })
 
     .forEach(() => {
@@ -926,97 +941,72 @@ export default async function agentYes({
       // if (cli === "codex" && !process.stdin.isTTY) shell.write(`\u001b[1;1R`); // send cursor position response when stdin is not tty
 
       let lastRendered = "";
-      return e
-        .forEach((chunk) => {
-          // NOTE: terminalRender is already updated by terminalStream.writable.write() in onData()
-          // (terminal-render v1.5+ calls renderer.write() as a side effect of the writable).
-          // Calling terminalRender.write(chunk) here again would double-process every chunk,
-          // corrupting cursor state and breaking all pattern matching.
-          // ============ HANDLE special control sequences
-          // Handle Device Attributes query (DA) - ESC[c or ESC[0c
-          // This must be handled regardless of TTY status
-          if (chunk.includes("\u001b[c") || chunk.includes("\u001b[0c")) {
-            // Respond shell with VT100 with Advanced Video Option
-            shell.write("\u001b[?1;2c");
-            if (verbose) {
-              logger.debug("device|respond DA: VT100 with Advanced Video Option");
+      return (
+        e
+          // Terminal query responses (DA, DSR, etc.) are handled automatically
+          // by XtermProxy via @xterm/headless — no ad-hoc interception needed.
+          .forEach(async (line, lineIndex) => {
+            // ============ respond on rendered screen
+            const rendered = xtermProxy.tail(24);
+            // Skip processing if output hasn't changed
+            if (rendered === lastRendered) return;
+            lastRendered = rendered;
+
+            logger.debug(`stdout|${line}`);
+
+            // ready matcher: if matched, mark stdin ready
+            if (conf.ready?.some((rx: RegExp) => line.match(rx))) {
+              logger.debug(`ready |${line}`);
+              if (cli === "gemini" && lineIndex <= 80) return; // gemini initial noise, only after many lines
+              ctx.stdinReady.ready();
+              ctx.stdinFirstReady.ready();
             }
-            return;
-          }
-
-          // Only handle cursor position when stdin is not tty, because tty already handled this
-          if (process.stdin.isTTY) return;
-
-          // Handle cursor position request - ESC[6n
-          if (!chunk.includes("\u001b[6n")) return;
-
-          // xterm replies CSI row; column R if asked cursor position
-          // https://en.wikipedia.org/wiki/ANSI_escape_code#:~:text=citation%20needed%5D-,xterm%20replies,-CSI%20row%C2%A0%3B
-          const { col, row } = terminalRender.getCursorPosition();
-          shell.write(`\u001b[${row};${col}R`); // reply cli when getting cursor position
-
-          logger.debug(`cursor|respond position: row=${String(row)}, col=${String(col)}`);
-        })
-        .forEach(async (line, lineIndex) => {
-          // ============ respond on rendered screen
-          const rendered = terminalRender.tail(24);
-          // Skip processing if output hasn't changed
-          if (rendered === lastRendered) return;
-
-          logger.debug(`stdout|${line}`);
-
-          // ready matcher: if matched, mark stdin ready
-          if (conf.ready?.some((rx: RegExp) => line.match(rx))) {
-            logger.debug(`ready |${line}`);
-            if (cli === "gemini" && lineIndex <= 80) return; // gemini initial noise, only after many lines
-            ctx.stdinReady.ready();
-            ctx.stdinFirstReady.ready();
-          }
 
-          // enter matchers: send Enter when any enter regex matches
-          if (conf.enter?.some((rx: RegExp) => line.match(rx))) {
-            logger.debug(`sendEnter matched|${line}`);
-            return await sendEnter(ctx.messageContext, 400); // wait for idle for a short while and then send Enter
-          }
+            // enter matchers: send Enter when any enter regex matches
+            if (conf.enter?.some((rx: RegExp) => line.match(rx))) {
+              logger.debug(`sendEnter matched|${line}`);
+              return await sendEnter(ctx.messageContext, 400); // wait for idle for a short while and then send Enter
+            }
 
-          // typingRespond matcher: if matched, send the specified message
-          const typeingRespondMatched = Object.entries(conf.typingRespond ?? {}).filter(
-            ([_sendString, onThePatterns]) => onThePatterns.some((rx) => line.match(rx)),
-          );
-          const typingResponded =
-            typeingRespondMatched.length &&
-            (await sflow(typeingRespondMatched)
-              .map(
-                async ([sendString]) =>
-                  await sendMessage(ctx.messageContext, sendString, { waitForReady: false }),
-              )
-              .toCount());
-          if (typingResponded) return;
-
-          // fatal matchers: set isFatal flag when matched
-          if (conf.fatal?.some((rx: RegExp) => line.match(rx))) {
-            logger.debug(`fatal |${line}`);
-            ctx.isFatal = true;
-            await exitAgent();
-          }
+            // typingRespond matcher: if matched, send the specified message
+            const typeingRespondMatched = Object.entries(conf.typingRespond ?? {}).filter(
+              ([_sendString, onThePatterns]) => onThePatterns.some((rx) => line.match(rx)),
+            );
+            const typingResponded =
+              typeingRespondMatched.length &&
+              (await sflow(typeingRespondMatched)
+                .map(
+                  async ([sendString]) =>
+                    await sendMessage(ctx.messageContext, sendString, { waitForReady: false }),
+                )
+                .toCount());
+            if (typingResponded) return;
+
+            // fatal matchers: set isFatal flag when matched
+            if (conf.fatal?.some((rx: RegExp) => line.match(rx))) {
+              logger.debug(`fatal |${line}`);
+              ctx.isFatal = true;
+              await exitAgent();
+            }
 
-          // restartWithoutContinueArg matchers: set flag to restart without continue args
-          if (conf.restartWithoutContinueArg?.some((rx: RegExp) => line.match(rx))) {
-            logger.debug(`restart-without-continue|${line}`);
-            ctx.shouldRestartWithoutContinue = true;
-            ctx.isFatal = true; // also set fatal to trigger exit
-            await exitAgent();
-          }
+            // restartWithoutContinueArg matchers: set flag to restart without continue args
+            if (conf.restartWithoutContinueArg?.some((rx: RegExp) => line.match(rx))) {
+              logger.debug(`restart-without-continue|${line}`);
+              ctx.shouldRestartWithoutContinue = true;
+              ctx.isFatal = true; // also set fatal to trigger exit
+              await exitAgent();
+            }
 
-          // session ID capture for codex
-          if (cli === "codex") {
-            const sessionId = extractSessionId(line);
-            if (sessionId) {
-              logger.debug(`session|captured session ID: ${sessionId}`);
-              await storeSessionForCwd(workingDir, sessionId);
+            // session ID capture for codex
+            if (cli === "codex") {
+              const sessionId = extractSessionId(line);
+              if (sessionId) {
+                logger.debug(`session|captured session ID: ${sessionId}`);
+                await storeSessionForCwd(workingDir, sessionId);
+              }
             }
-          }
-        });
+          })
+      );
     })
 
     // auto-response
@@ -1043,7 +1033,7 @@ export default async function agentYes({
     .by(createTerminatorStream(pendingExitCode.promise))
     .to(fromWritable(process.stdout));
 
-  await saveLogFile(ctx.logPaths.logPath, terminalRender.render());
+  await saveLogFile(ctx.logPaths.logPath, xtermProxy.render());
 
   // and then get its exitcode
   const exitCode = await pendingExitCode.promise;
@@ -1052,13 +1042,14 @@ export default async function agentYes({
   // Final pidStore cleanup
   await pidStore.close();
 
-  // Update task status.writable release lock
-  await outputWriter.close();
+  // Capture final render before disposing xterm proxy
+  const finalRender = xtermProxy.render();
+  xtermProxy.dispose();
 
   // deprecated logFile option, we have logPath now, but keep for backward compatibility
-  await saveDeprecatedLogFile(logFile, terminalRender.render(), verbose);
+  await saveDeprecatedLogFile(logFile, finalRender, verbose);
 
-  return { exitCode, logs: terminalRender.render() };
+  return { exitCode, logs: finalRender };
 
   async function exitAgent() {
     ctx.robust = false; // disable robust to avoid auto restart

package/ts/logger.spec.ts

@@ -0,0 +1,27 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+// Reset module state between tests by re-importing fresh
+describe("logger", () => {
+  it("queues messages before winston loads and flushes them", async () => {
+    const { logger, flushLogger } = await import("./logger.ts");
+    const logs: string[] = [];
+    logger.info("queued message");
+    await flushLogger();
+    // If we reach here without throwing, the lazy init succeeded
+    expect(true).toBe(true);
+  });
+
+  it("logs directly when already initialized", async () => {
+    const { logger } = await import("./logger.ts");
+    // Second call — _inner should be set, no queue
+    expect(() => logger.info("direct message")).not.toThrow();
+  });
+
+  it("addTransport adds a transport after init", async () => {
+    const { addTransport, flushLogger } = await import("./logger.ts");
+    await flushLogger(); // ensure initialized
+    const winston = (await import("winston")).default;
+    const transport = new winston.transports.Console({ silent: true });
+    await expect(addTransport(transport)).resolves.toBeUndefined();
+  });
+});

package/ts/logger.ts

@@ -1,21 +1,65 @@
-import winston from "winston";
+type LogLevel = "error" | "warn" | "info" | "http" | "verbose" | "debug" | "silly";
+type WinstonLike = Record<LogLevel, (msg: string, ...meta: unknown[]) => void>;
 
-// Configure Winston logger
-const logFormat = winston.format.combine(
-  winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
-  winston.format.printf(({ timestamp, level, message, ...meta }) => {
-    const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : "";
-    return `${timestamp} [${level}]: ${message}${metaStr}`;
-  }),
-);
+let _inner: WinstonLike | null = null;
+let _initPromise: Promise<void> | null = null;
+const _queue: Array<{ level: LogLevel; msg: string; meta: unknown[] }> = [];
 
-export const logger = winston.createLogger({
-  level: process.env.VERBOSE ? "debug" : "info",
-  format: logFormat,
-  transports: [
-    new winston.transports.Console({
-      format: winston.format.combine(winston.format.colorize(), logFormat),
-    }),
-  ],
-  silent: false,
-});
+function init(): Promise<void> {
+  if (_initPromise) return _initPromise;
+  _initPromise = import("winston").then(({ default: winston }) => {
+    const logFormat = winston.format.combine(
+      winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+      winston.format.printf(({ timestamp, level, message, ...meta }) => {
+        const metaStr = Object.keys(meta).length ? ` ${JSON.stringify(meta)}` : "";
+        return `${timestamp} [${level}]: ${message}${metaStr}`;
+      }),
+    );
+    _inner = winston.createLogger({
+      level: process.env.VERBOSE ? "debug" : "info",
+      format: logFormat,
+      transports: [
+        new winston.transports.Console({
+          format: winston.format.combine(winston.format.colorize(), logFormat),
+        }),
+      ],
+      silent: false,
+    }) as unknown as WinstonLike;
+    for (const { level, msg, meta } of _queue.splice(0)) {
+      _inner[level](msg, ...meta);
+    }
+  });
+  return _initPromise;
+}
+
+function makeMethod(level: LogLevel) {
+  return (msg: string, ...meta: unknown[]) => {
+    if (_inner) {
+      _inner[level](msg, ...meta);
+    } else {
+      _queue.push({ level, msg, meta });
+      init().catch((e) => console.error("[logger] Failed to load winston:", e));
+    }
+  };
+}
+
+/** Wait for all queued log messages to be flushed. Call before process.exit when needed. */
+export async function flushLogger(): Promise<void> {
+  await init();
+}
+
+/** Add a winston transport. Awaits logger initialization first. */
+export async function addTransport(transport: unknown): Promise<void> {
+  await init();
+  (_inner as unknown as { add(t: unknown): void }).add(transport);
+}
+
+export const logger = {
+  error: makeMethod("error"),
+  warn: makeMethod("warn"),
+  info: makeMethod("info"),
+  http: makeMethod("http"),
+  verbose: makeMethod("verbose"),
+  debug: makeMethod("debug"),
+  silly: makeMethod("silly"),
+};

package/ts/parseCliArgs.spec.ts

@@ -333,4 +333,92 @@ describe("CLI argument parsing", () => {
     expect(result.cli).toBe("claude");
     expect(result.autoYes).toBe(true);
   });
+
+  it("should parse bare positional words as prompt (cy arg1 arg2)", () => {
+    const result = parseCliArgs(["node", "/usr/local/bin/cy", "arg1", "arg2"]);
+
+    expect(result.cli).toBe("claude");
+    expect(result.prompt).toBe("arg1 arg2");
+    expect(result.cliArgs).toEqual([]);
+  });
+
+  it("should parse bare positional words as prompt with explicit CLI name", () => {
+    const result = parseCliArgs(["node", "/path/to/cli", "claude", "fix", "this", "bug"]);
+
+    expect(result.cli).toBe("claude");
+    expect(result.prompt).toBe("fix this bug");
+    expect(result.cliArgs).toEqual([]);
+  });
+
+  it("should parse bare words as prompt with claude-yes script name", () => {
+    const result = parseCliArgs(["node", "/usr/local/bin/claude-yes", "solve", "all", "todos"]);
+
+    expect(result.cli).toBe("claude");
+    expect(result.prompt).toBe("solve all todos");
+    expect(result.cliArgs).toEqual([]);
+  });
+
+  it("should separate CLI flags from bare words as prompt", () => {
+    const result = parseCliArgs([
+      "node",
+      "/usr/local/bin/claude-yes",
+      "--some-flag",
+      "value",
+      "fix",
+      "the",
+      "bug",
+    ]);
+
+    expect(result.cli).toBe("claude");
+    expect(result.prompt).toBe("fix the bug");
+    expect(result.cliArgs).toContain("--some-flag");
+    expect(result.cliArgs).toContain("value");
+  });
+
+  it("should combine --prompt flag with bare positional words", () => {
+    const result = parseCliArgs([
+      "node",
+      "/usr/local/bin/claude-yes",
+      "--prompt",
+      "prefix:",
+      "solve",
+      "this",
+    ]);
+
+    expect(result.prompt).toBe("prefix: solve this");
+  });
+
+  it("should combine bare positional words with dash prompt", () => {
+    const result = parseCliArgs([
+      "node",
+      "/usr/local/bin/claude-yes",
+      "solve",
+      "--",
+      "this",
+      "too",
+    ]);
+
+    expect(result.prompt).toBe("solve this too");
+  });
+
+  it("should not pass --no-rust to the target CLI", () => {
+    const result = parseCliArgs(["node", "/path/to/cy", "--no-rust"]);
+
+    expect(result.useRust).toBe(false);
+    expect(result.cliArgs).not.toContain("--no-rust");
+  });
+
+  it("should not pass --no-robust to the target CLI", () => {
+    const result = parseCliArgs(["node", "/path/to/cy", "--no-robust"]);
+
+    expect(result.robust).toBe(false);
+    expect(result.cliArgs).not.toContain("--no-robust");
+  });
+
+  it("should not pass --no-queue to the target CLI", () => {
+    const result = parseCliArgs(["node", "/path/to/cy", "--no-queue"]);
+
+    expect(result.queue).toBe(false);
+    expect(result.cliArgs).not.toContain("--no-queue");
+  });
 });

package/ts/parseCliArgs.ts

@@ -1,12 +1,11 @@
 import ms from "ms";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-import { SUPPORTED_CLIS } from "./SUPPORTED_CLIS.ts";
 /**
  * Parse CLI arguments the same way cli.ts does
  * This is a test helper that mirrors the parsing logic in cli.ts
  */
-export function parseCliArgs(argv: string[]) {
+export function parseCliArgs(argv: string[], supportedClis?: readonly string[]) {
   // Detect cli name from script name (same logic as cli.ts:10-14)
   const scriptBaseName =
     argv[1]
@@ -171,7 +170,7 @@ export function parseCliArgs(argv: string[]) {
     .positional("cli", {
       describe: "The AI CLI to run, e.g., claude, codex, copilot, cursor, gemini",
       type: "string",
-      choices: SUPPORTED_CLIS,
+      choices: supportedClis as string[] | undefined,
       demandOption: false,
       default: cliName,
     })
@@ -211,12 +210,33 @@ export function parseCliArgs(argv: string[]) {
     }
   });
 
+  // Collect bare positional words as prompt text (e.g., `cy arg1 arg2` → prompt = "arg1 arg2")
+  const positionalPromptWords: string[] = [];
+
   const cliArgsForSpawn = (() => {
     if (parsedArgv._[0] && !cliName) {
-      // Explicit CLI name provided as positional arg
-      return rawArgs.slice((cliArgIndex ?? 0) + 1, dashIndex ?? undefined);
+      // Explicit CLI name provided as positional arg — separate flags from bare words
+      const allAfterCli = rawArgs.slice((cliArgIndex ?? 0) + 1, dashIndex ?? undefined);
+      const result: string[] = [];
+      for (let i = 0; i < allAfterCli.length; i++) {
+        const arg = allAfterCli[i]!;
+        if (arg.startsWith("-")) {
+          result.push(arg);
+          // Consume the next arg as the flag's value if separate (--flag value)
+          if (!arg.includes("=") && i + 1 < allAfterCli.length) {
+            const nextArg = allAfterCli[i + 1];
+            if (nextArg && !nextArg.startsWith("-")) {
+              result.push(nextArg);
+              i++;
+            }
+          }
+        } else {
+          positionalPromptWords.push(arg);
+        }
+      }
+      return result;
     } else if (cliName) {
-      // CLI name from script, filter out only what yargs consumed
+      // CLI name from script, filter out what yargs consumed; bare words become prompt
       const result: string[] = [];
       const argsToCheck = rawArgs.slice(0, dashIndex ?? undefined);
 
@@ -226,7 +246,11 @@ export function parseCliArgs(argv: string[]) {
 
         const [flag] = arg.split("=");
 
-        if (flag && yargsConsumed.has(flag)) {
+        // Check both the flag itself and its --no- negation (yargs stores --no-x as key "x")
+        const isConsumed =
+          (flag && yargsConsumed.has(flag)) ||
+          (flag?.startsWith("--no-") && yargsConsumed.has(`--${flag.slice(5)}`));
+        if (isConsumed) {
           // Skip consumed flag and its value if separate
           if (!arg.includes("=") && i + 1 < argsToCheck.length) {
             const nextArg = argsToCheck[i + 1];
@@ -234,14 +258,27 @@ export function parseCliArgs(argv: string[]) {
               i++; // Skip value
             }
           }
-        } else {
+        } else if (arg.startsWith("-")) {
+          // Non-consumed flag → pass to target CLI
           result.push(arg);
+          // Consume the next arg as the flag's value if separate
+          if (!arg.includes("=") && i + 1 < argsToCheck.length) {
+            const nextArg = argsToCheck[i + 1];
+            if (nextArg && !nextArg.startsWith("-")) {
+              result.push(nextArg);
+              i++;
+            }
+          }
+        } else {
+          // Bare word → treat as prompt text
+          positionalPromptWords.push(arg);
         }
       }
       return result;
     }
     return [];
   })();
+  const positionalPrompt = positionalPromptWords.join(" ") || undefined;
   const dashPrompt: string | undefined =
     dashIndex === undefined ? undefined : rawArgs.slice(dashIndex + 1).join(" ");
 
@@ -260,9 +297,10 @@ export function parseCliArgs(argv: string[]) {
       parsedArgv.cli ||
       (dashIndex !== 0
         ? parsedArgv._[0]?.toString()?.replace?.(/-yes$/, "")
-        : undefined)) as (typeof SUPPORTED_CLIS)[number],
+        : undefined)) as string,
     cliArgs: [...cliArgsForSpawn, ...(parsedArgv.yes ? ["--dangerously-skip-permissions"] : [])],
-    prompt: [parsedArgv.prompt, dashPrompt].filter(Boolean).join(" ") || undefined,
+    prompt:
+      [parsedArgv.prompt, positionalPrompt, dashPrompt].filter(Boolean).join(" ") || undefined,
     install: parsedArgv.install,
     exitOnIdle: Number(
       (parsedArgv.timeout || parsedArgv.idle || parsedArgv.exitOnIdle)?.replace(/.*/, (e) =>