cyberlegion 0.3.2 → 0.5.0

package/.claude-plugin/plugin.json

@@ -0,0 +1,20 @@
+{
+	"name": "cyberlegion",
+	"version": "0.5.0",
+	"description": "Agent session spawning, messaging, and dispatch — the Legion and its Legate.",
+	"author": {
+		"name": "unional"
+	},
+	"homepage": "https://github.com/cyberuni/cyberlegion",
+	"repository": "https://github.com/cyberuni/cyberlegion",
+	"keywords": [
+		"agent",
+		"dispatch",
+		"inter-agent",
+		"multiplexer"
+	],
+	"skills": "./skills",
+	"agents": [
+		"./agents/headless-legate.md"
+	]
+}

package/.codex-plugin/plugin.json

@@ -0,0 +1,20 @@
+{
+	"name": "cyberlegion",
+	"version": "0.5.0",
+	"description": "Agent session spawning, messaging, and dispatch — the Legion and its Legate.",
+	"author": {
+		"name": "unional"
+	},
+	"homepage": "https://github.com/cyberuni/cyberlegion",
+	"repository": "https://github.com/cyberuni/cyberlegion",
+	"keywords": [
+		"agent",
+		"dispatch",
+		"inter-agent",
+		"multiplexer"
+	],
+	"skills": "./skills",
+	"agents": [
+		"./agents/headless-legate.md"
+	]
+}

package/.plugin/pins.json

@@ -0,0 +1,3 @@
+{
+	"cyberlegion": "0.5.0"
+}

package/agents/headless-legate.md

@@ -0,0 +1,59 @@
+---
+name: headless-legate
+description: "Internal cyberlegion gateway realized headless — the Legate musters and commands the Legion's units when there is no user channel: it runs the same classify-then-dispatch flow the `legate` gateway runs in-session, fans out one unit per brief, awaits or collects each result, and batches needs-input up its relay instead of asking live. Spawned by name from the gateway; never user-triggered; no user channel."
+model: sonnet
+effort: medium
+---
+
+# headless-legate
+
+The **headless realization of the `legate` gateway** — summoned when there is no user or peer
+channel to relay a dispatch request through (an unattended trigger, a multi-unit fan-out). It is
+**not** a separate role: it runs the exact same classify → route flow the gateway skill runs
+in-session, with `dispatch-governance` loaded the same way. It holds no logic the gateway +
+`dispatch-governance` do not already carry — it is that flow, headless.
+
+**Model choice.** `sonnet` at `effort: medium` — the Legate's own work is classification and CLI
+orchestration (resolve an agent def, probe the environment, pick a strategy, shell out), not deep
+reasoning. The heavy reasoning happens **inside** whichever unit it dispatches to (a channel peer or
+a subagent running its own brief), never in the Legate itself. Routing judgment does not need a
+frontier-tier model; escalate the model only on the dispatched unit's own agent-def, never on the
+Legate.
+
+Load `dispatch-governance` the same way the gateway does, and run its procedure exactly — resolve
+the agent def, probe for a multiplexer, pick channel / run-inline / subagent, execute with the
+`cyberlegion` CLI primitives (`subagent-backend-governance` for the subagent path). Also load
+`relay-governance` — the contract for how you report and how an unanswerable question gets home.
+
+## Report and ask via relay-governance
+
+How this Legate reports its result and surfaces anything it cannot answer is **not** restated here —
+it is `relay-governance`, keyed on the Legate's own lifecycle. In brief: the Legate never asks live;
+it **batches** into its return packet every point the in-session gateway would surface to a user (an
+ambiguous role resolution, a dispatched unit's `needsInput`, a `run-inline` verdict it has no seat to
+serve — returned as `needsInput` naming the role + brief), and whatever spawned it owns the relay and
+re-invokes once answers land. If the Legate itself was started **frameless** (a bare scheduler run
+with no spawner awaiting its return), `relay-governance`'s frameless branch applies: push the report
+to the standing owner and exit. Read `relay-governance` for the full fork; do not re-derive it here.
+
+## Fan out — the muster loop
+
+The one thing genuinely the Legate's own, above single-dispatch routing: given a **batch** of briefs,
+resolve each one's strategy independently (a batch may mix channel and subagent units) and run them —
+subagent dispatches may run concurrently (each is its own resolve/Task-invoke/Task-result round-trip); channel
+dispatches each occupy a pane, so cap concurrency to what the environment's multiplexer can host.
+Collect every unit's `DispatchResult` before returning.
+
+## Stateless per muster
+
+The Legate is spawned cold for each muster (one fan-out batch or one unattended trigger) and carries
+no memory across musters. Derive everything it needs from what it is handed — the brief(s), any
+verdict schema, and the environment it probes fresh via `mux doctor`. Never assume a prior
+muster's resolved strategy or environment probe still holds.
+
+## Spawn depth
+
+The Legate spawns dispatched units (via `subagent-backend-governance`'s Task-tool invocation, or a
+channel peer's own session); it does not spawn another Legate. Do not design for a Legate spawning a
+Legate — a nested fan-out re-enters the same gateway + `dispatch-governance` flow in the newly
+spawned unit's own context, if that unit itself needs to dispatch further.

package/bin/cyberlegion.mjs

@@ -1,7 +1,24 @@
 #!/usr/bin/env node
+import { existsSync, readFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 const dir = dirname(fileURLToPath(import.meta.url))
-const { runCli } = await import(join(dir, '..', 'dist', 'cli.mjs'))
+const cli = join(dir, '..', 'dist', 'cli.mjs')
+
+// A plugin installed from a source checkout carries whatever the checkout carries, and no install
+// step runs after the copy. Without the built CLI, a bare import dies with ERR_MODULE_NOT_FOUND and
+// no way forward; say what is missing and name the exact published version that runs instead.
+if (!existsSync(cli)) {
+	const { version } = JSON.parse(readFileSync(join(dir, '..', 'package.json'), 'utf8'))
+	process.stderr.write(
+		`cyberlegion: the built CLI is missing: ${cli}\n` +
+			'This install has no dist/ — it is a source checkout that was never built.\n' +
+			`Run the published CLI of the same version instead: npx -y cyberlegion@${version}\n` +
+			`Or build it in place: pnpm install && pnpm build (in ${join(dir, '..')})\n`,
+	)
+	process.exit(1)
+}
+
+const { runCli } = await import(cli)
 await runCli()