agent-yes 1.265.4 → 1.266.0

package/dist/parentPingLoop-BIKxzbPH.js

@@ -0,0 +1,469 @@
+import { n as logger } from "./logger-CDIsZ-Pp.js";
+import "./globalPidIndex-Dq4KY2IV.js";
+import { t as classifyNeedsInput } from "./needsInput-103zhZ90.js";
+import { n as replyTargetOf, r as shortenHome } from "./initMsg-C-w4A_eF.js";
+import { t as resolveSpawner } from "./parentLink-C0cIRjfL.js";
+import { spawn } from "node:child_process";
+
+//#region ts/parentPing.ts
+const DEFAULT_PING_CONFIG = {
+	idleConfirmMs: 3e4,
+	repeatBaseMs: 12e4,
+	repeatMaxMs: 9e5,
+	maxRepeats: 4
+};
+function initialPingState() {
+	return {
+		state: null,
+		idleSince: null,
+		episode: null,
+		episodeQuestion: null,
+		sent: 0,
+		nextAt: null
+	};
+}
+/** Exponential backoff for repeat N (1-based), capped. */
+function repeatDelayMs(attempt, cfg) {
+	const raw = cfg.repeatBaseMs * 2 ** Math.max(0, attempt - 1);
+	return Math.min(raw, cfg.repeatMaxMs);
+}
+/**
+* Advance by one tick. Returns the ping to send (or null) and the next state.
+*
+* Episode semantics:
+*  - `needs_input` opens a `stuck` episode immediately. A CHANGED question
+*    re-opens it (the agent is asking something new — that's fresh information,
+*    not a repeat), which also resets the backoff.
+*  - `idle` opens a `finished` episode only after `idleConfirmMs` of continuous
+*    idleness — hysteresis, so a breath between tool calls is not "done".
+*  - `exited` fires once, terminally, and cannot be superseded or repeated: the
+*    process is gone, so there is nothing left to re-observe.
+*  - `active` closes any open episode. The child is working again; whatever we
+*    reported is stale and the parent will hear about the next edge.
+*/
+function stepParentPing(prev, obs, cfg = DEFAULT_PING_CONFIG) {
+	const state = { ...prev };
+	const question = obs.question ?? null;
+	const wasExited = prev.episode === "exited";
+	state.state = obs.state;
+	if (wasExited) {
+		state.idleSince = null;
+		state.nextAt = null;
+		return {
+			state,
+			ping: null
+		};
+	}
+	if (obs.state === "exited") {
+		state.idleSince = null;
+		state.episode = "exited";
+		state.episodeQuestion = null;
+		state.sent = 1;
+		state.nextAt = null;
+		return {
+			state,
+			ping: {
+				reason: "exited",
+				attempt: 1,
+				question: null
+			}
+		};
+	}
+	if (obs.state === "active") {
+		state.idleSince = null;
+		state.episode = null;
+		state.episodeQuestion = null;
+		state.sent = 0;
+		state.nextAt = null;
+		return {
+			state,
+			ping: null
+		};
+	}
+	if (obs.state === "needs_input") {
+		state.idleSince = null;
+		if (prev.episode !== "stuck" || prev.episodeQuestion !== question) {
+			state.episode = "stuck";
+			state.episodeQuestion = question;
+			state.sent = 1;
+			state.nextAt = obs.now + repeatDelayMs(1, cfg);
+			return {
+				state,
+				ping: {
+					reason: "stuck",
+					attempt: 1,
+					question
+				}
+			};
+		}
+		return repeatIfDue(state, obs.now, cfg, question);
+	}
+	state.idleSince = prev.idleSince ?? obs.now;
+	if (prev.episode === "finished") return repeatIfDue(state, obs.now, cfg, null);
+	if (prev.episode === "stuck") return repeatIfDue(state, obs.now, cfg, prev.episodeQuestion);
+	if (obs.now - state.idleSince < cfg.idleConfirmMs) return {
+		state,
+		ping: null
+	};
+	state.episode = "finished";
+	state.episodeQuestion = null;
+	state.sent = 1;
+	state.nextAt = obs.now + repeatDelayMs(1, cfg);
+	return {
+		state,
+		ping: {
+			reason: "finished",
+			attempt: 1,
+			question: null
+		}
+	};
+}
+/** Emit the next repeat of an already-open episode if its timer is due. */
+function repeatIfDue(state, now, cfg, question) {
+	if (state.nextAt === null || now < state.nextAt) return {
+		state,
+		ping: null
+	};
+	if (state.sent > cfg.maxRepeats) {
+		state.nextAt = null;
+		return {
+			state,
+			ping: null
+		};
+	}
+	const attempt = state.sent + 1;
+	state.sent = attempt;
+	state.nextAt = attempt > cfg.maxRepeats ? null : now + repeatDelayMs(attempt, cfg);
+	return {
+		state,
+		ping: {
+			reason: state.episode,
+			attempt,
+			question
+		}
+	};
+}
+
+//#endregion
+//#region ts/parentPingSend.ts
+/**
+* Delivery side of the sub-agent→parent ping: turn a `PingDecision` into a
+* message and inject it into the parent's stdin.
+*
+* We deliberately deliver through the real `ay send` subprocess rather than
+* writing the parent's FIFO directly. `ay send` is where the `<ay-msg nonce
+* from …>` attribution wrapper, the paste/submit handling and the durable
+* message log all live; re-implementing any of that here would drift. The cost
+* is one short-lived process per ping, which happens at most a handful of times
+* per agent lifetime.
+*
+* Two flags are load-bearing:
+*   --force    the recency guard ("you must have tailed this target lately")
+*              exists to stop an agent from firing at a target it never looked
+*              at. A child reporting to its own parent is the one relationship
+*              where that guard is pure false-positive.
+*   --no-wait  the wrapper must never block its own PTY loop waiting for the
+*              parent's screen to settle.
+*/
+const HEADLINE = {
+	finished: "looks FINISHED (idle at its prompt, no longer working)",
+	stuck: "is STUCK (parked waiting for input / not making progress)",
+	exited: "has EXITED"
+};
+/** Trim to `max` chars on a whitespace boundary where possible. */
+function clip(s, max) {
+	const t = s.trim();
+	if (t.length <= max) return t;
+	return t.slice(0, max).replace(/\s+\S*$/, "") + "…";
+}
+/**
+* The report body. Pure so the wording is testable and stable.
+*
+* It is explicitly framed as coming from the WRAPPER, not the agent: the agent
+* itself may have said nothing at all (that is usually why this fires), and a
+* parent that mistakes an automatic ping for the child's considered answer would
+* act on a summary the child never wrote. The tail is included because the whole
+* point is that the parent is not tailing.
+*/
+function buildPingBody(decision, self, tail) {
+	const attempt = decision.attempt > 1 ? ` (reminder #${decision.attempt - 1} — no reply yet)` : "";
+	const lines = [
+		`<ay-report from ${self.cli} #${self.pid} @ ${shortenHome(self.cwd)}>`,
+		`Your sub-agent ${HEADLINE[decision.reason]}${attempt}.`,
+		`This is an automatic report from its agent-yes wrapper, not from the agent itself —`,
+		`treat the tail below as evidence, not as its answer.`
+	];
+	if (self.prompt) lines.push(`Task it was spawned with: ${clip(self.prompt, 200)}`);
+	if (decision.reason === "exited" && self.exitCode != null) lines.push(`Exit code: ${self.exitCode}`);
+	if (decision.question) lines.push(`It is asking: ${clip(decision.question, 300)}`);
+	if (tail?.trim()) lines.push(`Last output:`, clip(tail, 1200));
+	lines.push(decision.reason === "exited" ? `Next: ay result get ${self.pid} | ay cat ${self.pid}` : `Next: ay tail ${self.pid} | ay send ${self.pid} "..." | ay exit ${self.pid}`, `</ay-report>`);
+	return lines.join("\n");
+}
+/**
+* Argv for the `ay send` that carries `body` to `target`. Re-invokes THIS
+* entrypoint (argv[0] + argv[1]) rather than a bare `ay` on PATH, so a wrapper
+* running from a checkout, a global link, or `npx` all ping through the exact
+* same build they are part of.
+*/
+function buildSendArgv(target, argv1) {
+	const send = [
+		"send",
+		target,
+		"-",
+		"--force",
+		"--no-wait"
+	];
+	if (argv1) return {
+		cmd: process.execPath,
+		args: [argv1, ...send]
+	};
+	return {
+		cmd: "ay",
+		args: send
+	};
+}
+/**
+* Fire one ping. Resolves when the send subprocess exits; never throws — a
+* failed report must not take down the agent it is reporting about.
+*
+* `selfWrapperPid` is stamped as AGENT_YES_PID for the subprocess so `ay send`
+* attributes the message to THIS child. Without it the subprocess would inherit
+* the wrapper's own AGENT_YES_PID — which is the PARENT's wrapper pid — and the
+* parent would receive a message apparently sent by itself.
+*/
+async function deliverPing(opts) {
+	const { cmd, args } = buildSendArgv(opts.target, process.argv[1]);
+	return await new Promise((resolve) => {
+		let done = false;
+		const finish = (ok) => {
+			if (done) return;
+			done = true;
+			resolve(ok);
+		};
+		try {
+			const child = spawn(cmd, args, {
+				stdio: [
+					"pipe",
+					"ignore",
+					"ignore"
+				],
+				env: {
+					...process.env,
+					AGENT_YES_PID: String(opts.selfWrapperPid)
+				}
+			});
+			const timer = setTimeout(() => {
+				child.kill("SIGKILL");
+				finish(false);
+			}, opts.timeoutMs ?? 3e4);
+			timer.unref?.();
+			child.on("error", (err) => {
+				clearTimeout(timer);
+				logger.debug(`[parent-ping] send failed: ${err.message}`);
+				finish(false);
+			});
+			child.on("exit", (code) => {
+				clearTimeout(timer);
+				finish(code === 0);
+			});
+			child.stdin?.on("error", () => {});
+			child.stdin?.end(opts.body);
+		} catch (err) {
+			logger.debug(`[parent-ping] spawn failed: ${err.message}`);
+			finish(false);
+		}
+	});
+}
+
+//#endregion
+//#region ts/parentWatching.ts
+/**
+* "Is my parent already monitoring me?" — the suppression signal for the
+* automatic finished/stuck/exited push.
+*
+* A parent harness that HAS a monitor loop (Claude Code's Monitor tool, an
+* `ay ls --watch` NDJSON stream, `ay notify watch`, or just a polling `ay tail`)
+* already sees the child go idle / needs_input / stopped, with better fidelity
+* and on its own schedule. Injecting an `<ay-report …>` into that parent's stdin
+* on top of it is pure noise — worse than noise, since a message lands in the
+* parent's composer and interrupts whatever it was doing.
+*
+* So the push is a FALLBACK, not a duplicate channel: it fires only when nobody
+* is looking. Two independent signals count as "looking", and either is enough:
+*
+*   1. A live `ay notify watch` heartbeat for this parent (the explicit,
+*      purpose-built watcher — see notifyStore's watcher registry).
+*   2. This parent tailed/read THIS child within the read window — the same
+*      recency ledger `ay send`'s misdelivery guard uses. This is what catches
+*      an ad-hoc monitor loop that just polls `ay tail`/`ay ls`, which is what a
+*      harness-driven parent actually does.
+*
+* Failing OPEN (assume not watching, so we do send) is deliberate: a duplicate
+* report is a minor annoyance, a silently stranded parent is the bug this whole
+* feature exists to fix.
+*/
+/**
+* Parse the mode from the env value. Anything unrecognised (including unset)
+* is `auto` — the setting is an escape hatch, not something to fail a run over.
+*/
+function parseReportMode(raw) {
+	const v = raw?.trim().toLowerCase();
+	return v === "always" || v === "never" ? v : "auto";
+}
+/**
+* Decide whether to actually deliver a report. Pure, so the policy is testable
+* without touching the fs.
+*
+* `always` and `never` are absolute. `auto` sends only when the parent shows no
+* sign of monitoring — EXCEPT that `exited` always goes out: it is terminal, it
+* is the one edge a poll can miss entirely (the child's record can be reaped
+* between two polls), and it can never repeat, so it cannot become spam.
+*/
+function shouldDeliverReport(opts) {
+	if (opts.mode === "never") return false;
+	if (opts.mode === "always") return true;
+	if (opts.reason === "exited") return true;
+	return !opts.parentIsWatching;
+}
+/**
+* Whether `parentWrapperPid` currently appears to be monitoring the agent
+* `selfAgentPid`. Best-effort and fail-open (returns false on any error).
+*/
+async function isParentWatching(parentWrapperPid, parentAgentPid, selfAgentPid, now = Date.now()) {
+	try {
+		const { liveWatchers } = await import("./notifyStore-CEDiVyis.js");
+		if ((await liveWatchers(now)).has(parentWrapperPid)) return true;
+	} catch (error) {
+		logger.debug("[parent-ping] watcher lookup failed:", error);
+	}
+	try {
+		const { lastReadAt, READ_WINDOW_MS } = await import("./subcommands-C04exkIM.js");
+		const last = await lastReadAt(`agent:${parentAgentPid}`, selfAgentPid);
+		if (last !== null && now - last <= READ_WINDOW_MS) return true;
+	} catch (error) {
+		logger.debug("[parent-ping] read-recency lookup failed:", error);
+	}
+	return false;
+}
+
+//#endregion
+//#region ts/parentPingLoop.ts
+/**
+* Wiring for the sub-agent→parent ping: a small poller the wrapper owns for its
+* OWN agent, feeding `stepParentPing` and delivering whatever it decides.
+*
+* Kept out of ts/index.ts (already ~1400 lines) and out of the auto-response
+* heartbeat: this must not share a tick budget with the thing that answers
+* permission prompts, and its classification is a different question ("is my
+* agent done/stuck?") from the heartbeat's ("does this line need a keystroke?").
+*
+* No-parent is the common case (a human-launched top-level agent), and it costs
+* nothing: we resolve the spawner once and simply never start a timer.
+*/
+const POLL_MS = 5e3;
+/**
+* Classify the wrapper's own agent from its rendered screen.
+*
+* Order matters and is the same precedence `deriveLiveState` uses: a `working`
+* spinner beats everything (a long silent tool call is NOT done), then a pending
+* menu, then an idle prompt. Anything unrecognised falls back to `active` —
+* always the safe default, because a false `active` costs a delayed report while
+* a false `idle` tells the parent "finished" about an agent mid-task.
+*/
+function classifySelfState(lines, conf) {
+	const text = lines.join("\n");
+	if (conf.working?.some((re) => re.test(text))) return "active";
+	if (classifyNeedsInput(lines, conf)) return "needs_input";
+	if (conf.ready?.some((re) => re.test(text))) return "idle";
+	return "active";
+}
+/**
+* Start watching our own agent and reporting to whoever spawned it.
+*
+* `screen()` returns the currently-rendered tail lines (the wrapper's xterm
+* proxy); it is called on every poll, so it must be cheap and must not throw.
+*/
+function startParentPingLoop(opts) {
+	const cfg = opts.config ?? DEFAULT_PING_CONFIG;
+	const now = opts.now ?? (() => Date.now());
+	const mode = opts.mode ?? parseReportMode(process.env.AGENT_YES_REPORT_PARENT);
+	let state = initialPingState();
+	let target = null;
+	let parentAgentPid = null;
+	let timer = null;
+	let stopped = false;
+	let inFlight = Promise.resolve();
+	const send = (decision, tail) => {
+		if (!decision || !target) return Promise.resolve();
+		const t = target;
+		inFlight = inFlight.then(async () => {
+			const watching = mode === "auto" && opts.parentPid !== void 0 && parentAgentPid !== null ? await isParentWatching(opts.parentPid, parentAgentPid, opts.self.pid, now()) : false;
+			if (!shouldDeliverReport({
+				mode,
+				parentIsWatching: watching,
+				reason: decision.reason
+			})) {
+				logger.debug(`[parent-ping] ${decision.reason} suppressed (mode=${mode}, parent watching=${watching})`);
+				return;
+			}
+			const ok = await deliverPing({
+				target: t,
+				body: buildPingBody(decision, opts.self, tail),
+				selfWrapperPid: opts.selfWrapperPid
+			});
+			logger.debug(`[parent-ping] ${decision.reason} attempt ${decision.attempt} → ${t}: ${ok ? "sent" : "FAILED"}`);
+		}).catch(() => {});
+		return inFlight;
+	};
+	const ready = resolveSpawner(opts.parentPid).then((spawner) => {
+		if (!spawner || stopped) return false;
+		target = replyTargetOf(spawner);
+		parentAgentPid = spawner.pid;
+		timer = setInterval(() => {
+			let lines = [];
+			try {
+				lines = opts.screen();
+			} catch {
+				return;
+			}
+			const stepped = stepParentPing(state, {
+				now: now(),
+				state: classifySelfState(lines, opts.patterns)
+			}, cfg);
+			state = stepped.state;
+			if (stepped.ping) send(stepped.ping, lines.join("\n"));
+		}, opts.pollMs ?? POLL_MS);
+		timer.unref?.();
+		return true;
+	}).catch(() => false);
+	return {
+		stop() {
+			stopped = true;
+			if (timer) clearInterval(timer);
+			timer = null;
+		},
+		ready,
+		async pingExit(exitCode) {
+			await ready;
+			this.stop();
+			if (!target) return;
+			let tail = null;
+			try {
+				tail = opts.screen().join("\n");
+			} catch {}
+			opts.self.exitCode = exitCode;
+			const stepped = stepParentPing(state, {
+				now: now(),
+				state: "exited"
+			}, cfg);
+			state = stepped.state;
+			if (!stepped.ping) return;
+			await send(stepped.ping, tail);
+		}
+	};
+}
+
+//#endregion
+export { startParentPingLoop };
+//# sourceMappingURL=parentPingLoop-BIKxzbPH.js.map

