agent-yes 1.169.1 → 1.170.1

package/dist/subcommands-DLDpwrfG.js

@@ -0,0 +1,9 @@
+import "./logger-CDIsZ-Pp.js";
+import "./globalPidIndex-CoNr7tS8.js";
+import "./configShared-0MnIQ652.js";
+import { A as resolveOne, B as writeKeysPaced, C as matchKeyword, D as renderLogTailLines, E as readPtysize, F as snapshotStatus, I as stdinActivityPath, L as stopTipForCli, M as resolveResumeArgs, N as restartHintLines, O as renderRawLog, P as runSubcommand, R as submitAndConfirm, S as listRecords, T as readNotes, V as writeToIpc, _ as isPidAlive, a as cmdHelp, b as isUserTyping, c as deriveLiveState, d as extractMenu, f as extractNeedsInput, g as isExitRequest, h as isAgentStuck, i as backoffWhileTyping, j as resolveReadWindow, k as renderRawLogLines, l as deriveLiveStatus, m as finalizedLines, n as READ_PAGE_DEFAULT, o as controlCodeFromName, p as extractTaskCounts, r as TYPING_WINDOW_MS, s as cursorAbs, t as GRACEFUL_EXIT_COMMANDS, u as extractBadges, v as isSlashCommand, w as menuSelectKeys, x as lastStdinAt, y as isSubcommand, z as waitForLogQuiet } from "./subcommands-BFlpV23b.js";
+import "./e2e-jb0Hp43q.js";
+import "./webrtcLink-B7REGtK2.js";
+import "./remotes-CC-4GuJb.js";
+
+export { cmdHelp, isSubcommand, runSubcommand };

package/dist/{tray-CWUpaZF4.js → tray-DXr7iK3E.js}

@@ -1,4 +1,4 @@
-import { n as getRunningAgentCount } from "./runningLock-BobVW1_A.js";
+import { n as getRunningAgentCount } from "./runningLock-CNMl13dC.js";
 import { existsSync } from "fs";
 import { mkdir, readFile, unlink, writeFile } from "fs/promises";
 import { homedir } from "os";
