agent-yes 1.72.4 → 1.73.0

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,
@@ -185,9 +185,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 +334,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);
@@ -447,6 +455,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 +557,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 +611,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 +628,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 +906,7 @@ export default async function agentYes({
           shell.write(data);
         },
       }),
-      readable: terminalStream.readable,
+      readable: xtermProxy.readable,
     })
 
     .forEach(() => {
@@ -926,97 +937,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 +1029,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 +1038,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/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

@@ -211,12 +211,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 +247,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 +259,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(" ");
 
@@ -262,7 +300,8 @@ export function parseCliArgs(argv: string[]) {
         ? parsedArgv._[0]?.toString()?.replace?.(/-yes$/, "")
         : undefined)) as (typeof SUPPORTED_CLIS)[number],
     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) =>

package/ts/rustBinary.ts

@@ -2,9 +2,11 @@
  * Rust binary helper - finds or downloads the appropriate prebuilt binary
  */
 
+import { execFileSync } from "child_process";
 import { existsSync, mkdirSync, unlinkSync } from "fs";
 import { chmod, copyFile } from "fs/promises";
 import path from "path";
+import pkg from "../package.json" with { type: "json" };
 
 // Platform/arch to binary name mapping
 const PLATFORM_MAP: Record<string, string> = {
@@ -192,6 +194,70 @@ export async function downloadBinary(verbose = false): Promise<string> {
   return binaryPath;
 }
 
+/**
+ * Get the version of a Rust binary by running it with --version
+ */
+function getRustBinaryVersion(binaryPath: string): string | null {
+  try {
+    const output = execFileSync(binaryPath, ["--version"], {
+      timeout: 5000,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+    });
+    // Output is like "agent-yes 1.72.3" or "agent-yes v1.72.3"
+    const match = output.match(/(\d+\.\d+\.\d+)/);
+    return match ? match[1] : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if a binary path is inside a git repo (dev build), and rebuild if outdated.
+ * Returns the same path if up-to-date or rebuilt, undefined if rebuild failed.
+ */
+function autoRebuildIfOutdated(binaryPath: string, verbose: boolean): boolean {
+  // Only auto-rebuild for local dev builds (target/release or target/debug)
+  if (!binaryPath.includes("/target/release") && !binaryPath.includes("/target/debug")) {
+    return true; // not a dev build, skip
+  }
+
+  const binaryVersion = getRustBinaryVersion(binaryPath);
+  if (verbose) {
+    console.log(`[rust] Binary version: ${binaryVersion}, package version: ${pkg.version}`);
+  }
+
+  if (binaryVersion === pkg.version) {
+    return true; // up to date
+  }
+
+  // Find the rs/ directory relative to the binary (binary is at rs/target/release/agent-yes)
+  const rsDir = binaryPath.replace(/\/target\/(release|debug)\/agent-yes.*$/, "");
+  if (!existsSync(path.join(rsDir, "Cargo.toml"))) {
+    if (verbose) console.log(`[rust] Cannot find Cargo.toml at ${rsDir}, skipping rebuild`);
+    return true; // can't rebuild, use as-is
+  }
+
+  process.stderr.write(
+    `\x1b[33m[rust] Binary outdated (${binaryVersion ?? "unknown"} → ${pkg.version}), rebuilding…\x1b[0m\n`,
+  );
+
+  try {
+    const isRelease = binaryPath.includes("/target/release");
+    const args = ["build", ...(isRelease ? ["--release"] : [])];
+    execFileSync("cargo", args, {
+      cwd: rsDir,
+      stdio: "inherit",
+      timeout: 300_000, // 5 min max
+    });
+    process.stderr.write(`\x1b[32m[rust] Rebuild complete\x1b[0m\n`);
+    return true;
+  } catch {
+    process.stderr.write(`\x1b[31m[rust] Auto-rebuild failed, using outdated binary\x1b[0m\n`);
+    return true; // still usable, just old
+  }
+}
+
 /**
  * Get or download the Rust binary
  */
@@ -210,6 +276,8 @@ export async function getRustBinary(
       if (verbose) {
         console.log(`[rust] Using existing binary: ${existing}`);
       }
+      // Auto-rebuild if it's a dev build and version is outdated
+      autoRebuildIfOutdated(existing, verbose);
       return existing;
     }
   }

package/ts/versionChecker.spec.ts

@@ -4,6 +4,8 @@ import {
   compareVersions,
   fetchLatestVersion,
   displayVersion,
+  detectInstallMethod,
+  versionString,
 } from "./versionChecker";
 
 vi.mock("execa", () => ({ execaCommand: vi.fn().mockResolvedValue({}) }));
@@ -12,6 +14,16 @@ vi.mock("fs/promises", () => ({
   readFile: vi.fn(),
   writeFile: vi.fn().mockResolvedValue(undefined),
 }));
+vi.mock("fs", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("fs")>();
+  return {
+    ...actual,
+    // Return false for .git checks so the dev-checkout guard doesn't skip auto-update in tests
+    existsSync: vi.fn(() => false),
+    lstatSync: actual.lstatSync,
+    readlinkSync: actual.readlinkSync,
+  };
+});
 vi.mock("child_process", () => ({
   execFileSync: vi.fn(() => {
     // Simulate successful re-exec by throwing an exit-like error
@@ -106,6 +118,14 @@ describe("versionChecker", () => {
       expect(fetch).not.toHaveBeenCalled();
     });
 
+    it("should skip when running from a git dev checkout", async () => {
+      const fs = await import("fs");
+      // Make the .git check return true so the dev-checkout guard triggers
+      vi.mocked(fs.existsSync).mockReturnValueOnce(true);
+      await checkAndAutoUpdate();
+      expect(fetch).not.toHaveBeenCalled();
+    });
+
     it("should skip when AGENT_YES_UPDATED matches current version", async () => {
       const pkg = await import("../package.json");
       process.env.AGENT_YES_UPDATED = pkg.default.version;
@@ -252,4 +272,32 @@ describe("versionChecker", () => {
       expect(console.log).toHaveBeenCalledWith(expect.stringContaining("unable to check"));
     });
   });
+
+  describe("detectInstallMethod", () => {
+    it("should return a string", () => {
+      const method = detectInstallMethod();
+      expect(typeof method).toBe("string");
+      expect(method.length).toBeGreaterThan(0);
+    });
+
+    it("should return 'git' when .git exists in parent of script dir", async () => {
+      const fs = await import("fs");
+      vi.mocked(fs.existsSync).mockReturnValueOnce(true);
+      expect(detectInstallMethod()).toBe("git");
+    });
+
+    it("should return 'source' when not in node_modules and no .git", async () => {
+      const fs = await import("fs");
+      vi.mocked(fs.existsSync).mockReturnValueOnce(false);
+      expect(detectInstallMethod()).toBe("source");
+    });
+  });
+
+  describe("versionString", () => {
+    it("should include version and install method", () => {
+      const str = versionString();
+      expect(str).toContain("agent-yes v");
+      expect(str).toMatch(/agent-yes v\d+\.\d+\.\d+ \(.+\)/);
+    });
+  });
 });