package/dist/{remotes-DWVw-Q7V.js → remotes-Dg_JscKk.js}

@@ -1,5 +1,5 @@
 import "./e2e-CUMZC53I.js";
-import "./webrtcLink-CS4D-3G1.js";
-import { a as resolveRemoteSpec, i as readRemotes, n as deleteRemoteAlias, o as writeRemoteAlias, r as parseDirectRemoteSpec, t as cmdRemote } from "./remotes-iIvqiFWK.js";
+import "./webrtcLink-DyCj380i.js";
+import { a as resolveRemoteSpec, i as readRemotes, n as deleteRemoteAlias, o as writeRemoteAlias, r as parseDirectRemoteSpec, t as cmdRemote } from "./remotes-iMhdZytp.js";
 
 export { cmdRemote };

package/dist/{remotes-iIvqiFWK.js → remotes-iMhdZytp.js}

@@ -1,4 +1,4 @@
-import { n as isWebrtcSpec } from "./webrtcLink-CS4D-3G1.js";
+import { n as isWebrtcSpec } from "./webrtcLink-DyCj380i.js";
 import { mkdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
 import path from "path";
@@ -86,7 +86,7 @@ async function resolveRemoteSpec(spec) {
 * The bridge lives for the rest of the process (torn down on `process.exit`).
 */
 async function resolveWebrtc(link, keyword) {
-	const { startWebrtcBridge } = await import("./webrtcRemote-zQybN9IR.js");
+	const { startWebrtcBridge } = await import("./webrtcRemote-BDg0jjTs.js");
 	const bridge = await startWebrtcBridge(link);
 	return {
 		url: bridge.baseUrl,
@@ -173,4 +173,4 @@ async function cmdRemote(rest) {
 
 //#endregion
 export { resolveRemoteSpec as a, readRemotes as i, deleteRemoteAlias as n, writeRemoteAlias as o, parseDirectRemoteSpec as r, cmdRemote as t };
-//# sourceMappingURL=remotes-iIvqiFWK.js.map
+//# sourceMappingURL=remotes-iMhdZytp.js.map

package/dist/{rustBinary-DSVRhDzO.js → rustBinary-JGNROWfY.js}

@@ -1,4 +1,4 @@
-import { r as getInstalledPackage } from "./versionChecker-CMOLbEEi.js";
+import { r as getInstalledPackage } from "./versionChecker-CJgW9DHY.js";
 import { execFileSync } from "child_process";
 import { existsSync, mkdirSync, unlinkSync } from "fs";
 import { chmod, copyFile } from "fs/promises";
@@ -243,4 +243,4 @@ async function getRustBinary(options = {}) {
 
 //#endregion
 export { findTrayLauncher as n, getRustBinary as r, findSpawnHiddenLauncher as t };
-//# sourceMappingURL=rustBinary-DSVRhDzO.js.map
+//# sourceMappingURL=rustBinary-JGNROWfY.js.map

package/dist/{schedule-i4o5SJ_h.js → schedule-DbLpjgl5.js}

@@ -1,14 +1,14 @@
 import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-CMOLbEEi.js";
-import "./ts-nuUnrVcf.js";
+import "./versionChecker-CJgW9DHY.js";
+import "./ts-CGtoPER5.js";
 import "./todoAutomation-BQRW614S.js";
 import "./JsonlStore-CPGIR0Wy.js";
 import "./globalPidIndex-Dq4KY2IV.js";
 import "./pidStore-DJqSZPJi.js";
 import "./messageLog-BYFwioFY.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-C3tcRetU.js";
-import { f as resolveSpawnCwd } from "./workspaceConfig-BDqp7fYl.js";
-import { n as liveEnv, t as ensureNodeRuntime } from "./nodeRuntime-CT0w6zsB.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-AFV5pjSx.js";
+import { f as resolveSpawnCwd } from "./workspaceConfig-HiWQzq6A.js";
+import { n as liveEnv, t as ensureNodeRuntime } from "./nodeRuntime-CRoEMWkp.js";
 import { createHash } from "node:crypto";
 
 //#region ts/oxmgrService.ts
@@ -153,4 +153,4 @@ async function cmdSchedule(rest) {
 
 //#endregion
 export { cmdSchedule };
-//# sourceMappingURL=schedule-i4o5SJ_h.js.map
+//# sourceMappingURL=schedule-DbLpjgl5.js.map