agent-yes 1.267.2 → 1.269.1

package/README.md

@@ -204,6 +204,79 @@ cy stop <keyword>                      # graceful shutdown (claude/codex: /exit)
 so subcommands work whether the target agent is the TS or Rust runtime.
 Detailed reference (Japanese): [`docs/cy-subcommands.md`](./docs/cy-subcommands.md).
 
+### Shared task list across agents (`ay todo`)
+
+A lifecycle-tracked task list that every agent working on a repo reads and
+writes. The store is one append-only file at `<repo>/.agent-yes/todos.jsonl`,
+resolved from the repo's **common root** — so agents running in different git
+worktrees of the same repo share one list rather than each keeping a private
+one. Pass `--root <dir>` (or set `AGENT_YES_TODO_ROOT`) to point somewhere else.
+
+```bash
+ay todo                                 # help: every verb, with descriptions
+ay todo new fix the flaky test --kind code   # owner defaults to the calling agent
+ay todo ls                              # OWNER column marks dead agents: lane-3(exited)
+ay todo ls --owner me                   # just my tasks
+ay todo claim T4                        # take it over (refuses to steal from a live agent)
+ay todo claim T4 --force                # take it anyway
+ay todo block T4 --type waiting-on-agent --agent lane-2
+ay todo dep add T5 T4                   # T5 waits for T4 (cycles rejected)
+ay todo digest                          # per-tag board + "unblocked, resume these"
+ay todo reconcile                       # orphan tasks whose owner agent exited, clear stale blocks
+```
+
+Ownership is cross-referenced against the same agent registry `ay ls` reads, so
+"who owns this and are they still alive?" is answerable in one command:
+`--owner me` resolves to the calling agent's registry id, `ls` annotates each
+owner with that agent's live status, and `reconcile` orphans tasks whose owner
+exited (listing idle agents as reassignment candidates). Use `--owner none` to
+create a task nobody owns, and `--format json` for machine-readable output —
+JSON keeps `owner` verbatim and reports liveness in a separate `ownerLiveness`
+field, so filters that match on `owner` keep working.
+
+Tasks move through a lifecycle per `--kind`, and gated transitions require
+**independent verification**: whoever did the work cannot approve it. See
+`ts/todoStore.ts` for the gate model.
+
+### Ask another agent a question (`ay ask`)
+
+`ay send` delivers a question but leaves no trace of it: if the asker moves on
+and the other agent dies, wedges, or simply never replies, nothing records that
+an answer is owed. `ay ask` delivers the same way — returning immediately — and
+also writes a task carrying **both** parties, so an unanswered question is
+self-describing.
+
+```bash
+ay ask lane-b "does the cache need invalidating before deploy?"
+#   asked lane-b → T4
+#     monitor the answer:   ay todo get T4 --root "/path/to/repo"
+#     monitor the answerer: ay status lane-b
+
+ay answer T4 --root "/path/to/repo" "yes — bump CACHE_VERSION first"
+```
+
+The task stores the asker as its `owner` and the answering agent as a
+`waiting-on-answer` block, so `ay todo ls` shows both, each with that agent's
+live status:
+
+```
+ID  STATE     KIND      OWNER           WAITING-ON      SUMMARY
+T4  pending   question  lane-a(active)  lane-b(exited)  does the cache need inv…
+```
+
+That is the failure mode a bare send cannot report: **whoever died holding the
+question is visible in one command.** `ay todo reconcile` says the same thing in
+words (`T4: lane-b exited without answering`) and orphans the task if the
+*asker* is the one that died — without ever closing the question itself, since
+the answer is still owed.
+
+Answering is gated on independent verification, which the store enforces: the
+validator must differ from the task's owner, so an asker can never quietly mark
+its own question answered. Targets are agents on this machine (same registry
+`ay ls` reads). `ay ask` respects `ay send`'s recency guard — pass `--force` to
+skip it; `ay answer` replies without it, since its recipient comes off the task
+record rather than from a typed keyword.
+
 ### Docker Usage
 
 You can run `agent-yes` in a Docker container with all AI CLI tools pre-installed.

package/dist/{SUPPORTED_CLIS-CpWKDCtL.js → SUPPORTED_CLIS-Bne04-66.js}

@@ -1,8 +1,8 @@
-import { t as CLIS_CONFIG } from "./ts-ClwhahH9.js";
+import { t as CLIS_CONFIG } from "./ts-D0Pk-WJg.js";
 
 //#region ts/SUPPORTED_CLIS.ts
 const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { SUPPORTED_CLIS as t };
