agent-yes 1.168.0 → 1.169.1

package/dist/{webrtcLink-CBZkZ-LT.js → webrtcLink-BG0Xc4-W.js}

@@ -1,4 +1,4 @@
-import { u as parseSecret } from "./e2e-Bfw7qL9O.js";
+import { u as parseSecret } from "./e2e-BeKjLhmO.js";
 
 //#region ts/webrtcLink.ts
 const SIGNAL_SUBPROTOCOL = "ay-signal-1";
@@ -42,4 +42,4 @@ function isWebrtcSpec(spec) {
 
 //#endregion
 export { isWebrtcSpec as n, parseWebrtcLink as r, SIGNAL_SUBPROTOCOL as t };
-//# sourceMappingURL=webrtcLink-CBZkZ-LT.js.map
+//# sourceMappingURL=webrtcLink-BG0Xc4-W.js.map

package/dist/{webrtcRemote-GAgF5K45.js → webrtcRemote-SybKurg9.js}

@@ -1,5 +1,5 @@
-import { a as computeTranscriptHash, c as open, d as randomHex, f as seal, l as packEnvelope, n as FLAG_CONFIRM, o as deriveAuthToken, p as unpackEnvelope, s as deriveDirKeys } from "./e2e-Bfw7qL9O.js";
-import { n as isWebrtcSpec, r as parseWebrtcLink, t as SIGNAL_SUBPROTOCOL } from "./webrtcLink-CBZkZ-LT.js";
+import { a as computeTranscriptHash, c as open, d as randomHex, f as seal, l as packEnvelope, n as FLAG_CONFIRM, o as deriveAuthToken, p as unpackEnvelope, s as deriveDirKeys } from "./e2e-BeKjLhmO.js";
+import { n as isWebrtcSpec, r as parseWebrtcLink, t as SIGNAL_SUBPROTOCOL } from "./webrtcLink-BG0Xc4-W.js";
 import { RTCPeerConnection } from "node-datachannel/polyfill";
 
 //#region ts/webrtcRemote.ts
@@ -256,4 +256,4 @@ async function startWebrtcBridge(link) {
 
 //#endregion
 export { startWebrtcBridge };
-//# sourceMappingURL=webrtcRemote-GAgF5K45.js.map
+//# sourceMappingURL=webrtcRemote-SybKurg9.js.map

package/dist/{workspaceConfig-D3OH7and.js → workspaceConfig-BC03X4Y1.js}

@@ -162,4 +162,4 @@ function resolveSpawnCwd(input) {
 
 //#endregion
 export { getSpawnWaitMs as a, isProvisionAllowed as c, getSpawnHook as i, resolveSpawnCwd as l, getMinFreeMb as n, getWorkspaceRoot as o, getProvisionRoot as r, hasSpawnHook as s, getMaxAgents as t, setWorkspaceRoot as u };
-//# sourceMappingURL=workspaceConfig-D3OH7and.js.map
+//# sourceMappingURL=workspaceConfig-BC03X4Y1.js.map

package/lab/ui/console-logic.js

@@ -180,6 +180,22 @@ export function taskLabel(e) {
   return `${t.done}/${t.total}`;
 }
 
+// Display metadata for status flags matched server-side against an agent's
+// screen (ts/badges.ts BADGE_DEFS — matching runs server-side; the API sends
+// just the matched ids in e.badges). Keep the label/title text here in sync
+// with ts/badges.ts. An id with no entry still renders (falls back to the raw
+// id), so a newly-added server-side badge is never silently dropped.
+export const BADGE_META = {
+  "goal-active": { label: "goal", title: "A /goal Stop-hook loop is active on this agent" },
+};
+
+// Status-flag chips ("badges") matched against the agent's screen — e.g. an
+// active /goal loop. [] when e.badges is missing/empty. Returns
+// { id, label, title } objects ready for the caller to render as chips.
+export function badgesFor(e) {
+  return (e.badges || []).map((id) => ({ id, ...(BADGE_META[id] || { label: id, title: id }) }));
+}
+
 // Human age of an agent ("12s" / "5m" / "3h"). `now` is injectable so tests
 // don't depend on the wall clock; the browser calls age(e) and gets Date.now().
 export function age(e, now = Date.now()) {

package/lab/ui/index.html

@@ -891,6 +891,20 @@
         color: var(--green);
         border-color: #2a3a2a;
       }
+      /* Status-flag chip ("badge") matched server-side against the agent's
+         screen — e.g. an active /goal loop (ts/badges.ts). Same pill shape as
+         .tasks but accent-colored so a matched flag stands out as a distinct
+         signal, not just a counter. */
+      .flag {
+        font-family: var(--mono);
+        font-size: 10.5px;
+        color: var(--accent);
+        white-space: nowrap;
+        flex: none;
+        padding: 0 5px;
+        border: 1px solid var(--accent);
+        border-radius: 8px;
+      }
       /* The pending question when an agent needs_input — blue accent to match the
          needs_input dot, reading as "your turn / here's what it's asking". */
       .detail.ask {
@@ -1543,6 +1557,7 @@
         sortEntries,
         SORT_MODES,
         taskLabel,
+        badgesFor,
         hashHue,
         selFromBottom,
         parseSel,
@@ -3219,6 +3234,17 @@
         return `<span class="tasks${allDone ? " done" : ""}" title="${esc(tip)}">${esc(label)}</span>`;
       }
 
+      // Status-flag chips ("badges") matched server-side against the agent's
+      // screen (ts/badges.ts) — e.g. an active /goal loop. One small pill per
+      // matched flag; "" when none matched. CSS class is "flag" (not "badge")
+      // to avoid colliding with the existing pid pill's .badge class. See
+      // BADGE_META in console-logic.js for the id → label/title mapping.
+      function badgeChipsHtml(e) {
+        return badgesFor(e)
+          .map((b) => `<span class="flag" title="${esc(b.title)}">${esc(b.label)}</span>`)
+          .join("");
+      }
+
       // A room/peer group header row. Non-selectable; carries the same tree rails
       // as agent rows so the hierarchy reads as one tree. The room/peer layers
       // only appear here when there are ≥2 of them (single ones fold away in
@@ -3268,6 +3294,7 @@
         ${cli ? `<span class="cname">${esc(cli)}</span>` : ""}
         <span class="ctitle ${e.title ? "" : "dim"}" title="${esc(t)}">${esc(t)}</span>
         ${taskChipHtml(e)}
+        ${badgeChipsHtml(e)}
         ${gitChipHtml(e)}
         <span class="age">${age(e)}</span></div>`;
               })
@@ -3293,6 +3320,7 @@
           <span class="name">${esc(cliLabel(e) || ident(e) || "agent")}</span>
           <span class="badge">pid ${e.pid}</span>
           ${taskChipHtml(e)}
+          ${badgeChipsHtml(e)}
           ${gitChipHtml(e)}
           <span class="age">${age(e)}</span></div>
         ${e.title ? `<div class="rowtitle" title="${esc(e.title)}">${esc(e.title)}</div>` : ""}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.168.0",
+  "version": "1.169.1",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",

package/ts/badges.spec.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { badgeDef, BADGE_DEFS, matchBadges, type BadgeDef } from "./badges.ts";
+
+describe("matchBadges", () => {
+  it("matches goal-active when the /goal status line is on screen", () => {
+    const lines = ["some output", "/goal active (42s)", "more output"];
+    expect(matchBadges(lines)).toEqual(["goal-active"]);
+  });
+
+  it("is case-insensitive", () => {
+    expect(matchBadges(["/GOAL ACTIVE (1s)"])).toEqual(["goal-active"]);
+  });
+
+  it("returns empty when nothing matches", () => {
+    expect(matchBadges(["just some regular CLI output", "nothing special here"])).toEqual([]);
+  });
+
+  it("returns empty for an empty screen", () => {
+    expect(matchBadges([])).toEqual([]);
+  });
+
+  it("matches across a join boundary between lines (pattern spans the joined text)", () => {
+    // Sanity: matchBadges joins lines with \n before testing, so a pattern that
+    // doesn't care about line boundaries still finds a hit split across two lines.
+    const defs: BadgeDef[] = [{ id: "spans", label: "x", title: "t", pattern: /foo\nbar/ }];
+    expect(matchBadges(["foo", "bar"], defs)).toEqual(["spans"]);
+  });
+
+  it("supports custom def sets independent of the built-in BADGE_DEFS", () => {
+    const defs: BadgeDef[] = [
+      { id: "custom-error", label: "err", title: "custom error banner", pattern: /FATAL: boom/ },
+    ];
+    expect(matchBadges(["FATAL: boom"], defs)).toEqual(["custom-error"]);
+    expect(matchBadges(["FATAL: boom"])).toEqual([]); // not in the default set
+  });
+
+  it("can match multiple badges at once, in def order", () => {
+    const defs: BadgeDef[] = [
+      { id: "a", label: "a", title: "a", pattern: /alpha/ },
+      { id: "b", label: "b", title: "b", pattern: /beta/ },
+    ];
+    expect(matchBadges(["alpha and beta both here"], defs)).toEqual(["a", "b"]);
+  });
+});
+
+describe("badgeDef", () => {
+  it("looks up a built-in definition by id", () => {
+    expect(badgeDef("goal-active")).toBe(BADGE_DEFS[0]);
+  });
+
+  it("returns undefined for an unknown id", () => {
+    expect(badgeDef("does-not-exist")).toBeUndefined();
+  });
+});

package/ts/badges.ts

@@ -0,0 +1,42 @@
+/**
+ * Badge/flag matchers: small regex patterns run against an agent's last
+ * rendered screen (the same tail window `ay tail` shows — see
+ * extractBadges in subcommands.ts) to surface a short status chip in the
+ * web console's agent list. Extensible: add more entries to BADGE_DEFS as
+ * useful patterns turn up (a known error banner, a loop-state flag, etc.).
+ * Pure and CLI-agnostic — a definition just won't match on CLIs that never
+ * print its pattern.
+ */
+
+export interface BadgeDef {
+  /** Stable id, used as the wire value and as the key when re-deriving the label. */
+  id: string;
+  /** Short chip text, e.g. "goal". Keep it a couple of characters — the chip is tiny. */
+  label: string;
+  /** Tooltip shown on hover, explaining what the badge means. */
+  title: string;
+  /** Matched against the tail-rendered screen text (lines joined with \n). */
+  pattern: RegExp;
+}
+
+export const BADGE_DEFS: BadgeDef[] = [
+  {
+    id: "goal-active",
+    label: "goal",
+    title: "A /goal Stop-hook loop is active on this agent",
+    pattern: /\/goal active/i,
+  },
+];
+
+/**
+ * Which badge ids match the given rendered screen lines. Pure so it's
+ * unit-tested without a live PTY/log file.
+ */
+export function matchBadges(lines: string[], defs: BadgeDef[] = BADGE_DEFS): string[] {
+  const text = lines.join("\n");
+  return defs.filter((d) => d.pattern.test(text)).map((d) => d.id);
+}
+
+export function badgeDef(id: string, defs: BadgeDef[] = BADGE_DEFS): BadgeDef | undefined {
+  return defs.find((d) => d.id === id);
+}

package/ts/cli.ts

@@ -106,6 +106,52 @@ if (config.useRust) {
       console.log(`[rust] Args: ${rustArgs.join(" ")}`);
     }
 
+    // Nested + non-tty (e.g. an agent ran this via its Bash tool): detach the
+    // agent so we don't block the parent's tool call for the whole session, then
+    // print how to drive it and exit. `--attach`/AGENT_YES_ATTACH=1 opts out.
+    const attach = config.attach || process.env.AGENT_YES_ATTACH === "1";
+    const { shouldForkNested, buildSpawnTutorial, waitForFifo } = await import("./forkNested.ts");
+    if (
+      shouldForkNested({
+        isTTY: Boolean(process.stdout.isTTY),
+        ayPid: process.env.AGENT_YES_PID,
+        attach,
+      })
+    ) {
+      const forked = spawn(rustBinary, rustArgs, {
+        detached: true,
+        stdio: "ignore",
+        env: process.env,
+        cwd: process.cwd(),
+      });
+      const forkedPid = forked.pid;
+      if (!forkedPid) {
+        console.error("Failed to spawn agent: no pid.");
+        process.exit(1);
+      }
+      // Race a fast startup failure against FIFO registration so we never print a
+      // success tutorial for a dead pid. The wrapper keeps its own per-pid log, so
+      // real output stays reachable via `ay tail` even with stdio ignored. Store a
+      // pre-formatted message (not a union) — the callbacks run async, so control-flow
+      // analysis can't narrow a union here anyway.
+      let deathMsg: string | null = null;
+      forked.on("error", (err) => {
+        deathMsg ??= `Failed to spawn agent: ${err.message}`;
+      });
+      forked.on("exit", (code, signal) => {
+        deathMsg ??= `Agent exited immediately (${signal ?? `code ${code}`}). See: ay tail ${forkedPid}`;
+      });
+      const registered = await waitForFifo(forkedPid, 2000, () => deathMsg !== null);
+      if (deathMsg) {
+        console.error(deathMsg);
+        process.exit(1);
+      }
+      forked.unref();
+      console.log(buildSpawnTutorial(config.cli || "agent", forkedPid));
+      if (!registered) console.log(`(note: still registering — give ay send/tail a moment)`);
+      process.exit(0);
+    }
+
     const child = spawn(rustBinary, rustArgs, {
       stdio: "inherit",
       env: process.env,

package/ts/forkNested.spec.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import { buildSpawnTutorial, shouldForkNested } from "./forkNested";
+
+describe("shouldForkNested", () => {
+  it("forks when nested (AGENT_YES_PID set) and stdout is not a TTY", () => {
+    expect(shouldForkNested({ isTTY: false, ayPid: "1234", attach: false })).toBe(true);
+  });
+
+  it("does NOT fork on an interactive TTY (a human running it directly)", () => {
+    expect(shouldForkNested({ isTTY: true, ayPid: "1234", attach: false })).toBe(false);
+  });
+
+  it("does NOT fork when not nested — a human piping output has no AGENT_YES_PID", () => {
+    expect(shouldForkNested({ isTTY: false, ayPid: undefined, attach: false })).toBe(false);
+    expect(shouldForkNested({ isTTY: false, ayPid: "", attach: false })).toBe(false);
+    expect(shouldForkNested({ isTTY: false, ayPid: "   ", attach: false })).toBe(false);
+  });
+
+  it("does NOT fork when attach opts out, regardless of context", () => {
+    expect(shouldForkNested({ isTTY: false, ayPid: "1234", attach: true })).toBe(false);
+  });
+});
+
+describe("buildSpawnTutorial", () => {
+  it("names the cli + pid and lists the drive commands with that pid", () => {
+    const out = buildSpawnTutorial("claude", 4242);
+    expect(out).toContain("Spawned claude agent as pid 4242");
+    expect(out).toContain("ay tail 4242");
+    expect(out).toContain("ay send 4242");
+    expect(out).toContain("ay ls");
+    expect(out).toContain("ay result get 4242");
+    expect(out).toContain("ay exit 4242");
+  });
+});

package/ts/forkNested.ts

@@ -0,0 +1,64 @@
+import { existsSync } from "fs";
+import path from "path";
+import { agentYesHome } from "./agentYesHome.ts";
+
+/**
+ * Should a nested agent-run detach (fork) instead of blocking the caller?
+ *
+ * A claude/codex agent that runs `ay <cli> -- <task>` inside its Bash tool would
+ * otherwise block that Bash call for the whole (possibly very long) session and
+ * time out. When we detect that context we spawn the agent detached, print a
+ * tutorial, and return immediately so the parent stays responsive.
+ *
+ * The context is: we are NESTED inside another agent (`AGENT_YES_PID` is injected
+ * into an agent's environment by its wrapper — a human shell never has it) AND
+ * stdout is not a TTY (captured/piped, e.g. a tool's Bash). A human piping output
+ * (`ay claude | cat`) has no `AGENT_YES_PID`, so they still block as before.
+ * `attach` (the `--attach` flag or `AGENT_YES_ATTACH=1`) forces foreground.
+ */
+export function shouldForkNested(opts: {
+  isTTY: boolean;
+  ayPid: string | undefined;
+  attach: boolean;
+}): boolean {
+  if (opts.attach) return false;
+  if (opts.isTTY) return false;
+  return Boolean(opts.ayPid && opts.ayPid.trim());
+}
+
+/** The tutorial printed to the parent agent after a detached spawn, telling it
+ *  exactly how to drive the agent it just started. */
+export function buildSpawnTutorial(cli: string, pid: number): string {
+  return [
+    `Spawned ${cli} agent as pid ${pid} (detached — this shell returned immediately).`,
+    `It runs in the background; drive it with:`,
+    `  ay tail ${pid}          # watch its output (live)`,
+    `  ay send ${pid} "..."    # send it a message / instruction`,
+    `  ay send ${pid} /compact # send a slash command`,
+    `  ay ls                   # list running agents`,
+    `  ay result get ${pid}    # read its final result when done`,
+    `  ay exit ${pid}          # stop it`,
+  ].join("\n");
+}
+
+/**
+ * Poll for the spawned wrapper's stdin FIFO to appear, so the tutorial's
+ * `ay send`/`ay tail` work the instant we print them (the wrapper registers its
+ * FIFO a moment after spawn). Resolves true once registered, false on timeout or
+ * if `aborted()` reports the child already died (so a startup failure fails fast
+ * instead of waiting out the whole window).
+ */
+export async function waitForFifo(
+  pid: number,
+  timeoutMs = 2000,
+  aborted?: () => boolean,
+): Promise<boolean> {
+  const fifo = path.join(agentYesHome(), "fifo", `${pid}.stdin`);
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (aborted?.()) return false;
+    if (existsSync(fifo)) return true;
+    await new Promise((r) => setTimeout(r, 50));
+  }
+  return existsSync(fifo);
+}

