agent-yes 1.228.0 → 1.229.0

package/dist/{todoAutomation-Cwnh4aWo.js → todoAutomation-x6guaQXc.js}

@@ -1,7 +1,19 @@
-import { t as JsonlStore } from "./JsonlStore-Bm5Nj6v_.js";
+import { t as JsonlStore } from "./JsonlStore-CWOA3aDH.js";
 import path from "path";
 import { lock } from "proper-lockfile";
 
+//#region ts/removeControlCharacters.ts
+const ESC = String.fromCharCode(27);
+const C1 = String.fromCharCode(155);
+const BACKSLASH = String.fromCharCode(92);
+const ST_PATTERN_SOURCE = ESC + BACKSLASH + BACKSLASH;
+const OSC_PATTERN = new RegExp(ESC + "][^\x07\x1B]*(?:\x07|" + ST_PATTERN_SOURCE + ")", "g");
+const CSI_PATTERN = new RegExp("[" + ESC + C1 + "][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]", "g");
+function removeControlCharacters(str) {
+	return str.replace(OSC_PATTERN, "").replace(CSI_PATTERN, "");
+}
+
+//#endregion
 //#region ts/todoLifecycle.ts
 /**
 * States considered "finished" across every kind. A finished task is never
@@ -499,7 +511,10 @@ var TodoStore = class TodoStore {
 		return this.rawUpdate(id, () => ({ acceptanceCriteria: trimmed }));
 	}
 	setBlock(id, block) {
-		return this.rawUpdate(id, () => ({ block }));
+		return this.rawUpdate(id, (fresh) => ({
+			block,
+			blockRev: (fresh.blockRev ?? 0) + 1
+		}));
 	}
 	/**
 	* Clears a `waiting-on-agent` block ONLY if the FRESH record's block is
@@ -514,7 +529,101 @@ var TodoStore = class TodoStore {
 	clearWaitingOnAgentBlock(id, expectedAgentId) {
 		return this.rawUpdate(id, (fresh) => {
 			if (fresh.block?.type !== "waiting-on-agent" || fresh.block.agentId !== expectedAgentId) throw new Error(`task ${id}: block changed since this was decided (expected waiting-on-agent for "${expectedAgentId}") — not clearing`);
-			return { block: null };
+			return {
+				block: null,
+				blockRev: (fresh.blockRev ?? 0) + 1
+			};
+		});
+	}
+	/**
+	* Clears `block` ONLY if the FRESH record's `blockRev` still equals
+	* `expectedBlockRev` — the generalized form of `clearWaitingOnAgentBlock`
+	* above, for a caller (e.g. `askApi.ts`'s `answerAsk`) that decided to
+	* clear a specific `blocked-by-human` block instance from a snapshot
+	* taken at the start of a longer operation.
+	*
+	* Compares `blockRev`, NOT the block's own content: an earlier version of
+	* this method compared `JSON.stringify(fresh.block)` against the snapshot,
+	* which missed an ABA race — another process could replace the block with
+	* a byte-for-byte IDENTICAL `{type, who, question/options/actionLink}`
+	* value (e.g. the exact same question asked again) between the caller's
+	* read and this call, and the content-only check would see no difference,
+	* silently erasing that distinct, newer block instance as if it were the
+	* one the caller actually decided to answer (codex-review round-17
+	* Important). `blockRev` increments on every write to `block` regardless
+	* of whether the new value differs from the old one, so it uniquely
+	* identifies THIS PARTICULAR block-setting event, not just its shape.
+	*
+	* Clearing unconditionally by `id` alone (or by content alone) could
+	* silently erase a genuinely different, newer block that another process
+	* set in the meantime — the task would then look unblocked even though a
+	* real, later block exists (codex-review Important). Throws instead of
+	* silently no-op-ing so the caller can report the conflict rather than
+	* claim success.
+	*/
+	clearBlockIfMatches(id, expectedBlockRev) {
+		return this.rawUpdate(id, (fresh) => {
+			if ((fresh.blockRev ?? 0) !== expectedBlockRev) throw new Error(`task ${id}: block changed since this was decided — not clearing`);
+			return {
+				block: null,
+				blockRev: (fresh.blockRev ?? 0) + 1
+			};
+		});
+	}
+	/**
+	* Atomically clears a `blocked-by-human` block AND, if `gate` is given,
+	* appends its evidence and advances the transition it names — all inside
+	* ONE `rawUpdate` write (one lock acquisition, one reload, one write).
+	*
+	* This exists specifically so `askApi.ts`'s `answerAsk()` never composes
+	* "verify blockRev, approve() a gate, transition(), clearBlockIfMatches()"
+	* as separate locked writes again. That composition (this method's
+	* predecessor) had a real gap: `approve()`/`transition()` could durably
+	* succeed — evidence appended, state advanced — and ONLY THEN could the
+	* final `clearBlockIfMatches()` fail because another process replaced the
+	* block in between. The task was left in a state no caller intended:
+	* already transitioned/evidenced for the OLD block, while `block` still
+	* held a DIFFERENT, newer `blocked-by-human` ask that was never gated at
+	* all (codex-review round-18 Important — the exact race this module's
+	* whole `blockRev` mechanism exists to close, just one step further out
+	* than `clearBlockIfMatches` alone could reach). Folding everything into
+	* one `rawUpdate` cycle makes the two outcomes (nothing changed / gate +
+	* transition + clear all changed together) the only two possible ones —
+	* there is no window in which one succeeded and the other didn't.
+	*
+	* `blockRev` re-validates `canTransition` against the FRESH state (not a
+	* value captured before this call), matching `transition()`'s own
+	* concurrent-state-drift defense — a state change unrelated to `block`
+	* (and so invisible to the `blockRev` check alone) must still be caught.
+	*
+	* Independent verification (this module's single most important
+	* invariant — see the file's own header comment) is re-checked here
+	* against the FRESH owner, exactly as `approve()` checks it: `gate`, when
+	* given, is never applied if its `validator` is the task's own owner.
+	* This method does not call `approve()` (it is not a separate write), so
+	* skipping this check here would silently let a human answer their own
+	* gated ask with no independent-verification enforcement at all.
+	*/
+	answerHumanBlock(id, expectedBlockRev, gate) {
+		return this.rawUpdate(id, (fresh) => {
+			if ((fresh.blockRev ?? 0) !== expectedBlockRev) throw new Error(`task ${id}: this ask has changed since it was loaded (expected blockRev ${expectedBlockRev}, current ${fresh.blockRev ?? 0}) — refresh and try again`);
+			const patch = {
+				block: null,
+				blockRev: (fresh.blockRev ?? 0) + 1
+			};
+			if (gate) {
+				if (fresh.owner && fresh.owner.trim().toLowerCase() === gate.validator.trim().toLowerCase()) throw new Error(`task ${id}: independent verification required — validator "${gate.validator}" is the same identity as owner "${fresh.owner}"; the worker cannot certify their own work`);
+				if (!canTransition(fresh.kind, fresh.state, gate.toState)) throw new Error(`task ${id}: no transition ${fresh.state} -> ${gate.toState} for kind "${fresh.kind}" (state changed concurrently) — not clearing`);
+				const evidenceEntry = {
+					gate: gate.name,
+					passedAt: (/* @__PURE__ */ new Date()).toISOString(),
+					validator: gate.validator,
+					note: gate.note
+				};
+				patch.verifyEvidence = [...fresh.verifyEvidence, evidenceEntry];
+				patch.state = gate.toState;
+			}
+			return patch;
 		});
 	}
 	/**
@@ -602,7 +711,7 @@ function monitorHint(block) {
 function describeBlock(block) {
 	switch (block.type) {
 		case "blocked-by-task": return `blocked by task ${block.taskId}`;
-		case "blocked-by-human": return `waiting on ${block.who}${block.question ? `: ${block.question}` : ""}`;
+		case "blocked-by-human": return `waiting on ${block.who}${block.question ? `: ${block.question}` : ""}${block.actionLink ? ` (action: ${block.actionLink})` : ""}`;
 		case "blocked-by-external": return `waiting on external signal: ${block.signal}`;
 		case "waiting-on-agent": return `waiting on agent ${block.agentId}`;
 	}
@@ -848,5 +957,5 @@ function reconcileTodos(tasks, agents, registeredGates) {
 }
 
 //#endregion
-export { isKnownKind as _, renderTree as a, statesOf as b, monitorHint as c, openStore as d, DONE_STATE as f, initialState as g, canTransition as h, renderDigest as i, CycleError as l, ORPHANED_STATE as m, buildTreeJSON as n, unblockedTasks as o, LIFECYCLES as p, openBlockers as r, describeBlock as s, reconcileTodos as t, TodoStore as u, nextStates as v, requiredGate as y };
-//# sourceMappingURL=todoAutomation-Cwnh4aWo.js.map
+export { isKnownKind as _, renderTree as a, statesOf as b, monitorHint as c, openStore as d, DONE_STATE as f, initialState as g, canTransition as h, renderDigest as i, CycleError as l, ORPHANED_STATE as m, buildTreeJSON as n, unblockedTasks as o, LIFECYCLES as p, openBlockers as r, describeBlock as s, reconcileTodos as t, TodoStore as u, nextStates as v, removeControlCharacters as x, requiredGate as y };
+//# sourceMappingURL=todoAutomation-x6guaQXc.js.map

package/dist/{todoCli-6v1CYdxN.js → todoCli-Cjhx3DqQ.js}

@@ -1,7 +1,7 @@
 import "./logger-CDIsZ-Pp.js";
-import "./JsonlStore-Bm5Nj6v_.js";
-import { i as readGlobalPids } from "./globalPidIndex-CoNr7tS8.js";
-import { _ as isKnownKind, a as renderTree, d as openStore, i as renderDigest, l as CycleError, n as buildTreeJSON, o as unblockedTasks, p as LIFECYCLES, s as describeBlock, t as reconcileTodos } from "./todoAutomation-Cwnh4aWo.js";
+import { _ as isKnownKind, a as renderTree, d as openStore, i as renderDigest, l as CycleError, n as buildTreeJSON, o as unblockedTasks, p as LIFECYCLES, s as describeBlock, t as reconcileTodos, x as removeControlCharacters } from "./todoAutomation-x6guaQXc.js";
+import "./JsonlStore-CWOA3aDH.js";
+import { i as readGlobalPids } from "./globalPidIndex-Ca4sTr1b.js";
 import yargs from "yargs";
 
 //#region ts/todoCli.ts
@@ -47,6 +47,26 @@ import yargs from "yargs";
 function fail(message) {
 	throw new Error(message);
 }
+/**
+* Same check ask.html's own render-time guard uses — a real URL parse, not
+* just a scheme-prefix regex, which could still let a malformed string
+* through. Returns the parser's own normalized `.href` (not the raw input)
+* on success, `null` otherwise: WHATWG URL parsing tolerates/strips some
+* control characters (e.g. embedded tabs/newlines) from the input while
+* still returning a valid http(s) URL, so validating against `s` but then
+* STORING `s` verbatim could still persist those raw control characters
+* into the store — later rendered as terminal/log text by `describeBlock()`
+* (codex-review Important). Storing `.href` instead guarantees the store
+* only ever holds what the parser actually validated.
+*/
+function normalizeHttpUrl(s) {
+	try {
+		const u = new URL(s);
+		return u.protocol === "http:" || u.protocol === "https:" ? u.href : null;
+	} catch {
+		return null;
+	}
+}
 function parseKind(raw) {
 	if (!raw) fail(`--kind is required (one of: ${Object.keys(LIFECYCLES).join(", ")})`);
 	if (!isKnownKind(raw)) fail(`unknown kind "${raw}" (one of: ${Object.keys(LIFECYCLES).join(", ")})`);
@@ -236,7 +256,11 @@ const blockCmd = {
 		describe: "required for --type blocked-by-human"
 	}).option("question", { type: "string" }).option("options", {
 		type: "string",
-		array: true
+		array: true,
+		describe: "choice-shape ask (/ask renders buttons)"
+	}).option("action-link", {
+		type: "string",
+		describe: "action-shape ask (/ask renders an 'open link, then confirm' button) — e.g. an OAuth/CAPTCHA URL"
 	}).option("signal", {
 		type: "string",
 		describe: "required for --type blocked-by-external"
@@ -257,11 +281,19 @@ const blockCmd = {
 				break;
 			case "blocked-by-human":
 				if (!argv.who) fail("--who <name> is required for --type blocked-by-human");
+				if (argv.options?.length && argv["action-link"]) fail("--options and --action-link are mutually exclusive (choice-shape vs action-shape ask)");
+				let normalizedActionLink;
+				if (argv["action-link"]) {
+					const normalized = normalizeHttpUrl(argv["action-link"]);
+					if (!normalized) fail(`--action-link must be a valid http:// or https:// URL (got "${removeControlCharacters(argv["action-link"]).replace(/[\r\n]+/g, " ")}")`);
+					normalizedActionLink = normalized;
+				}
 				block = {
 					type: "blocked-by-human",
 					who: argv.who,
 					question: argv.question,
-					options: argv.options
+					options: argv.options,
+					actionLink: normalizedActionLink
 				};
 				break;
 			case "blocked-by-external":
@@ -424,4 +456,4 @@ async function runTodoSubcommand(rest0) {
 
 //#endregion
 export { runTodoSubcommand };
-//# sourceMappingURL=todoCli-6v1CYdxN.js.map
+//# sourceMappingURL=todoCli-Cjhx3DqQ.js.map

package/dist/{tray-DBt8X-Qj.js → tray-C8VfnS7s.js}

@@ -1,4 +1,4 @@
-import { n as getRunningAgentCount } from "./runningLock-CNMl13dC.js";
+import { n as getRunningAgentCount } from "./runningLock-BFk3Mo8K.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-DBt8X-Qj.js.map
+//# sourceMappingURL=tray-C8VfnS7s.js.map

package/dist/{ts-Cl3CmLH9.js → ts-oYrTk4Z_.js}

@@ -1,11 +1,12 @@
 import { n as logger, t as addTransport } from "./logger-CDIsZ-Pp.js";
-import { r as getInstalledPackage } from "./versionChecker-Dhjyjxs_.js";
+import { r as getInstalledPackage } from "./versionChecker-CgCXc8CJ.js";
 import { t as agentYesHome } from "./agentYesHome-CtHb5b71.js";
-import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-CNMl13dC.js";
-import { i as readGlobalPids } from "./globalPidIndex-CoNr7tS8.js";
-import { t as PidStore } from "./pidStore-DCqpU_bI.js";
-import { r as recordInbox } from "./messageLog-Bb_Ie3Ck.js";
-import { n as register, r as sweep } from "./reaper-BNKvujYy.js";
+import { d as openStore, p as LIFECYCLES, x as removeControlCharacters } from "./todoAutomation-x6guaQXc.js";
+import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-BFk3Mo8K.js";
+import { i as readGlobalPids } from "./globalPidIndex-Ca4sTr1b.js";
+import { t as PidStore } from "./pidStore-Hjba3K6Q.js";
+import { r as recordInbox } from "./messageLog-zVGWLX7w.js";
+import { n as register, r as sweep } from "./reaper-iQXyufgp.js";
 import { arch, platform } from "process";
 import { execSync } from "child_process";
 import { closeSync, constants, createReadStream, existsSync, mkdirSync, openSync } from "fs";
@@ -23,6 +24,7 @@ import { execSync as execSync$1 } from "node:child_process";
 import os from "node:os";
 import { readFile as readFile$1 } from "node:fs/promises";
 import path$1 from "node:path";
+import { existsSync as existsSync$1 } from "node:fs";
 
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -288,18 +290,6 @@ try {
 const ptyPackage = globalThis.Bun ? "bun-pty" : "node-pty";
 var pty_default = pty;
 
-//#endregion
-//#region ts/removeControlCharacters.ts
-const ESC = String.fromCharCode(27);
-const C1 = String.fromCharCode(155);
-const BACKSLASH = String.fromCharCode(92);
-const ST_PATTERN_SOURCE = ESC + BACKSLASH + BACKSLASH;
-const OSC_PATTERN = new RegExp(ESC + "][^\x07\x1B]*(?:\x07|" + ST_PATTERN_SOURCE + ")", "g");
-const CSI_PATTERN = new RegExp("[" + ESC + C1 + "][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]", "g");
-function removeControlCharacters(str) {
-	return str.replace(OSC_PATTERN, "").replace(CSI_PATTERN, "");
-}
-
 //#endregion
 //#region ts/sessionEnv.ts
 const CLAUDE_SESSION_PIN_ENV = [
@@ -1200,6 +1190,99 @@ async function notifyWebhook(status, details, cwd = process.cwd()) {
 	}
 }
 
+//#endregion
+//#region ts/askApi.ts
+/**
+* `/ask` decision panel (A7): aggregates every `blocked-by-human` task across
+* every project this host's agents have registered onto one human-facing
+* view, and closes the loop when a human answers.
+*
+* Pure store logic only — no HTTP, no live-agent notification. `ts/serve.ts`
+* wires this into `GET /api/asks` / `POST /api/asks/answer` and, as a
+* best-effort follow-up after `answerAsk()` resolves, writes the answer into
+* the owning agent's terminal via the same FIFO mechanism `/api/send`
+* already uses (see that route) — kept out of this module so it stays
+* testable without a live server or live agent processes.
+*/
+/** Whether `projectRoot` has ever had an `ay todo` store created — used to skip candidate project roots (e.g. from a live-agent scan) that never called `ay todo` at all. */
+function hasTodoStore(projectRoot) {
+	return existsSync$1(path$1.join(projectRoot, ".agent-yes", "todos.jsonl"));
+}
+async function listAsksForProject(projectRoot) {
+	const store = await openStore(projectRoot);
+	const asks = [];
+	for (const t of store.all()) {
+		if (t.block?.type !== "blocked-by-human") continue;
+		const block = t.block;
+		asks.push({
+			projectRoot,
+			taskId: t._id,
+			summary: t.summary,
+			who: block.who,
+			question: block.question,
+			options: block.options,
+			actionLink: block.actionLink,
+			shape: block.actionLink ? "action" : block.options?.length ? "choice" : "acknowledge",
+			blockRev: t.blockRev ?? 0
+		});
+	}
+	return asks;
+}
+/**
+* Aggregates asks across every project root that actually has a store —
+* candidates are supplied by the caller (`ts/serve.ts` derives them from the
+* live-agent registry's distinct `cwd`s), keeping this module itself
+* agent-registry-agnostic.
+*
+* Uses `Promise.allSettled`, not `Promise.all`: this is a cross-project
+* aggregation by design, and `Promise.all`'s fail-fast behavior meant ONE
+* project with an unreadable/corrupt store made the ENTIRE decision panel
+* return nothing (a 500 at the route level) — hiding every other project's
+* perfectly healthy asks too (codex-review Important). A failed project is
+* logged and skipped; the healthy ones are still returned.
+*/
+async function listAsks(projectRoots) {
+	const withStore = [...new Set(projectRoots)].filter(hasTodoStore);
+	const results = await Promise.allSettled(withStore.map((root) => listAsksForProject(root)));
+	const asks = [];
+	for (const [i, result] of results.entries()) if (result.status === "fulfilled") asks.push(...result.value);
+	else console.error(`[askApi] listAsksForProject(${withStore[i]}) failed:`, result.reason);
+	return asks;
+}
+async function answerAsk(projectRoot, taskId, answer) {
+	const store = await openStore(projectRoot);
+	const rec = store.get(taskId);
+	if (!rec) throw new Error(`no such task: ${taskId}`);
+	if (rec.block?.type !== "blocked-by-human") throw new Error(`task ${taskId} is not currently blocked-by-human (already answered, or blocked on something else)`);
+	const expectedBlockRev = answer.expectedBlockRev ?? rec.blockRev ?? 0;
+	const block = rec.block;
+	let answerText;
+	if (block.actionLink) {
+		if (!answer.acknowledged) throw new Error(`task ${taskId}: this ask requires { acknowledged: true } after completing ${block.actionLink}`);
+		answerText = "acknowledged";
+	} else if (block.options?.length) {
+		if (!answer.choice) throw new Error(`task ${taskId}: this ask requires a choice (one of: ${block.options.join(", ")})`);
+		if (!block.options.includes(answer.choice)) throw new Error(`task ${taskId}: "${answer.choice}" is not one of the offered options (${block.options.join(", ")})`);
+		answerText = answer.choice;
+	} else {
+		if (!answer.acknowledged) throw new Error(`task ${taskId}: this ask requires { acknowledged: true }`);
+		answerText = "acknowledged";
+	}
+	const gate = rec.kind === "human" || rec.kind === "decision" ? (() => {
+		const primary = LIFECYCLES[rec.kind].transitions.find((tr) => tr.from === rec.state && tr.gate);
+		return primary?.gate ? {
+			name: primary.gate,
+			toState: primary.to,
+			validator: block.who,
+			note: answerText
+		} : null;
+	})() : null;
+	return {
+		record: await store.answerHumanBlock(taskId, expectedBlockRev, gate),
+		answerText
+	};
+}
+
 //#endregion
 //#region ts/index.ts
 const config = await import("./agent-yes.config-0G11aPWe.js").then((mod) => mod.default || mod);
@@ -1960,5 +2043,5 @@ function sleep(ms) {
 }
 
 //#endregion
-export { CLAUDE_SESSION_PIN_ENV as a, AgentContext as i, agentYes as n, removeControlCharacters as o, config as r, CLIS_CONFIG as t };
-//# sourceMappingURL=ts-Cl3CmLH9.js.map
+export { hasTodoStore as a, AgentContext as c, answerAsk as i, CLAUDE_SESSION_PIN_ENV as l, agentYes as n, listAsks as o, config as r, listAsksForProject as s, CLIS_CONFIG as t };
+//# sourceMappingURL=ts-oYrTk4Z_.js.map

package/dist/{versionChecker-Dhjyjxs_.js → versionChecker-CgCXc8CJ.js}

@@ -7,7 +7,7 @@ import { fileURLToPath } from "url";
 
 //#region package.json
 var name = "agent-yes";
-var version = "1.228.0";
+var version = "1.229.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-Dhjyjxs_.js.map
+//# sourceMappingURL=versionChecker-CgCXc8CJ.js.map

package/dist/{ws-Dw2fGxTI.js → ws-D5q3R1kY.js}

@@ -1,8 +1,8 @@
 import "./logger-CDIsZ-Pp.js";
-import "./globalPidIndex-CoNr7tS8.js";
-import "./messageLog-Bb_Ie3Ck.js";
+import "./globalPidIndex-Ca4sTr1b.js";
+import "./messageLog-zVGWLX7w.js";
 import "./configShared-YKfS6NMe.js";
-import { S as listRecords } from "./subcommands-DSyCT0vl.js";
+import { S as listRecords } from "./subcommands-DzJbnYAx.js";
 import "./e2e-DB7BDdEA.js";
 import "./webrtcLink-CjckgIZe.js";
 import "./remotes-ZqD0FHl_.js";
@@ -418,4 +418,4 @@ async function cmdWs(args) {
 
 //#endregion
 export { WS_JSON_SCHEMA, cmdWs, collectWorkspaces, isPathInside, loadProvision, workspaceStatus };
-//# sourceMappingURL=ws-Dw2fGxTI.js.map
+//# sourceMappingURL=ws-D5q3R1kY.js.map

package/package.json

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