agent-yes 1.226.1 → 1.227.0

package/dist/{subcommands-D8zJxifk.js → subcommands-FTkZkqKy.js}

@@ -3,9 +3,9 @@ import { n as logger } from "./logger-CDIsZ-Pp.js";
 import { t as agentYesHome } from "./agentYesHome-CtHb5b71.js";
 import { a as updateGlobalPidStatus, i as readGlobalPids } from "./globalPidIndex-CoNr7tS8.js";
 import { a as recordOutbox, i as recordMessage, n as readMailbox, t as partyMatches } from "./messageLog-Bb_Ie3Ck.js";
-import { t as loadSharedCliDefaults } from "./configShared-nnIwDYY-.js";
-import { n as isWebrtcSpec } from "./webrtcLink-DknpJQ0y.js";
-import { a as resolveRemoteSpec, i as readRemotes } from "./remotes-BtXom7Rp.js";
+import { t as loadSharedCliDefaults } from "./configShared-YKfS6NMe.js";
+import { n as isWebrtcSpec } from "./webrtcLink-CjckgIZe.js";
+import { a as resolveRemoteSpec, i as readRemotes } from "./remotes-ZqD0FHl_.js";
 import ms from "ms";
 import yargs from "yargs";
 import { appendFile, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "fs/promises";
@@ -1239,35 +1239,35 @@ async function runSubcommand(argv) {
 			case "restart": return await cmdRestart(rest);
 			case "note": return await cmdNote(rest);
 			case "todo": {
-				const { runTodoSubcommand } = await import("./todoCli-D8bL164c.js");
+				const { runTodoSubcommand } = await import("./todoCli-6v1CYdxN.js");
 				return runTodoSubcommand(rest);
 			}
 			case "serve": {
-				const { cmdServe } = await import("./serve-BeHHkDIn.js");
+				const { cmdServe } = await import("./serve-C2KCUxTP.js");
 				return cmdServe(rest);
 			}
 			case "setup": {
-				const { cmdSetup } = await import("./setup-nAQJffmr.js");
+				const { cmdSetup } = await import("./setup-CCKS4rtW.js");
 				return cmdSetup(rest);
 			}
 			case "ws": {
-				const { cmdWs } = await import("./ws-YCNt3rNz.js");
+				const { cmdWs } = await import("./ws-B4zHUwc6.js");
 				return cmdWs(rest);
 			}
 			case "schedule": {
-				const { cmdSchedule } = await import("./schedule-HHBT6eGE.js");
+				const { cmdSchedule } = await import("./schedule-0p4V_khb.js");
 				return cmdSchedule(rest);
 			}
 			case "remote": {
-				const { cmdRemote } = await import("./remotes-DZ_G2wkM.js");
+				const { cmdRemote } = await import("./remotes-BCgowsiu.js");
 				return cmdRemote(rest);
 			}
 			case "expose": {
-				const { cmdExpose } = await import("./expose-CKWXAkzK.js");
+				const { cmdExpose } = await import("./expose-GWRXTGpj.js");
 				return cmdExpose(rest);
 			}
 			case "callback": {
-				const { cmdCallback } = await import("./callback-BmgFE-2j.js");
+				const { cmdCallback } = await import("./callback-BgWZmpqC.js");
 				return cmdCallback(rest);
 			}
 			case "reap":
@@ -1685,7 +1685,7 @@ async function fetchRemoteRecordsRaw(url, token, opts) {
 		let base = url;
 		let bearer = token;
 		if (isWebrtcSpec(url)) {
-			const { startWebrtcBridge } = await import("./webrtcRemote-C974zjSt.js");
+			const { startWebrtcBridge } = await import("./webrtcRemote-BMzEt9Cp.js");
 			bridge = await startWebrtcBridge(url);
 			base = bridge.baseUrl;
 			bearer = bridge.token;
@@ -4305,7 +4305,7 @@ async function cmdNotify(rest) {
 	}
 	const ensure = async () => {
 		if (!argv["ensure-daemon"]) return;
-		const { ensureDaemon } = await import("./notifyDaemon-4qxS_FjO.js");
+		const { ensureDaemon } = await import("./notifyDaemon-CyLvaAwc.js");
 		await ensureDaemon().catch(() => null);
 	};
 	await heartbeatWatcher(parent, selfStartedAt);
@@ -4379,7 +4379,7 @@ async function cmdNotifyCursor(args) {
 }
 async function cmdNotifyd(rest) {
 	const sub = rest[0] ?? "status";
-	const daemon = await import("./notifyDaemon-4qxS_FjO.js");
+	const daemon = await import("./notifyDaemon-CyLvaAwc.js");
 	switch (sub) {
 		case "run": return daemon.runDaemon();
 		case "once": return daemon.runDaemon({ once: true });
@@ -4406,4 +4406,4 @@ async function cmdNotifyd(rest) {
 
 //#endregion
 export { daemonLockDir as $, renderLogTailLines as A, stopTipForCli as B, matchKeyword as C, readPtysize as D, readNotes as E, resolveResumeArgs as F, appendEvent as G, waitForLogQuiet as H, restartHintLines as I, isTransientLockMkdirError as J, gcInboxes as K, runSubcommand as L, renderRawLogLines as M, resolveOne as N, recentMessageEdges as O, resolveReadWindow as P, shouldStealLock as Q, snapshotStatus as R, listRecords as S, readAgentPtysize as T, writeKeysPaced as U, submitAndConfirm as V, writeToIpc as W, liveWatchers as X, listInboxParents as Y, readInbox as Z, isPidAlive as _, cmdHelp as a, isUserTyping as b, deriveLiveState as c, extractMenu as d, daemonLockOwnerPath as et, extractNeedsInput as f, isExitRequest as g, isAgentStuck as h, backoffWhileTyping as i, renderRawLog as j, recentReadEdges as k, deriveLiveStatus as l, finalizedLines as m, READ_PAGE_DEFAULT as n, TYPING_BADGE as nt, controlCodeFromName as o, extractTaskCounts as p, hostId as q, TYPING_WINDOW_MS as r, cursorAbs as s, GRACEFUL_EXIT_COMMANDS as t, notifyDir as tt, extractBadges as u, isSlashCommand as v, menuSelectKeys as w, lastStdinAt as x, isSubcommand as y, stdinActivityPath as z };
-//# sourceMappingURL=subcommands-D8zJxifk.js.map
+//# sourceMappingURL=subcommands-FTkZkqKy.js.map

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

@@ -1,8 +1,152 @@
 import { t as JsonlStore } from "./JsonlStore-Bm5Nj6v_.js";
-import { a as unblockedTasks, c as ORPHANED_STATE, l as canTransition, o as DONE_STATE, p as requiredGate, s as LIFECYCLES, u as initialState } from "./todoDigest-DSTG9ksk.js";
 import path from "path";
 import { lock } from "proper-lockfile";
 
+//#region ts/todoLifecycle.ts
+/**
+* States considered "finished" across every kind. A finished task is never
+* reopened by automation (see `todoAutomation.ts` in a later milestone) —
+* only a human explicitly reopening it (e.g. `verify-failed` → the kind's
+* doing state) moves a task out of a finished-adjacent state.
+*/
+const DONE_STATE = "done";
+/**
+* Not a normal graph edge on any kind's `transitions` list — a task can be
+* moved here from ANY state, by automation only (see `todoAutomation.ts`),
+* when its owning agent process has vanished. Kept out of the declarative
+* graphs deliberately: it is a side-channel signal about the WORKER, not a
+* statement about the work itself, so it should never appear as a normal
+* `canTransition`-reachable edge a human/CLI could aim for directly.
+*/
+const ORPHANED_STATE = "orphaned";
+const LIFECYCLES = {
+	code: {
+		states: [
+			"doing",
+			"merged",
+			"shipped",
+			"verifying",
+			"done",
+			"verify-failed",
+			"orphaned"
+		],
+		transitions: [
+			{
+				from: "doing",
+				to: "merged"
+			},
+			{
+				from: "merged",
+				to: "shipped"
+			},
+			{
+				from: "shipped",
+				to: "verifying"
+			},
+			{
+				from: "verifying",
+				to: "done",
+				gate: "verify-green"
+			},
+			{
+				from: "verifying",
+				to: "verify-failed",
+				gate: "verify-red"
+			},
+			{
+				from: "verify-failed",
+				to: "doing"
+			}
+		]
+	},
+	decision: {
+		states: [
+			"deciding",
+			"decided",
+			"done"
+		],
+		transitions: [{
+			from: "deciding",
+			to: "decided",
+			gate: "human-decided"
+		}, {
+			from: "decided",
+			to: "done"
+		}]
+	},
+	doc: {
+		states: [
+			"drafting",
+			"review",
+			"done"
+		],
+		transitions: [{
+			from: "drafting",
+			to: "review"
+		}, {
+			from: "review",
+			to: "done",
+			gate: "human-approved"
+		}]
+	},
+	investigation: {
+		states: [
+			"investigating",
+			"reported",
+			"done"
+		],
+		transitions: [{
+			from: "investigating",
+			to: "reported"
+		}, {
+			from: "reported",
+			to: "done",
+			gate: "human-acknowledged"
+		}]
+	},
+	human: {
+		states: [
+			"pending",
+			"decided",
+			"done"
+		],
+		transitions: [{
+			from: "pending",
+			to: "decided",
+			gate: "human-replied"
+		}, {
+			from: "decided",
+			to: "done"
+		}]
+	}
+};
+/** The state a newly-created task of `kind` starts in (its graph's first state). */
+function initialState(kind) {
+	const first = LIFECYCLES[kind].states[0];
+	if (!first) throw new Error(`lifecycle kind "${kind}" has no states`);
+	return first;
+}
+/** States reachable in one transition from `currentState`, regardless of gates. */
+function nextStates(kind, currentState) {
+	return LIFECYCLES[kind].transitions.filter((t) => t.from === currentState).map((t) => t.to);
+}
+/** Whether `from`→`to` is a transition that exists in `kind`'s graph at all (gate not evaluated here). */
+function canTransition(kind, from, to) {
+	return LIFECYCLES[kind].transitions.some((t) => t.from === from && t.to === to);
+}
+/** The gate name required for `from`→`to`, or null if the edge is ungated or does not exist. */
+function requiredGate(kind, from, to) {
+	return LIFECYCLES[kind].transitions.find((e) => e.from === from && e.to === to)?.gate ?? null;
+}
+/** All valid state names for `kind` — used to validate stored records and CLI input. */
+function statesOf(kind) {
+	return LIFECYCLES[kind].states;
+}
+function isKnownKind(value) {
+	return value in LIFECYCLES;
+}
+
+//#endregion
 //#region ts/todoStore.ts
 /**
 * Persistence and gate-enforcement layer for the `ay todo` engine.
@@ -180,6 +324,7 @@ var TodoStore = class TodoStore {
 				createdAt: now,
 				updatedAt: now,
 				...input.targetTier ? { targetTier: input.targetTier } : {},
+				...input.acceptanceCriteria?.trim() ? { acceptanceCriteria: input.acceptanceCriteria.trim() } : {},
 				...input.owner ? { owner: input.owner } : {}
 			};
 			await this.jsonl.append({
@@ -240,7 +385,8 @@ var TodoStore = class TodoStore {
 				link: evidence?.link,
 				gate: gateName,
 				passedAt: (/* @__PURE__ */ new Date()).toISOString(),
-				validator
+				validator,
+				...rec.acceptanceCriteria ? { acceptanceCriteriaAtApproval: rec.acceptanceCriteria } : {}
 			};
 			await this.jsonl.updateById(id, {
 				satisfiedGates: [...satisfied],
@@ -339,6 +485,19 @@ var TodoStore = class TodoStore {
 			return this.mustGet(id);
 		});
 	}
+	/**
+	* Set or update a task's acceptance criteria (free text) after creation —
+	* criteria may firm up once a task is underway, not just at `create()`
+	* time. Requires non-empty text: this method updates criteria, it does
+	* not clear them (clearing would need a `null`-vs-`undefined` sentinel
+	* distinction, like `block` has, which isn't needed for the "set/update"
+	* use case this exists for).
+	*/
+	async setAcceptanceCriteria(id, text) {
+		const trimmed = text.trim();
+		if (!trimmed) throw new Error(`task ${id}: acceptance criteria text must not be empty`);
+		return this.rawUpdate(id, () => ({ acceptanceCriteria: trimmed }));
+	}
 	setBlock(id, block) {
 		return this.rawUpdate(id, () => ({ block }));
 	}
@@ -449,6 +608,143 @@ function describeBlock(block) {
 	}
 }
 
+//#endregion
+//#region ts/todoDigest.ts
+/**
+* Read-side views over the `ay todo` store: dependency-tree rendering and a
+* per-tag digest board. Pure functions over an already-loaded task list — no
+* I/O — so they are trivially unit-testable and reusable by both the CLI
+* (`todoCli.ts`) and any future web view.
+*
+* `unblockedTasks` is ported near-verbatim from the equivalent, already
+* mutation-tested algorithm in symval-dev-cli's `deps.ts` (a closed-source
+* downstream consumer of an earlier, less general version of this idea) —
+* generalized here to the new `TodoRecord` shape and the `done` state name
+* from `todoLifecycle.ts` instead of a hardcoded status string.
+*/
+/**
+* The full set of task ids `t` is waiting on: the structural `blockedBy`
+* array PLUS, if `t.block` is a `blocked-by-task` shape, that block's own
+* `taskId`. Without folding the latter in, a task blocked via
+* `ay todo block --type blocked-by-task --task X` would never be detected
+* as resolved once X reaches `done` — contradicting `todoBlock.ts`'s own
+* documented promise that this block type "clears itself... pure data, no
+* monitor needed" (codex-review Important: the two mechanisms didn't
+* actually talk to each other, making `blocked-by-task` blocks inert).
+*/
+function declaredTaskDeps(t) {
+	return t.block?.type === "blocked-by-task" ? [...t.blockedBy, t.block.taskId] : t.blockedBy;
+}
+/**
+* A task is "unblocked" when it is not itself finished, it declares task
+* dependencies (via `blockedBy` and/or a `blocked-by-task` block), and
+* every one of them has reached `done`.
+* Surfaced for a caller to act on — never auto-applied here (deciding to
+* resume a task is left to automation, a later milestone, or a human).
+*/
+function unblockedTasks(tasks) {
+	const byId = new Map(tasks.map((t) => [t._id, t]));
+	return tasks.filter((t) => {
+		if (t.state === DONE_STATE) return false;
+		const deps = declaredTaskDeps(t);
+		if (deps.length === 0) return false;
+		return deps.every((d) => byId.get(d)?.state === DONE_STATE);
+	});
+}
+/** Blockers of `t` that have not reached `done` yet (a missing id is reported as-is, still "open"). */
+function openBlockers(t, byId) {
+	return declaredTaskDeps(t).filter((d) => byId.get(d)?.state !== DONE_STATE);
+}
+function nodeLine(t) {
+	return [`${t._id} [${t.state}] ${t.summary}`, ...t.owner ? [`owner:${t.owner}`] : []].join("  ");
+}
+/**
+* Dependency tree, rendered from roots (tasks nothing depends on, that
+* themselves declare at least one dependency) down their `blockedBy` edges:
+* a parent's children are what it is waiting for.
+*/
+function renderTree(tasks, rootId) {
+	const byId = new Map(tasks.map((t) => [t._id, t]));
+	const dependedOn = new Set(tasks.flatMap((t) => t.blockedBy));
+	const roots = rootId ? [byId.get(rootId) ?? null].filter((t) => t !== null) : tasks.filter((t) => !dependedOn.has(t._id) && t.blockedBy.length > 0);
+	if (rootId && roots.length === 0) throw new Error(`no such task: ${rootId}`);
+	if (roots.length === 0) return "(no dependency links)";
+	const lines = [];
+	const walk = (t, prefix, isLast, depth, seen) => {
+		lines.push(depth === 0 ? nodeLine(t) : `${prefix}${isLast ? "└─" : "├─"} ${nodeLine(t)}`);
+		if (seen.has(t._id)) return;
+		seen.add(t._id);
+		const deps = t.blockedBy.map((d) => byId.get(d)).filter((x) => x !== void 0);
+		deps.forEach((d, i) => {
+			walk(d, depth === 0 ? "" : `${prefix}${isLast ? "   " : "│  "}`, i === deps.length - 1, depth + 1, seen);
+		});
+	};
+	roots.forEach((r) => walk(r, "", true, 0, /* @__PURE__ */ new Set()));
+	return lines.join("\n");
+}
+/**
+* JSON-shaped equivalent of `renderTree` — same roots-and-edges logic, built
+* as data instead of formatted lines, so a machine caller (`--format json`)
+* gets the actual tree structure rather than a string it would have to
+* re-parse (codex-review Important: the CLI previously ignored --format for
+* this command entirely, always writing the human text with exit code 0).
+*/
+function buildTreeJSON(tasks, rootId) {
+	const byId = new Map(tasks.map((t) => [t._id, t]));
+	const dependedOn = new Set(tasks.flatMap((t) => t.blockedBy));
+	const roots = rootId ? [byId.get(rootId) ?? null].filter((t) => t !== null) : tasks.filter((t) => !dependedOn.has(t._id) && t.blockedBy.length > 0);
+	if (rootId && roots.length === 0) throw new Error(`no such task: ${rootId}`);
+	const build = (t, ancestors) => {
+		const node = {
+			id: t._id,
+			state: t.state,
+			summary: t.summary,
+			...t.owner ? { owner: t.owner } : {},
+			children: []
+		};
+		if (ancestors.has(t._id)) return node;
+		const nextAncestors = new Set(ancestors).add(t._id);
+		node.children = t.blockedBy.map((d) => byId.get(d)).filter((x) => x !== void 0).map((d) => build(d, nextAncestors));
+		return node;
+	};
+	return roots.map((r) => build(r, /* @__PURE__ */ new Set()));
+}
+/** Per-tag board: state counts per tag, plus an unblocked-tasks callout. */
+function renderDigest(tasks) {
+	if (tasks.length === 0) return "(no tasks)";
+	const byId = new Map(tasks.map((t) => [t._id, t]));
+	const unblocked = new Set(unblockedTasks(tasks).map((t) => t._id));
+	const streams = /* @__PURE__ */ new Map();
+	for (const t of tasks) for (const tag of t.tags.length ? t.tags : ["(untagged)"]) {
+		if (!streams.has(tag)) streams.set(tag, []);
+		streams.get(tag).push(t);
+	}
+	const lines = [];
+	for (const [stream, items] of [...streams.entries()].sort(([a], [b]) => a.localeCompare(b))) {
+		const allStates = [...new Set(items.map((t) => t.state))].sort();
+		const counts = allStates.map((s) => `${s}:${items.filter((t) => t.state === s).length}`).join(" ");
+		lines.push(`## ${stream}  (${counts})`);
+		for (const s of allStates) for (const t of items.filter((x) => x.state === s)) {
+			const open = openBlockers(t, byId);
+			const extra = [
+				...t.owner ? [`owner:${t.owner}`] : [],
+				...t.block ? [`block:${t.block.type}`] : [],
+				...open.length ? [`blockedBy:${open.join(",")}`] : [],
+				...unblocked.has(t._id) ? ["UNBLOCKED"] : []
+			];
+			lines.push(`  [${t.state}] ${t._id} ${t.summary}${extra.length ? `  [${extra.join(" ")}]` : ""}`);
+		}
+		lines.push("");
+	}
+	const ub = unblockedTasks(tasks);
+	if (ub.length) {
+		lines.push("## unblocked (all blockers reached done — resume these)");
+		for (const t of ub) lines.push(`  ${t._id} ${t.summary}${t.owner ? `  (owner:${t.owner})` : ""}`);
+		lines.push("");
+	}
+	return lines.join("\n").trimEnd();
+}
+
 //#endregion
 //#region ts/todoAutomation.ts
 /**
@@ -552,5 +848,5 @@ function reconcileTodos(tasks, agents, registeredGates) {
 }
 
 //#endregion
-export { TodoStore as a, CycleError as i, describeBlock as n, openStore as o, monitorHint as r, reconcileTodos as t };
-//# sourceMappingURL=todoAutomation-fxtfT_44.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, requiredGate as y };
+//# sourceMappingURL=todoAutomation-Cwnh4aWo.js.map