-//# sourceMappingURL=SUPPORTED_CLIS-CpWKDCtL.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-Bne04-66.js.map

package/dist/SUPPORTED_CLIS-CdyjhpZP.js

@@ -0,0 +1,12 @@
+import "./logger-CDIsZ-Pp.js";
+import "./versionChecker-V6ceVsu9.js";
+import "./ts-D0Pk-WJg.js";
+import "./todoAutomation-BETGOik9.js";
+import "./JsonlStore-CPGIR0Wy.js";
+import "./globalPidIndex-Dq4KY2IV.js";
+import "./pidStore-DJqSZPJi.js";
+import "./messageLog-BYFwioFY.js";
+import "./todoStore-Wk8U4zJ8.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-Bne04-66.js";
+
+export { SUPPORTED_CLIS };

package/dist/{agent-yes.config-DzNini0E.js → agent-yes.config-2xKNJM5Y.js}

@@ -1,5 +1,5 @@
 import { n as logger } from "./logger-CDIsZ-Pp.js";
-import { n as normalizeAgentYesConfig, t as loadSharedCliDefaults } from "./configShared-DtHMBCl7.js";
+import { n as normalizeAgentYesConfig, t as loadSharedCliDefaults } from "./configShared-DYxlvrH0.js";
 import path from "node:path";
 import os from "node:os";
 import { access, mkdir, readFile, writeFile } from "node:fs/promises";
