cyberlegion 0.1.0 → 0.2.0

package/dist/{watch-BuYsdwhx.mjs → watch-nkm6F1_f.mjs}

@@ -1,56 +1,38 @@
 import { basename, dirname, join, resolve } from "node:path";
+import { callerPane, currentPane, herdrMuxAdapter, nodeExec, probeMultiplexer, tmuxMuxAdapter } from "cyber-mux";
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { execFileSync } from "node:child_process";
+import { assertDistinctFromPrimary, gitWorktreeAdapter, resolvePrimaryRoot } from "cyber-mux/worktree";
 import { randomBytes } from "node:crypto";
+import { execFileSync } from "node:child_process";
 import { homedir } from "node:os";
-//#region src/console/worktree.ts
-/** The only worktree backend at MVP — plain `git worktree`. */
-const gitWorktreeAdapter = {
-	add(exec, opts) {
-		if (exec("git", [
-			"-C",
-			opts.primaryRoot,
-			"worktree",
-			"add",
-			"-b",
-			opts.branch,
-			opts.path
-		]) === null) throw new Error(`git worktree add failed for ${opts.path}`);
-		return {
-			root: resolve(opts.path),
-			branch: opts.branch
-		};
-	},
-	remove(exec, path, opts) {
-		if (exec("git", [
-			"-C",
-			opts.primaryRoot,
-			"worktree",
-			"remove",
-			path,
-			"--force"
-		]) === null) throw new Error(`git worktree remove failed for ${path}`);
-	}
-};
+//#region src/mux-env.ts
 /**
-* Resolve the primary checkout's root regardless of whether the caller's cwd is the primary
-* checkout or a linked worktree — `--git-common-dir` always points at the main repo's `.git`.
-*/
-function resolvePrimaryRoot(exec) {
-	const commonDir = exec("git", [
-		"rev-parse",
-		"--path-format=absolute",
-		"--git-common-dir"
-	]);
-	if (!commonDir) throw new Error("cannot resolve the primary checkout — not inside a git repository");
-	return dirname(commonDir);
-}
-/**
-* Refuse the primary checkout: a spawned unit's resolved worktree root must never be the primary
-* checkout itself. A unit is never run in the primary checkout.
+* Transitional env-normalization seam (mux.feature: "a pane carrying only the legacy fast-path vars
+* is still honored"). cyber-mux's own fast-path reads `$CYBER_MUX`/`$CYBER_MUX_PANE` — its
+* `currentPane` hardcodes those names (no `envPrefix` override), and `probeMultiplexer`'s `envPrefix`
+* option renames the WHOLE pair together, so neither can be steered to fall back onto a
+* differently-named legacy pair. Every call into cyber-mux that reads the fast-path
+* (`probeMultiplexer`, `currentPane`, `callerPane`, `resolveMuxAdapter`) must be handed this seam's
+* output instead of the raw env.
+*
+* When `$CYBER_MUX`/`$CYBER_MUX_PANE` are both absent and either legacy `$CYBERLEGION_MUX`/
+* `$CYBERLEGION_MUX_PANE` var is present, copies the legacy pair onto the current names. Never
+* overwrites an already-set current var — the current pair always wins outright the moment either
+* half of it is set, exactly matching the frozen precedence chain (mux.feature: "the current
+* fast-path vars win over the legacy pair when both are set").
+*
+* Transitional — deleted once no pre-migration pane (one that only ever exported the legacy pair) is
+* still alive.
 */
