agent-yes 1.267.2 → 1.269.1

package/dist/{todoCli-BYGZ7_C5.js → todoCli-DUoxA1dh.js}

@@ -1,7 +1,9 @@
 import "./logger-CDIsZ-Pp.js";
-import { _ as isKnownKind, a as renderTree, d as openStore, i as renderDigest, l as CycleError, n as buildTreeJSON, o as unblockedTasks, p as LIFECYCLES, s as describeBlock, t as reconcileTodos, x as removeControlCharacters } from "./todoAutomation-BQRW614S.js";
+import { a as renderTree, c as describeBlock, i as renderDigest, n as buildTreeJSON, o as unblockedTasks, s as blockedOnAgent, t as reconcileTodos, u as removeControlCharacters } from "./todoAutomation-BETGOik9.js";
 import "./JsonlStore-CPGIR0Wy.js";
 import { i as readGlobalPids } from "./globalPidIndex-Dq4KY2IV.js";
+import { a as LIFECYCLES, l as isKnownKind, r as openStore, t as CycleError } from "./todoStore-Wk8U4zJ8.js";
+import { a as resolveTodoRoot, i as resolveSelf, n as SELF_OWNER, r as ownerLiveness, t as NO_OWNER } from "./todoIdentity-BffBxRHA.js";
 import yargs from "yargs";
 
 //#region ts/todoCli.ts
@@ -14,13 +16,18 @@ import yargs from "yargs";
 * `runTodoSubcommand`, so this file (and everything it pulls in) is only
 * loaded when `ay todo ...` is actually invoked.
 *
-* Store location: `--root <dir>` (default: current working directory) is
-* where `.agent-yes/todos.jsonl` lives, mirroring `PidStore`'s own
-* `<workingDir>/.agent-yes/...` convention. This module has no notion of any
-* particular consuming project's directory-resolution rules (e.g. "find the
-* monorepo root") — a project wanting that behavior supplies it by always
-* invoking with an explicit `--root`, or by calling `openStore()` as a
-* library from its own code instead of through this CLI.
+* Store location: `--root <dir>` is where `.agent-yes/todos.jsonl` lives,
+* mirroring `PidStore`'s own `<workingDir>/.agent-yes/...` convention. Left
+* unset it resolves to the REPO's common root rather than the cwd, so agents
+* in different worktrees share one list — see `todoRoot.ts` for why that
+* matters and where the line is drawn.
+*
+* Cross-agent surface, on top of that shared store: `--owner me` resolves to
+* the calling agent's registry id (`todoIdentity.ts`), `new` assigns to the
+* caller by default, `claim` takes a task over while refusing to steal from a
+* live agent, and `ls`/`get` annotate each owner with whether that agent is
+* still alive. `reconcile` (already present) closes the loop by orphaning
+* tasks whose owner agent exited.
 *
 * Argument parsing: a real yargs COMMAND TREE — one `yargs(argv)` instance
 * with a `CommandModule` per verb registered via `.command()`, `--root`/
@@ -72,13 +79,15 @@ function parseKind(raw) {
 	if (!isKnownKind(raw)) fail(`unknown kind "${raw}" (one of: ${Object.keys(LIFECYCLES).join(", ")})`);
 	return raw;
 }
