agent-yes 1.169.1 → 1.171.0

package/lab/ui/index.html

@@ -37,6 +37,9 @@
         --purple: #bc8cff;
         --pink: #f778ba;
         --red: #f85149;
+        /* Peer-focus yellow: a human collaborator (not you) is on this agent.
+           Distinct from your own blue (--accent) and the idle-dot amber. */
+        --peer: #e3b341;
         --mono: ui-monospace, SFMono-Regular, "SF Mono", Menlo, monospace;
         /* Safe-area insets — non-zero only in a standalone PWA on a notched /
            gesture-bar device (else 0, so these are harmless on desktop). Consumed
@@ -70,6 +73,7 @@
           --purple: #8250df;
           --pink: #bf3989;
           --red: #cf222e;
+          --peer: #bf8700;
         }
       }
       * {
@@ -420,6 +424,21 @@
         font-size: 11.5px;
         margin-top: 8px;
       }
+      .metaleft {
+        display: inline-flex;
+        align-items: center;
+        gap: 8px;
+      }
+      /* Peers badge beside the agent counter — how many other humans are in the
+         fleet right now. Yellow ("here") when a peer shares the agent you have
+         open, muted otherwise. Hidden entirely when you're alone. */
+      .peers {
+        color: var(--muted);
+        cursor: default;
+      }
+      .peers.here {
+        color: var(--peer);
+      }
       .connbadge {
         cursor: pointer;
         user-select: none;
@@ -630,6 +649,10 @@
       .omni-spawn .omni-title {
         color: var(--green);
       }
+      /* Destructive slash command (/kill) — red title, matching the ⋯-menu Force-kill. */
+      .omni-spawn.danger .omni-title {
+        color: var(--red);
+      }
       .omni-empty {
         padding: 14px;
         color: var(--muted);
@@ -814,6 +837,39 @@
         background: var(--panel);
         box-shadow: inset 3px 0 0 var(--accent);
       }
+      /* A human peer (not you) is watching this agent: yellow, mirrored on the
+         RIGHT edge so it can coexist with your own blue selection bar on the
+         left — a row you BOTH have open shows blue-left + yellow-right. */
+      .row.peerfocus {
+        box-shadow: inset -3px 0 0 var(--peer);
+        background: color-mix(in srgb, var(--peer) 7%, transparent);
+      }
+      .row.sel.peerfocus {
+        background: var(--panel);
+        box-shadow: inset 3px 0 0 var(--accent), inset -3px 0 0 var(--peer);
+      }
+      /* stdin just landed here (someone typed, or `ay send` pushed a command) —
+         pulse the row regardless of who (if anyone) is focused on it. Runs while
+         the .stdinflash class is present; index.html removes it after the window. */
+      .row.stdinflash {
+        animation: stdinpulse 0.6s ease-in-out infinite;
+      }
+      @keyframes stdinpulse {
+        0%,
+        100% {
+          background-color: transparent;
+        }
+        50% {
+          background-color: color-mix(in srgb, var(--peer) 24%, transparent);
+        }
+      }
+      /* Per-row chip: how many peers are watching THIS agent (yellow, mono). */
+      .peerchip {
+        font-family: var(--mono);
+        font-size: 11px;
+        color: var(--peer);
+        flex: none;
+      }
       .r1 {
         display: flex;
         align-items: center;
@@ -891,6 +947,26 @@
         color: var(--green);
         border-color: #2a3a2a;
       }
+      /* Folded-subagent summary chip ("⊞ 3/5" = 3 working of 5 hidden subagents),
+         shown on a root agent row when the subagent trees are collapsed. Same pill
+         shape as .tasks; the ⊞ glyph echoes the fold toolbar button. Turns accent
+         when any hidden subagent is still working, so a collapsed tree with live
+         children stands out from a quiet one. Hover for the count + last-active. */
+      .subs {
+        font-family: var(--mono);
+        font-size: 10.5px;
+        color: var(--muted);
+        white-space: nowrap;
+        flex: none;
+        padding: 0 5px;
+        border: 1px solid var(--line);
+        border-radius: 8px;
+        cursor: pointer;
+      }
+      .subs.active {
+        color: var(--accent);
+        border-color: var(--accent);
+      }
       /* 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
@@ -1368,8 +1444,12 @@
             />
           </div>
           <div class="meta">
-            <span id="count"></span>
+            <span class="metaleft">
+              <span id="count"></span>
+              <span id="peers" class="peers" hidden></span>
+            </span>
             <span class="metaright">
+              <button id="foldbtn" class="viewbtn" title="fold subagent trees">⊞ subs</button>
               <button id="sortbtn" class="viewbtn" title="cycle sort order">⇅ state</button>
               <button id="viewbtn" class="viewbtn" title="toggle compact list">☰</button>
               <button id="newbtn" class="newbtn" title="spawn a new agent on this fleet">
@@ -1554,10 +1634,13 @@
         hasIdent,
         deviceCount,
         layeredRows,
+        foldSummaries,
         sortEntries,
         SORT_MODES,
         taskLabel,
         badgesFor,
+        advanceStdinFlashes,
+        focusSummary,
         hashHue,
         selFromBottom,
         parseSel,
@@ -1584,6 +1667,17 @@
 
       let entries = [];
       let sel = null; // selected agent's composite key (room#pid)
+      // Collaborative presence, fleet-wide: focusByKey maps an agent's _key ->
+      // how many OTHER human peers are watching it (yellow bars + per-row chip);
+      // peerTotal is the distinct-peer count for the header badge. stdinSeen +
+      // flashUntil drive the stdin pulse: stdinSeen remembers each agent's last
+      // last_stdin_at so we can spot a bump, flashUntil holds the deadline the
+      // row keeps pulsing to. See advanceStdinFlashes/focusSummary (console-logic).
+      let focusByKey = new Map();
+      let peerTotal = 0;
+      const stdinSeen = new Map();
+      const flashUntil = new Map();
+      const STDIN_FLASH_MS = 1200;
       let es = null; // live-tail subscription closer
       let term = null; // xterm.js Terminal rendering the raw PTY stream
       let fit = null;
@@ -2687,10 +2781,65 @@
         }
         renderPeerSelections();
       }
+      // Fleet-wide presence: unlike pollPresence (only the SELECTED agent's host,
+      // for the terminal overlay), this reads EVERY live source's blackboard so
+      // the left panel can colour any agent a peer is watching. Each viewer
+      // self-reports the pid it's on; we map that back to the source's composite
+      // _key. Best-effort — a source that 404s (older host) contributes nothing.
+      async function pollFleetPresence() {
+        const recs = [];
+        await Promise.all(
+          [...sources.values()].map(async (s) => {
+            if (!s.tx || !s.live) return;
+            let all;
+            try {
+              all = await s.tx.fetchJSON("/api/presence");
+            } catch {
+              return;
+            }
+            if (!Array.isArray(all)) return;
+            const keyOfPid = new Map((s.agents || []).map((e) => [String(e.pid), e._key]));
+            for (const v of all) {
+              if (!v || v.viewer === myViewerId) continue;
+              const key = keyOfPid.get(String(v.agent));
+              // Prefix the viewer id with its source so the same id on two hosts
+              // still counts as two distinct people in the fleet total.
+              if (key) recs.push({ key, viewer: s.id + ":" + v.viewer });
+            }
+          }),
+        );
+        const sum = focusSummary(recs);
+        focusByKey = sum.byKey;
+        peerTotal = sum.total;
+        paintPeersBadge();
+        renderList();
+      }
+      // "N peers" badge beside the agent counter. Yellow when a peer shares the
+      // agent you have open ("same agent"); its tooltip breaks the count down by
+      // agent so you can see who's where. Hidden when you're the only one here.
+      function paintPeersBadge() {
+        const el = $("peers");
+        if (!el) return;
+        if (!peerTotal) {
+          el.hidden = true;
+          el.removeAttribute("title");
+          return;
+        }
+        el.hidden = false;
+        el.textContent = `👤 ${peerTotal} peer${peerTotal === 1 ? "" : "s"}`;
+        el.classList.toggle("here", !!(sel && focusByKey.get(sel)));
+        const lines = [...focusByKey.entries()].map(([k, n]) => {
+          const e = entries.find((x) => x._key === k);
+          const name = e ? e.title || cliLabel(e) || ident(e) || `pid ${e.pid}` : k;
+          return `  ${n} on ${name}`;
+        });
+        el.title = "peers watching agents in this fleet:\n" + lines.join("\n");
+      }
       // 3s heartbeat (< the host's 12s TTL): refresh our presence + read others',
       // and follow the canonical grid size (resize+scale, never reflow) so all
       // viewers stay on one shared canvas and selections line up.
       setInterval(() => {
+        pollFleetPresence(); // fleet-wide peer focus (independent of what's selected)
         if (!sel) return;
         sendPresence();
         pollPresence();
@@ -2701,6 +2850,20 @@
             .then(followAgentSize)
             .catch(() => {});
       }, 3000);
+      // Fast pulse loop: drive the stdin flash on the STABLE list DOM (toggle a
+      // class, no re-render) so a pulse begins/ends promptly regardless of the
+      // list's own render cadence. Cheap — a no-op until something is flashing.
+      setInterval(() => {
+        if (!flashUntil.size) return;
+        const now = Date.now();
+        for (const [k, until] of [...flashUntil.entries()]) if (until <= now) flashUntil.delete(k);
+        const listEl = $("list");
+        if (!listEl) return;
+        for (const el of listEl.querySelectorAll(".row[data-key]")) {
+          const on = (flashUntil.get(el.getAttribute("data-key")) || 0) > now;
+          el.classList.toggle("stdinflash", on);
+        }
+      }, 200);
 
       // Peer-selection overlay. The coordinate math (parseSel / selSegments /
       // hashHue) lives in console-logic.js (unit-tested); here we just measure the
@@ -2819,8 +2982,10 @@
       //   Force — escalation a stuck agent can't ignore: a real SIGKILL of its process
       //           GROUP, server-side via POST /api/kill. Use when /exit does nothing.
       const GRACEFUL_EXIT = { claude: "/exit", codex: "/exit", gemini: "/quit" };
-      async function stopAgent(force) {
-        const e = sel ? entries.find((x) => x._key === sel) : null;
+      // `ent` targets a specific agent (the Cmd+K /kill · /restart commands pass the
+      // omnibox anchor); the ⋯-menu buttons omit it and act on the selected agent.
+      async function stopAgent(force, ent) {
+        const e = ent || (sel ? entries.find((x) => x._key === sel) : null);
         if (!e) return;
         const who = `pid ${e.pid} ${cliLabel(e) || ident(e) || ""}`.trim();
         const tx = txFor(e),
@@ -2843,8 +3008,8 @@
       // Restart — stop (if live) + relaunch resuming the session, server-side via
       // POST /api/restart (the `ay restart` flow). The server runs it detached, so
       // it's decoupled from this agent's lifecycle — no prompt typed into the agent.
-      async function restartAgent() {
-        const e = sel ? entries.find((x) => x._key === sel) : null;
+      async function restartAgent(ent) {
+        const e = ent || (sel ? entries.find((x) => x._key === sel) : null);
         if (!e) return;
         const who = `pid ${e.pid} ${cliLabel(e) || ident(e) || ""}`.trim();
         if (!confirm(`Restart ${who}?\nStops it (if live) and relaunches resuming the session.`))
@@ -3191,6 +3356,14 @@
       // Compact list: one line per agent (dot + cli + title), persisted per device.
       let compactList = localStorage.getItem("ay.compactList") === "1";
 
+      // Fold subagent trees: hide nested (sub)agent rows and roll each root's
+      // hidden descendants into a summary chip. Folded BY DEFAULT (only "0" opts
+      // out) so a busy fleet reads as a flat list of top-level agents at a glance.
+      let foldSubs = localStorage.getItem("ay.foldSubs") !== "0";
+      // Per-render Map(rootEntry → { total, working, lastActive }); rebuilt by
+      // renderList whenever folding is on, consumed by foldChipHtml.
+      let foldSum = null;
+
       // Display sort order, cycled by the sort button and persisted per device.
       // Default "state" (attention-first state, then git busyness). Guard against
       // a stale/garbage stored value so we never start in an unknown mode.
@@ -3234,6 +3407,21 @@
         return `<span class="tasks${allDone ? " done" : ""}" title="${esc(tip)}">${esc(label)}</span>`;
       }
 
+      // Folded-subagent summary chip ("⊞ 3/5") for a root agent whose subagent
+      // tree is collapsed — working/total of its hidden descendants, from the
+      // per-render foldSum map. "" when folding is off or this row has no hidden
+      // subagents. Clicking it expands the trees (see the list click handler).
+      // The tooltip carries the recency the badge face omits ("last active 5s ago").
+      function foldChipHtml(e) {
+        const s = foldSum && foldSum.get(e);
+        if (!s) return "";
+        const rel = s.lastActive != null ? age({ last_active_at: s.lastActive }) : "";
+        const tip =
+          `${s.total} subagent${s.total === 1 ? "" : "s"} folded · ${s.working} working` +
+          (rel ? ` · last active ${rel} ago` : "");
+        return `<span class="subs${s.working ? " active" : ""}" data-fold-chip="1" title="${esc(tip)}">⊞ ${s.working}/${s.total}</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")
@@ -3260,13 +3448,39 @@
         return `<div class="ghead g-${r.kind}">${r.branch ? `<span class="tbranch">${esc(r.branch)}</span>` : ""}<span class="gicon">${icon}</span><span class="glabel">${esc(r.label || "")}</span>${ctag}<span class="gkind">${r.kind}</span></div>`;
       }
 
+      // Extra row classes for collaborative presence: a yellow bar when a human
+      // peer is watching this agent, plus the stdin pulse while its input just
+      // advanced. Empty in the solo case, so a single-user list is unchanged.
+      function rowFlags(e) {
+        const peers = focusByKey.get(e._key) || 0;
+        const flash = (flashUntil.get(e._key) || 0) > Date.now();
+        return (peers ? " peerfocus" : "") + (flash ? " stdinflash" : "");
+      }
+      // A yellow chip showing how many peers are watching this agent ("" if none).
+      function peerChipHtml(e) {
+        const n = focusByKey.get(e._key) || 0;
+        return n
+          ? `<span class="peerchip" title="${n} peer${n === 1 ? "" : "s"} watching this agent">👤${n}</span>`
+          : "";
+      }
+
       function renderList() {
         const toks = $("q").value.trim().split(/\s+/).filter(Boolean);
         // Build the full signalling-server > rooms > peers > agents > subagents
         // tree. Single-node room/peer layers fold away; ≥2 become ├ └ │ branches.
-        const rows = layeredRows(orderedEntries(toks));
-        const agentRows = rows.filter((r) => r.kind === "agent");
+        const fullRows = layeredRows(orderedEntries(toks));
+        const agentRows = fullRows.filter((r) => r.kind === "agent");
+        // Fold: summarize each root's hidden descendants, then drop subagent rows
+        // (any agent row with a parent agent). The count still reports every
+        // matching agent, so folding never makes the fleet look smaller.
+        foldSum = foldSubs ? foldSummaries(fullRows) : null;
+        const rows = foldSubs
+          ? fullRows.filter((r) => !(r.kind === "agent" && r.parentEntry))
+          : fullRows;
         $("count").textContent = `${agentRows.length} / ${entries.length} agents`;
+        paintPeersBadge(); // keep the peers badge in step with sel / the entry list
+        $("foldbtn").textContent = foldSubs ? "⊞ subs" : "⊟ subs";
+        $("foldbtn").classList.toggle("on", !foldSubs);
         $("viewbtn").classList.toggle("on", compactList);
         // Show the active sort mode on the button so it's self-documenting; the
         // default ("state") is also highlighted to hint it's the implicit order.
@@ -3287,15 +3501,17 @@
                 const t = e.title || e.prompt || "";
                 const id = compactIdent(e, ctx, 3, r.parentEntry);
                 const cli = cliLabel(e);
-                return `<div class="row crow ${e._key === sel ? "sel" : ""}" data-key="${esc(e._key)}">
+                return `<div class="row crow ${e._key === sel ? "sel" : ""}${rowFlags(e)}" data-key="${esc(e._key)}">
         ${r.branch ? `<span class="tbranch">${esc(r.branch)}</span>` : ""}
         <span class="dot ${esc(e.status)}"></span>
         ${hasIdent(id) ? `<span class="cident" title="${esc(fullIdent(e))}">${esc(id)}</span>` : ""}
         ${cli ? `<span class="cname">${esc(cli)}</span>` : ""}
         <span class="ctitle ${e.title ? "" : "dim"}" title="${esc(t)}">${esc(t)}</span>
+        ${foldChipHtml(e)}
         ${taskChipHtml(e)}
         ${badgeChipsHtml(e)}
         ${gitChipHtml(e)}
+        ${peerChipHtml(e)}
         <span class="age">${age(e)}</span></div>`;
               })
               .join("") || `<div class="empty">no match</div>`;
@@ -3315,13 +3531,15 @@
                     `<span class="rtag" data-k="${k}"><span style="opacity:.55">${k}:</span>${esc(v)}</span>`,
                 )
                 .join("");
-              return `<div class="row ${e._key === sel ? "sel" : ""}" data-key="${esc(e._key)}">
+              return `<div class="row ${e._key === sel ? "sel" : ""}${rowFlags(e)}" data-key="${esc(e._key)}">
         <div class="r1">${r.branch ? `<span class="tbranch">${esc(r.branch)}</span>` : ""}<span class="dot ${esc(e.status)}"></span>
           <span class="name">${esc(cliLabel(e) || ident(e) || "agent")}</span>
           <span class="badge">pid ${e.pid}</span>
+          ${foldChipHtml(e)}
           ${taskChipHtml(e)}
           ${badgeChipsHtml(e)}
           ${gitChipHtml(e)}
+          ${peerChipHtml(e)}
           <span class="age">${age(e)}</span></div>
         ${e.title ? `<div class="rowtitle" title="${esc(e.title)}">${esc(e.title)}</div>` : ""}
         ${
@@ -3383,6 +3601,13 @@
       function mergeRender() {
         const srcs = [...sources.values()];
         entries = srcs.flatMap((s) => s.agents || []);
+        // Spot agents whose stdin just advanced (last_stdin_at bumped since we
+        // last saw them — someone typed, or `ay send` pushed input) and arm the
+        // pulse. Runs before renderList so the flashing rows render pulsing; the
+        // fast loop above stops them when the window lapses. Streamed deltas carry
+        // the new mtime, so a silent `ay send` still trips the flash within ~1s.
+        const until = Date.now() + STDIN_FLASH_MS;
+        for (const k of advanceStdinFlashes(entries, stdinSeen)) flashUntil.set(k, until);
         // Badge: total agents + how many rooms are live. Red only when nothing
         // at all is reachable (no source answered).
         const roomSrcs = srcs.filter((s) => s.id !== LOCAL);
@@ -3680,6 +3905,14 @@
       }
 
       $("list").addEventListener("click", (ev) => {
+        // Clicking a folded-subagent chip expands the trees instead of selecting
+        // the row, so the hidden children it summarizes become reachable.
+        if (ev.target.closest("[data-fold-chip]")) {
+          foldSubs = false;
+          localStorage.setItem("ay.foldSubs", "0");
+          renderList();
+          return;
+        }
         const row = ev.target.closest(".row");
         if (row) select(row.dataset.key);
       });
@@ -3739,6 +3972,12 @@
         localStorage.setItem("ay.compactList", compactList ? "1" : "0");
         renderList();
       });
+      // Fold / unfold every subagent tree (global toggle, persisted per device).
+      $("foldbtn").addEventListener("click", () => {
+        foldSubs = !foldSubs;
+        localStorage.setItem("ay.foldSubs", foldSubs ? "1" : "0");
+        renderList();
+      });
       // Cycle the sort order: state → created → identity → state.
       $("sortbtn").addEventListener("click", () => {
         sortMode = SORT_MODES[(SORT_MODES.indexOf(sortMode) + 1) % SORT_MODES.length];
@@ -3781,9 +4020,10 @@
       // renders. Clamps at the ends, scrolls the row into view.
       function stepSelection(dir) {
         const toks = $("q").value.trim().split(/\s+/).filter(Boolean);
-        // Must match renderList's order; step only over agent rows (skip headers).
+        // Must match renderList's order; step only over agent rows (skip headers),
+        // and skip folded-away subagents so nav lands only on visible rows.
         const shown = layeredRows(orderedEntries(toks))
-          .filter((r) => r.kind === "agent")
+          .filter((r) => r.kind === "agent" && !(foldSubs && r.parentEntry))
           .map((r) => r.entry);
         if (!shown.length) return;
         const cur = shown.findIndex((e) => e._key === sel);
@@ -3889,6 +4129,66 @@
         return cur && cur.cwd && cur.git && cur.git.branch ? cur : null;
       }
 
+      // Slash commands that act on the OPEN agent (the omnibox anchor), mirroring the
+      // ⋯-menu recovery buttons. Typing "/" in the omnibox lists them; "/k" / "/r"
+      // narrows. Each runs the very same handler the dropdown button does, so the
+      // confirm prompt and server call are identical — /kill = Force-kill (SIGKILL),
+      // /restart = Restart (resume). "/fork [topic]" is also offered here (built in
+      // omniCommandRows, not this list, since it spawns rather than acts in place).
+      const OMNI_COMMANDS = [
+        {
+          cmd: "/restart",
+          icon: "↻",
+          title: "Restart (resume)",
+          desc: "stops it (if live) and relaunches resuming the session",
+          run: (e) => restartAgent(e),
+        },
+        {
+          cmd: "/kill",
+          icon: "✕",
+          title: "Force-kill (SIGKILL)",
+          desc: "terminates the process immediately",
+          danger: true,
+          run: (e) => stopAgent(true, e),
+        },
+      ];
+      // Build the command rows for a "/…"-prefixed query, targeting the anchor agent.
+      // Empty when nothing is open (a command with no agent to act on is a no-op) so
+      // the omnibox falls through to its normal search/spawn behaviour.
+      function omniCommandRows(q) {
+        const target = omniAnchor();
+        if (!target) return [];
+        // Match on the FIRST token so a command can carry args after it
+        // (e.g. "/fork fix the auth bug" → cmd "fork", topic "fix the auth bug").
+        const parts = q.slice(1).trim().split(/\s+/).filter(Boolean);
+        const cmdTerm = (parts[0] || "").toLowerCase(); // command token after "/"
+        const rows = OMNI_COMMANDS.filter((c) => c.cmd.slice(1).startsWith(cmdTerm)).map((c) => ({
+          kind: "cmd",
+          cmd: c,
+          target,
+        }));
+        // "/fork [topic]" — a slash alias for the fork spawn row so fork is reachable
+        // straight from the command palette (⌘K → "/fork"), not only via the row that
+        // auto-appends to a search. It's a spawn (kind:"fork"), not a kind:"cmd" that
+        // acts on an existing agent, so it's built here rather than in OMNI_COMMANDS —
+        // omniActivate's fork branch (branch prompt → /api/spawn {fork}) handles it.
+        // Needs a real fork source (the open agent with a live git branch); when the
+        // anchor has none, forking is meaningless so the row is omitted.
+        if ("fork".startsWith(cmdTerm)) {
+          const src = omniForkSource();
+          if (src)
+            rows.push({
+              kind: "fork",
+              branch: forkSlug(parts.slice(1).join(" "), src.git.branch),
+              srcBranch: src.git.branch,
+              fromCwd: src.cwd,
+              cli: src.cli,
+              room: src._room,
+            });
+        }
+        return rows;
+      }
+
       // Which agent the highlighted candidate should preview in the background: an
       // agent row → that agent; the spawn row / an empty list → the launch-time
       // agent (so the backdrop shows the spawn target's cwd).
@@ -3975,6 +4275,16 @@
                   <div class="omni-sub">⏎ to choose a working dir &nbsp;·&nbsp; prompt: ${esc(q || "(empty)")}</div>
                 </div></div>`;
             }
+            if (r.kind === "cmd") {
+              const t = r.target;
+              const dz = r.cmd.danger ? " danger" : "";
+              return `<div class="omni-row omni-spawn${dz}${sc}" data-i="${i}">
+                <span class="dot ${esc(t.status)}"></span>
+                <div class="omni-main">
+                  <div class="omni-title">${r.cmd.icon} ${esc(r.cmd.title)} <span style="opacity:.55">${esc(r.cmd.cmd)}</span></div>
+                  <div class="omni-sub">pid ${esc(String(t.pid))} ${esc(cliLabel(t) || ident(t) || "")} &nbsp;·&nbsp; ${esc(r.cmd.desc)}</div>
+                </div></div>`;
+            }
             const e = r.entry;
             const snip = r.snippet ? `<div class="omni-snip">…${r.snippet}…</div>` : "";
             return `<div class="omni-row${sc}" data-i="${i}">
@@ -3993,6 +4303,18 @@
 
       function runOmni() {
         const q = $("omni-input").value.trim();
+        // A "/…" query is a slash command against the open agent, not a search —
+        // show the matching command rows and skip the agent/spawn/tail machinery.
+        if (q.startsWith("/")) {
+          const cmds = omniCommandRows(q);
+          if (cmds.length) {
+            if (omniTailTimer) clearTimeout(omniTailTimer);
+            omniRows = cmds;
+            omniIdx = 0;
+            renderOmni();
+            return;
+          }
+        }
         const toks = q.split(/\s+/).filter(Boolean);
         // Tier 1 — instant title/identity match, ranked title-first then by recency.
         const hits = entries
@@ -4085,6 +4407,13 @@
         const q = $("omni-input").value.trim();
         const row = omniRows[omniIdx];
         const anchor = omniAnchor();
+        // A slash command runs its ⋯-menu handler against the pinned target. Handled
+        // before the spawn fallthrough so ⌘⏎ on a "/kill" row can't spawn instead.
+        if (row && row.kind === "cmd") {
+          closeOmni(false);
+          await row.cmd.run(row.target);
+          return;
+        }
         // ⌘⏎ always = spawn-here (the fast default), regardless of the selected row.
         if (forceSpawn || (row && row.kind === "spawn")) {
           closeOmni(false); // committing — keep the bg as-is, spawnAndSelect takes over

package/lab/ui/landing.html

@@ -214,7 +214,7 @@
           spawn agents from anywhere.
         </p>
         <div class="cta">
-          <a class="btn" href="/w/">Open the console →</a>
+          <a class="btn" href="/w/" autofocus>Open the console →</a>
           <a class="btn ghost" href="https://github.com/snomiao/agent-yes">Star on GitHub</a>
         </div>
         <div class="install">
@@ -273,5 +273,15 @@ powershell -c "irm https://agent-yes.com/setup.ps1 | iex"</code></pre>
         </div>
       </footer>
     </div>
+    <script>
+      // Focus the "Open the console" CTA on load so keyboard/Enter users land
+      // straight on it. `autofocus` on <a> isn't honored everywhere, so back it
+      // up here — but skip on touch devices where focusing scroll-jumps the page.
+      (function () {
+        if (matchMedia("(hover: none)").matches) return;
+        var cta = document.querySelector(".hero .cta a.btn");
+        if (cta) cta.focus({ preventScroll: true });
+      })();
+    </script>
   </body>
 </html>

package/package.json

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

package/scripts/build-rs.ts

@@ -18,11 +18,15 @@ import path from "path";
 const repoRoot = path.resolve(import.meta.dirname, "..");
 const cargoHome = process.env.CARGO_HOME || path.join(os.homedir(), ".cargo");
 
-// Both binaries cargo touches: the build output and the installed copy.
-const targets = [
-  path.join(repoRoot, "rs", "target", "release", "agent-yes.exe"),
-  path.join(cargoHome, "bin", "agent-yes.exe"),
-];
+// Every binary cargo touches: the build output and the installed copy, for
+// each [[bin]] in the package. Any of these can be locked by a live process,
+// and cargo install refuses to overwrite an existing installed binary (even
+// with --force it can't delete a locked one), so each must be moved aside.
+const exeNames = ["agent-yes.exe", "ay-spawn-hidden.exe"];
+const targets = exeNames.flatMap((exe) => [
+  path.join(repoRoot, "rs", "target", "release", exe),
+  path.join(cargoHome, "bin", exe),
+]);
 
 function moveLockedBinariesAside(): Array<{ original: string; aside: string }> {
   const moved: Array<{ original: string; aside: string }> = [];