-function assertDistinctFromPrimary(worktreeRoot, primaryRoot) {
-	if (resolve(worktreeRoot) === resolve(primaryRoot)) throw new Error("refusing to run a unit in the primary checkout — spawn a worktree distinct from the primary checkout");
+function normalizeMuxEnv(env) {
+	const hasCurrent = env.CYBER_MUX !== void 0 || env.CYBER_MUX_PANE !== void 0;
+	const hasLegacy = env.CYBERLEGION_MUX !== void 0 || env.CYBERLEGION_MUX_PANE !== void 0;
+	if (hasCurrent || !hasLegacy) return env;
+	return {
+		...env,
+		CYBER_MUX: env.CYBERLEGION_MUX,
+		CYBER_MUX_PANE: env.CYBERLEGION_MUX_PANE
+	};
 }
 //#endregion
 //#region src/paths.ts
@@ -132,7 +114,7 @@ const paths = {
 	inboxReadDir: (root, id) => join(root, "inbox", id, "read"),
 	dataDir: (root, id) => join(root, "data", id),
 	briefFile: (root, id) => join(root, "data", id, "brief.md"),
-	resultFile: (root, id) => join(root, "data", id, "result.json")
+	mainPaneFile: (root) => join(root, "main-pane.id")
 };
 /**
 * Where a spawned unit's own git worktree is checked out by default — a sibling of the primary
@@ -154,20 +136,18 @@ function sanitizePane(pane) {
 }
 //#endregion
 //#region src/identity.ts
-const realExec = (cmd, args) => {
-	try {
-		return execFileSync(cmd, args, {
-			encoding: "utf8",
-			stdio: [
-				"ignore",
-				"pipe",
-				"ignore"
-			]
-		}).trim();
-	} catch {
-		return null;
-	}
-};
+const realExec = nodeExec;
+/** `currentPane`, narrowed to a backend the registry can actually store a locator under. A caller
+* inside a pane-carrying-but-unstorable multiplexer (wezterm/zellij) is simply unpaned here — it can
+* still resolve an identity via the `$CYBERLEGION_AGENT_ID` env fallback, it just cannot bind a pane
+* locator to it. */
+function storablePane(env) {
+	const cur = currentPane(normalizeMuxEnv(env));
+	return cur && (cur.mux === "tmux" || cur.mux === "herdr") ? {
+		mux: cur.mux,
+		pane: cur.pane
+	} : void 0;
+}
 const nowIso = (ctx) => new Date(ctx.now?.() ?? Date.now()).toISOString();
 function randomId() {
 	return randomBytes(8).toString("hex");
@@ -206,15 +186,16 @@ function detectHarness(explicit, ctx) {
 	}
 }
 /**
-* Recover the calling agent's own id. In tmux the pane index is authoritative — a pane with no
-* pane entry is simply unregistered and must NOT adopt `$CYBERLEGION_AGENT_ID` (that env fallback
-* applies only when there is no `$TMUX_PANE`). There is no shared bare "self" file — self-id is
-* always pane-keyed or explicit via the env var.
+* Recover the calling agent's own id, mux-agnostically. Inside any multiplexer pane (tmux or herdr)
+* the pane index is authoritative — a pane with no pane entry is simply unregistered and must NOT
+* adopt `$CYBERLEGION_AGENT_ID` (that env fallback applies ONLY when the session is in no
+* multiplexer pane at all). There is no shared bare "self" file — self-id is always pane-keyed or
+* explicit via the env var.
 */
 function resolveSelfId(ctx) {
 	const env = ctx.env ?? process.env;
-	const pane = env.TMUX_PANE;
-	if (pane) return ctx.store.resolvePaneId(pane);
+	const cur = currentPane(normalizeMuxEnv(env));
+	if (cur) return ctx.store.resolvePaneId(cur.pane);
 	return env.CYBERLEGION_AGENT_ID || void 0;
 }
 /** Register (or idempotently refresh) this session's identity. */
@@ -227,7 +208,7 @@ function register(ctx, input) {
 	const existing = existingId ? loadAgent(ctx.store, existingId) : void 0;
 	const id = existing?.id ?? existingId ?? randomId();
 	const ts = nowIso(ctx);
-	const pane = env.TMUX_PANE;
+	const cur = storablePane(env);
 	const exec = ctx.exec ?? realExec;
 	const rec = {
 		id,
@@ -235,17 +216,7 @@ function register(ctx, input) {
 		harness,
 		cwd: process.cwd(),
 		worktree: existing?.worktree ?? gitWorktree(exec),
-		tmux: pane ? {
-			pane,
-			window: exec("tmux", [
-				"display-message",
-				"-p",
-				"-t",
-				pane,
-				"#{window_id}"
-			]) ?? void 0,
-			session: env.TMUX?.split(",")[0]
-		} : null,
+		pane: cur ? paneLocator(cur, exec, env) : null,
 		status: "active",
 		createdAt: existing?.createdAt ?? ts,
 		lastSeen: ts,
@@ -253,9 +224,29 @@ function register(ctx, input) {
 		...existing?.spawnedBy ? { spawnedBy: existing.spawnedBy } : {}
 	};
 	saveAgent(ctx.store, rec);
-	if (pane) ctx.store.putPaneIndex(pane, id);
+	if (cur) ctx.store.putPaneIndex(cur.pane, id);
 	return rec;
 }
+/** Build the record's pane locator. `window`/`session` are tmux-only (herdr's pane id is
+* self-contained and its CLI needs nothing more to address a pane). */
+function paneLocator(cur, exec, env) {
+	if (cur.mux === "tmux") return {
+		mux: "tmux",
+		id: cur.pane,
+		window: exec("tmux", [
+			"display-message",
+			"-p",
+			"-t",
+			cur.pane,
+			"#{window_id}"
+		]) ?? void 0,
+		session: env.TMUX?.split(",")[0]
+	};
+	return {
+		mux: cur.mux,
+		id: cur.pane
+	};
+}
 /** Derive a standing record's stable id from its handle — same slug rule as `sanitizePane`, prefixed
 * so it reads distinct from a random 16-hex session id or a pane pointer. */
 function standingId(handle) {
@@ -275,7 +266,7 @@ function registerStanding(ctx, input) {
 		id,
 		handle: input.handle,
 		kind: "standing",
-		tmux: null,
+		pane: null,
 		harness: void 0,
 		cwd: process.cwd(),
 		status: "active",
@@ -302,18 +293,102 @@ function gitWorktree(exec) {
 function preferStanding(matches) {
 	return matches.find((a) => a.kind === "standing") ?? matches[0];
 }
+/** Split a handle's matches into live and exited. An exited unit's pane is gone and its inbox has
+* no reader, so a *name* must never resolve to one — a handle is reusable across units, and the
+* dead holders of it outnumber the live one over time. Standing records never exit. An explicit id
+* still resolves either way: naming a unit outright is a deliberate choice, unlike reaching for a
+* handle and silently landing on a corpse. */
+function matchHandle(agents, handle) {
+	const matched = agents.filter((a) => a.handle === handle);
+	return {
+		live: matched.filter((a) => a.status !== "exited"),
+		exited: matched.filter((a) => a.status === "exited")
+	};
+}
+/** Fail loudly when a handle names only the dead — never fall through to a corpse. */
+function unaddressable(ref, exited, tried) {
+	if (exited.length > 0) {
+		const dead = exited.map((a) => `${a.id.slice(0, 6)}${a.pane ? ` (${a.pane.id})` : ""}`).join(", ");
+		return /* @__PURE__ */ new Error(`"${ref}" matches only exited unit(s) — ${dead} — which have no reader. Address a live unit ('cyberlegion unit who'), or run 'cyberlegion unit register --standing --handle ${ref}' for a durable inbox.`);
+	}
+	return /* @__PURE__ */ new Error(`no agent addressable as "${ref}" (tried ${tried})`);
+}
 /** Resolve a handle to its standing owner record's id — never falls back to a live session agent
 * sharing that handle, so `--owner` can never be pointed at a session's inbox by mistake. */
 function resolveStandingOwner(store, handle) {
 	const match = listAgents(store).find((a) => a.handle === handle && a.kind === "standing");
-	if (!match) throw new Error(`no standing owner "${handle}" — run 'cyberlegion identity owner --handle ${handle}'`);
+	if (!match) throw new Error(`no standing owner "${handle}" — run 'cyberlegion unit register --standing --handle ${handle}'`);
 	return match.id;
 }
-/** Resolve a recipient argument (id or handle) to an agent id. */
+/**
+* Bind the caller's own unit as a standing owner's presence — the live unit standing in for a
+* durable record that has no session of its own. Order matters: resolve the standing record first
+* (an unknown handle throws via `resolveStandingOwner` — fail-loud, never auto-mints), THEN gate on
+* spawn capability, THEN resolve the caller's own id — so an unknown handle or a caller with no
+* multiplexer never touches the pointer. Last claim wins: a plain overwrite, no merge.
+*/
+function claimPresence(ctx, handle) {
+	const rec = loadAgent(ctx.store, resolveStandingOwner(ctx.store, handle));
+	if (!rec) throw new Error(`no standing owner "${handle}" — run 'cyberlegion unit register --standing --handle ${handle}'`);
+	if (probeMultiplexer(ctx.exec ?? realExec, normalizeMuxEnv(ctx.env ?? process.env)).mux === "none") throw new Error("claiming a presence needs a multiplexer to open panes");
+	const selfId = resolveSelfId(ctx);
+	if (!selfId) throw new Error("no identity in this session — run `cyberlegion unit register` first");
+	rec.presence = selfId;
+	saveAgent(ctx.store, rec);
+	return rec;
+}
+/**
+* Unbind a standing owner's presence. The unknown-handle throw (via `resolveStandingOwner`) wins
+* over this call's own tolerance: `--clear` is forgiving about *nothing being bound* (a no-op, never
+* an error), never about *the owner not existing* — a typo'd handle fails loudly instead of silently
+* reporting a clear it never performed.
+*/
+function clearPresence(ctx, handle) {
+	const rec = loadAgent(ctx.store, resolveStandingOwner(ctx.store, handle));
+	if (!rec) throw new Error(`no standing owner "${handle}" — run 'cyberlegion unit register --standing --handle ${handle}'`);
+	if (rec.presence !== void 0) {
+		rec.presence = void 0;
+		saveAgent(ctx.store, rec);
+	}
+	return rec;
+}
+/**
+* The live-only presence rule, keyed off a standing record the caller ALREADY HOLDS — the pointer
+* records a unit id, and that unit can exit while the standing record it stands in for never does,
+* so a presence whose unit is missing or `status: exited` reads as no presence bound, exactly as if
+* none were ever claimed. Nothing here self-heals the stale pointer; it stays inert until re-claimed
+* via `claimPresence`.
+*
+* Separate from `resolvePresence` because this one is INCAPABLE of throwing: the delivery doorbell
+* must never fail a send that already landed durably, so it cannot resolve the presence through a
+* handle-resolving path that throws when the standing record races away underneath it (a concurrent
+* `unit close`/`decommission` between loading the recipient and reading its presence). It is also
+* strictly cheaper — no O(n) registry scan to re-find a record the caller is holding.
+*/
+function presenceOf(store, rec) {
+	if (!rec.presence) return void 0;
+	const presenceUnit = loadAgent(store, rec.presence);
+	if (!presenceUnit || presenceUnit.status === "exited") return void 0;
+	return presenceUnit;
+}
+/**
+* Resolve a standing owner's presence by handle, live-only (`presenceOf`). The handle-keyed front
+* door for the CLI read path: it keeps the fail-loud unknown-handle throw (via `resolveStandingOwner`)
+* so `unit claim <handle> --show` on a typo'd handle errors rather than reporting a definitive `none`
+* for an owner that does not exist.
+*/
+function resolvePresence(store, handle) {
+	const rec = loadAgent(store, resolveStandingOwner(store, handle));
+	if (!rec) return void 0;
+	return presenceOf(store, rec);
+}
+/** Resolve a recipient argument (id or handle) to an agent id. A handle resolves to live units
+* only — mail addressed to an exited unit lands in an inbox nobody reads. */
 function resolveRecipient(store, to) {
 	if (loadAgent(store, to)) return to;
-	const match = preferStanding(listAgents(store).filter((a) => a.handle === to));
-	if (!match) throw new Error(`no agent addressable as "${to}" — run 'cyberlegion identity owner --handle ${to}' to create a standing inbox`);
+	const { live, exited } = matchHandle(listAgents(store), to);
+	const match = preferStanding(live);
+	if (!match) throw unaddressable(to, exited, "id and handle");
 	return match.id;
 }
 /**
@@ -325,11 +400,13 @@ function resolveAgent(store, ref) {
 	const byId = loadAgent(store, ref);
 	if (byId) return byId;
 	const agents = listAgents(store);
-	const byHandle = preferStanding(agents.filter((a) => a.handle === ref));
+	const { live, exited } = matchHandle(agents, ref);
+	const byHandle = preferStanding(live);
 	if (byHandle) return byHandle;
-	const byBranch = agents.find((a) => a.worktree?.branch === ref);
+	const byBranchAll = agents.filter((a) => a.worktree?.branch === ref);
+	const byBranch = byBranchAll.find((a) => a.status !== "exited");
 	if (byBranch) return byBranch;
-	throw new Error(`no agent addressable as "${ref}" (tried id, handle, and worktree branch/CR)`);
+	throw unaddressable(ref, [...exited, ...byBranchAll.filter((a) => a.status === "exited")].filter((a, i, all) => all.findIndex((b) => b.id === a.id) === i), "id, handle, and worktree branch/CR");
 }
 function bumpLastSeen(ctx, id) {
 	const rec = loadAgent(ctx.store, id);
@@ -343,24 +420,100 @@ function touch(ctx) {
 	if (id) bumpLastSeen(ctx, id);
 }
 const STALE_MS = 900 * 1e3;
-/** Mark agents whose pane is gone or whose last-seen is stale as exited. */
+/** The per-mux session adapters `prune` consults for pane liveness — each answers with its own
+* backend primitive so a herdr pane is never probed with a tmux query, and vice versa. */
+const PANE_ADAPTERS = {
+	tmux: tmuxMuxAdapter,
+	herdr: herdrMuxAdapter
+};
+/** Map a backend-reported agent string to a known harness — substring-matched like the tmux
+* pane-command probe in `detectHarness`; anything else is unclassifiable. */
+function harnessFromAgent(agent) {
+	if (!agent) return void 0;
+	if (agent.includes("cursor")) return "cursor";
+	if (agent.includes("codex")) return "codex";
+	if (agent.includes("claude")) return "claude";
+}
+/**
+* Adopt half of reconcile-against-mux: mint a record for each live pane with a detectable harness
+* and no matching record — bind pane→id, handle from the pane's reported cwd basename (sanitized;
+* `id.slice(0, 6)` when the backend reports no cwd), status active, lastSeen now. A pane is bound —
+* and never adopted — when its pane index resolves to an existing record or any record (any status,
+* exited included) bears it; resurrecting an exited record is the in-pane session's own `register`
+* via the pane pointer, never reconcile's. tmux panes carry no harness signal, so only herdr panes
+* are adoptable today.
+*/
+function adopt(ctx, panes) {
+	const agents = listAgents(ctx.store);
+	const adopted = [];
+	for (const pane of panes) {
+		if (pane.mux !== "tmux" && pane.mux !== "herdr") continue;
+		const harness = harnessFromAgent(pane.harness);
+		if (!harness) continue;
+		const boundId = ctx.store.resolvePaneId(pane.id);
+		if (boundId && loadAgent(ctx.store, boundId)) continue;
+		if (agents.some((a) => a.pane?.mux === pane.mux && a.pane.id === pane.id)) continue;
+		const id = randomId();
+		const ts = nowIso(ctx);
+		const rec = {
+			id,
+			handle: pane.cwd ? sanitizePane(basename(pane.cwd)) : id.slice(0, 6),
+			harness,
+			cwd: pane.cwd ?? "",
+			pane: {
+				mux: pane.mux,
+				id: pane.id
+			},
+			status: "active",
+			createdAt: ts,
+			lastSeen: ts
+		};
+		saveAgent(ctx.store, rec);
+		ctx.store.putPaneIndex(pane.id, id);
+		adopted.push(rec);
+	}
+	return adopted;
+}
+/**
+* Cull dead records against the current mux's live pane set (the mux the caller is actually inside,
+* per `currentPane`) — mux-scoped: it never declares the *other* mux's records dead, since it can't
+* enumerate them. Standing records are exempt; a `pane: null` record can't be pane-culled by
+* enumeration (left to `prune`'s staleness timer). Outside any multiplexer pane there is nothing to
+* enumerate, so it culls nothing. With `adopt` set (the `who --reconcile` path — `prune` stays
+* cull-only), the same live set also feeds adoption of unbound harness-bearing panes.
+*/
+function reconcile(ctx, opts) {
+	const exec = ctx.exec ?? realExec;
+	const cur = storablePane(ctx.env ?? process.env);
+	if (!cur) return [];
+	const panes = PANE_ADAPTERS[cur.mux].listPanes(exec);
+	const live = new Set(panes.map((p) => p.id));
+	const changed = [];
+	for (const rec of listAgents(ctx.store)) {
+		if (rec.kind === "standing") continue;
+		if (rec.status === "exited") continue;
+		if (!rec.pane) continue;
+		if (rec.pane.mux !== cur.mux) continue;
+		if (!live.has(rec.pane.id)) {
+			rec.status = "exited";
+			saveAgent(ctx.store, rec);
+			changed.push(rec);
+		}
+	}
+	if (opts?.adopt) changed.push(...adopt(ctx, panes));
+	return changed;
+}
+/** Mark agents whose pane is gone or whose last-seen is stale as exited. Reconcile-culls against the
+* current mux's live set first, then falls through to the per-record paneExists + staleness check
+* (covers the other mux and sessions outside any multiplexer pane). */
 function prune(ctx) {
 	const exec = ctx.exec ?? realExec;
 	const now = ctx.now?.() ?? Date.now();
-	const changed = [];
+	const changed = reconcile(ctx);
 	for (const rec of listAgents(ctx.store)) {
 		if (rec.kind === "standing") continue;
 		if (rec.status === "exited") continue;
-		const paneGone = rec.tmux?.pane ? exec("tmux", [
-			"has-session",
-			"-t",
-			rec.tmux.pane
-		]) === null && !(exec("tmux", [
-			"list-panes",
-			"-a",
-			"-F",
-			"#{pane_id}"
-		]) ?? "").split("\n").includes(rec.tmux.pane) : false;
+		const paneGone = rec.pane ? !PANE_ADAPTERS[rec.pane.mux].paneExists(exec, { id: rec.pane.id }) : false;
 		const stale = now - new Date(rec.lastSeen).getTime() > STALE_MS;
 		if (paneGone || stale) {
 			rec.status = "exited";
@@ -371,356 +524,186 @@ function prune(ctx) {
 	return changed;
 }
 //#endregion
-//#region src/console/mux-probe.ts
-const KNOWN_MUX = [
-	"tmux",
-	"herdr",
-	"screen",
-	"none"
-];
-function isKnownMux(v) {
-	return v != null && KNOWN_MUX.includes(v);
-}
+//#region src/mux-select.ts
 /**
-* Two-mode multiplexer detection.
+* Backend selection via cyber-mux's two-mode mux probe, normalized through the transitional
+* `$CYBERLEGION_MUX*` → `$CYBER_MUX*` env seam (`mux-env.ts`) — tmux/herdr map to their existing
+* cyber-mux adapters.
 *
-* Fast-path: `$CYBERLEGION_MUX` (tmux | herdr | screen | none) is trusted outright — this also
-* serves as an OVERRIDE (`=none` forces no-mux even inside a real multiplexer). `$CYBERLEGION_MUX_PANE`
-* carries the pane id alongside it.
-*
-* Discovery (else): walk the process ancestry from `$$` via `ps -o ppid=,comm= -p <pid>`, since the
-* tool's own shell may not be the human's pane. `$TMUX`/`$HERDR_ENV` are NOT trusted alone — they
-* are used only as a fast-positive hint the ancestry walk falls back to when the walk itself is
-* inconclusive (e.g. `ps` unavailable), never as a substitute for it.
+* cyber-mux detects MORE backends than `unit/registry`'s `AgentRecord.pane` can carry a locator
+* under (`'tmux' | 'herdr'` only). A DETECTED wezterm/zellij is refused HERE, before anything opens,
+* naming the backend it found (mux.feature: "a detected backend a unit record cannot carry is
+* refused before opening anything") — driving it would open a real pane no record could name,
+* stranding a live session `prune` can never reap and no caller can nudge. Anything else (`none`,
+* `screen`) falls through to the plain "no backend" refusal, unchanged from before the migration.
 */
-function probeMultiplexer(exec, env, opts = {}) {
-	if (isKnownMux(env.CYBERLEGION_MUX)) return {
-		mux: env.CYBERLEGION_MUX,
-		...env.CYBERLEGION_MUX_PANE ? { pane: env.CYBERLEGION_MUX_PANE } : {},
-		via: "env"
-	};
-	if (opts.discover === false) return {
-		mux: "none",
-		via: "ancestry"
-	};
-	return discoverByAncestry(exec, env);
-}
-const MUX_COMM = [
-	{
-		re: /^tmux(:|$)/,
-		mux: "tmux",
-		pane: (env) => env.TMUX_PANE
-	},
-	{
-		re: /^herdr(:|$)/,
-		mux: "herdr",
-		pane: (env) => env.HERDR_PANE
-	},
-	{
-		re: /^screen(:|$)/,
-		mux: "screen",
-		pane: () => void 0
-	}
-];
-const MAX_ANCESTORS = 32;
-function walkAncestry(exec, env) {
-	let pid = process.pid;
-	const seen = /* @__PURE__ */ new Set();
-	for (let i = 0; i < MAX_ANCESTORS; i++) {
-		if (seen.has(pid)) break;
-		seen.add(pid);
-		const line = exec("ps", [
-			"-o",
-			"ppid=,comm=",
-			"-p",
-			String(pid)
-		]);
-		if (!line) break;
-		const trimmed = line.trim();
-		const spaceIdx = trimmed.indexOf(" ");
-		const ppidStr = spaceIdx === -1 ? trimmed : trimmed.slice(0, spaceIdx);
-		const comm = spaceIdx === -1 ? "" : trimmed.slice(spaceIdx + 1).trim();
-		const ppid = Number.parseInt(ppidStr, 10);
-		for (const entry of MUX_COMM) if (entry.re.test(comm)) return {
-			mux: entry.mux,
-			pane: entry.pane(env),
-			via: "ancestry"
-		};
-		if (!Number.isFinite(ppid) || ppid <= 1) break;
-		pid = ppid;
-	}
-}
-function discoverByAncestry(exec, env) {
-	const found = walkAncestry(exec, env);
-	if (found) return found;
-	if (env.TMUX) return {
-		mux: "tmux",
-		pane: env.TMUX_PANE,
-		via: "ancestry"
-	};
-	if (env.HERDR_ENV) return {
-		mux: "herdr",
-		pane: env.HERDR_PANE,
-		via: "ancestry"
-	};
-	return {
-		mux: "none",
-		via: "ancestry"
-	};
+function selectSessionAdapter(env, exec = realExec) {
+	const probe = probeMultiplexer(exec, normalizeMuxEnv(env));
+	if (probe.mux === "tmux") return tmuxMuxAdapter;
+	if (probe.mux === "herdr") return herdrMuxAdapter;
+	if (probe.mux === "wezterm" || probe.mux === "zellij") throw new Error(`spawn detected ${probe.mux}, a backend unit/registry cannot store a pane locator under (only tmux and herdr) — refusing before opening anything`);
+	throw new Error("spawn requires a session backend — run inside tmux ($TMUX) or herdr ($HERDR_ENV=1)");
 }
 //#endregion
-//#region src/console/session.herdr.ts
+//#region src/workspace-label.ts
 /**
-* herdr backend — detected via `$HERDR_ENV`. herdr (https://herdr.dev) is an agent-aware terminal
-* multiplexer that also reports real busy-state (working / idle / blocked / done); this adapter
-* only drives its pane lifecycle, not the state feed. Talks to herdr's own CLI (`herdr pane ...`)
-* rather than its Unix-socket API, so it composes with this codebase's synchronous `Exec`
-* convention exactly like the tmux adapter — no new client/transport needed.
+* Workspace labels — the short, human-scannable name a `workspace` placement opens under.
 *
-* The pane lifecycle (split/run/read/close) is verified against a live herdr binary; `pane split`
-* returns a JSON `pane_info` envelope whose id is extracted in `parsePaneId`.
+* A unit's own visible space is what a human scans to find a session, so a bare backend default
+* ("workspace 4") costs a search every time. A label is `<code>-<subject>`, capped at 30 characters
+* INCLUDING the code, so it stays readable in a sidebar/status bar at a glance.
+*
+* The code is a NieR YoRHa unit class picked from the brief's leading action word in one fixed
+* order, so the same brief always yields the same code:
+*   - `A2-` — the action tears down or reverts (A2 is the rogue/attack unit)
+*   - `9S-` — the action is read-only recon (9S is the Scanner)
+*   - `2B-` — everything else: build-and-change work, the default (2B is the battle unit)
 */
-const herdrSessionAdapter = {
-	name: "herdr",
-	open(exec, opts) {
-		let id;
-		if (opts.at === "workspace") {
-			const out = exec("herdr", [
-				"workspace",
-				"create",
-				"--cwd",
-				opts.cwd,
-				"--no-focus"
-			]);
-			if (!out) throw new Error("herdr workspace create failed");
-			id = parseWorkspaceRootPaneId(out);
-		} else {
-			const out = exec("herdr", [
-				"pane",
-				"split",
-				"--current",
-				"--direction",
-				opts.at === "pane:down" ? "down" : "right",
-				"--cwd",
-				opts.cwd
-			]);
-			if (!out) throw new Error("herdr pane split failed");
-			id = parsePaneId(out);
-		}
-		const target = { id };
-		exec("herdr", [
-			"pane",
-			"run",
-			id,
-			opts.launch
-		]);
-		return target;
-	},
-	openInNewWorktree(exec, opts) {
-		const out = exec("herdr", [
-			"worktree",
-			"create",
-			"--cwd",
-			opts.primaryRoot,
-			"--branch",
-			opts.branch,
-			"--path",
-			opts.path,
-			"--no-focus"
-		]);
-		if (!out) throw new Error("herdr worktree create failed");
-		const { paneId, worktree } = parseWorktreeCreate(out);
-		const target = { id: paneId };
-		exec("herdr", [
-			"pane",
-			"run",
-			paneId,
-			opts.launch
-		]);
-		return {
-			target,
-			worktree
-		};
-	},
-	send(exec, target, text) {
-		exec("herdr", [
-			"pane",
-			"run",
-			target.id,
-			text
-		]);
-	},
-	read(exec, target, opts) {
-		const args = [
-			"pane",
-			"read",
-			target.id,
-			"--source",
-			"visible"
-		];
-		if (opts?.lines != null) args.push("--lines", String(opts.lines));
-		return exec("herdr", args) ?? "";
-	},
-	focus(exec, target) {
-		exec("herdr", [
-			"pane",
-			"focus",
-			target.id
-		]);
-	},
-	teardown(exec, target) {
-		exec("herdr", [
-			"pane",
-			"close",
-			target.id
-		]);
-	}
-};
+/** Total label budget, code included. */
+const LABEL_CAP = 30;
+/** Every code is the same width, so the subject budget is a constant. */
+const CODE_WIDTH = 3;
+/** Leading actions that tear down or revert — the `A2-` class, checked first. */
+const TEARDOWN_ACTIONS = new Set([
+	"clean",
+	"cleanup",
+	"decommission",
+	"delete",
+	"deprecate",
+	"disable",
+	"drop",
+	"prune",
+	"purge",
+	"remove",
+	"retire",
+	"revert",
+	"revoke",
+	"rollback",
+	"teardown",
+	"undo",
+	"uninstall",
+	"unregister"
+]);
+/** Leading actions that only look and report — the `9S-` class, checked after teardown. */
+const RECON_ACTIONS = new Set([
+	"analyze",
+	"assess",
+	"audit",
+	"check",
+	"compare",
+	"debug",
+	"diagnose",
+	"evaluate",
+	"examine",
+	"explain",
+	"explore",
+	"find",
+	"identify",
+	"inspect",
+	"investigate",
+	"locate",
+	"measure",
+	"profile",
+	"read",
+	"reproduce",
+	"research",
+	"review",
+	"scan",
+	"survey",
+	"trace",
+	"triage",
+	"verify"
+]);
 /**
-* `herdr pane split` emits a JSON envelope, not a bare id:
-* `{"id":"cli:pane:split","result":{"pane":{"pane_id":"w3:pB", ...},"type":"pane_info"}}`.
-* The pane id herdr's other `pane` subcommands accept lives at `.result.pane.pane_id`. Extract it —
-* passing the whole blob downstream lands it in a filename and blows the path length limit.
+* Leading actions that build or change — the `2B-` class. `2B-` is also the code for a brief whose
+* lead matches nothing at all, but the two cases differ in the SUBJECT: a recognized action is
+* dropped from it (the code already says "build"), an unrecognized leading word is kept (it is the
+* subject's own first noun, and dropping it would strip real signal).
 */
-function parsePaneId(out) {
-	let paneId;
-	try {
-		paneId = JSON.parse(out)?.result?.pane?.pane_id;
-	} catch {
-		throw new Error(`herdr pane split returned unparseable output: ${out.slice(0, 200)}`);
-	}
-	if (typeof paneId !== "string" || paneId === "") throw new Error(`herdr pane split output had no result.pane.pane_id: ${out.slice(0, 200)}`);
-	return paneId;
-}
+const BUILD_ACTIONS = new Set([
+	"add",
+	"backfill",
+	"build",
+	"create",
+	"document",
+	"enable",
+	"extend",
+	"fix",
+	"generalize",
+	"harden",
+	"implement",
+	"introduce",
+	"make",
+	"migrate",
+	"move",
+	"port",
+	"refactor",
+	"rename",
+	"replace",
+	"rework",
+	"ship",
+	"split",
+	"support",
+	"swap",
+	"update",
+	"wire",
+	"write"
+]);
+/** Dropped when it leads the subject — an article carries no identifying signal. */
+const LEADING_ARTICLES = new Set([
+	"a",
+	"an",
+	"the"
+]);
 /**
-* `herdr workspace create` emits its new workspace's initial pane at `.result.root_pane.pane_id`
-* (a different path than `pane split`'s `.result.pane.pane_id`).
+* Resolve the label a `workspace` placement opens under. Total width never exceeds `LABEL_CAP`, and
+* the result always carries a code — a brief that yields no usable subject falls back to the unit's
+* own short id rather than to a bare code.
 */
-function parseWorkspaceRootPaneId(out) {
-	let paneId;
-	try {
-		paneId = JSON.parse(out)?.result?.root_pane?.pane_id;
-	} catch {
-		throw new Error(`herdr workspace create returned unparseable output: ${out.slice(0, 200)}`);
+function deriveWorkspaceLabel(input) {
+	const briefWords = tokenize(firstNonEmptyLine(input.brief));
+	const lead = briefWords[0];
+	let code = "2B-";
+	let leadIsAction = false;
+	if (lead && TEARDOWN_ACTIONS.has(lead)) {
+		code = "A2-";
+		leadIsAction = true;
+	} else if (lead && RECON_ACTIONS.has(lead)) {
+		code = "9S-";
+		leadIsAction = true;
+	} else if (lead && BUILD_ACTIONS.has(lead)) leadIsAction = true;
+	let subjectWords;
+	if (input.handle) subjectWords = tokenize(input.handle);
+	else {
+		subjectWords = leadIsAction ? briefWords.slice(1) : briefWords.slice();
+		if (subjectWords[0] && LEADING_ARTICLES.has(subjectWords[0])) subjectWords.shift();
 	}
-	if (typeof paneId !== "string" || paneId === "") throw new Error(`herdr workspace create output had no result.root_pane.pane_id: ${out.slice(0, 200)}`);
-	return paneId;
+	const subject = fitWords(subjectWords, LABEL_CAP - CODE_WIDTH) || input.id.slice(0, 6);
+	return `${code}${subject}`;
 }
-/**
-* `herdr worktree create` emits the same `.result.root_pane.pane_id` shape as `workspace create`,
-* plus the created worktree's own checkout at `.result.worktree.{path,branch}`.
-*/
-function parseWorktreeCreate(out) {
-	let parsed;
-	try {
-		parsed = JSON.parse(out);
-	} catch {
-		throw new Error(`herdr worktree create returned unparseable output: ${out.slice(0, 200)}`);
-	}
-	const result = parsed?.result;
-	const paneId = result?.root_pane?.pane_id;
-	const path = result?.worktree?.path;
-	const branch = result?.worktree?.branch;
-	if (typeof paneId !== "string" || paneId === "") throw new Error(`herdr worktree create output had no result.root_pane.pane_id: ${out.slice(0, 200)}`);
-	if (typeof path !== "string" || path === "" || typeof branch !== "string" || branch === "") throw new Error(`herdr worktree create output had no result.worktree.{path,branch}: ${out.slice(0, 200)}`);
-	return {
-		paneId,
-		worktree: {
-			root: resolve(path),
-			branch
-		}
-	};
+/** The brief's first line with any content — a leading blank line is not the subject. */
+function firstNonEmptyLine(brief) {
+	for (const line of brief.split("\n")) if (line.trim() !== "") return line;
+	return "";
+}
+/** Lowercase alphanumeric runs; every other character is a separator, never part of a word. */
+function tokenize(text) {
+	return text.toLowerCase().split(/[^a-z0-9]+/).filter((w) => w !== "");
 }
-//#endregion
-//#region src/console/session.tmux.ts
-/** tmux backend — detected via `$TMUX`. */
-const tmuxSessionAdapter = {
-	name: "tmux",
-	open(exec, opts) {
-		const args = opts.at === "workspace" ? [
-			"new-session",
-			"-d",
-			"-c",
-			opts.cwd,
-			"-P",
-			"-F",
-			"#{pane_id}"
-		] : opts.at === "pane:down" ? [
-			"split-window",
-			"-v",
-			"-c",
-			opts.cwd,
-			"-P",
-			"-F",
-			"#{pane_id}"
-		] : opts.at === "tab" || opts.at === "window" ? [
-			"new-window",
-			"-c",
-			opts.cwd,
-			"-P",
-			"-F",
-			"#{pane_id}"
-		] : [
-			"split-window",
-			"-h",
-			"-c",
-			opts.cwd,
-			"-P",
-			"-F",
-			"#{pane_id}"
-		];
-		const pane = exec("tmux", args);
-		if (!pane) throw new Error(`tmux ${args[0]} failed`);
-		const target = { id: pane };
-		tmuxSessionAdapter.send(exec, target, opts.launch);
-		return target;
-	},
-	send(exec, target, text) {
-		exec("tmux", [
-			"send-keys",
-			"-t",
-			target.id,
-			text,
-			"Enter"
-		]);
-	},
-	read(exec, target, opts) {
-		const args = [
-			"capture-pane",
-			"-p",
-			"-t",
-			target.id
-		];
-		if (opts?.lines != null) args.push("-S", `-${opts.lines}`);
-		return exec("tmux", args) ?? "";
-	},
-	focus(exec, target) {
-		exec("tmux", [
-			"select-pane",
-			"-t",
-			target.id
-		]);
-	},
-	teardown(exec, target) {
-		exec("tmux", [
-			"kill-pane",
-			"-t",
-			target.id
-		]);
-	}
-};
-//#endregion
-//#region src/console/index.ts
 /**
-* Backend selection via the two-mode mux probe (`$CYBERLEGION_MUX` fast-path/override, else
-* ancestry discovery from `$$` falling back to the `$TMUX`/`$HERDR_ENV` hint when the walk is
-* inconclusive) — tmux/herdr map to their existing adapters; anything else is a clear error.
+* Join whole words with `-` while they fit `budget`, so the label ends on a complete word rather
+* than mid-word. A single first word wider than the whole budget is hard-truncated — that is the
+* only case where a label can end mid-word, and the alternative is no subject at all.
 */
-function selectSessionAdapter(env, exec = realExec) {
-	const probe = probeMultiplexer(exec, env);
-	if (probe.mux === "tmux") return tmuxSessionAdapter;
-	if (probe.mux === "herdr") return herdrSessionAdapter;
-	throw new Error("spawn requires a session backend — run inside tmux ($TMUX) or herdr ($HERDR_ENV=1)");
+function fitWords(words, budget) {
+	if (words.length === 0) return "";
+	let out = words[0].slice(0, budget);
+	for (const word of words.slice(1)) {
+		const next = `${out}-${word}`;
+		if (next.length > budget) break;
+		out = next;
+	}
+	return out;
 }
 //#endregion
 //#region src/session.ts
@@ -731,6 +714,37 @@ const LAUNCH_MAP = {
 	codex: "codex"
 };
 /**
+* Per-harness fresh-context ("reset") command `clear` injects into a warm peer's pane to return
+* its conversation to a cold context without tearing the pane/session down — keyed on genuine
+* fresh-context semantics, never on the literal word "clear".
+*/
+const RESET_MAP = {
+	claude: "/clear",
+	codex: "/clear",
+	copilot: "/clear",
+	cursor: "/new-chat"
+};
+/**
+* Harnesses whose apparent "clear" command does NOT truly empty the model context — e.g. gemini's
+* `/clear` wipes only the terminal screen, leaving the model's own context stale. There is no
+* honest fresh-context command for these, so they are refused explicitly rather than lumped in
+* with a harness that is merely unmapped.
+*/
+const FALSE_FRIEND_HARNESSES = new Set(["gemini"]);
+/**
+* Resolve `harness`'s own fresh-context command from the reset map. String-keyed (not `Harness`)
+* so it also guards a harness present in `LAUNCH_MAP`/`identity.ts`'s `Harness` union but not yet
+* given an honest reset mapping here. Throws rather than guessing:
+* - a known false-friend harness (its "clear" only clears the screen, not the context)
+* - any harness absent from the map entirely
+*/
+function resetCommandFor(harness) {
+	const mapped = RESET_MAP[harness];
+	if (mapped) return mapped;
+	if (FALSE_FRIEND_HARNESSES.has(harness)) throw new Error(`"${harness}" has no honest fresh-context command — its own "/clear" clears only the terminal screen, not the model context, so unit clear refuses to send a false-friend reset that would leave stale context behind`);
+	throw new Error(`"${harness}" is not in the reset map (${Object.keys(RESET_MAP).join(" | ")}) — unit clear refuses to guess a command`);
+}
+/**
 * Launch a new peer session as a genuine sibling unit: create a real git worktree distinct from
 * the primary checkout (refuse the primary checkout), open a session backend (tmux or herdr) with
 * its cwd set to that worktree, pre-register the peer, and drop its brief as a file the peer's own
@@ -746,6 +760,7 @@ function spawn(ctx, input) {
 	const env = ctx.env ?? process.env;
 	const exec = ctx.exec ?? realExec;
 	const sessionAdapter = selectSessionAdapter(env, exec);
+	const normalizedEnv = normalizeMuxEnv(env);
 	const harness = input.harness;
 	if (!harness || !(harness in LAUNCH_MAP)) throw new Error(`spawn needs a --harness in the launch map (${Object.keys(LAUNCH_MAP).join(" | ")})`);
 	const brief = resolveBrief(input);
@@ -755,6 +770,7 @@ function spawn(ctx, input) {
 	const primaryRoot = resolvePrimaryRoot(exec);
 	const launch = input.command ?? LAUNCH_MAP[harness];
 	const fullLaunch = `${muxEnvPrefix(sessionAdapter.name)}${launch}`;
+	const from = callerPane(sessionAdapter, normalizedEnv);
 	let cwd;
 	let worktree;
 	let target;
@@ -763,20 +779,25 @@ function spawn(ctx, input) {
 		cwd = resolve(input.cwd);
 		assertDistinctFromPrimary(cwd, primaryRoot);
 		worktree = null;
+		const at = input.at ?? "tab";
 		target = sessionAdapter.open(exec, {
 			cwd,
 			launch: fullLaunch,
-			at: input.at
+			at,
+			from,
+			...labelFor(at, input, brief, id)
 		});
 	} else {
 		const branch = input.branch ?? `cyberlegion/unit-${id}`;
+		const at = input.at ?? "workspace";
 		const worktreePath = input.worktreePath ?? resolveUnitWorktreePath(primaryRoot, id.slice(0, 6));
-		if (input.at === "workspace" && sessionAdapter.openInNewWorktree) {
-			const opened = sessionAdapter.openInNewWorktree(exec, {
+		if (at === "workspace" && sessionAdapter.worktree) {
+			const opened = sessionAdapter.worktree.createInWorkspace(exec, {
 				primaryRoot,
 				branch,
 				path: worktreePath,
-				launch: fullLaunch
+				launch: fullLaunch,
+				...labelFor(at, input, brief, id)
 			});
 			assertDistinctFromPrimary(opened.worktree.root, primaryRoot);
 			ensureMarker(join(opened.worktree.root, ".agents", "cyberlegion"));
@@ -796,18 +817,24 @@ function spawn(ctx, input) {
 			target = sessionAdapter.open(exec, {
 				cwd,
 				launch: fullLaunch,
-				at: input.at
+				at,
+				from,
+				...labelFor(at, input, brief, id)
 			});
 		}
 	}
 	const ts = new Date(ctx.now?.() ?? Date.now()).toISOString();
+	const muxName = sessionAdapter.name;
 	const rec = {
 		id,
 		handle: input.handle ?? id.slice(0, 6),
 		harness,
 		cwd,
 		worktree,
-		tmux: sessionAdapter.name === "tmux" ? { pane: target.id } : null,
+		pane: muxName === "tmux" || muxName === "herdr" ? {
+			mux: muxName,
+			id: target.id
+		} : null,
 		status: "spawning",
 		createdAt: ts,
 		lastSeen: ts,
@@ -824,17 +851,59 @@ function spawn(ctx, input) {
 	};
 }
 /**
+* The label a `workspace` placement opens under — the short human-scannable name that makes a unit's
+* own visible space findable by eye (`console/workspace-label.ts` owns the naming rule). Only the
+* `workspace` placement carries one: a pane or tab lives inside a space the caller is already
+* looking at, so it has nothing of its own to name. Spread into the adapter options, so a
+* non-workspace placement passes no `label` key at all rather than an explicit `undefined`.
+*
+* The gate is load-bearing, not defensive: cyber-mux names whatever tier `at` opens — a workspace,
+* a tab, or a pane — so passing a label on a `tab` placement would rename the caller's own tab.
+* Exported so that gate is tested directly rather than only through a backend's arguments.
+*/
+function labelFor(at, input, brief, id) {
+	if (at !== "workspace") return {};
+	return { label: deriveWorkspaceLabel({
+		brief,
+		handle: input.handle,
+		id
+	}) };
+}
+/**
 * The env prefix typed ahead of the launch command so the spawned peer inherits the caller's
-* multiplexer fast-path and never has to run its own ancestry discovery (`$CYBERLEGION_MUX` /
-* `$CYBERLEGION_MUX_PANE`). `VAR=val cmd` scopes the vars to that one process (and its children)
+* multiplexer fast-path and never has to run its own ancestry discovery (`$CYBER_MUX` /
+* `$CYBER_MUX_PANE`). `VAR=val cmd` scopes the vars to that one process (and its children)
 * without needing `export`. tmux natively sets `$TMUX_PANE` for a pane's own processes, so the
 * pane var is expanded by the child's own shell rather than baked in here.
 */
 function muxEnvPrefix(muxName) {
-	if (muxName === "tmux") return "CYBERLEGION_MUX=tmux CYBERLEGION_MUX_PANE=$TMUX_PANE ";
-	if (muxName === "herdr") return "CYBERLEGION_MUX=herdr ";
+	if (muxName === "tmux") return "CYBER_MUX=tmux CYBER_MUX_PANE=$TMUX_PANE ";
+	if (muxName === "herdr") return "CYBER_MUX=herdr ";
 	return "";
 }
+/**
+* Reset a warm peer's context to cold WITHOUT tearing anything down — injects the peer's own
+* harness fresh-context command (`resetCommandFor`) into its pane through the session adapter.
+* Warmth is the unit (pane/process stays warm — no cold-start), coldness is the context. The
+* command is resolved (and any false-friend/unmapped harness throws) BEFORE anything is sent, so
+* a fail-loud harness never has anything typed into its pane. Touches neither the registry record
+* nor the worktree — `close` (`decommission`) owns teardown.
+*/
+function clearUnit(ctx, ref) {
+	const agent = resolveAgent(ctx.store, ref);
+	const pane = agent.pane?.id ?? ctx.store.findPaneByAgentId(agent.id);
+	if (!pane) throw new Error(`unit "${ref}" has no known session pane`);
+	if (!agent.harness) throw new Error(`unit "${ref}" has no harness on record — cannot resolve its reset command`);
+	const command = resetCommandFor(agent.harness);
+	const env = ctx.env ?? process.env;
+	const exec = ctx.exec ?? realExec;
+	selectSessionAdapter(env, exec).submit(exec, { id: pane }, command);
+	return {
+		agent,
+		pane,
+		command
+	};
+}
 /** Resolve a spawn brief from --brief-file, --task -, or --task <text>; null if no source given. */
 function resolveBrief(input, readStdin = () => readFileSync(0, "utf8")) {
 	if (input.briefFile) return readFileSync(input.briefFile, "utf8");
@@ -864,18 +933,6 @@ function realizeLaunch(def, opts = {}) {
 		command: parts.join(" ")
 	};
 }
-/** Build the instruction string a parent model uses to spawn its OWN harness Task subagent for
-* `def` — cyberlegion never invokes the Task tool itself. Names `subagent_type: <def.name>` for a
-* harness that recognizes it, but always inlines the model + full instructions too so the same
-* instruction string is correct even when the harness has no such named subagent type. */
-function realizeSubagentInstruction(def, opts) {
-	const lines = [`Spawn a subagent (subagent_type: ${def.name} if your harness recognizes that name, else a generic one).`];
-	if (def.model) lines.push(`Model: ${def.model}.`);
-	if (def.effort) lines.push(`Effort: ${def.effort}.`);
-	lines.push(`Read the brief at ${opts.briefFile} and write its result JSON to ${opts.resultFile}.`);
-	if (def.instructions) lines.push("", "Instructions:", def.instructions);
-	return lines.join("\n");
-}
 //#endregion
 //#region src/agentdef/resolve.ts
 function parseAgentDefFile(text) {
@@ -1008,7 +1065,7 @@ function decommission(ctx, input) {
 	if (worktreeRoot && resolve(worktreeRoot) === resolve(primaryRoot)) throw new Error(`refusing to decommission "${input.id}" — its worktree is the primary checkout; --force does not override this`);
 	const worktreeExists = worktreeRoot != null && existsSync(worktreeRoot);
 	if (worktreeExists && !input.force && isDirty(exec, worktreeRoot)) throw new Error(`unit "${input.id}" has uncommitted changes in its worktree — pass --force to discard them`);
-	const pane = rec.tmux?.pane ?? ctx.store.findPaneByAgentId(input.id);
+	const pane = rec.pane?.id ?? ctx.store.findPaneByAgentId(input.id);
 	if (worktreeExists) try {
 		gitWorktreeAdapter.remove(exec, worktreeRoot, { primaryRoot });
 	} catch (err) {
@@ -1035,272 +1092,15 @@ function isDirty(exec, worktreeRoot) {
 	]);
 }
 //#endregion
-//#region src/message.ts
-/** Write one message into the recipient's inbox. Collision-free by <epochMs>-<hex>. */
-function send(ctx, input) {
-	const toId = resolveRecipient(ctx.store, input.to);
-	const from = loadAgent(ctx.store, input.fromId);
-	const ts = ctx.now?.() ?? Date.now();
-	const msg = {
-		id: `${ts}-${randomBytes(3).toString("hex")}`,
-		from: input.fromId,
-		fromHandle: from?.handle ?? input.fromId,
-		to: toId,
-		...input.subject ? { subject: input.subject } : {},
-		body: input.body,
-		...input.thread ? { thread: input.thread } : {},
-		...input.replyTo ? { replyTo: input.replyTo } : {},
-		ts,
-		sentAt: new Date(ts).toISOString()
-	};
-	ctx.store.putMessage(toId, msg);
-	return msg;
-}
-/** Resolve a message body from the --body flag, a --body-file path, or stdin (--body-file -). */
-function resolveBody(body, bodyFile, readStdin = () => readFileSync(0, "utf8")) {
-	if (body != null) return body;
-	if (bodyFile) return bodyFile === "-" ? readStdin() : readFileSync(bodyFile, "utf8");
-	throw new Error("provide --body <text> or --body-file <path|->");
-}
-/** List the caller's mail, chronological (lexical id sort == time order). */
-function inbox(ctx, q) {
-	const snap = ctx.store.listInbox(q.meId);
-	const unread = snap.unread.map((m) => ({
-		...m,
-		read: false
-	}));
-	const acked = q.unread ? [] : snap.read.map((m) => ({
-		...m,
-		read: true
-	}));
-	let items = [...unread, ...acked];
-	if (q.from) items = items.filter((m) => m.from === q.from || m.fromHandle === q.from);
-	if (q.thread) items = items.filter((m) => m.thread === q.thread);
-	return items.sort((a, b) => a.id.localeCompare(b.id));
-}
-/** Peek at a message (unread or already-acked) without changing its state. */
-function peek(ctx, meId, msgId) {
-	const snap = ctx.store.listInbox(meId);
-	return [...snap.unread, ...snap.read].find((m) => m.id === msgId);
-}
-/** Acknowledge a message by moving it out of the unread set. Errors if not currently unread. */
-function ack(ctx, meId, msgId) {
-	return ctx.store.ackMessage(meId, msgId);
-}
-/** Permanently remove a message (unread or already-acked) from the caller's inbox. */
-function deleteMessage(ctx, meId, msgId) {
-	ctx.store.removeMessage(meId, msgId);
-}
-//#endregion
-//#region src/wake/await.ts
-/** Internal poll interval — not user-facing (the round-trip cost of one `mail await` cycle). */
-const POLL_MS$1 = 1e3;
-const DEFAULT_TIMEOUT_MS = 6e5;
-const DEFAULT_MAX_WAIT_S = 240;
-/**
-* Block on the caller's UNREAD inbox until a message matching `thread` (and optional `from`)
-* arrives, polling on a fixed ~1s internal interval. Three unambiguous outcomes:
-*
-* - `matched` — a message arrived; it is printed by the caller AND acked here (moved to read/), so
-*   it leaves the unread set. Block-then-read: each await consumes exactly its round.
-* - `waiting` — this call's internal poll cycle hit its `maxWaitS` cap (default 240s, always well
-*   under a harness tool-timeout SIGKILL) with no match yet. A clean, non-error return the caller
-*   re-arms on (calls `awaitReply` again) — NOT the same as giving up.
-* - `timed-out` — the caller's overall `timeoutMs` (default 600_000ms / 600s; `0` = wait forever)
-*   elapsed across re-arms with no match. The caller should exit non-zero.
-*/
-async function awaitReply(ctx, input) {
-	const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
-	const maxWaitMs = (input.maxWaitS ?? DEFAULT_MAX_WAIT_S) * 1e3;
-	const now = input.now ?? (() => Date.now());
-	const sleep = input.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
-	const start = now();
-	const cycleDeadline = start + maxWaitMs;
-	for (;;) {
-		const items = inbox(ctx, {
-			meId: input.meId,
-			unread: true,
-			thread: input.thread,
-			from: input.from
-		});
-		if (items.length > 0) {
-			const message = items[0];
-			ack(ctx, input.meId, message.id);
-			return {
-				kind: "matched",
-				message
-			};
-		}
-		const elapsed = now() - start;
-		if (timeoutMs !== 0 && elapsed >= timeoutMs) return { kind: "timed-out" };
-		if (now() >= cycleDeadline) return { kind: "waiting" };
-		await sleep(POLL_MS$1);
-	}
-}
-//#endregion
-//#region src/dispatch/prep.ts
-/** The instruction a caller uses when no agent def is given — still names both slot paths so a
-* generic Task-tool spawn (or a human) can carry out the same contract. */
-function genericInstruction(role, briefFile, resultFile) {
-	const lines = [`Spawn a subagent${role ? ` (role: ${role})` : ""}.`];
-	lines.push(`Read the brief at ${briefFile} and write its result JSON to ${resultFile}.`);
-	return lines.join("\n");
-}
-/**
-* Allocate a dispatch: mint an id (thread defaults to it), write the brief into the Store, compute
-* the result-slot path, and build the instruction from a resolved agent def (or a generic one).
-* Spawns nothing — the envelope is handed to whatever spawns next (a Task tool, `channel()`, a
-* human).
-*/
-function prep(ctx, input, readStdin) {
-	const id = randomId();
-	const thread = input.thread ?? id;
-	const briefText = resolveBody(input.briefText, input.briefFile, readStdin);
-	ctx.store.writeBrief(id, briefText);
-	const briefFile = paths.briefFile(ctx.store.root, id);
-	const resultFile = ctx.store.resultPath(id);
-	let def;
-	if (input.agent || input.agentFile) def = resolveAgentDef({
-		name: input.agent,
-		file: input.agentFile
-	});
-	return {
-		id,
-		thread,
-		briefFile,
-		resultFile,
-		instruction: def ? realizeSubagentInstruction(def, {
-			briefFile,
-			resultFile
-		}) : genericInstruction(input.role, briefFile, resultFile)
-	};
-}
-//#endregion
-//#region src/dispatch/verdict.ts
-function primitiveTypeOf(v) {
-	if (Array.isArray(v)) return "array";
-	return typeof v;
-}
-/**
-* Parse `body` as JSON and, when `schemaFile` is given, structurally check it against a minimal
-* required/type schema. Any failure — invalid JSON, an unreadable/invalid schema file, a missing
-* required key, or a type mismatch — is `{ ok: false }`, never a pass.
-*/
-function validateVerdict(body, schemaFile) {
-	let value;
-	try {
-		value = JSON.parse(body);
-	} catch (err) {
-		return {
-			ok: false,
-			error: `verdict body is not valid JSON: ${err instanceof Error ? err.message : String(err)}`
-		};
-	}
-	if (!schemaFile) return {
-		ok: true,
-		value
-	};
-	let schema;
-	try {
-		schema = JSON.parse(readFileSync(schemaFile, "utf8"));
-	} catch (err) {
-		return {
-			ok: false,
-			error: `verdict schema "${schemaFile}" is not readable/valid JSON: ${err instanceof Error ? err.message : String(err)}`
-		};
-	}
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return {
-		ok: false,
-		error: "verdict body must be a JSON object to validate against a schema"
-	};
-	const obj = value;
-	for (const key of schema.required ?? []) if (!(key in obj)) return {
-		ok: false,
-		error: `verdict is missing required key "${key}"`
-	};
-	for (const [key, expected] of Object.entries(schema.properties ?? {})) {
-		if (!(key in obj)) continue;
-		const actual = primitiveTypeOf(obj[key]);
-		if (actual !== expected) return {
-			ok: false,
-			error: `verdict key "${key}" expected type "${expected}" but got "${actual}"`
-		};
-	}
-	return {
-		ok: true,
-		value
-	};
-}
-//#endregion
-//#region src/dispatch/channel.ts
-/** Thrown by a `--wait` channel call when its internal poll-cycle cap is hit with no reply yet — a
-* clean, re-armable sentinel (mirrors `mail await`'s "waiting" outcome), never a failure. */
-var DispatchWaitingError = class extends Error {
-	thread;
-	constructor(thread) {
-		super(`waiting — no reply on thread "${thread}" yet; re-run to keep waiting`);
-		this.thread = thread;
-	}
-};
-/**
-* `prep()` + spawn a peer session realized from the same agent def + (optionally) `awaitReply` on
-* the thread. Requires `--agent`/`--agent-file` (a channel peer needs a real launch to realize).
-*/
-async function channel(ctx, input, readStdin) {
-	if (!input.agent && !input.agentFile) throw new Error("dispatch channel needs --agent <name> or --agent-file <path> to realize the peer launch");
-	const envelope = prep(ctx, input, readStdin);
-	const realized = realizeLaunch(resolveAgentDef({
-		name: input.agent,
-		file: input.agentFile
-	}));
-	spawn(ctx, {
-		harness: realized.harness,
-		command: realized.command,
-		briefFile: envelope.briefFile,
-		at: input.at
-	});
-	if (!input.wait) return envelope;
-	const meId = resolveSelfId(ctx);
-	if (!meId) throw new Error("dispatch channel --wait needs an identity — run `cyberlegion identity register` first");
-	const outcome = await awaitReply({
-		store: ctx.store,
-		now: ctx.now
-	}, {
-		meId,
-		thread: envelope.thread,
-		timeoutMs: input.timeoutMs,
-		maxWaitS: input.maxWaitS
-	});
-	if (outcome.kind === "waiting") throw new DispatchWaitingError(envelope.thread);
-	if (outcome.kind === "timed-out") throw new Error(`no reply on thread "${envelope.thread}" within timeout`);
-	const validated = validateVerdict(outcome.message.body, input.verdictSchema);
-	if (!validated.ok) throw new Error(validated.error);
-	return {
-		id: envelope.id,
-		verdict: validated.value,
-		body: outcome.message.body,
-		ts: outcome.message.ts
-	};
+//#region src/install.ts
+const PIN_TOKEN = /^[0-9A-Za-z][0-9A-Za-z._+-]*$/;
+function validatePin(pin) {
+	if (!PIN_TOKEN.test(pin)) throw new Error(`invalid --pin "${pin}" — expected a version or dist-tag token like 0.2.0 or latest (no spaces, ranges, or shell metacharacters)`);
 }
-//#endregion
-//#region src/dispatch/collect.ts
-/** Read + validate a dispatch's result file. Throws (fail-loud) when the file is not yet written,
-* or when it fails the optional verdict schema. */
-function collect(ctx, id, verdictSchema) {
-	const body = ctx.store.readResult(id);
-	if (body === void 0) throw new Error(`no result written yet for dispatch "${id}" — the subagent has not written its result file`);
-	const validated = validateVerdict(body, verdictSchema);
-	if (!validated.ok) throw new Error(validated.error);
-	return {
-		id,
-		verdict: validated.value,
-		body,
-		ts: ctx.now?.() ?? Date.now()
-	};
+const hookCommand = (event, pin) => pin ? `npx cyberlegion@${pin} mail hook --event ${event}` : `npx cyberlegion mail hook --event ${event}`;
+function hookTarget(command) {
+	return command.match(/^(?:npx cyberlegion(?:@[^\s]+)?|cyberlegion) (mail hook --event \S+)$/)?.[1];
 }
-//#endregion
-//#region src/install.ts
-const hookCommand = (event) => `cyberlegion mail hook --event ${event}`;
 const VENDORS = {
 	claude: {
 		file: ".claude/settings.json",
@@ -1337,14 +1137,15 @@ function writeJson$1(file, data) {
 	writeFileSync(file, `${JSON.stringify(data, null, 2)}\n`);
 }
 /** Register the surfacing hook into one harness's config, idempotently. */
-function install(harness, projectDir = process.cwd()) {
+function install(harness, projectDir = process.cwd(), pin) {
 	const spec = VENDORS[harness];
 	if (!spec) throw new Error(`unknown harness "${harness}" (expected claude | cursor | codex)`);
+	if (pin !== void 0) validatePin(pin);
 	const file = join(projectDir, spec.file);
 	const settings = readJson(file);
 	const results = [];
 	for (const [canonical, vendorEvent] of Object.entries(spec.events)) {
-		const command = hookCommand(canonical);
+		const command = hookCommand(canonical, pin);
 		const status = spec.shape === "claude" ? upsertClaude(settings, vendorEvent, command) : upsertCursor(settings, vendorEvent, command);
 		results.push({
 			harness,
@@ -1360,7 +1161,14 @@ function install(harness, projectDir = process.cwd()) {
 function upsertClaude(settings, event, command) {
 	const hooks = settings.hooks ??= {};
 	const groups = hooks[event] ??= [];
-	if (groups.some((g) => g.hooks?.some((h) => h.command === command))) return "already present";
+	const target = hookTarget(command);
+	for (const g of groups) for (const h of g.hooks ?? []) {
+		if (h.command === command) return "already present";
+		if (target && hookTarget(h.command) === target) {
+			h.command = command;
+			return "already present";
+		}
+	}
 	const group = { hooks: [{
 		type: "command",
 		command
@@ -1373,11 +1181,91 @@ function upsertCursor(settings, event, command) {
 	if (settings.version == null) settings.version = 1;
 	const hooks = settings.hooks ??= {};
 	const list = hooks[event] ??= [];
-	if (list.some((h) => h.command === command)) return "already present";
+	const target = hookTarget(command);
+	for (const h of list) {
+		if (h.command === command) return "already present";
+		if (target && hookTarget(h.command) === target) {
+			h.command = command;
+			return "already present";
+		}
+	}
 	list.push({ command });
 	return "registered";
 }
 //#endregion
+//#region src/message.ts
+/** Write one message into the recipient's inbox. Collision-free by <epochMs>-<hex>. */
+function send(ctx, input) {
+	const toId = resolveRecipient(ctx.store, input.to);
+	const from = loadAgent(ctx.store, input.fromId);
+	const ts = ctx.now?.() ?? Date.now();
+	const msg = {
+		id: `${ts}-${randomBytes(3).toString("hex")}`,
+		from: input.fromId,
+		fromHandle: from?.handle ?? input.fromId,
+		to: toId,
+		...input.subject ? { subject: input.subject } : {},
+		body: input.body,
+		...input.thread ? { thread: input.thread } : {},
+		...input.replyTo ? { replyTo: input.replyTo } : {},
+		ts,
+		sentAt: new Date(ts).toISOString()
+	};
+	ctx.store.putMessage(toId, msg);
+	return msg;
+}
+/** Resolve a message body from the --body flag, a --body-file path, or stdin (--body-file -). */
+function resolveBody(body, bodyFile, readStdin = () => readFileSync(0, "utf8")) {
+	if (body != null) return body;
+	if (bodyFile) return bodyFile === "-" ? readStdin() : readFileSync(bodyFile, "utf8");
+	throw new Error("provide --body <text> or --body-file <path|->");
+}
+/** List the caller's mail, chronological (lexical id sort == time order). */
+function inbox(ctx, q) {
+	const snap = ctx.store.listInbox(q.meId);
+	const unread = snap.unread.map((m) => ({
+		...m,
+		read: false
+	}));
+	const acked = q.unread ? [] : snap.read.map((m) => ({
+		...m,
+		read: true
+	}));
+	let items = [...unread, ...acked];
+	if (q.from) items = items.filter((m) => m.from === q.from || m.fromHandle === q.from);
+	if (q.thread) items = items.filter((m) => m.thread === q.thread);
+	return items.sort((a, b) => a.id.localeCompare(b.id));
+}
+/** Peek at a message (unread or already-acked) without changing its state. */
+function peek(ctx, meId, msgId) {
+	const snap = ctx.store.listInbox(meId);
+	return [...snap.unread, ...snap.read].find((m) => m.id === msgId);
+}
+/** Acknowledge a message by moving it out of the unread set. Errors if not currently unread. */
+function ack(ctx, meId, msgId) {
+	return ctx.store.ackMessage(meId, msgId);
+}
+/** Read and consume a message in one atomic step: returns the body and acks it if still unread.
+* Idempotent — an already-acked message is returned with `acked: false` rather than erroring (unlike
+* bare `ack`); an unknown message id throws. Backs `mail read --ack`. */
+function readAck(ctx, meId, msgId) {
+	const snap = ctx.store.listInbox(meId);
+	if (snap.unread.some((m) => m.id === msgId)) return {
+		msg: ctx.store.ackMessage(meId, msgId),
+		acked: true
+	};
+	const already = snap.read.find((m) => m.id === msgId);
+	if (already) return {
+		msg: already,
+		acked: false
+	};
+	throw new Error(`"${msgId}" is not a message in this inbox`);
+}
+/** Permanently remove a message (unread or already-acked) from the caller's inbox. */
+function deleteMessage(ctx, meId, msgId) {
+	ctx.store.removeMessage(meId, msgId);
+}
+//#endregion
 //#region src/output.ts
 function stringifyCell(v) {
 	if (v == null) return "";
@@ -1421,8 +1309,16 @@ const EVENTS = ["SessionStart", "PostToolUse"];
 */
 function injectInbox(ctx, event) {
 	if (!EVENTS.includes(event)) throw new Error(`unsupported --event "${event}" (expected ${EVENTS.join(" | ")})`);
-	const meId = resolveSelfId(ctx);
-	if (!meId) return null;
+	let meId = resolveSelfId(ctx);
+	if (!meId) {
+		if (currentPane(normalizeMuxEnv(ctx.env ?? process.env))) try {
+			register(ctx, {});
+			meId = resolveSelfId(ctx);
+		} catch {
+			return null;
+		}
+		if (!meId) return null;
+	}
 	const parts = [];
 	const rec = loadAgent(ctx.store, meId);
 	if (rec?.status === "spawning") {
@@ -1439,18 +1335,25 @@ function injectInbox(ctx, event) {
 		const lines = unread.map((m) => `- **${m.fromHandle}**${m.subject ? ` — ${m.subject}` : ""}: ${m.body} \`(${m.id})\``);
 		parts.push(`## Unread mail (${unread.length})\n\n${lines.join("\n")}`);
 	}
+	const cur = currentPane(normalizeMuxEnv(ctx.env ?? process.env));
 	if (rec && !rec.spawnedBy) try {
-		const standing = listAgents(ctx.store).filter((a) => a.kind === "standing");
-		for (const owner of standing) {
-			const ownerUnread = inbox({ store: ctx.store }, {
-				meId: owner.id,
-				unread: true
-			});
-			if (ownerUnread.length === 0) continue;
-			const lines = ownerUnread.map((m) => `- **${m.fromHandle}**${m.subject ? ` — ${m.subject}` : ""}: ${m.body} \`(${m.id})\``);
-			parts.push(`## Owner mail — ${owner.handle} (${ownerUnread.length})\n\n${lines.join("\n")}`);
+		const bound = ctx.store.getMainPane();
+		if (!bound || cur?.pane === bound) {
+			const standing = listAgents(ctx.store).filter((a) => a.kind === "standing");
+			for (const owner of standing) {
+				const ownerUnread = inbox({ store: ctx.store }, {
+					meId: owner.id,
+					unread: true
+				});
+				if (ownerUnread.length === 0) continue;
+				const lines = ownerUnread.map((m) => `- **${m.fromHandle}**${m.subject ? ` — ${m.subject}` : ""}: ${m.body} \`(${m.id})\``);
+				parts.push(`## Owner mail — ${owner.handle} (${ownerUnread.length})\n\n${lines.join("\n")}`);
+			}
 		}
 	} catch {}
+	if (rec && !rec.spawnedBy) try {
+		if (cur ? !ctx.store.getMainPane() : !listAgents(ctx.store).some((a) => a.kind === "standing")) parts.push("## Legion setup\n\nThis pane has no owner inbox bound yet — run `cyberlegion init` to register the surfacing hook and bind this pane as the owner live presence.");
+	} catch {}
 	if (parts.length === 0) return null;
 	return { hookSpecificOutput: {
 		hookEventName: event,
@@ -1561,18 +1464,66 @@ var FileStore = class {
 		const file = paths.briefFile(this.root, agentId);
 		return existsSync(file) ? readFileSync(file, "utf8") : void 0;
 	}
-	resultPath(id) {
-		return paths.resultFile(this.root, id);
-	}
-	writeResult(id, value) {
-		writeJson(paths.resultFile(this.root, id), value);
+	setMainPane(pane) {
+		const file = paths.mainPaneFile(this.root);
+		if (pane) {
+			writeText(file, pane);
+			return;
+		}
+		rmSync(file, { force: true });
 	}
-	readResult(id) {
-		const file = paths.resultFile(this.root, id);
-		return existsSync(file) ? readFileSync(file, "utf8") : void 0;
+	getMainPane() {
+		const file = paths.mainPaneFile(this.root);
+		return existsSync(file) ? readFileSync(file, "utf8").trim() : void 0;
 	}
 };
 //#endregion
+//#region src/wake/await.ts
+/** Internal poll interval — not user-facing (the round-trip cost of one `mail await` cycle). */
+const POLL_MS$1 = 1e3;
+const DEFAULT_TIMEOUT_MS = 6e5;
+const DEFAULT_MAX_WAIT_S = 240;
+/**
+* Block on the caller's UNREAD inbox until a message matching `thread` (and optional `from`)
+* arrives, polling on a fixed ~1s internal interval. Three unambiguous outcomes:
+*
+* - `matched` — a message arrived; it is printed by the caller AND acked here (moved to read/), so
+*   it leaves the unread set. Block-then-read: each await consumes exactly its round.
+* - `waiting` — this call's internal poll cycle hit its `maxWaitS` cap (default 240s, always well
+*   under a harness tool-timeout SIGKILL) with no match yet. A clean, non-error return the caller
+*   re-arms on (calls `awaitReply` again) — NOT the same as giving up.
+* - `timed-out` — the caller's overall `timeoutMs` (default 600_000ms / 600s; `0` = wait forever)
+*   elapsed across re-arms with no match. The caller should exit non-zero.
+*/
+async function awaitReply(ctx, input) {
+	const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+	const maxWaitMs = (input.maxWaitS ?? DEFAULT_MAX_WAIT_S) * 1e3;
+	const now = input.now ?? (() => Date.now());
+	const sleep = input.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+	const start = now();
+	const cycleDeadline = start + maxWaitMs;
+	for (;;) {
+		const items = inbox(ctx, {
+			meId: input.meId,
+			unread: true,
+			thread: input.thread,
+			from: input.from
+		});
+		if (items.length > 0) {
+			const message = items[0];
+			ack(ctx, input.meId, message.id);
+			return {
+				kind: "matched",
+				message
+			};
+		}
+		const elapsed = now() - start;
+		if (timeoutMs !== 0 && elapsed >= timeoutMs) return { kind: "timed-out" };
+		if (now() >= cycleDeadline) return { kind: "waiting" };
+		await sleep(POLL_MS$1);
+	}
+}
+//#endregion
 //#region src/wake/watch.ts
 const POLL_MS = 1e3;
 /**
@@ -1606,4 +1557,4 @@ async function watchMail(ctx, input, onMessage, opts = {}) {
 	}
 }
 //#endregion
-export { detectHarness as A, resolveStandingOwner as B, resolveAgentDef as C, selectSessionAdapter as D, spawn as E, register as F, resolveProjectLocalRoot as G, ensureMarker as H, registerStanding as I, gitWorktreeAdapter as J, resolveRoot as K, resolveAgent as L, loadAgent as M, prune as N, probeMultiplexer as O, realExec as P, resolveRecipient as R, listAgentDefs as S, realizeSubagentInstruction as T, paths as U, touch as V, projectRoot as W, resolvePrimaryRoot as Y, inbox as _, fail as a, send as b, toonObject as c, DispatchWaitingError as d, channel as f, deleteMessage as g, ack as h, emit as i, listAgents as j, bumpLastSeen as k, install as l, awaitReply as m, FileStore as n, nextStep as o, prep as p, assertDistinctFromPrimary as q, injectInbox as r, toonList as s, watchMail as t, collect as u, peek as v, realizeLaunch as w, decommission as x, resolveBody as y, resolveSelfId as z };
+export { loadAgent as A, resolveSelfId as B, spawn as C, clearPresence as D, claimPresence as E, register as F, projectRoot as G, touch as H, registerStanding as I, normalizeMuxEnv as J, resolveProjectLocalRoot as K, resolveAgent as L, prune as M, realExec as N, detectHarness as O, reconcile as P, resolvePresence as R, clearUnit as S, bumpLastSeen as T, ensureMarker as U, resolveStandingOwner as V, paths as W, install as _, emit as a, resolveAgentDef as b, toonList as c, deleteMessage as d, inbox as f, send as g, resolveBody as h, injectInbox as i, presenceOf as j, listAgents as k, toonObject as l, readAck as m, awaitReply as n, fail as o, peek as p, resolveRoot as q, FileStore as r, nextStep as s, watchMail as t, ack as u, decommission as v, selectSessionAdapter as w, realizeLaunch as x, listAgentDefs as y, resolveRecipient as z };