agent-yes 1.169.1 → 1.171.0

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-WHYKp13w.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-BoPKPL9B.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-WHYKp13w.js.map

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

@@ -7,7 +7,7 @@ import { fileURLToPath } from "url";
 
 //#region package.json
 var name = "agent-yes";
-var version = "1.169.1";
+var version = "1.171.0";
 
 //#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-BoPKPL9B.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.
@@ -480,6 +549,52 @@ export function nextIndex(len, i, dir) {
 // coordinate math lives here so it's unit-testable without a browser.
 // ---------------------------------------------------------------------------
 
+// ---- collaborative presence: peer focus + stdin flash ----------------------
+// The left panel colour-codes who's on which agent: your own selection is blue
+// (the .sel bar), every OTHER human peer's focus is yellow (.peerfocus), and a
+// row pulses when its stdin was just written — independent of focus, since an
+// `ay send` feeds an agent no one is looking at. These pure helpers own the
+// bookkeeping so index.html only measures the DOM.
+
+// Detect agents whose stdin just advanced. `seen` maps _key -> the last
+// last_stdin_at we observed; given the current entries, return the _keys whose
+// last_stdin_at is NEWER than what we'd seen (someone typed / `ay send` pushed),
+// and fold the new values into `seen`. A key seen for the FIRST time never
+// flashes (else every agent would pulse on initial load) — only a later bump
+// does. Keys no longer present are pruned so `seen` can't grow without bound.
+export function advanceStdinFlashes(entries, seen) {
+  const fresh = [];
+  const alive = new Set();
+  for (const e of entries) {
+    const key = e._key;
+    if (!key) continue;
+    alive.add(key);
+    const at = e.last_stdin_at;
+    if (typeof at !== "number") continue;
+    const prev = seen.get(key);
+    if (prev !== undefined && at > prev) fresh.push(key);
+    if (prev === undefined || at > prev) seen.set(key, at);
+  }
+  for (const key of [...seen.keys()]) if (!alive.has(key)) seen.delete(key);
+  return fresh;
+}
+
+// Summarize fleet presence for the peers badge + per-row chips. `records` is one
+// entry per OTHER viewer currently watching an agent: { key, viewer } (key = the
+// composite _key of the agent they're on). Returns { total, byKey }: `total`
+// distinct viewers (the "N peers" badge), `byKey` a Map of _key -> how many
+// peers watch that agent (the yellow per-row chip + .peerfocus trigger).
+export function focusSummary(records) {
+  const viewers = new Set();
+  const byKey = new Map();
+  for (const r of records) {
+    if (!r || !r.key || !r.viewer) continue;
+    viewers.add(r.viewer);
+    byKey.set(r.key, (byKey.get(r.key) || 0) + 1);
+  }
+  return { total: viewers.size, byKey };
+}
+
 // Stable per-viewer hue (0..359) for colour-coding peers' selections.
 export function hashHue(s) {
   let h = 0;