package/ts/index.ts

@@ -896,7 +896,12 @@ export default async function agentYes({
       // Silently ignore heartbeat errors to avoid disrupting main flow
       logger.debug(`heartbeat|error: ${error}`);
     }
-  }, 800); // Run every 800ms
+  }, 100); // Run every 100ms — cheap when unchanged (see the rendered === lastHeartbeatRendered
+  // guard above): most ticks bail after one xtermProxy.tail(12) + string compare. A short
+  // interval matters for two things this heartbeat drives: no-EOL ready/fatal detection
+  // (CSI-redrawn output never fires the newline-driven consoleResponder path) and auto-retry
+  // backoff timing precision (AUTO_RETRY_MIN_IDLE_MS gating). Previously 800ms; still coarser
+  // than Rust's HEARTBEAT_INTERVAL_MS=50 (rs/src/context.rs) since Rust's per-tick cost is lower.
 
   // Clear heartbeat on exit
   const cleanupHeartbeat = () => clearInterval(heartbeatInterval);
@@ -1312,14 +1317,18 @@ export default async function agentYes({
     await Promise.race([
       pendingExitCode.promise.then(() => (exited = true)), // resolve when shell exits
 
-      // if shell doesn't exit in 5 seconds, kill it
+      // if shell doesn't exit in 2 seconds, kill it. Rust's equivalent (rs/src/context.rs)
+      // doesn't wait for the child's own exit at all — it sends the exit command(s) and tears
+      // down immediately. 2s keeps a real grace window for a CLI to actually process `/exit`
+      // (flush session state, close connections) while still bounding the worst case — down
+      // from a previous 5s that mostly just delayed force-killing CLIs that never respond.
       new Promise<void>((resolve) =>
         setTimeout(() => {
           if (exited) return; // if shell already exited, do nothing
           shell.kill(); // kill the shell process if it doesn't exit in time
           resolve();
-        }, 5000),
-      ), // 5 seconds timeout
+        }, 2000),
+      ), // 2 seconds timeout
     ]);
   }
 

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/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";