claude-yes 1.167.0 → 1.169.0

package/ts/needsInput.ts

@@ -78,7 +78,7 @@ export interface MenuState {
 
 // An option row: an optional cursor glyph / bullet, then "N. " (the trailing
 // space rejects version-like "3.5GB" that isn't a menu option).
-const OPTION_LINE = /^[\s❯›>▶◉○●·*\-]*?(\d+)\.\s/;
+const OPTION_LINE = /^[\s❯›>▶◉○●·*-]*?(\d+)\.\s/;
 
 /**
  * Parse the selection menu a `needs_input` agent is parked on into a cursor

package/ts/parseCliArgs.spec.ts

@@ -439,4 +439,22 @@ describe("CLI argument parsing", () => {
     expect(afterCli.useStdinAppend).toBe(true);
     expect(afterCli.cliArgs).toContain("--no-stdpush");
   });
+
+  it("consumes --attach as an agent-yes flag before the CLI positional", () => {
+    const result = parseCliArgs(["node", "/path/to/ay", "--attach", "claude", "--", "task"]);
+    expect(result.attach).toBe(true);
+  });
+
+  it("defaults attach to false so fork-by-default stays enabled", () => {
+    const result = parseCliArgs(["node", "/path/to/ay", "claude"]);
+    expect(result.attach).toBe(false);
+  });
+
+  it("does NOT treat --attach after -- as an agent-yes flag (passthrough safety)", () => {
+    // Everything after `--` is prompt / CLI passthrough, never an agent-yes flag —
+    // so `ay claude -- --attach` sends --attach to the CLI and still forks.
+    const result = parseCliArgs(["node", "/path/to/ay", "claude", "--", "--attach"]);
+    expect(result.attach).toBe(false);
+    expect(result.prompt).toContain("--attach");
+  });
 });

package/ts/parseCliArgs.ts

@@ -30,6 +30,13 @@ export function parseCliArgs(argv: string[], supportedClis?: readonly string[])
       description: "re-spawn Claude with --continue if it crashes, only works for claude yet",
       alias: "r",
     })
+    .option("attach", {
+      type: "boolean",
+      default: false,
+      description:
+        "Run the agent in the foreground even when nested inside another agent (disables fork-by-default; also AGENT_YES_ATTACH=1).",
+      alias: "foreground",
+    })
     .option("logFile", {
       type: "string",
       description: "Rendered log file to write to.",
@@ -307,6 +314,7 @@ export function parseCliArgs(argv: string[], supportedClis?: readonly string[])
     ),
     queue: parsedArgv.queue,
     robust: parsedArgv.robust,
+    attach: parsedArgv.attach,
     logFile: parsedArgv.logFile,
     verbose: parsedArgv.verbose,
     resume: parsedArgv.continue, // Note: intentional use resume here to avoid preserved keyword (continue)

package/ts/removeControlCharacters.spec.ts

@@ -70,4 +70,25 @@ describe("removeControlCharacters", () => {
     const expected = "TextClearLine";
     expect(removeControlCharacters(input)).toBe(expected);
   });
+
+  it("should remove OSC sequences (e.g. window title updates)", () => {
+    const input = "Before\u001b]0;window title\u0007After";
+    const expected = "BeforeAfter";
+    expect(removeControlCharacters(input)).toBe(expected);
+  });
+
+  it("does NOT strip trailing text when an OSC sequence is unterminated (no BEL)", () => {
+    const input = "Before\u001b]0;titleAfter";
+    expect(removeControlCharacters(input)).toBe(input);
+  });
+
+  it("should remove OSC sequences terminated by ST (ESC backslash), not just BEL", () => {
+    const input = "Before\u001b]8;;https://example.com\u001b\\After";
+    expect(removeControlCharacters(input)).toBe("BeforeAfter");
+  });
+
+  it("does not let an ST-terminated OSC run on and eat real text before a later BEL", () => {
+    const input = "Before\u001b]0;t\u001b\\visible\u0007After";
+    expect(removeControlCharacters(input)).toBe("Beforevisible\u0007After");
+  });
 });

package/ts/removeControlCharacters.ts

@@ -1,8 +1,34 @@
+const ESC = String.fromCharCode(0x1b);
+const C1 = String.fromCharCode(0x9b);
+const BEL = String.fromCharCode(0x07);
+const BACKSLASH = String.fromCharCode(0x5c);
+// String Terminator (ESC \) as REGEX SOURCE text: a literal backslash inside a
+// regex pattern is itself an escape character, so matching one literal
+// backslash requires two backslash characters in the pattern source.
+const ST_PATTERN_SOURCE = ESC + BACKSLASH + BACKSLASH;
+
+// OSC sequences (window/tab title updates, hyperlinks, etc.): ESC ] ...
+// terminated by either BEL or ST (ESC \) — both are valid per-spec and used
+// by real terminal apps. Not covered by the CSI pattern below — without this,
+// e.g. a periodic title update would count as "visible" content to callers
+// that gate activity on non-empty output.
+// The terminator is required, not optional: an unterminated ESC]... (the
+// terminator never arrives, e.g. a truncated chunk boundary) must NOT strip
+// through to end-of-string — that would eat real trailing text as if it were
+// part of the title sequence. The body excludes ESC too (not just BEL) so an
+// ST-terminated sequence can't accidentally run on and swallow real text up
+// to some unrelated, later BEL.
+const OSC_PATTERN = new RegExp(
+  ESC + "][^" + BEL + ESC + "]*(?:" + BEL + "|" + ST_PATTERN_SOURCE + ")",
+  "g",
+);
+
+// Matches control characters in the C0 and C1 ranges, including Delete (U+007F)
+const CSI_PATTERN = new RegExp(
+  "[" + ESC + C1 + "][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]",
+  "g",
+);
+
 export function removeControlCharacters(str: string): string {
-  // Matches control characters in the C0 and C1 ranges, including Delete (U+007F)
-  return str.replace(
-    // eslint-disable-next-line no-control-regex This is a control regex
-    /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g,
-    "",
-  );
+  return str.replace(OSC_PATTERN, "").replace(CSI_PATTERN, "");
 }

package/ts/runningLock.ts

@@ -171,6 +171,7 @@ async function checkLock(cwd: string, _prompt: string): Promise<LockCheckResult>
 
   // Find running tasks for this location
   const blockingTasks = lockFile.tasks.filter((task) => {
+    if (task.pid === process.pid) return false; // Never self-block on our own prior entry
     if (!isProcessRunning(task.pid)) return false; // Skip stale locks
     if (task.status !== "running") return false; // Only check running tasks
 

package/ts/serve.ts

@@ -9,6 +9,7 @@ import yargs from "yargs";
 import {
   controlCodeFromName,
   deriveLiveStatus,
+  extractBadges,
   extractNeedsInput,
   extractTaskCounts,
   listRecords,
@@ -935,6 +936,26 @@ export async function cmdServe(rest: string[]): Promise<number> {
     }
   };
 
+  // Per-agent status badges/flags (see badges.ts) matched against the agent's
+  // rendered screen — e.g. an active /goal Stop-hook loop. Cached per
+  // (size, mtime) exactly like logTasks. Extend BADGE_DEFS in badges.ts to
+  // surface more patterns (error banners, other flags); no server changes
+  // needed beyond that.
+  const badgeCache = new Map<string, { size: number; mtimeMs: number; badges: string[] }>();
+  const logBadges = async (logFile: string | null | undefined): Promise<string[]> => {
+    if (!logFile) return [];
+    try {
+      const { size, mtimeMs } = await stat(logFile);
+      const hit = badgeCache.get(logFile);
+      if (hit && hit.size === size && hit.mtimeMs === mtimeMs) return hit.badges;
+      const badges = await extractBadges(logFile);
+      badgeCache.set(logFile, { size, mtimeMs, badges });
+      return badges;
+    } catch {
+      return [];
+    }
+  };
+
   // Per-agent "waiting on you" detection: the agent is parked on an interactive
   // menu it did NOT auto-resolve (config `needsInput` patterns). Same source and
   // classifier as `ay ls` / `ay status`, so the console's dot matches the CLI's
@@ -1148,6 +1169,9 @@ export async function cmdServe(rest: string[]): Promise<number> {
       // Task progress from the rendered todo block (null when none detected → no
       // badge). Skipped for exited agents — their screen is no longer live.
       tasks: status === "exited" ? null : await logTasks(r.log_file),
+      // Status flags matched against the rendered screen (see badges.ts) — e.g.
+      // an active /goal loop. [] when none matched or for exited agents.
+      badges: status === "exited" ? [] : await logBadges(r.log_file),
     };
   };
 

package/ts/subcommands.spec.ts

@@ -964,6 +964,28 @@ describe("subcommands.isExitRequest", () => {
   });
 });
 
+describe("subcommands.isSlashCommand", () => {
+  it("matches a body that starts with a slash command (so it is sent unprefixed)", async () => {
+    const { isSlashCommand } = await loadModule();
+    for (const s of ["/compact", "/clear", "/model sonnet", "/resume\nmore text"]) {
+      expect(isSlashCommand(s)).toBe(true);
+    }
+  });
+  it("does NOT match plain prose, or a slash not at column 0", async () => {
+    const { isSlashCommand } = await loadModule();
+    for (const s of [
+      "please run /compact",
+      " /compact", // leading space — the CLI won't parse it as a command either
+      "//two slashes... wait, no letter after first slash",
+      "/ ",
+      "hello",
+      "",
+    ]) {
+      expect(isSlashCommand(s)).toBe(false);
+    }
+  });
+});
+
 describe("subcommands.writeToIpc reliable delivery", () => {
   const itUnix = process.platform === "linux" || process.platform === "darwin";
 

package/ts/subcommands.ts

@@ -18,6 +18,7 @@ import path from "path";
 import { type GlobalPidRecord, readGlobalPids, updateGlobalPidStatus } from "./globalPidIndex.ts";
 import { buildAgentForest, flattenForest } from "./agentTree.ts";
 import { parseTaskCounts, type TaskCounts } from "./todoParse.ts";
+import { matchBadges } from "./badges.ts";
 import {
   classifyNeedsInput,
   isWorkingScreen,
@@ -2128,6 +2129,17 @@ export async function extractNeedsInput(logPath: string, cli: string): Promise<N
   return classifyNeedsInput(lines, { needsInput: cfg.needsInput, working: cfg.working });
 }
 
+/**
+ * Which badges (see badges.ts) match an agent's current screen — the same 32 KB
+ * tail window `ay tail` renders, no CLI-specific config needed. Returns [] on
+ * any read/render error or an empty log, same failure shape as extractNeedsInput.
+ */
+export async function extractBadges(logPath: string): Promise<string[]> {
+  const lines = await renderLogTailLines(logPath, 40);
+  if (!lines) return [];
+  return matchBadges(lines);
+}
+
 /**
  * Whether an alive agent is wedged: its log has been silent for at least
  * STUCK_THRESHOLD_MS yet its screen still shows a `working` busy marker (a live
@@ -2388,7 +2400,10 @@ export async function extractMenu(logPath: string, cli: string): Promise<MenuSta
 
 /** Poll until the agent is no longer parked on a menu (selection accepted → it
  * resumed / moved on) or the deadline passes. Returns true if it cleared. */
-async function waitForNeedsInputClear(record: GlobalPidRecord, timeoutMs: number): Promise<boolean> {
+async function waitForNeedsInputClear(
+  record: GlobalPidRecord,
+  timeoutMs: number,
+): Promise<boolean> {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     await new Promise((r) => setTimeout(r, 250));
@@ -2476,10 +2491,15 @@ async function cmdSend(rest: string[]): Promise<number> {
   }
 
   // When an agent sends, prefix one line so the recipient knows who pinged it
-  // and exactly how to reply (to a resolvable pid — the sender's own).
-  const prefix = sender.agent
-    ? `[from ${sender.agent.cli} #${sender.agent.pid} @ ${shortenPath(sender.agent.cwd)} — reply: ay send ${sender.agent.pid} "..."]\n`
-    : "";
+  // and exactly how to reply (to a resolvable pid — the sender's own). BUT a
+  // slash command is only recognized when `/` is the very first character of the
+  // submitted message; the prefix would bump it to line 2 and the CLI would type
+  // the command as plain text. So skip the prefix for a command body and send it
+  // verbatim — attribution is dropped for the command, but it actually runs.
+  const prefix =
+    sender.agent && !isSlashCommand(body)
+      ? `[from ${sender.agent.cli} #${sender.agent.pid} @ ${shortenPath(sender.agent.cwd)} — reply: ay send ${sender.agent.pid} "..."]\n`
+      : "";
 
   const fullBody = prefix + body;
   if (fullBody && trailing) {
@@ -2610,9 +2630,7 @@ async function cmdSelect(rest: string[]): Promise<number> {
   const keyword = argv._[0] !== undefined ? String(argv._[0]) : undefined;
   const n = Number(argv._[1]);
   if (!keyword || !Number.isInteger(n) || n < 1) {
-    throw new Error(
-      "usage: ay select <keyword> <N>   (N = the 1-based option number to choose)",
-    );
+    throw new Error("usage: ay select <keyword> <N>   (N = the 1-based option number to choose)");
   }
 
   const opts: CommonOpts = {
@@ -2624,7 +2642,9 @@ async function cmdSelect(rest: string[]): Promise<number> {
   };
   const record = await resolveWritableAgent(keyword, opts);
   if (!record.log_file) {
-    throw new Error(`pid ${record.pid}: no log_file recorded — can't read the menu to select from.`);
+    throw new Error(
+      `pid ${record.pid}: no log_file recorded — can't read the menu to select from.`,
+    );
   }
   const force = Boolean(argv.force) || process.env.AGENT_YES_FORCE_SEND === "1";
   await enforceSendGuards(record, force);
@@ -2636,9 +2656,7 @@ async function cmdSelect(rest: string[]): Promise<number> {
     );
   }
   if (menu.options.length > 0 && !menu.options.includes(n)) {
-    throw new Error(
-      `option ${n} is out of range — this menu offers ${menu.options.join(", ")}.`,
-    );
+    throw new Error(`option ${n} is out of range — this menu offers ${menu.options.join(", ")}.`);
   }
 
   // Move the cursor from where it sits to option N, then confirm. Delta from the
@@ -2648,7 +2666,8 @@ async function cmdSelect(rest: string[]): Promise<number> {
   await writeKeysPaced(record.fifo_file!, byteSeqs, Math.max(0, argv.pace));
 
   const delta = n - menu.cursor;
-  const moved = delta === 0 ? "cursor already there" : `${Math.abs(delta)}× ${delta > 0 ? "down" : "up"}`;
+  const moved =
+    delta === 0 ? "cursor already there" : `${Math.abs(delta)}× ${delta > 0 ? "down" : "up"}`;
   process.stdout.write(
     `pid ${record.pid} (${record.cli}): selected option ${n} (${moved} + enter)\n`,
   );
@@ -2917,6 +2936,14 @@ export function isExitRequest(body: string): boolean {
   return t === "exit" || t === "/exit";
 }
 
+/** A body that the CLI will parse as a slash command — `/` as the very first
+ * character (claude requires column 0, no leading whitespace, then a letter).
+ * Such a body must be sent verbatim: any prefix line bumps the `/` off column 0
+ * and the CLI types the command as plain text instead of running it. */
+export function isSlashCommand(body: string): boolean {
+  return /^\/[A-Za-z]/.test(body);
+}
+
 /**
  * Gracefully terminate a live agent and record WHY in its note (the audit trail
  * shown by `ay ls`). Sends the CLI's graceful-exit command (e.g. claude's

package/dist/SUPPORTED_CLIS-DLFqRE8W.js

@@ -1,8 +0,0 @@
-import "./ts-s3wYccKf.js";
-import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-BvR6tV3u.js";
-import "./pidStore-BfoBWUjc.js";
-import "./globalPidIndex-DlmmJlO8.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DFBATC85.js";
-
-export { SUPPORTED_CLIS };

package/dist/subcommands-B-WoBVhk.js

@@ -1,9 +0,0 @@
-import "./logger-CDIsZ-Pp.js";
-import "./globalPidIndex-DlmmJlO8.js";
-import "./configShared-CEyhl0WH.js";
-import "./e2e-Bfw7qL9O.js";
-import "./webrtcLink-CBZkZ-LT.js";
-import "./remotes-T6nf0t3K.js";
-import { A as writeToIpc, C as resolveReadWindow, D as snapshotStatus, E as runSubcommand, O as stopTipForCli, S as resolveOne, T as restartHintLines, _ as menuSelectKeys, a as cursorAbs, b as renderRawLog, c as extractNeedsInput, d as isAgentStuck, f as isExitRequest, g as matchKeyword, h as listRecords, i as controlCodeFromName, k as writeKeysPaced, l as extractTaskCounts, m as isSubcommand, n as READ_PAGE_DEFAULT, o as deriveLiveStatus, p as isPidAlive, r as cmdHelp, s as extractMenu, t as GRACEFUL_EXIT_COMMANDS, u as finalizedLines, v as readNotes, w as resolveResumeArgs, x as renderRawLogLines, y as readPtysize } from "./subcommands-DWeo7ZLc.js";
-
-export { cmdHelp, isSubcommand, runSubcommand };