agent-yes 1.267.2 → 1.269.1

package/dist/{todoAutomation-BQRW614S.js → todoStore-Wk8U4zJ8.js}

@@ -2,18 +2,6 @@ import { t as JsonlStore } from "./JsonlStore-CPGIR0Wy.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
@@ -130,6 +118,21 @@ const LIFECYCLES = {
 			from: "decided",
 			to: "done"
 		}]
+	},
+	question: {
+		states: [
+			"pending",
+			"answered",
+			"done"
+		],
+		transitions: [{
+			from: "pending",
+			to: "answered",
+			gate: "answer-received"
+		}, {
+			from: "answered",
+			to: "done"
+		}]
 	}
 };
 /** The state a newly-created task of `kind` starts in (its graph's first state). */
@@ -138,6 +141,23 @@ function initialState(kind) {
 	if (!first) throw new Error(`lifecycle kind "${kind}" has no states`);
 	return first;
 }
+/**
+* Every transition of `kind`, or `[]` when this binary has never heard of that
+* kind.
+*
+* Use this — never a bare `LIFECYCLES[rec.kind]` — whenever the kind comes off
+* a STORED RECORD rather than from validated CLI input. The store is shared by
+* every agent on a machine, and those agents routinely run different builds
+* (one lane on a fresh `bun link`, another on the published npm package), so an
+* older binary WILL read records whose kind was added later. Indexing directly
+* throws `Cannot read properties of undefined`, taking down `ls`/`reconcile`
+* for every task rather than just the one it cannot interpret. Degrading to "no
+* transitions" instead means the unknown task is simply not actionable by the
+* old binary — it still lists, and its data is untouched.
+*/
+function transitionsOf(kind) {
+	return LIFECYCLES[kind]?.transitions ?? [];
+}
 /** 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);
@@ -388,7 +408,7 @@ var TodoStore = class TodoStore {
 		return this.withStoreLock(async () => {
 			await this.jsonl.load();
 			const rec = this.mustGet(id);
-			if (!LIFECYCLES[rec.kind].transitions.some((t) => t.from === rec.state && t.gate === gateName)) throw new Error(`task ${id}: "${gateName}" is not a gate on any transition from its current state "${rec.state}"`);
+			if (!transitionsOf(rec.kind).some((t) => t.from === rec.state && t.gate === gateName)) throw new Error(`task ${id}: "${gateName}" is not a gate on any transition from its current state "${rec.state}"`);
 			if (rec.owner && rec.owner.trim().toLowerCase() === validator.toLowerCase()) throw new Error(`task ${id}: independent verification required — validator "${validator}" is the same identity as owner "${rec.owner}"; the worker cannot certify their own work`);
 			const satisfied = new Set(rec.satisfiedGates);
 			satisfied.add(gateName);
@@ -433,7 +453,7 @@ var TodoStore = class TodoStore {
 	*/
 	async verify(id, gateName) {
 		const rec = this.mustGet(id);
-		const edges = LIFECYCLES[rec.kind].transitions.filter((t) => t.from === rec.state && t.gate);
+		const edges = transitionsOf(rec.kind).filter((t) => t.from === rec.state && t.gate);
 		if (edges.length === 0) throw new Error(`task ${id}: no gated transition from state "${rec.state}"`);
 		const targetEdge = gateName ? edges.find((e) => e.gate === gateName) : edges.find((e) => this.gates.has(e.gate));
 		if (!targetEdge || !targetEdge.gate) throw new Error(`task ${id}: no registered gate found for a transition from "${rec.state}"${gateName ? ` matching "${gateName}"` : ""}`);
@@ -510,6 +530,33 @@ var TodoStore = class TodoStore {
 		if (!trimmed) throw new Error(`task ${id}: acceptance criteria text must not be empty`);
 		return this.rawUpdate(id, () => ({ acceptanceCriteria: trimmed }));
 	}
+	/**
+	* Reassign a task (`ay todo claim`). Ownership is the one field in this
+	* store that TWO agents actively compete for, so this takes the owner the
+	* caller believed was current and re-checks it against the FRESH record
+	* inside the write lock.
+	*
+	* Without that check, the CLI's shape — read the task, decide whether its
+	* owner is a live agent, then write — is a textbook lost update: two agents
+	* that both read "unowned" a millisecond apart would both pass their own
+	* liveness check and both write, and the loser would never learn it lost.
+	* The same revalidate-against-fresh discipline `clearWaitingOnAgentBlock`
+	* and `markOrphaned` already use, for the same reason.
+	*
+	* `expectedOwner` is `undefined` to skip the check, `null` to require the
+	* task still be unowned, or a string to require that exact current owner.
+	*/
+	async setOwner(id, owner, expectedOwner) {
+		const trimmed = owner.trim();
+		if (!trimmed) throw new Error(`task ${id}: owner must not be empty`);
+		return this.rawUpdate(id, (fresh) => {
+			if (expectedOwner !== void 0) {
+				const current = fresh.owner ?? null;
+				if (current !== expectedOwner) throw new Error(`task ${id}: owner changed to ${current ?? "(none)"} while claiming (expected ${expectedOwner ?? "(none)"}) — re-read it and try again`);
+			}
+			return { owner: trimmed };
+		});
+	}
 	setBlock(id, block) {
 		return this.rawUpdate(id, (fresh) => ({
 			block,
@@ -693,269 +740,5 @@ async function openStore(projectRoot) {
 }
 
 //#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": 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}`;
-	}
-}
-
-//#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-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 (LIFECYCLES[t.kind].transitions.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 { 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-BQRW614S.js.map
+export { LIFECYCLES as a, initialState as c, requiredGate as d, statesOf as f, DONE_STATE as i, isKnownKind as l, TodoStore as n, ORPHANED_STATE as o, transitionsOf as p, openStore as r, canTransition as s, CycleError as t, nextStates as u };
+//# sourceMappingURL=todoStore-Wk8U4zJ8.js.map

package/dist/{tray-CzGs9-ch.js → tray-Bxq_sfvU.js}

@@ -187,4 +187,4 @@ async function startTray() {
 
 //#endregion
 export { ensureTray, startTray };
-//# sourceMappingURL=tray-CzGs9-ch.js.map
+//# sourceMappingURL=tray-Bxq_sfvU.js.map

package/dist/trayApp-BDMzlxRo.js

@@ -0,0 +1,5 @@
+import "./versionChecker-V6ceVsu9.js";
+import "./rustBinary-B2lNFJSe.js";
+import { a as trayHiddenMarker, i as launchTray, n as hasDesktop, r as isTrayHidden, t as cmdTray } from "./trayApp-DC4qjut7.js";
+
+export { cmdTray };

package/dist/{trayApp-DLMUu2sB.js → trayApp-DC4qjut7.js}

@@ -1,4 +1,4 @@
-import { n as findTrayLauncher } from "./rustBinary-B9FEbqTu.js";
+import { n as findTrayLauncher } from "./rustBinary-B2lNFJSe.js";
 import { t as agentYesHome } from "./agentYesHome-CtmsY6I-.js";
 import { existsSync } from "node:fs";
 import path from "node:path";
@@ -97,4 +97,4 @@ async function cmdTray(args) {
 
 //#endregion
 export { trayHiddenMarker as a, launchTray as i, hasDesktop as n, isTrayHidden as r, cmdTray as t };
-//# sourceMappingURL=trayApp-DLMUu2sB.js.map
+//# sourceMappingURL=trayApp-DC4qjut7.js.map

package/dist/{ts-ClwhahH9.js → ts-D0Pk-WJg.js}

@@ -1,13 +1,14 @@
 import { n as __esmMin, r as __exportAll } from "./chunk-cZBX9HZv.js";
 import { n as logger, t as addTransport } from "./logger-CDIsZ-Pp.js";
-import { r as getInstalledPackage } from "./versionChecker-ZQYirfMp.js";
+import { r as getInstalledPackage } from "./versionChecker-V6ceVsu9.js";
 import { t as agentYesHome } from "./agentYesHome-CtmsY6I-.js";
-import { d as openStore, p as LIFECYCLES, x as removeControlCharacters } from "./todoAutomation-BQRW614S.js";
+import { u as removeControlCharacters } from "./todoAutomation-BETGOik9.js";
 import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-DBoONoM-.js";
 import { i as readGlobalPids } from "./globalPidIndex-Dq4KY2IV.js";
 import { t as PidStore } from "./pidStore-DJqSZPJi.js";
 import { r as recordInbox } from "./messageLog-BYFwioFY.js";
 import { n as register, r as sweep } from "./reaper-C4BvNylH.js";
+import { a as LIFECYCLES, r as openStore } from "./todoStore-Wk8U4zJ8.js";
 import { arch, platform } from "process";
 import { execSync } from "child_process";
 import { closeSync, constants, createReadStream, existsSync, mkdirSync, openSync } from "fs";
@@ -1525,7 +1526,7 @@ async function compactRawLogTail(logPath, keepBytes = RAW_LOG_KEEP_BYTES) {
 		await fh.close();
 	}
 }
-const config = await import("./agent-yes.config-DzNini0E.js").then((mod) => mod.default || mod);
+const config = await import("./agent-yes.config-2xKNJM5Y.js").then((mod) => mod.default || mod);
 const CLIS_CONFIG = config.clis;
 /**
 * Main function to run agent-cli with automatic yes/no responses
@@ -1598,11 +1599,16 @@ async function agentYes({ cli, cliArgs = [], skipPermissions = false, prompt, ro
 	})();
 	const originalPrompt = prompt;
 	if (prompt && inheritedParentPid) try {
-		const { resolveSpawner } = await import("./parentLink-CQrn998L.js");
+		const { resolveSpawner } = await import("./parentLink-DS-XflaJ.js");
 		const spawner = await resolveSpawner(inheritedParentPid);
 		if (spawner) {
-			const { buildInitMsg } = await import("./initMsg-D8cmdY76.js");
-			prompt = buildInitMsg(prompt, spawner, randomBytes(4).toString("hex"));
+			const { buildInitMsg } = await import("./initMsg-Bat5PUDf.js");
+			const { formatIdentity } = await import("./identity-BmDYOuZE.js");
+			const identity = formatIdentity({
+				cwd: spawner.cwd,
+				pid: spawner.pid
+			});
+			prompt = buildInitMsg(prompt, spawner, randomBytes(4).toString("hex"), identity);
 		}
 	} catch (error) {
 		if (verbose) logger.warn("[init-msg] failed to wrap initial prompt:", { error });
@@ -2068,7 +2074,7 @@ async function agentYes({ cli, cliArgs = [], skipPermissions = false, prompt, ro
 	}, 100);
 	const cleanupHeartbeat = () => clearInterval(heartbeatInterval);
 	shell.onExit(cleanupHeartbeat);
-	const { startParentPingLoop } = await import("./parentPingLoop-BEvJ2ElR.js");
+	const { startParentPingLoop } = await import("./parentPingLoop-Bxd3dXWO.js");
 	const parentPingLoop = startParentPingLoop({
 		parentPid,
 		selfWrapperPid: process.pid,
@@ -2332,4 +2338,4 @@ function sleep(ms) {
 
 //#endregion
 export { hasTodoStore as a, permissionBadge as c, answerAsk as i, AgentContext as l, agentYes as n, listAsks as o, config as r, listAsksForProject as s, CLIS_CONFIG as t, CLAUDE_SESSION_PIN_ENV as u };
-//# sourceMappingURL=ts-ClwhahH9.js.map
+//# sourceMappingURL=ts-D0Pk-WJg.js.map

package/dist/{versionChecker-ZQYirfMp.js → versionChecker-V6ceVsu9.js}

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

package/dist/{webrtcLink-DyCj380i.js → webrtcLink-B72AQ2eb.js}

@@ -1,4 +1,4 @@
-import { u as parseSecret } from "./e2e-CUMZC53I.js";
+import { u as parseSecret } from "./e2e-OLfcNxiv.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-DyCj380i.js.map
+//# sourceMappingURL=webrtcLink-B72AQ2eb.js.map

package/dist/{webrtcRemote-Bl8eowma.js → webrtcRemote-D68dkqFp.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-CUMZC53I.js";
-import { n as isWebrtcSpec, r as parseWebrtcLink, t as SIGNAL_SUBPROTOCOL } from "./webrtcLink-DyCj380i.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-OLfcNxiv.js";
+import { n as isWebrtcSpec, r as parseWebrtcLink, t as SIGNAL_SUBPROTOCOL } from "./webrtcLink-B72AQ2eb.js";
 import { RTCPeerConnection } from "node-datachannel/polyfill";
 
 //#region ts/webrtcRemote.ts
@@ -256,4 +256,4 @@ async function startWebrtcBridge(link) {
 
 //#endregion
 export { startWebrtcBridge };
-//# sourceMappingURL=webrtcRemote-Bl8eowma.js.map
+//# sourceMappingURL=webrtcRemote-D68dkqFp.js.map

package/dist/{widget-DtZ1WXkf.js → widget-BM03OkC1.js}

@@ -28,7 +28,7 @@ function parseFlags(args, known) {
 }
 /** Resolve the local daemon base URL + token (flags override discovery). */
 async function daemonTarget(flags) {
-	const { resolveDaemonHttpBase, loadTokenReadOnly } = await import("./serve-BqRNIxeq.js");
+	const { resolveDaemonHttpBase, loadTokenReadOnly } = await import("./serve-BaHCO0bU.js");
 	const base = typeof flags.base === "string" ? flags.base : await resolveDaemonHttpBase();
 	if (!base) throw new Error("no running ay serve daemon found — start `ay serve` or pass --base <url> (e.g. http://127.0.0.1:PORT)");
 	const token = typeof flags.token === "string" ? flags.token : await loadTokenReadOnly() ?? "";
@@ -186,7 +186,7 @@ async function cmdMint(args) {
 	const bad = caps.filter((c) => !KNOWN_CAPS.has(c));
 	if (bad.length) throw new Error(`unknown cap(s): ${bad.join(", ")} (valid: ${[...KNOWN_CAPS].join(", ")})`);
 	const ttlSec = parseTtlSec(typeof flags.ttl === "string" ? flags.ttl : "15m");
-	const { mintScopedTermToken } = await import("./serve-BqRNIxeq.js");
+	const { mintScopedTermToken } = await import("./serve-BaHCO0bU.js");
 	const r = await mintScopedTermToken(target, {
 		ttlSec,
 		caps
@@ -202,4 +202,4 @@ async function cmdMint(args) {
 
 //#endregion
 export { cmdMint, cmdWidget };
-//# sourceMappingURL=widget-DtZ1WXkf.js.map
+//# sourceMappingURL=widget-BM03OkC1.js.map

package/dist/widget.js

@@ -142,7 +142,7 @@ var AyWidget = class {
 	}
 	async h2c(el, viewport, rect, unclipSelector) {
 		const g = globalThis;
-		const mod = await import("./html2canvas-pro.esm-cq4l_ZIw.js");
+		const mod = await import("./html2canvas-pro.esm-D19oTQeV.js");
 		const html2canvas = mod.default ?? mod;
 		const opts = {
 			backgroundColor: viewport ? "#ffffff" : null,

package/dist/widgets.js

@@ -1,8 +1,8 @@
-import "./e2e-CUMZC53I.js";
-import "./channels-yE1YUHCl.js";
-import "./peer-DIl5xtx8.js";
-import { t as AyChannel } from "./browser-B7eYrBy7.js";
-import { t as AyTerminal } from "./browser-DSduVZeZ.js";
+import "./e2e-OLfcNxiv.js";
+import "./channels-CkaCyvEp.js";
+import "./peer-Dr4zvtcd.js";
+import { t as AyChannel } from "./browser-_2ndf80G.js";
+import { t as AyTerminal } from "./browser-CorYp8Yu.js";
 import { AyWidget } from "./widget.js";
 
 export { AyChannel, AyTerminal, AyWidget };

package/dist/{workspaceConfig-CBKlgA_q.js → workspaceConfig-EK7XNsgR.js}

@@ -215,4 +215,4 @@ function allowsSkipPermissions() {
 
 //#endregion
 export { getProvisionRoot as a, getWorkspaceRoot as c, isProvisionAllowed as d, resolveSpawnCwd as f, getProvisionHook as i, hasProvisionHook as l, getMaxAgents as n, getSpawnHook as o, setWorkspaceRoot as p, getMinFreeMb as r, getSpawnWaitMs as s, allowsSkipPermissions as t, hasSpawnHook as u };
-//# sourceMappingURL=workspaceConfig-CBKlgA_q.js.map
+//# sourceMappingURL=workspaceConfig-EK7XNsgR.js.map

package/dist/{ws-CiR2nOD3.js → ws-6l7Wb_0r.js}

@@ -1,12 +1,12 @@
 import "./logger-CDIsZ-Pp.js";
 import "./globalPidIndex-Dq4KY2IV.js";
 import "./messageLog-BYFwioFY.js";
-import "./e2e-CUMZC53I.js";
-import "./configShared-DtHMBCl7.js";
-import "./subcommands-DJpVXIb6.js";
-import "./notifyStore-Cbw2ZJ0X.js";
-import "./webrtcLink-DyCj380i.js";
-import "./remotes-DdAfueOu.js";
-import { a as isPathInside, c as walkWorkspaces, i as importProvisionModule, l as workspaceStatus, n as cmdWs, o as loadProvision, r as collectWorkspaces, s as resolveOperand, t as WS_JSON_SCHEMA } from "./ws-Ba372Tym.js";
+import "./e2e-OLfcNxiv.js";
+import "./configShared-DYxlvrH0.js";
+import "./subcommands-03ghe-aZ.js";
+import "./notifyStore-Dus2D1XA.js";
+import "./webrtcLink-B72AQ2eb.js";
+import "./remotes-IzQHupeo.js";
+import { a as isPathInside, c as walkWorkspaces, i as importProvisionModule, l as workspaceStatus, n as cmdWs, o as loadProvision, r as collectWorkspaces, s as resolveOperand, t as WS_JSON_SCHEMA } from "./ws-pRFrqms9.js";
 
 export { WS_JSON_SCHEMA, cmdWs, collectWorkspaces, isPathInside, loadProvision, walkWorkspaces, workspaceStatus };

package/dist/{ws-Ba372Tym.js → ws-pRFrqms9.js}

@@ -1,5 +1,5 @@
-import { O as listRecords } from "./subcommands-DJpVXIb6.js";
-import { a as getProvisionRoot } from "./workspaceConfig-CBKlgA_q.js";
+import { O as listRecords } from "./subcommands-03ghe-aZ.js";
+import { a as getProvisionRoot } from "./workspaceConfig-EK7XNsgR.js";
 import { existsSync } from "fs";
 import { lstat, opendir } from "fs/promises";
 import path from "path";
@@ -424,4 +424,4 @@ async function cmdWs(args) {
 
 //#endregion
 export { isPathInside as a, walkWorkspaces as c, importProvisionModule as i, workspaceStatus as l, cmdWs as n, loadProvision as o, collectWorkspaces as r, resolveOperand as s, WS_JSON_SCHEMA as t };
-//# sourceMappingURL=ws-Ba372Tym.js.map
+//# sourceMappingURL=ws-pRFrqms9.js.map