@@ -226,4 +226,4 @@ async function getDefaultConfig() {
 
 //#endregion
 export { agent_yes_config_default as default };
-//# sourceMappingURL=agent-yes.config-DzNini0E.js.map
+//# sourceMappingURL=agent-yes.config-2xKNJM5Y.js.map

package/dist/{agentShare-D0reU6LW.js → agentShare-BI126Ej9.js}

@@ -1,13 +1,13 @@
 import "./logger-CDIsZ-Pp.js";
 import "./globalPidIndex-Dq4KY2IV.js";
 import "./messageLog-BYFwioFY.js";
-import "./e2e-CUMZC53I.js";
-import "./configShared-DtHMBCl7.js";
-import { B as resolveOne } from "./subcommands-DJpVXIb6.js";
-import "./notifyStore-Cbw2ZJ0X.js";
-import "./webrtcLink-DyCj380i.js";
-import "./remotes-DdAfueOu.js";
-import { a as startShare } from "./share-NUhi-Wdd.js";
+import "./e2e-OLfcNxiv.js";
+import "./configShared-DYxlvrH0.js";
+import { B as resolveOne } from "./subcommands-03ghe-aZ.js";
+import "./notifyStore-Dus2D1XA.js";
+import "./webrtcLink-B72AQ2eb.js";
+import "./remotes-IzQHupeo.js";
+import { a as startShare } from "./share-RgJUhzqG.js";
 
 //#region ts/agentShare.ts
 const MAX_SHARES = 8;
@@ -230,4 +230,4 @@ function transformEvent(rawEvent, agentId, forwarded) {
 
 //#endregion
 export { createScopedShare, listShares, revokeAllShares, revokeShare };
-//# sourceMappingURL=agentShare-D0reU6LW.js.map
+//# sourceMappingURL=agentShare-BI126Ej9.js.map

package/dist/askCli-Bbxt9Umz.js

@@ -0,0 +1,272 @@
+import "./logger-CDIsZ-Pp.js";
+import "./JsonlStore-CPGIR0Wy.js";
+import "./globalPidIndex-Dq4KY2IV.js";
+import { r as openStore } from "./todoStore-Wk8U4zJ8.js";
+import { t as formatIdentity } from "./identity-CLaJ9-uE.js";
+import { a as resolveTodoRoot, i as resolveSelf } from "./todoIdentity-BffBxRHA.js";
+import yargs from "yargs";
+import { randomBytes } from "crypto";
+
+//#region ts/askCli.ts
+/**
+* `ay ask <agent> <question>` and `ay answer <task> <text>` — one agent asking
+* another a question, with the question itself tracked as a task.
+*
+* The problem this solves is not delivery (`ay send` already delivers). It is
+* that a delivered question leaves NO trace: if the asker moves on and the
+* answering agent dies, wedges, or simply never replies, nothing anywhere
+* records that an answer is owed, and the asker discovers it only by noticing
+* that it is still waiting. So every ask also writes a `question` task
+* carrying BOTH parties:
+*
+*   owner  = the asking agent      → covered by reconcile's existing orphan
+*                                    rule: if the asker dies, the task is
+*                                    orphaned and offered to another agent.
+*   block  = waiting-on-answer{answerer}
+*                                  → keeps the answerer on the record, so
+*                                    `ay todo ls` can report whether the party
+*                                    that owes an answer is still alive.
+*
+* With both identities stored, an unfinished question is self-describing:
+* either side going `exited` is visible in one `ay todo ls`, which is exactly
+* the failure mode ("who died holding this?") that a bare send cannot answer.
+*
+* `ask` returns immediately, like `ay send` — it does not wait for the answer.
+* It prints the task id and the two commands worth watching (the task's state,
+* and the answering agent's liveness).
+*
+* Delivery deliberately reuses `ay send` rather than reimplementing it: this
+* module builds the `<ay-ask-msg …>` envelope and hands it over as a
+* pre-built body (`--raw`), inheriting the typing backoff, submit-confirm and
+* retry behaviour that path already has. Both the send function and the
+* agent-resolver are injected by the caller (`ts/subcommands.ts`) so this
+* module has no import cycle with it, and so tests can drive it without live
+* agents.
+*/
+function fail(message) {
+	throw new Error(message);
+}
+/**
+* Quote a path for a command line someone (or some agent) will actually run.
+*
+* NOT `JSON.stringify`, which escapes backslashes: a Windows root would be
+* embedded as `"C:\\Users\\x"`, and every shell there treats a backslash
+* literally, so the command carries doubled separators. Path normalisation
+* happens to absorb that today — but the reply command in the envelope below is
+* copied verbatim by an agent, and a command that only works by accident is not
+* one to hand out. Quote only when needed, escape only real quotes.
+*/
+function shellQuote(p) {
+	return /[\s"]/.test(p) ? `"${p.replace(/"/g, "\\\"")}"` : p;
+}
+const out = (s) => process.stdout.write(`${s}\n`);
+/** First line / first 72 chars of the question — the list view wants one line, `description` keeps the whole thing. */
+function summarize(question) {
+	const firstLine = question.split("\n")[0].trim();
+	return firstLine.length > 72 ? `${firstLine.slice(0, 71)}…` : firstLine || question.trim();
+}
+/**
+* How the answering agent should reply.
+*
+* `--root` is NOT optional here even though it usually resolves correctly:
+* `ay answer` looks the task up in the store at ITS OWN cwd, and the two
+* agents can be working in different repositories, where that id does not
+* exist (or, worse, exists and means something else). Naming the asker's
+* resolved store root removes the ambiguity — paths are valid across this
+* exchange because delivery is same-host regardless.
+*/
+function answerCommand(taskId, root) {
+	return `ay answer ${taskId} --root ${shellQuote(root)} "<your answer>"`;
+}
+/**
+* `<ay-ask-msg …>` — the same envelope shape `ay send` uses, with the reply
+* route pointing at `ay answer` instead of `ay send`. The nonce on the open
+* and close tags is what makes the block's boundaries trustworthy: it is
+* generated after the body was authored, so text inside the question cannot
+* forge a matching pair and truncate or extend the trusted region.
+*/
+function buildAskEnvelope(input) {
+	const nonce = input.nonce ?? randomBytes(4).toString("hex");
+	return [
+		`<ay-ask-msg ${nonce} from ${input.asker ? `${input.asker.cli} ${formatIdentity({
+			cwd: input.asker.cwd,
+			pid: input.asker.pid
+		})}` : "a human shell"} — task ${input.taskId} — reply: ${answerCommand(input.taskId, input.root)}>`,
+		input.question,
+		`</ay-ask-msg ${nonce}>`
+	].join("\n");
+}
+/** The mirror of the above, sent back to the asker when the answer lands. */
+function buildAnswerEnvelope(input) {
+	const nonce = input.nonce ?? randomBytes(4).toString("hex");
+	return [
+		`<ay-answer-msg ${nonce} from ${input.answerer ? `${input.answerer.cli} ${formatIdentity({
+			cwd: input.answerer.cwd,
+			pid: input.answerer.pid
+		})}` : "a human shell"} — answers task ${input.taskId} — close it with: ay todo transition ${input.taskId} done --root ${shellQuote(input.root)}>`,
+		input.answer,
+		`</ay-answer-msg ${nonce}>`
+	].join("\n");
+}
+const askCmd = (deps) => ({
+	command: "$0 <agent> <question..>",
+	describe: "ask another agent a question and track it as a task",
+	builder: (y) => y.positional("agent", {
+		type: "string",
+		demandOption: true,
+		describe: "target agent (pid, agent id, or a cwd/prompt fragment — same matching as `ay send`)"
+	}).positional("question", {
+		type: "string",
+		array: true,
+		demandOption: true,
+		describe: "the question (unquoted words are joined)"
+	}).option("tag", {
+		type: "string",
+		array: true,
+		describe: "tag(s) for the created task"
+	}).option("force", {
+		type: "boolean",
+		default: false,
+		describe: "skip `ay send`'s recency guard (which otherwise requires you to have tailed the target recently)"
+	}),
+	handler: async (argv) => {
+		const question = argv.question.map(String).join(" ").trim();
+		if (!question) fail("usage: ay ask <agent> \"<question>\"");
+		const target = await deps.resolveAgent(argv.agent);
+		const answerer = target.agent_id;
+		if (!answerer) fail(`agent ${target.pid} has no stable agent id, so an answer could not be attributed to it (it predates agent-id registration — restart it, or use \`ay send\` instead).`);
+		const root = await resolveTodoRoot(argv.root);
+		const self = await (deps.self ?? resolveSelf)();
+		const store = await openStore(root);
+		const task = await store.create({
+			summary: summarize(question),
+			kind: "question",
+			description: question,
+			owner: self?.agentId,
+			acceptanceCriteria: `${answerer} answers the question (\`ay answer\`), and the asker reads it.`,
+			tags: argv.tag ?? []
+		});
+		await store.setBlock(task._id, {
+			type: "waiting-on-answer",
+			agentId: answerer,
+			question
+		});
+		const body = buildAskEnvelope({
+			question,
+			taskId: task._id,
+			root,
+			asker: self ? {
+				cli: self.cli,
+				cwd: self.cwd,
+				pid: self.pid
+			} : null
+		});
+		let delivered = true;
+		try {
+			delivered = await deps.send([
+				String(target.pid),
+				body,
+				"--raw",
+				...argv.force ? ["--force"] : []
+			]) === 0;
+		} catch (err) {
+			delivered = false;
+			process.stderr.write(`warning: could not deliver the question to ${answerer}: ${err instanceof Error ? err.message : String(err)}\n`);
+		}
+		if (!delivered) process.stderr.write(`warning: ${task._id} was recorded but NOT delivered. If this was the recency guard, confirm the target first (\`ay tail ${target.pid}\`) then re-ask, or re-run with --force.\n`);
+		out(`asked ${answerer} → ${task._id}${delivered ? "" : "  (NOT DELIVERED)"}`);
+		out(`  question: ${summarize(question)}`);
+		out(`  monitor the answer:   ay todo get ${task._id} --root ${shellQuote(root)}`);
+		out(`  monitor the answerer: ay status ${answerer}`);
+		out(`  both at once:         ay todo ls --blocked --root ${shellQuote(root)}`);
+	}
+});
+const answerCmd = (deps) => ({
+	command: "$0 <task> <answer..>",
+	describe: "answer a question asked via `ay ask`",
+	builder: (y) => y.positional("task", {
+		type: "string",
+		demandOption: true,
+		describe: "task id from the ask"
+	}).positional("answer", {
+		type: "string",
+		array: true,
+		demandOption: true,
+		describe: "the answer (unquoted words are joined)"
+	}),
+	handler: async (argv) => {
+		const answer = argv.answer.map(String).join(" ").trim();
+		if (!answer) fail("usage: ay answer <task> \"<answer>\"");
+		const root = await resolveTodoRoot(argv.root);
+		const store = await openStore(root);
+		const task = store.get(argv.task);
+		if (!task) fail(`no such task in ${root}: ${argv.task}`);
+		if (task.kind !== "question") fail(`task ${argv.task} is a "${task.kind}" task, not a question from \`ay ask\``);
+		const self = await (deps.self ?? resolveSelf)();
+		const validator = self?.agentId ?? "human";
+		await store.approve(task._id, "answer-received", validator, { note: answer });
+		const answered = await store.transition(task._id, "answered");
+		await store.setBlock(task._id, null);
+		let notified = false;
+		if (answered.owner) {
+			const body = buildAnswerEnvelope({
+				answer,
+				taskId: task._id,
+				root,
+				answerer: self ? {
+					cli: self.cli,
+					cwd: self.cwd,
+					pid: self.pid
+				} : null
+			});
+			try {
+				const asker = await deps.resolveAgent(answered.owner);
+				notified = await deps.send([
+					String(asker.pid),
+					body,
+					"--raw",
+					"--force"
+				]) === 0;
+			} catch {
+				notified = false;
+			}
+		}
+		out(`answered ${task._id} (validator: ${validator}) → ${answered.state}`);
+		if (answered.owner) out(notified ? `  told the asker: ${answered.owner}` : `  could NOT reach the asker (${answered.owner}) — the answer is recorded on the task: ay todo get ${task._id} --root ${shellQuote(root)}`);
+		out(`  the asker closes it with: ay todo transition ${task._id} done --root ${shellQuote(root)}`);
+	}
+});
+/** Shared by both verbs: `--root` mirrors `ay todo`'s, resolved the same way. */
+function withGlobals(y, scriptName) {
+	return y.scriptName(scriptName).option("root", {
+		type: "string",
+		defaultDescription: "the repo's common root (shared across worktrees), else cwd",
+		describe: "project root holding .agent-yes/todos.jsonl",
+		global: true
+	}).check((argv) => {
+		if (argv.root === "") fail("--root must not be empty");
+		return true;
+	}).strict().help().version(false).exitProcess(false).fail((msg, err) => {
+		throw err ?? new Error(msg);
+	});
+}
+async function runAskSubcommand(rest, deps) {
+	if (rest.length === 0) {
+		withGlobals(yargs([]), "ay ask").command(askCmd(deps)).showHelp((s) => out(s));
+		return 0;
+	}
+	await withGlobals(yargs(rest), "ay ask").command(askCmd(deps)).parseAsync();
+	return 0;
+}
+async function runAnswerSubcommand(rest, deps) {
+	if (rest.length === 0) {
+		withGlobals(yargs([]), "ay answer").command(answerCmd(deps)).showHelp((s) => out(s));
+		return 0;
+	}
+	await withGlobals(yargs(rest), "ay answer").command(answerCmd(deps)).parseAsync();
+	return 0;
+}
+
+//#endregion
+export { runAnswerSubcommand, runAskSubcommand };
+//# sourceMappingURL=askCli-Bbxt9Umz.js.map

package/dist/{browser-DSduVZeZ.js → browser-CorYp8Yu.js}

@@ -13565,4 +13565,4 @@ const XTERM_CSS = `
 
 //#endregion
 export { AyTerminal as t };
-//# sourceMappingURL=browser-DSduVZeZ.js.map
+//# sourceMappingURL=browser-CorYp8Yu.js.map

package/dist/{browser-B7eYrBy7.js → browser-_2ndf80G.js}

@@ -1,7 +1,7 @@
-import { d as randomHex } from "./e2e-CUMZC53I.js";
-import { d as parseChannelLink, f as secretFromTopic, o as deriveChannelId, s as deriveRoom } from "./channels-yE1YUHCl.js";
-import { a as renderThread, c as makeOp, f as hlcSend, n as maxHlc, o as sortOps, r as mergeOps, s as isValidOp } from "./store-BW5NBouz.js";
-import { t as ChannelPeer } from "./peer-DIl5xtx8.js";
+import { d as randomHex } from "./e2e-OLfcNxiv.js";
+import { d as parseChannelLink, f as secretFromTopic, o as deriveChannelId, s as deriveRoom } from "./channels-CkaCyvEp.js";
+import { a as renderThread, c as makeOp, f as hlcSend, n as maxHlc, o as sortOps, r as mergeOps, s as isValidOp } from "./store-C7I2CAu9.js";
+import { t as ChannelPeer } from "./peer-Dr4zvtcd.js";
 
 //#region ts/channels/store.browser.ts
 const PREFIX = "ay29ch:";
@@ -308,4 +308,4 @@ const WIDGET_HTML = `
 
 //#endregion
 export { AyChannel as t };
-//# sourceMappingURL=browser-B7eYrBy7.js.map
+//# sourceMappingURL=browser-_2ndf80G.js.map

package/dist/callback-BnUbjH7p.js

@@ -0,0 +1,13 @@
+import "./logger-CDIsZ-Pp.js";
+import "./globalPidIndex-Dq4KY2IV.js";
+import "./messageLog-BYFwioFY.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 "./callbackCore-Bbe7rpN2.js";
+import { i as loadOrCreateCallbackSecret, n as isCallbackRevoked, r as loadCallbackSecretReadOnly, t as cmdCallback } from "./callback-DI2r3NrV.js";
+
+export { cmdCallback };

package/dist/{callback-Dlqwh9n7.js → callback-DI2r3NrV.js}

@@ -1,6 +1,6 @@
 import { t as agentYesHome } from "./agentYesHome-CtmsY6I-.js";
-import { B as resolveOne } from "./subcommands-DJpVXIb6.js";
-import { a as mintCapability, o as parseExpires } from "./callbackCore-K99x3C75.js";
+import { B as resolveOne } from "./subcommands-03ghe-aZ.js";
+import { a as mintCapability, o as parseExpires } from "./callbackCore-Bbe7rpN2.js";
 import { randomBytes } from "node:crypto";
 import { chmodSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import path from "node:path";
@@ -72,7 +72,7 @@ async function resolveBase(flag) {
 	if (flag) return flag;
 	if (process.env.AGENT_YES_CALLBACK_BASE) return process.env.AGENT_YES_CALLBACK_BASE;
 	try {
-		const { resolveLocalServeUrl } = await import("./serve-BqRNIxeq.js");
+		const { resolveLocalServeUrl } = await import("./serve-BaHCO0bU.js");
 		const url = await resolveLocalServeUrl();
 		if (url) return url;
 	} catch {}
@@ -170,7 +170,7 @@ async function cmdCallback(rest) {
 		createdAt: Date.now()
 	};
 	saveStore(all);
-	const { buildSnippet } = await import("./callbackCore-DcptaZwH.js");
+	const { buildSnippet } = await import("./callbackCore-C0Cg9RbS.js");
 	w(`callback ${id} → ${record.cli} #${record.pid} @ ${record.cwd}`);
 	w(`expires:  ${new Date(exp).toISOString()}  (${expiresSpec})`);
 	w(`endpoint: ${base.replace(/\/+$/, "")}/cb/${cap}`);
@@ -187,4 +187,4 @@ async function cmdCallback(rest) {
 
 //#endregion
 export { loadOrCreateCallbackSecret as i, isCallbackRevoked as n, loadCallbackSecretReadOnly as r, cmdCallback as t };
-//# sourceMappingURL=callback-Dlqwh9n7.js.map
+//# sourceMappingURL=callback-DI2r3NrV.js.map

package/dist/{callbackCore-K99x3C75.js → callbackCore-Bbe7rpN2.js}

@@ -140,4 +140,4 @@ function buildSnippet(opts) {
 
 //#endregion
 export { mintCapability as a, frameVisitorMessage as i, MAX_EXPIRES_MS as n, parseExpires as o, buildSnippet as r, verifyCapability as s, MAX_CALLBACK_MSG_BYTES as t };
-//# sourceMappingURL=callbackCore-K99x3C75.js.map
+//# sourceMappingURL=callbackCore-Bbe7rpN2.js.map

package/dist/{callbackCore-DcptaZwH.js → callbackCore-C0Cg9RbS.js}

@@ -1,3 +1,3 @@
-import { a as mintCapability, i as frameVisitorMessage, n as MAX_EXPIRES_MS, o as parseExpires, r as buildSnippet, s as verifyCapability, t as MAX_CALLBACK_MSG_BYTES } from "./callbackCore-K99x3C75.js";
+import { a as mintCapability, i as frameVisitorMessage, n as MAX_EXPIRES_MS, o as parseExpires, r as buildSnippet, s as verifyCapability, t as MAX_CALLBACK_MSG_BYTES } from "./callbackCore-Bbe7rpN2.js";
 
 export { buildSnippet };

package/dist/{channels-DQaZbare.js → channels-3gz9gHP7.js}

@@ -1,6 +1,6 @@
-import "./e2e-CUMZC53I.js";
-import { c as formatChannelLink, d as parseChannelLink, f as secretFromTopic, l as formatChannelWebLink, o as deriveChannelId, s as deriveRoom, u as isChannelLink } from "./channels-yE1YUHCl.js";
-import { a as renderThread, c as makeOp, f as hlcSend, n as maxHlc, o as sortOps, r as mergeOps, s as isValidOp } from "./store-BW5NBouz.js";
+import "./e2e-OLfcNxiv.js";
+import { c as formatChannelLink, d as parseChannelLink, f as secretFromTopic, l as formatChannelWebLink, o as deriveChannelId, s as deriveRoom, u as isChannelLink } from "./channels-CkaCyvEp.js";
+import { a as renderThread, c as makeOp, f as hlcSend, n as maxHlc, o as sortOps, r as mergeOps, s as isValidOp } from "./store-C7I2CAu9.js";
 import { appendFile, chmod, mkdir, readFile, rm, writeFile } from "fs/promises";
 import os from "os";
 import path from "path";
@@ -386,8 +386,8 @@ function printOp(op) {
 * `extraStdin` (pipe mode) drives it. Returns the started peer + a stop fn.
 */
 async function runMesh(cwd, entry, opts) {
-	const { ChannelPeer } = await import("./peer-Cvntlw1i.js");
-	const { importRTC, getIceServers } = await import("./share-Db_zb6gH.js");
+	const { ChannelPeer } = await import("./peer-u1AUAZeA.js");
+	const { importRTC, getIceServers } = await import("./share-DTPZgbfH.js");
 	const rtc = await importRTC();
 	const seen = new Set((await readOps(cwd, entry.channelId)).map((o) => o.id));
 	const peer = new ChannelPeer({
@@ -567,4 +567,4 @@ async function cmdCh(args) {
 
 //#endregion
 export { cmdCh };
-//# sourceMappingURL=channels-DQaZbare.js.map
+//# sourceMappingURL=channels-3gz9gHP7.js.map

package/dist/{channels-yE1YUHCl.js → channels-CkaCyvEp.js}

@@ -1,4 +1,4 @@
-import { m as validateS, u as parseSecret } from "./e2e-CUMZC53I.js";
+import { m as validateS, u as parseSecret } from "./e2e-OLfcNxiv.js";
 
 //#region ts/channels/link.ts
 const CH_DEFAULT_SIGHOST = "s.agent-yes.com";
@@ -134,4 +134,4 @@ function formatUntrustedInbound(op, opts) {
 
 //#endregion
 export { CH_DEFAULT_SIGHOST as a, formatChannelLink as c, parseChannelLink as d, secretFromTopic as f, parseCmd as i, formatChannelWebLink as l, isActionableCmd as n, deriveChannelId as o, isEphemeral as r, deriveRoom as s, formatUntrustedInbound as t, isChannelLink as u };
-//# sourceMappingURL=channels-yE1YUHCl.js.map
+//# sourceMappingURL=channels-CkaCyvEp.js.map

package/dist/channels.js

@@ -1,7 +1,7 @@
-import "./e2e-CUMZC53I.js";
-import { a as CH_DEFAULT_SIGHOST, c as formatChannelLink, d as parseChannelLink, f as secretFromTopic, i as parseCmd, l as formatChannelWebLink, n as isActionableCmd, o as deriveChannelId, r as isEphemeral, s as deriveRoom, t as formatUntrustedInbound, u as isChannelLink } from "./channels-yE1YUHCl.js";
-import { a as renderThread, c as makeOp, d as formatHlc, f as hlcSend, i as opsMissing, l as opId, n as maxHlc, o as sortOps, p as parseHlc, r as mergeOps, s as isValidOp, t as haveVector, u as compareHlc } from "./store-BW5NBouz.js";
-import "./peer-DIl5xtx8.js";
-import { t as AyChannel } from "./browser-B7eYrBy7.js";
+import "./e2e-OLfcNxiv.js";
+import { a as CH_DEFAULT_SIGHOST, c as formatChannelLink, d as parseChannelLink, f as secretFromTopic, i as parseCmd, l as formatChannelWebLink, n as isActionableCmd, o as deriveChannelId, r as isEphemeral, s as deriveRoom, t as formatUntrustedInbound, u as isChannelLink } from "./channels-CkaCyvEp.js";
+import { a as renderThread, c as makeOp, d as formatHlc, f as hlcSend, i as opsMissing, l as opId, n as maxHlc, o as sortOps, p as parseHlc, r as mergeOps, s as isValidOp, t as haveVector, u as compareHlc } from "./store-C7I2CAu9.js";
+import "./peer-Dr4zvtcd.js";
+import { t as AyChannel } from "./browser-_2ndf80G.js";
 
 export { AyChannel, AyChannel as default, CH_DEFAULT_SIGHOST, compareHlc, deriveChannelId, deriveRoom, formatChannelLink, formatChannelWebLink, formatHlc, formatUntrustedInbound, haveVector, hlcSend, isActionableCmd, isChannelLink, isEphemeral, isValidOp, makeOp, maxHlc, mergeOps, opId, opsMissing, parseChannelLink, parseCmd, parseHlc, renderThread, secretFromTopic, sortOps };

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env bun
 import { t as invokedCliName } from "./invokedCli-uqM2YYA7.js";
 import { n as logger } from "./logger-CDIsZ-Pp.js";
-import { i as versionString, n as displayVersion, t as checkAndAutoUpdate } from "./versionChecker-ZQYirfMp.js";
-import { r as getRustBinary } from "./rustBinary-B9FEbqTu.js";
+import { i as versionString, n as displayVersion, t as checkAndAutoUpdate } from "./versionChecker-V6ceVsu9.js";
+import { r as getRustBinary } from "./rustBinary-B2lNFJSe.js";
 import { argv } from "process";
 import { spawn } from "child_process";
 import ms from "ms";
@@ -295,7 +295,7 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 	const rawArg = process.argv[2];
 	const managerCommands = !invokedCliName(process.argv);
 	const isHelpFlag = rawArg === "-h" || rawArg === "--help";
-	const { isSubcommand, runSubcommand, cmdHelp, isUnknownManagerToken, isBareManagerInvocation } = await import("./subcommands-DLrJfG4D.js");
+	const { isSubcommand, runSubcommand, cmdHelp, isUnknownManagerToken, isBareManagerInvocation } = await import("./subcommands-BS4lnTrb.js");
 	if (isHelpFlag && process.argv.length === 3) {
 		await cmdHelp(managerCommands);
 		process.exit(0);
@@ -309,7 +309,7 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 		process.exit(code ?? 0);
 	}
 	{
-		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-DDs0xUvV.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-CdyjhpZP.js");
 		if (isUnknownManagerToken(rawArg, managerCommands, SUPPORTED_CLIS)) {
 			process.stderr.write(`ay: unknown subcommand or CLI '${rawArg}'.\n    See 'ay help' for subcommands. To run an agent, name a CLI:\n    'ay <cli> …' (e.g. 'ay claude …') or 'ay --cli <cli> …'.\n`);
 			process.exit(1);
@@ -317,7 +317,7 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 	}
 }
 {
-	const { detectCwdPassthrough, SUPPRESS_CWD_WARN_ENV } = await import("./cwdPassthroughHint-BlRuOGo_.js");
+	const { detectCwdPassthrough, SUPPRESS_CWD_WARN_ENV } = await import("./cwdPassthroughHint-BlWO-h5w.js");
 	const dep = detectCwdPassthrough(process.argv);
 	if (dep) {
 		console.warn(dep.message);
@@ -328,16 +328,16 @@ await checkAndAutoUpdate();
 logger.info(versionString());
 const config = parseCliArgs(process.argv);
 if (config.tray) {
-	const { startTray } = await import("./tray-CzGs9-ch.js");
+	const { startTray } = await import("./tray-Bxq_sfvU.js");
 	await startTray();
 	await new Promise(() => {});
 }
 {
-	const { ensureTray } = await import("./tray-CzGs9-ch.js");
+	const { ensureTray } = await import("./tray-Bxq_sfvU.js");
 	ensureTray();
 }
 if (!config.showVersion && !config.appendPrompt && !config.tray) {
-	const { waitForSpawnCapacity } = await import("./spawnGate-CZlMs6uV.js");
+	const { waitForSpawnCapacity } = await import("./spawnGate-C6YKlnmb.js");
 	await waitForSpawnCapacity({
 		onWait: (reason, waitedMs) => {
 			if (config.verbose || waitedMs === 0) console.error(`[agent-yes] spawn gate: ${reason} — waiting…`);
@@ -346,7 +346,7 @@ if (!config.showVersion && !config.appendPrompt && !config.tray) {
 	});
 }
 if (!config.showVersion && !config.appendPrompt && !config.tray) {
-	const { warnIfCwdOccupied } = await import("./cwdConflictWarn-BpweoAiy.js");
+	const { warnIfCwdOccupied } = await import("./cwdConflictWarn-Buy3r_qc.js");
 	await warnIfCwdOccupied(process.argv);
 }
 if (config.useRust) {
@@ -360,14 +360,14 @@ if (config.useRust) {
 		}
 	}
 	if (rustBinary) {
-		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-DDs0xUvV.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-CdyjhpZP.js");
 		const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
 		if (config.verbose) {
 			console.log(`[rust] Using binary: ${rustBinary}`);
 			console.log(`[rust] Args: ${rustArgs.join(" ")}`);
 		}
 		const attach = config.attach || process.env.AGENT_YES_ATTACH === "1";
-		const { shouldForkNested, buildSpawnTutorial, waitForRegistration, confirmAgentStarted, predictedLogPath } = await import("./forkNested-B_4c-TQk.js");
+		const { shouldForkNested, buildSpawnTutorial, waitForRegistration, confirmAgentStarted, predictedLogPath } = await import("./forkNested-jc2ER9xn.js");
 		if (shouldForkNested({
 			isTTY: Boolean(process.stdout.isTTY),
 			ayPid: process.env.AGENT_YES_PID,