-function renderRecord(t) {
+function renderRecord(t, agents = []) {
+	const waitingOn = blockedOnAgent(t.block);
+	const waitStatus = waitingOn ? ownerLiveness(waitingOn, agents) : "unknown";
 	const lines = [
 		`${t._id} [${t.state}] ${t.summary}`,
 		`kind:    ${t.kind}${t.targetTier ? `  tier:${t.targetTier}` : ""}`,
 		...t.owner ? [`owner:   ${t.owner}`] : [],
 		...t.acceptanceCriteria ? [`acceptanceCriteria: ${t.acceptanceCriteria}`] : [],
-		...t.block ? [`block:   ${describeBlock(t.block)}`] : [],
+		...t.block ? [`block:   ${describeBlock(t.block)}${waitingOn && waitStatus !== "unknown" ? ` [${waitingOn} is ${waitStatus}]` : ""}`] : [],
 		...t.blockedBy.length ? [`blockedBy: ${t.blockedBy.join(", ")}`] : [],
 		...t.tags.length ? [`tags:    ${t.tags.join(", ")}`] : [],
 		...t.satisfiedGates.length ? [`satisfiedGates: ${t.satisfiedGates.join(", ")}`] : [],
@@ -89,13 +98,39 @@ function renderRecord(t) {
 	if (t.description) lines.push("", t.description);
 	return lines.join("\n");
 }
-function renderList(tasks) {
+/**
+* `owner` as displayed: the stored string plus, when it names an agent the
+* registry knows, that agent's current status — `agt-7(exited)`. An owner with
+* no registry entry (a human, or an agent that never registered) prints bare,
+* because "unknown" there means "not an agent", not "possibly dead".
+*
+* This is the whole point of the shared store being readable across agents:
+* the interesting question about a task someone else owns is almost always
+* "is that someone still running?", and answering it by cross-referencing
+* `ay ls` by hand is exactly the step that gets skipped.
+*/
+function ownerCell(t, agents) {
+	if (!t.owner) return "";
+	const status = ownerLiveness(t.owner, agents);
+	return status === "unknown" ? t.owner : `${t.owner}(${status})`;
+}
+/** Same treatment for the agent a task is WAITING ON — `ay ask`'s answerer. */
+function waitingOnCell(t, agents) {
+	const who = blockedOnAgent(t.block);
+	if (!who) return "";
+	const status = ownerLiveness(who, agents);
+	return status === "unknown" ? who : `${who}(${status})`;
+}
+function renderList(tasks, agents = []) {
 	if (tasks.length === 0) return "(no tasks match)";
-	const rows = tasks.map((t) => [
+	const waiting = tasks.map((t) => waitingOnCell(t, agents));
+	const showWaiting = waiting.some(Boolean);
+	const rows = tasks.map((t, i) => [
 		t._id,
 		t.state,
 		t.kind,
-		t.owner ?? "",
+		ownerCell(t, agents),
+		...showWaiting ? [waiting[i]] : [],
 		t.summary
 	]);
 	const header = [
@@ -103,6 +138,7 @@ function renderList(tasks) {
 		"STATE",
 		"KIND",
 		"OWNER",
+		...showWaiting ? ["WAITING-ON"] : [],
 		"SUMMARY"
 	];
 	const widths = header.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
@@ -112,6 +148,44 @@ function renderList(tasks) {
 function emit(opts, obj, human) {
 	process.stdout.write((opts.format === "json" ? JSON.stringify(obj, null, 2) : human) + "\n");
 }
+/**
+* Open the store every verb works against. Resolution is deferred to call
+* time (rather than baked into a yargs `default:`) because the default is
+* DERIVED — it shells out to git — and a yargs default is evaluated eagerly at
+* parse time, on every invocation including `--help`.
+*/
+async function storeFor(opts) {
+	return openStore(await resolveTodoRoot(opts.root));
+}
+/**
+* Turn an `--owner` value into what gets stored: `me` → this agent's
+* `agent_id`, `none` → explicitly unowned, anything else verbatim.
+*
+* `me` is an ERROR outside an agent, never a silent fallback to a hostname or
+* pid: those look like an agent assignment to a reader but match nothing in
+* the agent index, so the task would sit permanently outside orphan recovery
+* (see `todoIdentity.ts`).
+*/
+/**
+* The agent snapshot every cross-agent view is read against.
+*
+* `liveOnly: false` deliberately: the interesting answer for an owner is often
+* "that agent EXITED", which a live-only read cannot express — it would drop
+* the record and make a dead owner indistinguishable from a human one. Same
+* reasoning (and same call) as `reconcile`, which needs exited records to
+* orphan against.
+*/
+async function liveAgents() {
+	return readGlobalPids({ liveOnly: false });
+}
+async function resolveOwnerArg(raw) {
+	if (raw === void 0) return void 0;
+	if (raw === NO_OWNER || raw === "") return void 0;
+	if (raw !== SELF_OWNER) return raw;
+	const self = await resolveSelf();
+	if (!self) fail(`--owner ${SELF_OWNER} needs an agent context: this process has no registered agent id (run it inside an \`ay\`-managed agent, or pass an explicit --owner).`);
+	return self.agentId;
+}
 const newCmd = {
 	command: "new <summary..>",
 	describe: "create a new task",
@@ -129,7 +203,10 @@ const newCmd = {
 	}).option("acceptance-criteria", {
 		type: "string",
 		describe: "definition of done for this task — what an independent validator should check before approving/verifying it"
-	}).option("owner", { type: "string" }).option("tag", {
+	}).option("owner", {
+		type: "string",
+		describe: `"me" (this agent), "${NO_OWNER}" to leave unowned, or any handle. Default: this agent when run inside one, else unowned`
+	}).option("tag", {
 		type: "string",
 		array: true
 	}).option("dep", {
@@ -138,16 +215,17 @@ const newCmd = {
 		describe: "blocker task id(s)"
 	}),
 	handler: async (argv) => {
-		const store = await openStore(argv.root);
+		const store = await storeFor(argv);
 		const summary = argv.summary.map(String).join(" ");
 		if (!summary) fail("usage: ay todo new <summary> --kind <kind> [--description ...] [--tier ...] [--acceptance-criteria ...] [--owner ...] [--tag t]... [--dep id]...");
+		const owner = argv.owner === void 0 ? (await resolveSelf())?.agentId : await resolveOwnerArg(argv.owner);
 		const rec = await store.create({
 			summary,
 			kind: parseKind(argv.kind),
 			description: argv.description,
 			targetTier: argv.tier,
 			acceptanceCriteria: argv["acceptance-criteria"],
-			owner: argv.owner,
+			owner,
 			tags: argv.tag ?? [],
 			blockedBy: argv.dep ?? []
 		});
@@ -157,19 +235,64 @@ const newCmd = {
 const lsCmd = {
 	command: "ls",
 	describe: "list tasks (filter by --kind, --state, --owner, --tag, --blocked)",
-	builder: (y) => y.option("kind", { type: "string" }).option("state", { type: "string" }).option("owner", { type: "string" }).option("tag", { type: "string" }).option("blocked", {
+	builder: (y) => y.option("kind", { type: "string" }).option("state", { type: "string" }).option("owner", {
+		type: "string",
+		describe: `owner handle, or "${SELF_OWNER}" for this agent`
+	}).option("tag", { type: "string" }).option("blocked", {
 		type: "boolean",
 		default: false
 	}),
 	handler: async (argv) => {
-		const tasks = (await openStore(argv.root)).list({
+		const tasks = (await storeFor(argv)).list({
 			kind: argv.kind ? parseKind(argv.kind) : void 0,
 			state: argv.state,
-			owner: argv.owner,
+			owner: await resolveOwnerArg(argv.owner),
 			tag: argv.tag,
 			blocked: argv.blocked
 		});
-		emit(argv, tasks, renderList(tasks));
+		const agents = await liveAgents();
+		emit(argv, tasks.map((t) => ({
+			...t,
+			ownerLiveness: ownerLiveness(t.owner, agents),
+			...blockedOnAgent(t.block) ? { waitingOnLiveness: ownerLiveness(blockedOnAgent(t.block), agents) } : {}
+		})), renderList(tasks, agents));
+	}
+};
+/**
+* `ay todo claim <id>` — take ownership of a task.
+*
+* Refuses when the current owner is an agent the registry still reports as
+* `active`/`idle`, because in a shared store the overwhelmingly likely reading
+* of "task X is owned by a running agent" is that the agent is working on it
+* right now; silently reassigning would put two agents on one task, each
+* believing it is theirs. A dead owner (`exited`) or a non-agent owner is
+* taken over without ceremony — that is the recovery path this verb exists
+* for. `--force` covers the rest ("it's wedged, I'm taking it").
+*/
+const claimCmd = {
+	command: "claim <id>",
+	describe: "take ownership of a task (refuses to steal from a live agent)",
+	builder: (y) => y.positional("id", {
+		type: "string",
+		demandOption: true
+	}).option("owner", {
+		type: "string",
+		describe: `who to assign to (default: "${SELF_OWNER}", this agent)`
+	}).option("force", {
+		type: "boolean",
+		default: false,
+		describe: "claim even if the current owner agent is still running"
+	}),
+	handler: async (argv) => {
+		const store = await storeFor(argv);
+		const before = store.get(argv.id);
+		if (!before) fail(`no such task: ${argv.id}`);
+		const next = await resolveOwnerArg(argv.owner ?? SELF_OWNER);
+		if (!next) fail(`--owner ${NO_OWNER} is not a claim — use \`ay todo claim <id> --owner <who>\``);
+		const held = ownerLiveness(before.owner, await liveAgents());
+		if (before.owner && before.owner !== next && !argv.force && (held === "active" || held === "idle")) fail(`task ${argv.id} is owned by ${before.owner}, an agent that is still ${held}. Re-run with --force to take it anyway.`);
+		const rec = await store.setOwner(argv.id, next, before.owner ?? null);
+		emit(argv, rec, `claimed ${rec._id} → ${next}\n${renderRecord(rec)}`);
 	}
 };
 const getCmd = {
@@ -180,9 +303,9 @@ const getCmd = {
 		demandOption: true
 	}),
 	handler: async (argv) => {
-		const rec = (await openStore(argv.root)).get(argv.id);
+		const rec = (await storeFor(argv)).get(argv.id);
 		if (!rec) fail(`no such task: ${argv.id}`);
-		emit(argv, rec, renderRecord(rec));
+		emit(argv, rec, renderRecord(rec, await liveAgents()));
 	}
 };
 const transitionCmd = {
@@ -196,7 +319,7 @@ const transitionCmd = {
 		demandOption: true
 	}),
 	handler: async (argv) => {
-		const rec = await (await openStore(argv.root)).transition(argv.id, argv.toState);
+		const rec = await (await storeFor(argv)).transition(argv.id, argv.toState);
 		emit(argv, rec, `transitioned ${rec._id} -> ${rec.state}\n${renderRecord(rec)}`);
 	}
 };
@@ -214,7 +337,7 @@ const approveCmd = {
 		demandOption: true
 	}).option("note", { type: "string" }).option("link", { type: "string" }),
 	handler: async (argv) => {
-		const rec = await (await openStore(argv.root)).approve(argv.id, argv.gate, argv.validatorIdentity, {
+		const rec = await (await storeFor(argv)).approve(argv.id, argv.gate, argv.validatorIdentity, {
 			note: argv.note,
 			link: argv.link
 		});
@@ -229,7 +352,7 @@ const verifyCmd = {
 		demandOption: true
 	}).positional("gate", { type: "string" }),
 	handler: async (argv) => {
-		const rec = await (await openStore(argv.root)).verify(argv.id, argv.gate || void 0);
+		const rec = await (await storeFor(argv)).verify(argv.id, argv.gate || void 0);
 		emit(argv, rec, `verified ${rec._id} -> ${rec.state}\n${renderRecord(rec)}`);
 	}
 };
@@ -311,7 +434,7 @@ const blockCmd = {
 				};
 				break;
 		}
-		const rec = await (await openStore(argv.root)).setBlock(argv.id, block);
+		const rec = await (await storeFor(argv)).setBlock(argv.id, block);
 		emit(argv, rec, `blocked ${rec._id}: ${describeBlock(block)}\n${renderRecord(rec)}`);
 	}
 };
@@ -323,7 +446,7 @@ const unblockCmd = {
 		demandOption: true
 	}),
 	handler: async (argv) => {
-		const rec = await (await openStore(argv.root)).setBlock(argv.id, null);
+		const rec = await (await storeFor(argv)).setBlock(argv.id, null);
 		emit(argv, rec, `unblocked ${rec._id}\n${renderRecord(rec)}`);
 	}
 };
@@ -339,7 +462,7 @@ const setCriteriaCmd = {
 		demandOption: true
 	}),
 	handler: async (argv) => {
-		const store = await openStore(argv.root);
+		const store = await storeFor(argv);
 		const text = argv.text.map(String).join(" ");
 		const rec = await store.setAcceptanceCriteria(argv.id, text);
 		emit(argv, rec, `set acceptance criteria on ${rec._id}\n${renderRecord(rec)}`);
@@ -362,7 +485,7 @@ const depCmd = {
 		describe: "task id it waits for"
 	}),
 	handler: async (argv) => {
-		const store = await openStore(argv.root);
+		const store = await storeFor(argv);
 		try {
 			const rec = argv.verb === "add" ? await store.addDep(argv.id, argv.blockerId) : await store.rmDep(argv.id, argv.blockerId);
 			emit(argv, rec, `${argv.verb === "add" ? "added" : "removed"} dep ${argv.blockerId} on ${rec._id}\n${renderRecord(rec)}`);
@@ -380,7 +503,7 @@ const treeCmd = {
 		describe: "root task id (default: all roots)"
 	}),
 	handler: async (argv) => {
-		const tasks = (await openStore(argv.root)).all();
+		const tasks = (await storeFor(argv)).all();
 		if (argv.format === "json") emit(argv, buildTreeJSON(tasks, argv.id), "");
 		else process.stdout.write(renderTree(tasks, argv.id) + "\n");
 	}
@@ -389,7 +512,7 @@ const digestCmd = {
 	command: "digest",
 	describe: "per-tag board: state counts, blockers, unblocked tasks",
 	handler: async (argv) => {
-		const tasks = (await openStore(argv.root)).all();
+		const tasks = (await storeFor(argv)).all();
 		if (argv.format === "json") emit(argv, {
 			tasks,
 			unblocked: unblockedTasks(tasks).map((t) => t._id)
@@ -401,7 +524,7 @@ const reconcileCmd = {
 	command: "reconcile",
 	describe: "apply automation: orphan dead-owned tasks, clear stale waiting-on-agent blocks, auto-verify, report unblocked tasks",
 	handler: async (argv) => {
-		const store = await openStore(argv.root);
+		const store = await storeFor(argv);
 		const agents = await readGlobalPids({ liveOnly: false });
 		const registeredGates = new Set(store.registeredGateNames());
 		const actions = reconcileTodos(store.all(), agents, registeredGates);
@@ -421,6 +544,9 @@ const reconcileCmd = {
 					applied.push(`auto-verified ${action.taskId} -> ${result.state}`);
 					break;
 				}
+				case "answerer-gone":
+					applied.push(`${action.taskId}: ${action.agentId} exited without answering` + (action.owner ? ` (asked by ${action.owner})` : ""));
+					break;
 				case "notify-unblocked":
 					applied.push(`${action.taskId} is now unblocked (owner: ${action.owner})`);
 					break;
@@ -435,9 +561,9 @@ const reconcileCmd = {
 	}
 };
 async function runTodoSubcommand(rest0) {
-	await yargs(rest0).scriptName("ay todo").option("root", {
+	const y = yargs(rest0).scriptName("ay todo").option("root", {
 		type: "string",
-		default: process.cwd(),
+		defaultDescription: "the repo's common root (shared across worktrees), else cwd",
 		describe: "project root holding .agent-yes/todos.jsonl",
 		global: true
 	}).option("format", {
@@ -448,12 +574,13 @@ async function runTodoSubcommand(rest0) {
 	}).check((argv) => {
 		if (argv.root === "") fail("--root must not be empty");
 		return true;
-	}).command(newCmd).command(lsCmd).command(getCmd).command(transitionCmd).command(approveCmd).command(verifyCmd).command(setCriteriaCmd).command(blockCmd).command(unblockCmd).command(depCmd).command(treeCmd).command(digestCmd).command(reconcileCmd).demandCommand(1, "unknown \"ay todo\" verb (expected: new/ls/get/transition/approve/verify/set-criteria/block/unblock/dep/tree/digest/reconcile)").strict().help().version(false).exitProcess(false).fail((msg, err) => {
+	}).command(newCmd).command(lsCmd).command(getCmd).command(transitionCmd).command(approveCmd).command(verifyCmd).command(setCriteriaCmd).command(blockCmd).command(unblockCmd).command(depCmd).command(claimCmd).command(treeCmd).command(digestCmd).command(reconcileCmd).strict().help().version(false).exitProcess(false).fail((msg, err) => {
 		throw err ?? new Error(msg);
-	}).parseAsync();
+	});
+	if ((await y.parseAsync())._.length === 0) y.showHelp((s) => process.stdout.write(`${s}\n`));
 	return 0;
 }
 
 //#endregion
 export { runTodoSubcommand };
-//# sourceMappingURL=todoCli-BYGZ7_C5.js.map
+//# sourceMappingURL=todoCli-DUoxA1dh.js.map

package/dist/todoIdentity-BffBxRHA.js

@@ -0,0 +1,138 @@
+import { i as readGlobalPids } from "./globalPidIndex-Dq4KY2IV.js";
+import { execFile } from "child_process";
+import path from "path";
+import { promisify } from "util";
+
+//#region ts/todoRoot.ts
+/**
+* Where `ay todo`'s store lives when the caller did not say.
+*
+* The engine is meant to be shared by every agent working on a repo, but the
+* store is a file at `<root>/.agent-yes/todos.jsonl`, so "which root" is what
+* actually decides who can see whom. Defaulting to `process.cwd()` — the
+* original behavior — quietly breaks that the moment agents run in git
+* WORKTREES (this project's own normal mode: `.claude/worktrees/<name>/`, one
+* agent each): every worktree is a different cwd, so every agent gets a
+* PRIVATE todo list, while `reconcileTodos` goes on matching task owners
+* against the GLOBAL cross-runtime agent index. That leaves the two halves of
+* a cross-agent feature disagreeing about what "everyone" means, and it fails
+* silently — an agent sees an empty list, not an error.
+*
+* So the default root is the repo's COMMON root: the main worktree, shared by
+* every linked worktree of the same repo. That is the parent of `git rev-parse
+* --git-common-dir`, NOT `--show-toplevel` — inside a linked worktree
+* `--show-toplevel` returns that worktree's own path (exactly the private
+* answer we are trying to get away from), while `--git-common-dir` is by
+* definition the directory all worktrees of a repo share.
+*
+* Scope deliberately stops at the repo. Going fleet-global (one store for
+* every repo on the machine, the way `ay ls` lists every agent) is a different
+* product decision — unrelated projects' tasks in one list — and is not taken
+* here; a caller who wants that passes an explicit `--root`.
+*/
+const execFileAsync = promisify(execFile);
+/**
+* Minimal `git` runner: stdout on success, `null` if git is missing, this
+* isn't a repo, or it hangs.
+*
+* `child_process` rather than `Bun.spawn` (which sibling modules like
+* `subcommands.ts` use) so this module works under BOTH runtimes. Bun
+* implements `child_process`, while `Bun` is undefined under Node — and the
+* failure mode there is the quiet kind: the catch below would swallow the
+* ReferenceError and every lookup would fall back to cwd, i.e. exactly the
+* per-directory store this module exists to prevent, with no error to notice.
+*/
+const spawnGit = async (args, cwd) => {
+	try {
+		const { stdout } = await execFileAsync("git", args, {
+			cwd,
+			timeout: 2e3
+		});
+		return stdout;
+	} catch {
+		return null;
+	}
+};
+/**
+* Resolve the todo store root, most explicit source first:
+*
+*   1. `--root <dir>` — the caller said it; never second-guessed.
+*   2. `$AGENT_YES_TODO_ROOT` — pins a root for a whole shell/agent session
+*      (also how tests point at a scratch dir with no git repo involved).
+*   3. the repo's common root — shared across worktrees, see the file header.
+*   4. `cwd` — not a git repo at all.
+*
+* Relative values in (1)/(2) resolve against `cwd`, so `--root .` keeps
+* meaning "here" instead of depending on where the process happened to start.
+*/
+async function resolveTodoRoot(explicit, cwd = process.cwd(), env = process.env, runGit = spawnGit) {
+	if (explicit) return path.resolve(cwd, explicit);
+	const pinned = env.AGENT_YES_TODO_ROOT;
+	if (pinned) return path.resolve(cwd, pinned);
+	const common = (await runGit(["rev-parse", "--git-common-dir"], cwd))?.trim();
+	if (!common) return path.resolve(cwd);
+	return path.dirname(path.resolve(cwd, common));
+}
+
+//#endregion
+//#region ts/todoIdentity.ts
+/**
+* "Who am I" for `ay todo`, so a task's owner is a value the rest of the
+* engine can actually reason about.
+*
+* `TodoRecord.owner` is deliberately opaque — a human handle OR an agent's
+* identifier — but `todoAutomation.ts` gives one specific string special
+* meaning: `deadOwnerAgent()` looks the owner up in the global agent index by
+* `agent_id`, and orphans the task when that agent has exited. An owner that
+* is anything else (a human name, a bare pid, a hostname) simply never matches
+* a record, and is therefore treated as a human owner and never orphaned.
+*
+* That asymmetry is the reason this module refuses to guess. Writing "some
+* plausible identifier" for an agent owner would not fail loudly; it would
+* produce a task that LOOKS assigned to an agent and silently opts out of
+* orphan recovery forever — the one automation that exists to notice its owner
+* died. So `resolveSelfAgentId` returns the registry's own `agent_id` or
+* nothing, and the CLI turns "nothing" into an error the caller can read.
+*
+* Resolution mirrors `resolveSender()` in `subcommands.ts`: the wrapper
+* injects its own pid as `AGENT_YES_PID` into the agent's environment (the
+* agent's own pid is not knowable until after spawn), so the env value maps
+* back to a record via `wrapper_pid`, falling back to `pid` for a process that
+* IS the wrapper.
+*/
+/** The literal an owner argument uses to mean "the agent running this command". */
+const SELF_OWNER = "me";
+/** The literal that explicitly means "no owner" — distinct from omitting the flag, which defaults to self. */
+const NO_OWNER = "none";
+/**
+* The calling agent's registry record, or `null` when this is a human shell
+* (no `AGENT_YES_PID`) or the agent is not registered under a stable id.
+*
+* The `agent_id`-less case returns `null` rather than falling back to the pid:
+* a pid is not what `reconcileTodos` compares against, so storing one would be
+* indistinguishable from a human owner to every downstream consumer while
+* looking, to a reader, like a working agent assignment.
+*/
+async function resolveSelf(env = process.env, readPids = () => readGlobalPids()) {
+	const envPid = env.AGENT_YES_PID ? Number(env.AGENT_YES_PID) : null;
+	if (!envPid || Number.isNaN(envPid)) return null;
+	const recs = await readPids();
+	const rec = recs.find((r) => r.wrapper_pid === envPid) ?? recs.find((r) => r.pid === envPid);
+	if (!rec?.agent_id) return null;
+	return {
+		agentId: rec.agent_id,
+		pid: rec.pid,
+		cwd: rec.cwd,
+		cli: rec.cli,
+		title: rec.title
+	};
+}
+/** Look an owner up in an agent snapshot. Same `agent_id` matching `deadOwnerAgent()` uses, so the two never disagree about who is an agent. */
+function ownerLiveness(owner, agents) {
+	if (!owner) return "unknown";
+	return agents.find((a) => a.agent_id === owner)?.status ?? "unknown";
+}
+
+//#endregion
+export { resolveTodoRoot as a, resolveSelf as i, SELF_OWNER as n, ownerLiveness as r, NO_OWNER as t };
+//# sourceMappingURL=todoIdentity-BffBxRHA.js.map