agent-yes 1.267.2 → 1.269.1

package/dist/todoAutomation-BETGOik9.js

@@ -0,0 +1,302 @@
+import { i as DONE_STATE, o as ORPHANED_STATE, p as transitionsOf } from "./todoStore-Wk8U4zJ8.js";
+
+//#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/todoBlock.ts
+/**
+* How a block of this type should be watched. Kept as one pure function so
+* every caller (CLI rendering, automation, `/ask` aggregation) agrees on the
+* same classification instead of re-deriving it ad hoc.
+*/
+function monitorHint(block) {
+	switch (block.type) {
+		case "blocked-by-task":
+		case "blocked-by-human": return "none";
+		case "waiting-on-agent":
+		case "waiting-on-answer": return "notify-agent";
+		case "blocked-by-external": return "poll-external";
+	}
+}
+/** One-line human-readable summary, used by CLI/digest rendering. */
+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}` : ""}${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}`;
+		case "waiting-on-answer": return `waiting for an answer from ${block.agentId}${block.question ? `: ${block.question}` : ""}`;
+	}
+}
+/**
+* The agent this block is waiting on, if any — the one identifier a caller
+* needs to ask "is that party still alive?". Centralised so every surface
+* (list rendering, reconcile, JSON output) agrees on which block shapes name
+* an agent, instead of each one re-listing the cases and quietly missing the
+* next shape that gets added.
+*/
+function blockedOnAgent(block) {
+	if (!block) return null;
+	return block.type === "waiting-on-agent" || block.type === "waiting-on-answer" ? block.agentId : null;
+}
+
+//#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 a private sibling 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
+/**
+* Reactive layer for the `ay todo` engine (Milestone 2): makes the engine
+* self-driving for agent-facing signals `agent-yes` already tracks, instead
+* of requiring every state change to be typed by hand.
+*
+* `reconcileTodos` is pure — decision logic only, no I/O — exactly the same
+* "decide" / "do" split a private sibling CLI's existing `watchdog.ts`
+* (`decideActions`) already uses successfully: the hard-to-get-right parts
+* (edge cases) live in a function that takes plain data in and returns plain
+* data out, so they are trivially unit-testable without a real store, real
+* processes, or real time. Applying the returned actions to a real
+* `TodoStore` (I/O) is a separate, thin step (see `todoCli.ts`'s `reconcile`
+* verb) deliberately kept out of this file — including revalidating each
+* action against a FRESH record immediately before writing, since the
+* snapshot this function decided from can be stale by the time the caller
+* applies it (codex-review Important, see the action shapes below).
+*/
+/**
+* `TodoRecord.owner` is opaque — a human name/handle OR a tracked agent's
+* stable id, this module cannot tell which just by looking at the string.
+* The only safe signal is whether the identifier appears in the live-agent
+* registry AT ALL: a KNOWN agent id whose latest record says `exited` is
+* confirmed dead and orphan-eligible; an identifier with NO record at all is
+* assumed to be a human owner (who was never going to appear there) and is
+* never orphaned on that basis alone. Getting this backwards would orphan
+* every human-owned task on every tick, since a human obviously never shows
+* up in the agent process table.
+*/
+function deadOwnerAgent(ownerId, agents) {
+	const rec = agents.find((a) => a.agent_id === ownerId);
+	return rec !== void 0 && rec.status === "exited";
+}
+/** Up to `limit` OTHER agent ids currently idle — candidates to hand an orphaned task to. */
+function idleCandidates(excludeAgentId, agents, limit = 3) {
+	return agents.filter((a) => !!a.agent_id).filter((a) => a.agent_id !== excludeAgentId && a.status === "idle").map((a) => a.agent_id).slice(0, limit);
+}
+/**
+* Decide what should happen given the current tasks and the current live-agent
+* snapshot. Four rules, each traceable to a specific requirement (see
+* `docs/2026-07-23-todo-lifecycle-execplan.md`'s Milestone 2 section):
+*
+*  - owner's agent process is gone and the task isn't finished → `orphan`.
+*  - a `waiting-on-agent` block whose agent went idle or exited successfully
+*    (exit code 0) → `clear-waiting-on-agent`.
+*  - a task currently in `unblockedTasks()` with an owner → `notify-unblocked`,
+*    reported on EVERY call (no dedup/state file): there is no real delivery
+*    channel wired yet (see `todoCli.ts`'s `reconcile` verb doc comment), so
+*    persisting "already notified" would silently retire the one signal an
+*    owner would ever get with nobody having actually received it
+*    (codex-review Important) — the same no-dedup convention `renderDigest`'s
+*    own "unblocked" section already uses.
+*  - a task in a state whose outgoing edge's gate is registered → `auto-verify`
+*    (the actual gate CALL is real I/O and happens in the caller via `store.verify()`;
+*    this only decides which tasks are eligible to try).
+*
+* An orphaned task is skipped for the OTHER rules this same tick (its owner is
+* gone, so it cannot also be "waiting on" that same dead agent in a meaningful
+* way, and it is no longer eligible for auto-verify either).
+*/
+function reconcileTodos(tasks, agents, registeredGates) {
+	const actions = [];
+	const orphanedThisTick = /* @__PURE__ */ new Set();
+	for (const t of tasks) {
+		if (t.state === DONE_STATE || t.state === ORPHANED_STATE) continue;
+		if (t.owner && deadOwnerAgent(t.owner, agents)) {
+			actions.push({
+				type: "orphan",
+				taskId: t._id,
+				from: t.state,
+				expectedOwner: t.owner,
+				candidates: idleCandidates(t.owner, agents)
+			});
+			orphanedThisTick.add(t._id);
+			continue;
+		}
+		if (t.block?.type === "waiting-on-answer") {
+			const block = t.block;
+			if (agents.find((a) => a.agent_id === block.agentId)?.status === "exited") actions.push({
+				type: "answerer-gone",
+				taskId: t._id,
+				agentId: block.agentId,
+				...t.owner ? { owner: t.owner } : {}
+			});
+		}
+		if (t.block?.type === "waiting-on-agent") {
+			const agentId = t.block.agentId;
+			const agent = agents.find((a) => a.agent_id === agentId);
+			if (agent && (agent.status === "idle" || agent.status === "exited" && agent.exit_code === 0)) actions.push({
+				type: "clear-waiting-on-agent",
+				taskId: t._id,
+				expectedAgentId: agentId
+			});
+		}
+		if (transitionsOf(t.kind).some((edge) => edge.from === t.state && edge.gate && registeredGates.has(edge.gate))) actions.push({
+			type: "auto-verify",
+			taskId: t._id
+		});
+	}
+	for (const t of unblockedTasks(tasks)) {
+		if (orphanedThisTick.has(t._id) || !t.owner) continue;
+		actions.push({
+			type: "notify-unblocked",
+			taskId: t._id,
+			owner: t.owner
+		});
+	}
+	return actions;
+}
+
+//#endregion
+export { renderTree as a, describeBlock as c, renderDigest as i, monitorHint as l, buildTreeJSON as n, unblockedTasks as o, openBlockers as r, blockedOnAgent as s, reconcileTodos as t, removeControlCharacters as u };
+//# sourceMappingURL=todoAutomation-BETGOik9.js.map