@@ -187,4 +187,4 @@ async function startTray() {
 
 //#endregion
 export { ensureTray, startTray };
-//# sourceMappingURL=tray-CWUpaZF4.js.map
+//# sourceMappingURL=tray-DXr7iK3E.js.map

package/dist/{ts-Bbhf5JbN.js → ts-DsxejviJ.js}

@@ -1,10 +1,10 @@
 import { n as logger, t as addTransport } from "./logger-CDIsZ-Pp.js";
-import { r as getInstalledPackage } from "./versionChecker-BmWkWhcJ.js";
-import { t as agentYesHome } from "./agentYesHome-_eJa3DaX.js";
-import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-BobVW1_A.js";
-import { t as PidStore } from "./pidStore-BfoBWUjc.js";
-import { i as readGlobalPids } from "./globalPidIndex-DlmmJlO8.js";
-import { n as register, r as sweep } from "./reaper-C-eWAxIj.js";
+import { r as getInstalledPackage } from "./versionChecker-Czk3aHqy.js";
+import { t as agentYesHome } from "./agentYesHome-CtHb5b71.js";
+import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-CNMl13dC.js";
+import { t as PidStore } from "./pidStore-BIvsBQ8X.js";
+import { i as readGlobalPids } from "./globalPidIndex-CoNr7tS8.js";
+import { n as register, r as sweep } from "./reaper-CWF2_ATd.js";
 import { arch, platform } from "process";
 import { execSync } from "child_process";
 import { closeSync, constants, createReadStream, existsSync, mkdirSync, openSync } from "fs";
@@ -1084,7 +1084,7 @@ async function notifyWebhook(status, details, cwd = process.cwd()) {
 
 //#endregion
 //#region ts/index.ts
-const config = await import("./agent-yes.config-Bl08kMpl.js").then((mod) => mod.default || mod);
+const config = await import("./agent-yes.config-ugPYTPOd.js").then((mod) => mod.default || mod);
 const CLIS_CONFIG = config.clis;
 /**
 * Main function to run agent-cli with automatic yes/no responses
@@ -1824,4 +1824,4 @@ function sleep(ms) {
 
 //#endregion
 export { removeControlCharacters as a, AgentContext as i, agentYes as n, config as r, CLIS_CONFIG as t };
-//# sourceMappingURL=ts-Bbhf5JbN.js.map
+//# sourceMappingURL=ts-DsxejviJ.js.map

package/dist/{versionChecker-BmWkWhcJ.js → versionChecker-Czk3aHqy.js}

@@ -7,7 +7,7 @@ import { fileURLToPath } from "url";
 
 //#region package.json
 var name = "agent-yes";
-var version = "1.169.1";
+var version = "1.170.1";
 
 //#endregion
 //#region ts/versionChecker.ts
@@ -215,4 +215,4 @@ async function displayVersion() {
 
 //#endregion
 export { versionString as i, displayVersion as n, getInstalledPackage as r, checkAndAutoUpdate as t };
-//# sourceMappingURL=versionChecker-BmWkWhcJ.js.map
+//# sourceMappingURL=versionChecker-Czk3aHqy.js.map

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

@@ -1,4 +1,4 @@
-import { u as parseSecret } from "./e2e-BeKjLhmO.js";
+import { u as parseSecret } from "./e2e-jb0Hp43q.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-BG0Xc4-W.js.map
+//# sourceMappingURL=webrtcLink-B7REGtK2.js.map

package/dist/{webrtcRemote-SybKurg9.js → webrtcRemote-Bx-eD_0I.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-BeKjLhmO.js";
-import { n as isWebrtcSpec, r as parseWebrtcLink, t as SIGNAL_SUBPROTOCOL } from "./webrtcLink-BG0Xc4-W.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-jb0Hp43q.js";
+import { n as isWebrtcSpec, r as parseWebrtcLink, t as SIGNAL_SUBPROTOCOL } from "./webrtcLink-B7REGtK2.js";
 import { RTCPeerConnection } from "node-datachannel/polyfill";
 
 //#region ts/webrtcRemote.ts
@@ -256,4 +256,4 @@ async function startWebrtcBridge(link) {
 
 //#endregion
 export { startWebrtcBridge };
-//# sourceMappingURL=webrtcRemote-SybKurg9.js.map
+//# sourceMappingURL=webrtcRemote-Bx-eD_0I.js.map

package/dist/{workspaceConfig-BC03X4Y1.js → workspaceConfig-BgqK-31W.js}

@@ -1,4 +1,4 @@
-import { t as agentYesHome } from "./agentYesHome-_eJa3DaX.js";
+import { t as agentYesHome } from "./agentYesHome-CtHb5b71.js";
 import { lstatSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import path from "path";
@@ -80,8 +80,17 @@ function isProvisionAllowed(owner, repo) {
 function getSpawnHook() {
 	const env = process.env.AGENT_YES_SPAWN_HOOK;
 	if (env && env.trim()) return env;
-	const h = readConfig().spawnHook;
-	if (!h || !h.trim()) return null;
+	return configHookIfTrusted(readConfig().spawnHook);
+}
+/**
+* Return a config-file hook value only when the config file is safe to trust as
+* a source of code to run: not a symlink (can't be swapped out from under us),
+* owned by us, and not group/world-writable (no other user can rewrite it). The
+* env-var forms of these hooks bypass this — they come from the daemon's own
+* environment, which is already trusted. Returns null when unset or guarded out.
+*/
+function configHookIfTrusted(value) {
+	if (!value || !value.trim()) return null;
 	if (process.platform !== "win32") try {
 		if (lstatSync(configPath()).isSymbolicLink()) return null;
 		const st = statSync(configPath());
@@ -90,13 +99,35 @@ function getSpawnHook() {
 	} catch {
 		return null;
 	}
-	return h;
+	return value;
 }
 /** Whether a usable {@link getSpawnHook} is configured (for read-only disclosure). */
 function hasSpawnHook() {
 	return getSpawnHook() !== null;
 }
 /**
+* A trusted, HOST-LOCAL shell hook run BEFORE a `fork`/`from` provisioning git
+* op — "koho-style" (codehost-style) provisioning. Env `AGENT_YES_PROVISION_HOOK`
+* overrides the config `provisionHook`; the config form is subject to the same
+* tamper guard as {@link getSpawnHook} ({@link configHookIfTrusted}).
+*
+* Its purpose is to prepare the host for provisioning — most usefully to select
+* the right git identity (e.g. `gh auth switch --user <who>`, keyed on the
+* `KOHO_OWNER`/`KOHO_REPO` env the caller exports) before the clone/worktree/
+* setup runs. When configured it is ALSO the provisioning gate: its exit code
+* decides admission (0 = allow, non-zero = deny), overriding
+* {@link getProvisionAllowlist}. Returns null when unset/guarded.
+*/
+function getProvisionHook() {
+	const env = process.env.AGENT_YES_PROVISION_HOOK;
+	if (env && env.trim()) return env;
+	return configHookIfTrusted(readConfig().provisionHook);
+}
+/** Whether a usable {@link getProvisionHook} is configured (for read-only disclosure). */
+function hasProvisionHook() {
+	return getProvisionHook() !== null;
+}
+/**
 * Cap on concurrently-live agents admitted via `/api/spawn`. Env
 * `AGENT_YES_MAX_AGENTS` overrides the config `maxAgents`. A non-positive,
 * missing, or unparseable value means **unlimited** (returns undefined), which
@@ -161,5 +192,5 @@ 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-BC03X4Y1.js.map
+export { getSpawnHook as a, hasProvisionHook as c, resolveSpawnCwd as d, setWorkspaceRoot as f, getProvisionRoot as i, hasSpawnHook as l, getMinFreeMb as n, getSpawnWaitMs as o, getProvisionHook as r, getWorkspaceRoot as s, getMaxAgents as t, isProvisionAllowed as u };
+//# sourceMappingURL=workspaceConfig-BgqK-31W.js.map

package/lab/ui/console-logic.js

@@ -187,6 +187,18 @@ export function taskLabel(e) {
 // 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" },
+  "session-limit": {
+    label: "limit",
+    title: "Usage session limit hit — waiting for the reset time shown on screen",
+  },
+  retrying: {
+    label: "retry",
+    title: "Waiting for the API — the CLI is auto-retrying on its own backoff (no action needed)",
+  },
+  typing: {
+    label: "typing",
+    title: "The user is typing at this agent's terminal — ay send backs off until they pause",
+  },
 };
 
 // Status-flag chips ("badges") matched against the agent's screen — e.g. an
@@ -196,11 +208,16 @@ 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().
+// Time since the agent was last active ("12s" / "5m" / "3h") — measured from
+// its last stdout write (last_active_at, the log file's mtime), so a long-lived
+// but quiet agent reads as stale rather than "new". Falls back to started_at
+// when the server hasn't stamped a last-active time (e.g. freshly spawned, no
+// log yet). `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()) {
-  if (!e.started_at) return "";
-  const s = Math.max(0, (now - e.started_at) / 1000);
+  const at = e.last_active_at ?? e.started_at;
+  if (!at) return "";
+  const s = Math.max(0, (now - at) / 1000);
   if (s < 60) return Math.floor(s) + "s";
   if (s < 3600) return Math.floor(s / 60) + "m";
   return Math.floor(s / 3600) + "h";
@@ -331,7 +348,7 @@ function agentForestNodes(list) {
 // flat entry list BEFORE layeredRows builds the room/peer/agent tree (which keeps
 // the given order for siblings and first-seen order for room/peer groups). So
 // sorting reorders roots and siblings without breaking the nesting.
-export const SORT_MODES = ["state", "created", "identity"];
+export const SORT_MODES = ["state", "active", "created", "identity"];
 
 // Attention-first state ranking: someone scanning the fleet wants the agents that
 // need them (needs_input) up top, then the wedged ones (stuck), then live work,
@@ -358,19 +375,29 @@ function gitWeight(e) {
   return (g.changed || 0) + (g.ahead || 0) + (g.behind || 0) + (g.dirty ? 0.5 : 0);
 }
 
+// Last-active instant for an entry: its last stdout write (last_active_at),
+// falling back to started_at when the server hasn't stamped one yet.
+function lastActive(e) {
+  return e.last_active_at ?? e.started_at ?? 0;
+}
+
 // Return a NEW array sorted for display per `mode` (default "state"):
 //   - "state":    attention-first state, then git busyness, then newest.
+//   - "active":   most recently active first (last_active_at desc).
 //   - "created":  newest first (started_at desc).
 //   - "identity": user@host:owner/repo/branch (alphabetical).
 // Every comparator falls back to newest-first so order is total & deterministic.
 export function sortEntries(entries, mode = "state") {
   const byNewest = (a, b) => (b.started_at || 0) - (a.started_at || 0);
+  const byActive = (a, b) => lastActive(b) - lastActive(a) || byNewest(a, b);
   const cmp =
-    mode === "created"
-      ? byNewest
-      : mode === "identity"
-        ? (a, b) => fullIdent(a).localeCompare(fullIdent(b)) || byNewest(a, b)
-        : (a, b) => stateRank(a) - stateRank(b) || gitWeight(b) - gitWeight(a) || byNewest(a, b);
+    mode === "active"
+      ? byActive
+      : mode === "created"
+        ? byNewest
+        : mode === "identity"
+          ? (a, b) => fullIdent(a).localeCompare(fullIdent(b)) || byNewest(a, b)
+          : (a, b) => stateRank(a) - stateRank(b) || gitWeight(b) - gitWeight(a) || byNewest(a, b);
   return entries.slice().sort(cmp);
 }
 
@@ -465,6 +492,48 @@ function toAgentNode(n) {
   return { kind: "agent", entry: n.entry, children: n.children.map(toAgentNode) };
 }
 
+// When the subagent trees are folded away, each surviving root agent shows a
+// summary chip of the descendants hidden beneath it. Given the FULL layeredRows
+// output, returns a Map keyed by the root agent's `entry` →
+// { total, working, lastActive }:
+//   total      = alive (non-exited) descendant subagents, at every depth
+//   working    = those whose status is "active"
+//   lastActive = newest last_active_at (fallback started_at) among the alive
+//                descendants, or null when none is stamped
+// Descendants roll up to their nearest folded-away ancestor's root, so a folded
+// tree summarizes its whole subtree in one chip. Roots with no alive descendant
+// aren't in the map (no chip). Pure so tests can exercise it without a DOM.
+export function foldSummaries(rows) {
+  // Direct parent-agent entry → child agent entries (skip room/peer headers).
+  const kids = new Map();
+  for (const r of rows) {
+    if (r.kind !== "agent" || !r.parentEntry) continue;
+    const arr = kids.get(r.parentEntry) || [];
+    arr.push(r.entry);
+    kids.set(r.parentEntry, arr);
+  }
+  const summaries = new Map();
+  for (const r of rows) {
+    if (r.kind !== "agent" || r.parentEntry) continue; // roots only
+    const acc = { total: 0, working: 0, lastActive: null };
+    const stack = [...(kids.get(r.entry) || [])];
+    const seen = new Set();
+    while (stack.length) {
+      const e = stack.pop();
+      if (seen.has(e)) continue; // guard a pathological parent cycle
+      seen.add(e);
+      for (const c of kids.get(e) || []) stack.push(c);
+      if (e.status === "exited") continue;
+      acc.total++;
+      if (e.status === "active") acc.working++;
+      const at = e.last_active_at ?? e.started_at;
+      if (at != null && (acc.lastActive == null || at > acc.lastActive)) acc.lastActive = at;
+    }
+    if (acc.total > 0) summaries.set(r.entry, acc);
+  }
+  return summaries;
+}
+
 // Next selection index when stepping the list by `dir` (+1 down / -1 up).
 // No current selection (i<0) lands on the first (down) or last (up) row;
 // otherwise clamps at the ends. Returns -1 for an empty list.

package/lab/ui/index.html

@@ -630,6 +630,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);
@@ -891,6 +895,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
@@ -1370,6 +1394,7 @@
           <div class="meta">
             <span id="count"></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,6 +1579,7 @@
         hasIdent,
         deviceCount,
         layeredRows,
+        foldSummaries,
         sortEntries,
         SORT_MODES,
         taskLabel,
@@ -2819,8 +2845,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 +2871,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 +3219,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 +3270,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")
@@ -3264,9 +3315,18 @@
         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`;
+        $("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.
@@ -3293,6 +3353,7 @@
         ${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)}
@@ -3319,6 +3380,7 @@
         <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)}
@@ -3680,6 +3742,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 +3809,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 +3857,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 +3966,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 +4112,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 +4140,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 +4244,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.170.1",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",