cyberlegion 2.0.0 → 2.0.1

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
 	"name": "cyberlegion",
-	"version": "2.0.0",
+	"version": "2.0.1",
 	"description": "Agent session spawning, messaging, and dispatch — the Legion and its Legate.",
 	"author": {
 		"name": "unional"

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
 	"name": "cyberlegion",
-	"version": "2.0.0",
+	"version": "2.0.1",
 	"description": "Agent session spawning, messaging, and dispatch — the Legion and its Legate.",
 	"author": {
 		"name": "unional"

package/.plugin/pins.json

@@ -1,3 +1,3 @@
 {
-	"cyberlegion": "2.0.0"
+	"cyberlegion": "2.0.1"
 }

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # cyberlegion
 
+## 2.0.1
+
+### Patch Changes
+
+- 7625b31: `unit prune` keeps an exited unit that only shares a worktree while it is the last record pointing at that worktree, the worktree is still on disk, and its work has not landed. Before, prune deleted it and left the work with nothing pointing at it. "Landed" is the worktree library's judgment (clean, and its branch landed on the default branch), exported as `landedWorktrees` for library callers to pass to `prune`; without it, `prune` keeps every such record.
+
 ## 2.0.0
 
 ### Major Changes

package/dist/cli.mjs

@@ -11163,10 +11163,13 @@ function terminalGone(ctx, rec, terminal, cache) {
 * work from. Reconcile-culls against the current mux's live set first, then judges each remaining
 * record (covers the other mux and sessions outside any multiplexer pane): a pane-bound record by its
 * pane alone — a live or unprobeable pane keeps it whatever its last-seen — and a pane-less record by
-* the staleness timer, its only signal. An exited unit whose worktree is still on disk is kept, since
-* `unit close` owns removing that worktree; every other exited unit is deleted with `deleteExited`.
+* the staleness timer, its only signal. An exited unit whose own linked worktree is still on disk is
+* kept, since `unit close` owns removing that worktree. So is an exited unit that is the last record
+* pointing at a linked worktree it shares, while that worktree is on disk and its work has not landed
+* (`options.landed`): deleting it would leave that work with nothing pointing at it. Every other
+* exited unit is deleted with `deleteExited`.
 */
-function prune(ctx) {
+function prune(ctx, options = {}) {
 	const exec = ctx.exec ?? realExec;
 	const now = ctx.now?.() ?? Date.now();
 	const marked = reconcile(ctx);
@@ -11180,7 +11183,7 @@ function prune(ctx) {
 			marked.push(rec);
 		}
 	}
-	const deleted = deleteExited(ctx);
+	const deleted = deleteExited(ctx, options.landed ?? (() => false));
 	const gone = new Set(deleted.map((r) => r.id));
 	return [...marked.filter((r) => !gone.has(r.id)).map((r) => ({
 		...r,
@@ -11190,11 +11193,26 @@ function prune(ctx) {
 		pruned: "deleted"
 	}))];
 }
-/** Whether an exited record still has a worktree on disk — the one thing it leaves behind that
-* `unit close` must deal with. A record that never had a worktree has nothing on disk. */
-function worktreeOnDisk(rec) {
-	if (rec.worktree?.root == null || !existsSync(rec.worktree.root)) return false;
-	return !isPrimaryCheckout(rec.worktree.root, rec.worktree.primaryRoot);
+/** Whether `checkout` is a linked worktree still on disk — something a record can point at. The
+* primary checkout always exists, but nothing removes it, so no record has to stay to point at it. */
+function linkedOnDisk(checkout) {
+	return checkout?.root != null && existsSync(checkout.root) && !isPrimaryCheckout(checkout.root, checkout.primaryRoot);
+}
+/** Whether another record in the store still points at the worktree at `root`, owned or shared. */
+function pointedAtByOther(store, root, self) {
+	const at = resolve(root);
+	return listAgents(store).some((a) => a.id !== self && (a.worktree?.root != null && resolve(a.worktree.root) === at || a.sharedWorktree?.root != null && resolve(a.sharedWorktree.root) === at));
+}
+/**
+* Whether deleting this exited record would orphan a worktree on disk. Its own linked worktree is kept
+* for `unit close` to remove. A worktree it only shares is kept while this record is the last one
+* pointing at it and its work has not landed — the owner's record is gone, so nothing else would
+* lead to that work.
+*/
+function keepsWorktree(store, rec, landed) {
+	if (linkedOnDisk(rec.worktree)) return true;
+	const shared = rec.sharedWorktree;
+	return linkedOnDisk(shared) && !pointedAtByOther(store, shared.root, rec.id) && !landed(shared.root);
 }
 /** Whether a worktree root is its repository's primary checkout — the one test `unit close` and
 * `unit prune` share for "a seat on the main checkout, which nothing removes". */
@@ -11202,7 +11220,7 @@ function isPrimaryCheckout(worktreeRoot, primaryRoot) {
 	return worktreeRoot != null && primaryRoot != null && resolve(worktreeRoot) === resolve(primaryRoot);
 }
 /**
-* Delete every exited unit with no worktree left to close (none on disk, or only the primary checkout): its record, brief, mailbox, and the pane
+* Delete every exited unit that leaves no work on disk (`keepsWorktree`): its record, brief, mailbox, and the pane
 * pointer that still names it. Nothing revives an exited unit (`unit restart` takes only a running or
 * stopped one), so these records are read by nobody. A pane pointer is dropped only when it still
 * resolves to the deleted unit, since a multiplexer may have handed the pane id to another unit
@@ -11211,11 +11229,11 @@ function isPrimaryCheckout(worktreeRoot, primaryRoot) {
 * `unit close` does. No pane is torn down: an exited unit's pane is already gone or belongs to
 * someone else.
 */
-function deleteExited(ctx) {
+function deleteExited(ctx, landed) {
 	const exec = ctx.exec ?? realExec;
 	const deleted = [];
 	for (const rec of listAgents(ctx.store)) {
-		if (rec.status !== "exited" || isSessionIndependent(rec) || worktreeOnDisk(rec)) continue;
+		if (rec.status !== "exited" || isSessionIndependent(rec) || keepsWorktree(ctx.store, rec, landed)) continue;
 		const primaryRoot = rec.worktree?.primaryRoot;
 		if (primaryRoot && existsSync(primaryRoot)) exec("git", [
 			"-C",
@@ -13201,6 +13219,42 @@ function removeCursor(settings, event, canonical) {
 	else delete hooks[event];
 	return true;
 }
+// src/landed.ts
+/**
+* Which worktrees a unit shares hold work that has landed, as the `landed` judgment `prune` takes.
+* It is the worktree library's own judgment, the one its `acquire` recycles a worktree by: the
+* checkout is clean and its branch has landed on the default branch. Asked once per repository
+* before prune's synchronous pass, for every shared worktree still on disk. A worktree git cannot
+* judge (detached, no default branch, a repository git does not know) does not count as landed, so
+* prune keeps the record that points at it.
+*/
+async function landedWorktrees(ctx) {
+	const exec = asyncExec(ctx.exec ?? realExec);
+	const roots = /* @__PURE__ */ new Map();
+	for (const rec of listAgents(ctx.store)) {
+		const shared = rec.sharedWorktree;
+		if (shared?.root && existsSync(shared.root)) roots.set(shared.root, shared.primaryRoot);
+	}
+	const landed = /* @__PURE__ */ new Set();
+	const asked = /* @__PURE__ */ new Set();
+	for (const [root, recorded] of roots) {
+		const primary = await primaryRoot({
+			from: root,
+			exec
+		}).catch(() => recorded);
+		if (!primary || asked.has(primary)) continue;
+		asked.add(primary);
+		const entries = await listWorktrees({
+			primaryRoot: primary,
+			exec,
+			ignore: LEASE_IGNORE
+		}).catch(() => []);
+		for (const e of entries) if (e.linked && e.merged === true && e.dirty === false) landed.add(e.root);
+	}
+	const normalized = /* @__PURE__ */ new Map();
+	for (const root of roots.keys()) normalized.set(root, landed.has(await normalizeWorktreePath(root)));
+	return (root) => normalized.get(root) ?? false;
+}
 // src/output.ts
 function stringifyCell(v) {
 	if (v == null) return "";
@@ -15016,10 +15070,10 @@ function runWho(opts) {
 	if (agents.length === 0) nextStep("cyberlegion unit register to join");
 }
 syncsUnits(withGlobals(unit.command("who"))).description("list the addressable units").option("--all", "include exited units").option("--reconcile", "live-probe the current mux: cull dead-pane records and adopt unbound harness-bearing panes before listing").action(runWho);
-syncsUnits(withGlobals(unit.command("prune"))).description("mark dead units exited and delete exited units with no worktree on disk").action((opts) => {
+syncsUnits(withGlobals(unit.command("prune"))).description("mark dead units exited and delete exited units that leave no work on disk").action(async (opts) => {
 	const ctx = ctxOf(opts);
 	touch(ctx);
-	const changed = prune(ctx);
+	const changed = prune(ctx, { landed: await landedWorktrees(ctx) });
 	emit(formatOf(opts), {
 		toon: toonList("pruned", changed, [
 			{

package/dist/index.d.mts

@@ -285,10 +285,22 @@ type PrunedRecord = AgentRecord & {
  * work from. Reconcile-culls against the current mux's live set first, then judges each remaining
  * record (covers the other mux and sessions outside any multiplexer pane): a pane-bound record by its
  * pane alone — a live or unprobeable pane keeps it whatever its last-seen — and a pane-less record by
- * the staleness timer, its only signal. An exited unit whose worktree is still on disk is kept, since
- * `unit close` owns removing that worktree; every other exited unit is deleted with `deleteExited`.
+ * the staleness timer, its only signal. An exited unit whose own linked worktree is still on disk is
+ * kept, since `unit close` owns removing that worktree. So is an exited unit that is the last record
+ * pointing at a linked worktree it shares, while that worktree is on disk and its work has not landed
+ * (`options.landed`): deleting it would leave that work with nothing pointing at it. Every other
+ * exited unit is deleted with `deleteExited`.
  */
-export declare function prune(ctx: IdContext): PrunedRecord[];
+export declare function prune(ctx: IdContext, options?: PruneOptions): PrunedRecord[];
+/** What `prune` is told from outside its synchronous pass. */
+interface PruneOptions {
+  /**
+   * Whether the work in the linked worktree at `root` has landed. Absent, no worktree counts as
+   * landed, so prune keeps every record it would otherwise orphan work by deleting. `unit prune`
+   * passes `landedWorktrees`, the worktree library's judgment, asked before the pass.
+   */
+  landed?: (root: string) => boolean;
+}
 interface AgentDef {
   name: string;
   description?: string;
@@ -431,6 +443,15 @@ interface InstallResult {
  * plugin ships it (removing an earlier project copy), otherwise register the PATH-first project hook.
  */
 export declare function install(harness: Harness, projectDir?: string, pin?: string): InstallResult[];
+/**
+ * Which worktrees a unit shares hold work that has landed, as the `landed` judgment `prune` takes.
+ * It is the worktree library's own judgment, the one its `acquire` recycles a worktree by: the
+ * checkout is clean and its branch has landed on the default branch. Asked once per repository
+ * before prune's synchronous pass, for every shared worktree still on disk. A worktree git cannot
+ * judge (detached, no default branch, a repository git does not know) does not count as landed, so
+ * prune keeps the record that points at it.
+ */
+export declare function landedWorktrees(ctx: Pick<IdContext, 'store' | 'exec'>): Promise<(root: string) => boolean>;
 interface MsgContext {
   store: Store;
   now?: () => number;
@@ -934,4 +955,4 @@ interface WatchOptions {
  * `watch` prints stays unread and still surfaces later in `mail inbox`/`mail await`.
  */
 export declare function watchMail(ctx: MsgContext, input: WatchInput, onMessage: (msg: InboxItem) => void, opts?: WatchOptions): Promise<void>;
-export { type AcquireInput, type AcquireResult, type AgentDef, type AgentRecord, type AwaitInput, type AwaitOutcome, type DecommissionInput, type DecommissionResult, type Exec, type Format, type Harness, type HookEvent, type IdContext, type InboxItem, type InboxQuery, type InboxSnapshot, type Message, type MuxProbe, type OwnershipErrorCode, type ProjectContext, type ProjectRecord, type RegisterInput, type RootOptions, type SendInput, type ServiceContext, type ServiceHealth, type ServiceLease, type ServiceView, type SpawnInput, type SpawnResult, type StartInput, type StartResult, type Store, assertDistinctFromPrimary, gitWorktreeAdapter, probeMultiplexer, resolvePrimaryRoot };
+export { type AcquireInput, type AcquireResult, type AgentDef, type AgentRecord, type AwaitInput, type AwaitOutcome, type DecommissionInput, type DecommissionResult, type Exec, type Format, type Harness, type HookEvent, type IdContext, type InboxItem, type InboxQuery, type InboxSnapshot, type Message, type MuxProbe, type OwnershipErrorCode, type ProjectContext, type ProjectRecord, type PruneOptions, type RegisterInput, type RootOptions, type SendInput, type ServiceContext, type ServiceHealth, type ServiceLease, type ServiceView, type SpawnInput, type SpawnResult, type StartInput, type StartResult, type Store, assertDistinctFromPrimary, gitWorktreeAdapter, probeMultiplexer, resolvePrimaryRoot };

package/dist/index.mjs

@@ -2,7 +2,7 @@ import { callerPane, currentPane, herdrMuxAdapter, isStaged, nodeExec, probeMult
 import { assertDistinctFromPrimary, assertDistinctFromPrimary as assertDistinctFromPrimary$1, gitWorktreeAdapter, gitWorktreeAdapter as gitWorktreeAdapter$1, resolvePrimaryRoot, resolvePrimaryRoot as resolvePrimaryRoot$1 } from "cyber-mux/worktree";
 import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
-import { acquire, gitWorktreeCreator, primaryRoot, release } from "cyber-agentkit/worktrees";
+import { acquire, gitWorktreeCreator, listWorktrees, normalizeWorktreePath, primaryRoot, release } from "cyber-agentkit/worktrees";
 import { createHash, randomBytes } from "node:crypto";
 import { execFileSync } from "node:child_process";
 import { homedir } from "node:os";
@@ -738,10 +738,13 @@ function terminalGone(ctx, rec, terminal, cache) {
 * work from. Reconcile-culls against the current mux's live set first, then judges each remaining
 * record (covers the other mux and sessions outside any multiplexer pane): a pane-bound record by its
 * pane alone — a live or unprobeable pane keeps it whatever its last-seen — and a pane-less record by
-* the staleness timer, its only signal. An exited unit whose worktree is still on disk is kept, since
-* `unit close` owns removing that worktree; every other exited unit is deleted with `deleteExited`.
+* the staleness timer, its only signal. An exited unit whose own linked worktree is still on disk is
+* kept, since `unit close` owns removing that worktree. So is an exited unit that is the last record
+* pointing at a linked worktree it shares, while that worktree is on disk and its work has not landed
+* (`options.landed`): deleting it would leave that work with nothing pointing at it. Every other
+* exited unit is deleted with `deleteExited`.
 */
-function prune(ctx) {
+function prune(ctx, options = {}) {
 	const exec = ctx.exec ?? realExec;
 	const now = ctx.now?.() ?? Date.now();
 	const marked = reconcile(ctx);
@@ -755,7 +758,7 @@ function prune(ctx) {
 			marked.push(rec);
 		}
 	}
-	const deleted = deleteExited(ctx);
+	const deleted = deleteExited(ctx, options.landed ?? (() => false));
 	const gone = new Set(deleted.map((r) => r.id));
 	return [...marked.filter((r) => !gone.has(r.id)).map((r) => ({
 		...r,
@@ -765,11 +768,26 @@ function prune(ctx) {
 		pruned: "deleted"
 	}))];
 }
-/** Whether an exited record still has a worktree on disk — the one thing it leaves behind that
-* `unit close` must deal with. A record that never had a worktree has nothing on disk. */
-function worktreeOnDisk(rec) {
-	if (rec.worktree?.root == null || !existsSync(rec.worktree.root)) return false;
-	return !isPrimaryCheckout(rec.worktree.root, rec.worktree.primaryRoot);
+/** Whether `checkout` is a linked worktree still on disk — something a record can point at. The
+* primary checkout always exists, but nothing removes it, so no record has to stay to point at it. */
+function linkedOnDisk(checkout) {
+	return checkout?.root != null && existsSync(checkout.root) && !isPrimaryCheckout(checkout.root, checkout.primaryRoot);
+}
+/** Whether another record in the store still points at the worktree at `root`, owned or shared. */
+function pointedAtByOther(store, root, self) {
+	const at = resolve(root);
+	return listAgents(store).some((a) => a.id !== self && (a.worktree?.root != null && resolve(a.worktree.root) === at || a.sharedWorktree?.root != null && resolve(a.sharedWorktree.root) === at));
+}
+/**
+* Whether deleting this exited record would orphan a worktree on disk. Its own linked worktree is kept
+* for `unit close` to remove. A worktree it only shares is kept while this record is the last one
+* pointing at it and its work has not landed — the owner's record is gone, so nothing else would
+* lead to that work.
+*/
+function keepsWorktree(store, rec, landed) {
+	if (linkedOnDisk(rec.worktree)) return true;
+	const shared = rec.sharedWorktree;
+	return linkedOnDisk(shared) && !pointedAtByOther(store, shared.root, rec.id) && !landed(shared.root);
 }
 /** Whether a worktree root is its repository's primary checkout — the one test `unit close` and
 * `unit prune` share for "a seat on the main checkout, which nothing removes". */
@@ -777,7 +795,7 @@ function isPrimaryCheckout(worktreeRoot, primaryRoot) {
 	return worktreeRoot != null && primaryRoot != null && resolve(worktreeRoot) === resolve(primaryRoot);
 }
 /**
-* Delete every exited unit with no worktree left to close (none on disk, or only the primary checkout): its record, brief, mailbox, and the pane
+* Delete every exited unit that leaves no work on disk (`keepsWorktree`): its record, brief, mailbox, and the pane
 * pointer that still names it. Nothing revives an exited unit (`unit restart` takes only a running or
 * stopped one), so these records are read by nobody. A pane pointer is dropped only when it still
 * resolves to the deleted unit, since a multiplexer may have handed the pane id to another unit
@@ -786,11 +804,11 @@ function isPrimaryCheckout(worktreeRoot, primaryRoot) {
 * `unit close` does. No pane is torn down: an exited unit's pane is already gone or belongs to
 * someone else.
 */
-function deleteExited(ctx) {
+function deleteExited(ctx, landed) {
 	const exec = ctx.exec ?? realExec;
 	const deleted = [];
 	for (const rec of listAgents(ctx.store)) {
-		if (rec.status !== "exited" || isSessionIndependent(rec) || worktreeOnDisk(rec)) continue;
+		if (rec.status !== "exited" || isSessionIndependent(rec) || keepsWorktree(ctx.store, rec, landed)) continue;
 		const primaryRoot = rec.worktree?.primaryRoot;
 		if (primaryRoot && existsSync(primaryRoot)) exec("git", [
 			"-C",
@@ -2371,6 +2389,42 @@ function removeCursor(settings, event, canonical) {
 	else delete hooks[event];
 	return true;
 }
+// src/landed.ts
+/**
+* Which worktrees a unit shares hold work that has landed, as the `landed` judgment `prune` takes.
+* It is the worktree library's own judgment, the one its `acquire` recycles a worktree by: the
+* checkout is clean and its branch has landed on the default branch. Asked once per repository
+* before prune's synchronous pass, for every shared worktree still on disk. A worktree git cannot
+* judge (detached, no default branch, a repository git does not know) does not count as landed, so
+* prune keeps the record that points at it.
+*/
+async function landedWorktrees(ctx) {
+	const exec = asyncExec(ctx.exec ?? realExec);
+	const roots = /* @__PURE__ */ new Map();
+	for (const rec of listAgents(ctx.store)) {
+		const shared = rec.sharedWorktree;
+		if (shared?.root && existsSync(shared.root)) roots.set(shared.root, shared.primaryRoot);
+	}
+	const landed = /* @__PURE__ */ new Set();
+	const asked = /* @__PURE__ */ new Set();
+	for (const [root, recorded] of roots) {
+		const primary = await primaryRoot({
+			from: root,
+			exec
+		}).catch(() => recorded);
+		if (!primary || asked.has(primary)) continue;
+		asked.add(primary);
+		const entries = await listWorktrees({
+			primaryRoot: primary,
+			exec,
+			ignore: LEASE_IGNORE
+		}).catch(() => []);
+		for (const e of entries) if (e.linked && e.merged === true && e.dirty === false) landed.add(e.root);
+	}
+	const normalized = /* @__PURE__ */ new Map();
+	for (const root of roots.keys()) normalized.set(root, landed.has(await normalizeWorktreePath(root)));
+	return (root) => normalized.get(root) ?? false;
+}
 // src/output.ts
 function stringifyCell(v) {
 	if (v == null) return "";
@@ -3352,4 +3406,4 @@ async function watchMail(ctx, input, onMessage, opts = {}) {
 		await sleep(POLL_MS);
 	}
 }
-export { DEFAULT_RESERVATION_TTL_MS, FileStore, ServiceOwnershipError, ack, acquireService, assertDistinctFromPrimary, awaitReply, bindService, bumpLastSeen, decommission, deleteMessage, detectHarness, emit, ensureMarker, fail, gitWorktreeAdapter, handoffService, inbox, injectInbox, install, listAgentDefs, listAgents, listProjects, loadAgent, nextStep, paths, peek, probeMultiplexer, projectRoot, prune, realExec, realizeLaunch, register, registerProject, releaseService, resolveAgent, resolveAgentDef, resolveBody, resolvePrimaryRoot, resolveProject, resolveProjectLocalRoot, resolveRecipient, resolveRoot, resolveSelfId, resolveService, selectSessionAdapter, send, serviceEndpointId, spawn, spawnAndWake, startService, toonList, toonObject, touch, verifyOwnership, watchMail, withOwnership };
+export { DEFAULT_RESERVATION_TTL_MS, FileStore, ServiceOwnershipError, ack, acquireService, assertDistinctFromPrimary, awaitReply, bindService, bumpLastSeen, decommission, deleteMessage, detectHarness, emit, ensureMarker, fail, gitWorktreeAdapter, handoffService, inbox, injectInbox, install, landedWorktrees, listAgentDefs, listAgents, listProjects, loadAgent, nextStep, paths, peek, probeMultiplexer, projectRoot, prune, realExec, realizeLaunch, register, registerProject, releaseService, resolveAgent, resolveAgentDef, resolveBody, resolvePrimaryRoot, resolveProject, resolveProjectLocalRoot, resolveRecipient, resolveRoot, resolveSelfId, resolveService, selectSessionAdapter, send, serviceEndpointId, spawn, spawnAndWake, startService, toonList, toonObject, touch, verifyOwnership, watchMail, withOwnership };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cyberlegion",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Harness-agnostic agent session spawning and messaging over the filesystem",
   "keywords": [
     "agent",

package/plugin.json

@@ -1,7 +1,7 @@
 {
 	"$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
 	"name": "cyberlegion",
-	"version": "2.0.0",
+	"version": "2.0.1",
 	"description": "Agent session spawning, messaging, and dispatch — the Legion and its Legate.",
 	"author": {
 		"name": "unional"

package/readme.md

@@ -30,7 +30,7 @@ npx cyberlegion unit register --handle scout        # register/refresh this sess
 npx cyberlegion unit register --standing --handle homa  # mint a standing, session-independent owner inbox
 npx cyberlegion unit whoami                          # print your own identity
 npx cyberlegion unit who                             # list addressable peers / live peer sessions
-npx cyberlegion unit prune                           # mark dead agents exited; delete exited ones with no worktree
+npx cyberlegion unit prune                           # mark dead agents exited; delete exited ones that leave no work on disk
 npx cyberlegion unit spawn --agent reviewer          # launch a peer in its own git worktree (tmux/herdr)
 npx cyberlegion unit focus <ref>                     # move input focus to a peer's session
 npx cyberlegion unit nudge <ref>                     # ring a peer's session (doorbell)

package/skills/dispatch-governance/SKILL.md

@@ -18,7 +18,7 @@ caller supplies `P`, it is the definition to use; the by-name lookup is skipped.
 > **Running the CLI.** Every `node scripts/cyberlegion.mjs …` command below runs the `cyberlegion` CLI
 > this plugin ships. The path is relative to this skill's own directory, not the working directory.
 > If you cannot resolve it, run the published CLI of the version that shipped this skill instead,
-> with the same arguments: `npx -y cyberlegion@2.0.0`.
+> with the same arguments: `npx -y cyberlegion@2.0.1`.
 
 ## 1. Resolve the agent definition