cyberlegion 0.1.0 → 0.3.0

package/dist/index.d.mts

@@ -1,3 +1,6 @@
+import { Exec, Exec as Exec$1, MuxAdapter, MuxPlacement, MuxProbe, NudgeOptions, probeMultiplexer } from "cyber-mux";
+import { assertDistinctFromPrimary, gitWorktreeAdapter, resolvePrimaryRoot } from "cyber-mux/worktree";
+
 //#region src/store/store.d.ts
 interface Message {
   id: string;
@@ -12,7 +15,10 @@ interface Message {
   sentAt: string;
 }
 type Harness = 'claude' | 'cursor' | 'codex';
-type AgentStatus = 'spawning' | 'active' | 'idle' | 'stale' | 'exited' | 'paused';
+/** The statuses this version writes. `spawning` is retired: spawn registers a peer `active`
+ * outright, since nothing flips it any more (the SessionStart hook injects no brief and mutates no
+ * status — see `mail/surface`). */
+type AgentStatus = 'active' | 'idle' | 'stale' | 'exited' | 'paused';
 interface AgentRecord {
   id: string;
   handle: string;
@@ -23,26 +29,47 @@ interface AgentRecord {
     root: string;
     branch?: string;
   } | null;
-  tmux?: {
-    pane: string;
+  /** Where this session lives, tagged with its multiplexer so `prune` runs the right liveness check.
+   * `null` for a session in no pane and for a standing record. `window`/`session` are tmux-only. */
+  pane?: {
+    mux: 'tmux' | 'herdr';
+    id: string;
     window?: string;
     session?: string;
   } | null;
   pid?: number;
-  status: AgentStatus;
+  /** A record migrated from an older hub (`admin migrate`) may carry a status this version no
+   * longer writes — the retired `spawning` is the known case. **Reads preserve it verbatim**: no
+   * read path validates, coerces, or normalizes a status, and none may start doing so
+   * (`mail/surface` freezes that a legacy `spawning` record keeps the status it was migrated with).
+   * A write that merely round-trips a record preserves it too.
+   *
+   * The exceptions are deliberate lifecycle writes, not normalizations: `register` asserts a session
+   * is live *now* and so writes `active`, while `prune`/`reconcile` write `exited` over whatever a
+   * record carried (`identity.ts`). A legacy record therefore does move off `spawning` — by an
+   * explicit lifecycle act, never by being read.
+   *
+   * The open member keeps the guarantee typed rather than accidental. */
+  status: AgentStatus | (string & {});
   createdAt: string;
   lastSeen: string;
   brief?: string;
   spawnedBy?: string;
   /** Absent ⇒ session (backward compat, no migration). 'standing' = a session-independent,
-   * prune-exempt owner inbox minted by `identity owner`. */
+   * prune-exempt owner inbox minted by `unit register --standing`. */
   kind?: 'session' | 'standing';
+  /** Only meaningful on a `kind: 'standing'` record — the id of the unit currently standing in for
+   * it (`unit claim`), a per-record singleton pointer that moves as the principal moves between
+   * units (last claim wins). Resolved live, never trusted: a presence unit that has exited reads as
+   * no presence bound, same as if none were ever claimed — nothing self-heals a stale pointer, it
+   * stays inert until re-claimed. Independent of the hub's `mainPane` (the human's read-pane). */
+  presence?: string;
 }
 interface InboxSnapshot {
   unread: Message[];
   read: Message[];
 }
-/** The seam all mailbox + registry + brief/result access goes through. */
+/** The seam all mailbox + registry + brief access goes through. */
 interface Store {
   /** This store's root (for path-relative concerns the Store itself doesn't cover, e.g. spawning
    * a worktree under a project-local root distinct from this hub). */
@@ -71,22 +98,19 @@ interface Store {
   removePaneIndex(pane: string): void;
   writeBrief(agentId: string, text: string): void;
   readBrief(agentId: string): string | undefined;
-  /** Path this dispatch's result file would live at (computed only — no IO; existence not implied). */
-  resultPath(id: string): string;
-  /** Write a dispatch's result as JSON text. */
-  writeResult(id: string, value: unknown): void;
-  /** Read a dispatch's result JSON text, or undefined if not yet written. */
-  readResult(id: string): string | undefined;
+  /** Set (or move) the hub's single main pane — the standing owner's live presence — or clear it
+   * (`null`, a no-op when already unbound). A hub-level singleton, independent of any agent record. */
+  setMainPane(pane: string | null): void;
+  /** The hub's currently bound main pane, or undefined when none is bound. */
+  getMainPane(): string | undefined;
 }
 //#endregion
 //#region src/identity.d.ts
-/** Runs a command synchronously; returns trimmed stdout, or null on any failure. */
-type Exec = (cmd: string, args: string[]) => string | null;
-declare const realExec: Exec;
+declare const realExec: Exec$1;
 interface IdContext {
   store: Store;
   env?: NodeJS.ProcessEnv;
-  exec?: Exec;
+  exec?: Exec$1;
   now?: () => number;
 }
 declare function loadAgent(store: Store, id: string): AgentRecord | undefined;
@@ -94,10 +118,11 @@ declare function listAgents(store: Store): AgentRecord[];
 /** Detect the harness: explicit wins, then env probes, then the tmux pane command. */
 declare function detectHarness(explicit: string | undefined, ctx: IdContext): Harness | undefined;
 /**
- * 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.
  */
 declare function resolveSelfId(ctx: IdContext): string | undefined;
 interface RegisterInput {
@@ -106,7 +131,8 @@ interface RegisterInput {
 }
 /** Register (or idempotently refresh) this session's identity. */
 declare function register(ctx: IdContext, input: RegisterInput): AgentRecord;
-/** Resolve a recipient argument (id or handle) to an agent id. */
+/** 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. */
 declare function resolveRecipient(store: Store, to: string): string;
 /**
  * Resolve a unit reference by id, handle, or its worktree branch (the unit↔CR join key: an
@@ -117,7 +143,9 @@ declare function resolveAgent(store: Store, ref: string): AgentRecord;
 declare function bumpLastSeen(ctx: IdContext, id: string): void;
 /** Refresh this session's own last-seen if it is registered — best-effort, never throws. */
 declare function touch(ctx: IdContext): void;
-/** Mark agents whose pane is gone or whose last-seen is stale as exited. */
+/** 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). */
 declare function prune(ctx: IdContext): AgentRecord[];
 //#endregion
 //#region src/agentdef/resolve.d.ts
@@ -168,143 +196,6 @@ interface RealizedLaunch {
  * `--model` when known, `--append-system-prompt` carrying the def's instructions body) since the
  * exact per-harness flag surface is realized later by the launching caller, not by cyberlegion. */
 declare function realizeLaunch(def: AgentDef, opts?: RealizeLaunchOptions): RealizedLaunch;
-interface RealizeSubagentOptions {
-  /** File the spawned subagent reads its brief from. */
-  briefFile: string;
-  /** File the spawned subagent writes its result JSON to. */
-  resultFile: string;
-}
-/** 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. */
-declare function realizeSubagentInstruction(def: AgentDef, opts: RealizeSubagentOptions): string;
-//#endregion
-//#region src/console/worktree.d.ts
-/** Generic multiplexer/worktree seam — no legion-specific concepts. */
-interface WorktreeAddOptions {
-  /** The primary checkout's root — the repo `git worktree add` runs against. */
-  primaryRoot: string;
-  /** Where the new worktree should be checked out. */
-  path: string;
-  /** Branch to create the worktree on. */
-  branch: string;
-}
-interface Worktree {
-  root: string;
-  branch: string;
-}
-interface WorktreeRemoveOptions {
-  primaryRoot: string;
-}
-interface WorktreeAdapter {
-  add(exec: Exec, opts: WorktreeAddOptions): Worktree;
-  remove(exec: Exec, path: string, opts: WorktreeRemoveOptions): void;
-}
-/** The only worktree backend at MVP — plain `git worktree`. */
-declare const gitWorktreeAdapter: WorktreeAdapter;
-/**
- * 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`.
- */
-declare function resolvePrimaryRoot(exec: Exec): string;
-/**
- * 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.
- */
-declare function assertDistinctFromPrimary(worktreeRoot: string, primaryRoot: string): void;
-//#endregion
-//#region src/console/session.d.ts
-/** Generic multiplexer seam — no legion-specific concepts, so this composes with any host. */
-/** Where a new pane/window/session should be placed relative to the caller's current one.
- * `'workspace'` opens a genuinely separate workspace/session (herdr: `workspace create`; tmux: a
- * new detached session) — the caller's current workspace/session is left untouched, unlike every
- * other placement, which adds a pane/window inside it. */
-type SessionPlacement = 'pane:right' | 'pane:down' | 'tab' | 'window' | 'workspace';
-interface SessionOpenOptions {
-  /** Working directory the new pane/window/session should start in. */
-  cwd: string;
-  /** Command line to launch inside the new pane once it is open. */
-  launch: string;
-  /** Placement relative to the caller; defaults to 'pane:right'. */
-  at?: SessionPlacement;
-}
-/** Opaque handle to an open pane/window/session; backend-specific id lives in `id`. */
-interface SessionTarget {
-  id: string;
-}
-interface SessionReadOptions {
-  /** How many trailing lines of output to capture; omit for the backend's default. */
-  lines?: number;
-}
-interface OpenInNewWorktreeOptions {
-  /** The primary checkout's root — the repo the new worktree branches from. */
-  primaryRoot: string;
-  /** Branch to create the worktree on. */
-  branch: string;
-  /** Where the new worktree should be checked out. */
-  path: string;
-  /** Command line to launch inside the new session once it is open. */
-  launch: string;
-}
-interface SessionAdapter {
-  /** Backend name, e.g. "tmux" or "herdr". */
-  readonly name: string;
-  /** Create a new pane/window running `opts.launch` in `opts.cwd`; returns its target handle. */
-  open(exec: Exec, opts: SessionOpenOptions): SessionTarget;
-  /**
-   * Atomically create a new worktree AND open it in a genuinely new workspace/session, when the
-   * backend has a native primitive for that combination (herdr's `worktree create` both creates
-   * the worktree and nests it under its source workspace in one call — a real organizational
-   * improvement over a separate worktree-add followed by a plain `open()`). Backends without such
-   * a primitive (tmux has none) omit this; callers fall back to creating the worktree themselves
-   * and then calling `open()` with `at: 'workspace'`.
-   */
-  openInNewWorktree?(exec: Exec, opts: OpenInNewWorktreeOptions): {
-    target: SessionTarget;
-    worktree: Worktree;
-  };
-  /** Type text into the target session (submitted, not queued). */
-  send(exec: Exec, target: SessionTarget, text: string): void;
-  /** Capture the target session's current output. */
-  read(exec: Exec, target: SessionTarget, opts?: SessionReadOptions): string;
-  /** Move input focus to the target session; best-effort (may no-op if the backend can't). */
-  focus(exec: Exec, target: SessionTarget): void;
-  /** Close the target session. */
-  teardown(exec: Exec, target: SessionTarget): void;
-}
-//#endregion
-//#region src/console/index.d.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.
- */
-declare function selectSessionAdapter(env: NodeJS.ProcessEnv, exec?: Exec): SessionAdapter;
-//#endregion
-//#region src/console/mux-probe.d.ts
-type Mux = 'tmux' | 'herdr' | 'screen' | 'none';
-interface MuxProbe {
-  mux: Mux;
-  pane?: string;
-  /** 'env' — trusted the $CYBERLEGION_MUX fast-path/override. 'ancestry' — walked the process tree. */
-  via: 'env' | 'ancestry';
-}
-/**
- * Two-mode multiplexer detection.
- *
- * 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.
- */
-declare function probeMultiplexer(exec: Exec, env: NodeJS.ProcessEnv, opts?: {
-  discover?: boolean;
-}): MuxProbe;
 //#endregion
 //#region src/decommission.d.ts
 interface DecommissionInput {
@@ -326,78 +217,6 @@ interface DecommissionResult {
  */
 declare function decommission(ctx: IdContext, input: DecommissionInput): DecommissionResult;
 //#endregion
-//#region src/dispatch/prep.d.ts
-interface DispatchContext {
-  store: Store;
-}
-interface PrepInput {
-  /** Resolve an agent def (`.agents/agents/<name>.md`) to build the instruction from. */
-  agent?: string;
-  /** Read an exact agent def file instead of resolving by name (plugin-scoped escape hatch). */
-  agentFile?: string;
-  /** Role label folded into the generic instruction when no agent def is given. */
-  role?: string;
-  /** Brief body text. */
-  briefText?: string;
-  /** Read the brief from a file, or `-` for stdin. */
-  briefFile?: string;
-  /** JSON schema file the eventual result must satisfy — carried through by callers that validate. */
-  verdictSchema?: string;
-  /** Thread id correlating a channel-path reply; defaults to the minted dispatch id. */
-  thread?: string;
-}
-interface DispatchEnvelope {
-  id: string;
-  thread: string;
-  briefFile: string;
-  resultFile: string;
-  instruction: string;
-}
-/**
- * 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).
- */
-declare function prep(ctx: DispatchContext, input: PrepInput, readStdin?: () => string): DispatchEnvelope;
-//#endregion
-//#region src/dispatch/channel.d.ts
-interface ChannelInput extends PrepInput {
-  /** Block for the mail-thread reply and return a validated `DispatchResult`; without it, the peer
-   * is spawned and the envelope is returned so the caller can `mail await` later. */
-  wait?: boolean;
-  /** Placement relative to the caller; defaults to 'pane:right'. */
-  at?: SessionPlacement;
-  timeoutMs?: number;
-  maxWaitS?: number;
-}
-interface DispatchResult {
-  id: string;
-  verdict?: unknown;
-  body: string;
-  ts: number;
-}
-/** 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. */
-declare class DispatchWaitingError extends Error {
-  readonly thread: string;
-  constructor(thread: string);
-}
-/**
- * `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).
- */
-declare function channel(ctx: IdContext, input: ChannelInput, readStdin?: () => string): Promise<DispatchResult | DispatchEnvelope>;
-//#endregion
-//#region src/dispatch/collect.d.ts
-interface CollectContext {
-  store: Store;
-  now?: () => number;
-}
-/** 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. */
-declare function collect(ctx: CollectContext, id: string, verdictSchema?: string): DispatchResult;
-//#endregion
 //#region src/runtime/inject-inbox.d.ts
 type HookEvent = 'SessionStart' | 'PostToolUse';
 interface InjectPayload {
@@ -407,9 +226,13 @@ interface InjectPayload {
   };
 }
 /**
- * Resolve the calling agent, gather its pending brief + unread mail, and return the
- * SessionStart-style injection payload — or null when there is nothing to inject (an
- * unregistered caller or an empty inbox never fails the harness hook).
+ * Resolve the calling agent, gather its unread mail (and a standing owner's, when this session is
+ * the hub's main pane), and return the SessionStart-style injection payload — or null when there is
+ * nothing to inject (an unregistered caller or an empty inbox never fails the harness hook).
+ *
+ * This never injects a brief. Brief delivery is the spawn wake's job: the first-turn doorbell
+ * carries the instruction and names the brief's file path, so pickup does not depend on this hook
+ * firing in the child (`unit/lifecycle`, superseding ADR-0027).
  */
 declare function injectInbox(ctx: IdContext, event: string): InjectPayload | null;
 //#endregion
@@ -423,7 +246,7 @@ interface InstallResult {
   status: InstallStatus;
 }
 /** Register the surfacing hook into one harness's config, idempotently. */
-declare function install(harness: Harness, projectDir?: string): InstallResult[];
+declare function install(harness: Harness, projectDir?: string, pin?: string): InstallResult[];
 //#endregion
 //#region src/message.d.ts
 interface MsgContext {
@@ -461,6 +284,21 @@ declare function ack(ctx: MsgContext, meId: string, msgId: string): Message;
 /** Permanently remove a message (unread or already-acked) from the caller's inbox. */
 declare function deleteMessage(ctx: MsgContext, meId: string, msgId: string): void;
 //#endregion
+//#region src/mux-select.d.ts
+/**
+ * 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.
+ *
+ * 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.
+ */
+declare function selectSessionAdapter(env: NodeJS.ProcessEnv, exec?: Exec): MuxAdapter;
+//#endregion
 //#region src/output.d.ts
 type Format = 'toon' | 'json';
 /** One TOON-encoded object: `key: value` lines, blank/undefined fields dropped. */
@@ -488,13 +326,13 @@ declare function fail(msg: string): never;
 /** Walk up from `cwd` to the nearest git repo root; fall back to `cwd`. */
 declare function projectRoot(cwd?: string): string;
 /** Runs a command synchronously in `cwd`; returns trimmed stdout, or null on any failure. */
-type Exec$1 = (cmd: string, args: string[]) => string | null;
+type Exec$2 = (cmd: string, args: string[]) => string | null;
 interface RootOptions {
   root?: string;
   space?: string;
   cwd?: string;
   env?: NodeJS.ProcessEnv;
-  exec?: Exec$1;
+  exec?: Exec$2;
 }
 /**
  * Resolve the cyberlegion hub root. Precedence: explicit --root/--space, then `$CYBERLEGION_ROOT`,
@@ -525,7 +363,7 @@ declare const paths: {
   inboxReadDir: (root: string, id: string) => string;
   dataDir: (root: string, id: string) => string;
   briefFile: (root: string, id: string) => string;
-  resultFile: (root: string, id: string) => string;
+  mainPaneFile: (root: string) => string;
 };
 //#endregion
 //#region src/session.d.ts
@@ -548,8 +386,8 @@ interface SpawnInput {
   /** Spawn into this existing directory instead — creates no worktree. Mutually exclusive with
    * `branch`/`worktreePath` (those create a worktree; this reuses one). */
   cwd?: string;
-  /** Placement relative to the caller; defaults to 'pane:right'. */
-  at?: SessionPlacement;
+  /** Placement relative to the caller; defaults to 'tab'. */
+  at?: MuxPlacement;
 }
 interface SpawnResult {
   agent: AgentRecord;
@@ -559,8 +397,10 @@ interface SpawnResult {
 /**
  * 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
- * SessionStart hook reads — never typed into its prompt.
+ * its cwd set to that worktree, pre-register the peer, and drop its brief as a file — never typed
+ * into its prompt. Nothing loads that file for the peer: it is the spawn wake that tells the peer to
+ * go read it, naming its path (`spawnAndWake` below, and ADR-0032). `spawn` alone therefore leaves a
+ * peer sitting idle with its brief unread, which is why callers want `spawnAndWake`.
  *
  * Spawned unit worktrees live sibling to the primary checkout (`<parent>/<repo>.worktrees/legion-<id6>`),
  * never nested inside it, even though the registry/mailbox itself lives in the global hub — the hub
@@ -568,6 +408,26 @@ interface SpawnResult {
  * scoped to this one project's git remote.
  */
 declare function spawn(ctx: IdContext, input: SpawnInput): SpawnResult;
+/**
+ * `unit spawn` end to end: open the peer, then deliver its first turn.
+ *
+ * The two acts live together here rather than at the CLI call site so the **brief path the doorbell
+ * names is derived from the record `spawn` just wrote**, not handed in by a caller. That is the
+ * point of the seam: a caller cannot ring with the wrong path because it supplies no path — an
+ * empty string, a stale path, or the brief's whole body are all unrepresentable here, rather than
+ * merely untested.
+ *
+ * The ring is best-effort on top of the guaranteed spawn effect (worktree + session + registry
+ * record): `--no-wake` rings nothing, and a ring that never completes is reported as a warning on
+ * the result rather than thrown, so it can never fail a spawn that already landed.
+ */
+declare function spawnAndWake(ctx: IdContext, input: SpawnInput, options?: {
+  noWake?: boolean;
+  nudgeOpts?: NudgeOptions;
+}): Promise<SpawnResult & {
+  rung: boolean;
+  warning?: string;
+}>;
 //#endregion
 //#region src/store/file-store.d.ts
 /** The on-disk `Store` implementation — current per-writer sharded `.json` layout (ADR-0020):
@@ -591,9 +451,8 @@ declare class FileStore implements Store {
   removePaneIndex(pane: string): void;
   writeBrief(agentId: string, text: string): void;
   readBrief(agentId: string): string | undefined;
-  resultPath(id: string): string;
-  writeResult(id: string, value: unknown): void;
-  readResult(id: string): string | undefined;
+  setMainPane(pane: string | null): void;
+  getMainPane(): string | undefined;
 }
 //#endregion
 //#region src/wake/await.d.ts
@@ -630,46 +489,6 @@ type AwaitOutcome = {
  */
 declare function awaitReply(ctx: MsgContext, input: AwaitInput): Promise<AwaitOutcome>;
 //#endregion
-//#region src/wake/wake-path.d.ts
-/**
- * The wake-matrix path a gateway would drive a turn through. Pure decision helper — no I/O, no
- * polling, no session backend calls; the gateway (`legion-gateway-legate`, CR-5) composes this with
- * the actual `mail await` / `session nudge` primitives.
- *
- * - **A** — a single unbounded `mail await` (not returned here; superseded by A-loop everywhere the
- *   gateway drives this decision, since a raw A risks a harness tool-timeout SIGKILL).
- * - **A-loop** — the portable default: a bounded `mail await` cycle, re-armed by the caller.
- * - **A-prime** — Claude Code with an observable background task: run `await` via
- *   `run_in_background` and poll its result instead of blocking the turn.
- * - **B** — a live foreign session behind a verified multiplexer: ring the doorbell
- *   (`session nudge`) instead of polling. Never selected without a mux.
- * - **C** — own-the-PTY (dropped from the shipped matrix; kept as a type for completeness).
- * - **D** — `/loop`-style external re-invocation (dropped from the shipped matrix).
- * - **E** — hook surfacing at a turn boundary (selected by the caller directly, not by this
- *   function — it has no wait/poll shape to decide between).
- */
-type WakePath = 'A' | 'A-loop' | 'A-prime' | 'B' | 'C' | 'D' | 'E';
-interface WakePathInput {
-  /** The calling harness, e.g. 'claude' | 'cursor' | 'codex'. */
-  harness: string;
-  mux: MuxProbe;
-  /** The harness can observe a backgrounded task's result without blocking the turn. */
-  observable?: boolean;
-  /** The target is a live, foreign interactive session that can be rung rather than polled. */
-  dedicatedListener?: boolean;
-}
-interface WakePathResult {
-  path: WakePath;
-  why: string;
-}
-/**
- * Select a wake path from the shipped matrix. Rule order: a `mux.mux === 'none'` caller can never
- * get **B** — it always falls through to the bounded poll. Claude Code + an observable background
- * task prefers **A-prime**. A live foreign session behind a verified mux prefers **B**. Otherwise
- * the portable default is **A-loop**.
- */
-declare function selectWakePath(input: WakePathInput): WakePathResult;
-//#endregion
 //#region src/wake/watch.d.ts
 interface WatchInput {
   meId: string;
@@ -688,4 +507,4 @@ interface WatchOptions {
  */
 declare function watchMail(ctx: MsgContext, input: WatchInput, onMessage: (msg: InboxItem) => void, opts?: WatchOptions): Promise<void>;
 //#endregion
-export { type AgentDef, type AgentRecord, type AwaitInput, type AwaitOutcome, type ChannelInput, type DecommissionInput, type DecommissionResult, type DispatchEnvelope, type DispatchResult, DispatchWaitingError, type Exec, FileStore, type Format, type Harness, type HookEvent, type IdContext, type InboxItem, type InboxQuery, type InboxSnapshot, type Message, type MuxProbe, type PrepInput, type RegisterInput, type RootOptions, type SendInput, type SpawnInput, type SpawnResult, type Store, type WakePathInput, type WakePathResult, ack, assertDistinctFromPrimary, awaitReply, bumpLastSeen, channel, collect, decommission, deleteMessage, detectHarness, emit, ensureMarker, fail, gitWorktreeAdapter, inbox, injectInbox, install, listAgentDefs, listAgents, loadAgent, nextStep, paths, peek, prep, probeMultiplexer, projectRoot, prune, realExec, realizeLaunch, realizeSubagentInstruction, register, resolveAgent, resolveAgentDef, resolveBody, resolvePrimaryRoot, resolveProjectLocalRoot, resolveRecipient, resolveRoot, resolveSelfId, selectSessionAdapter, selectWakePath, send, spawn, toonList, toonObject, touch, watchMail };
+export { type AgentDef, type AgentRecord, type AwaitInput, type AwaitOutcome, type DecommissionInput, type DecommissionResult, type Exec, FileStore, type Format, type Harness, type HookEvent, type IdContext, type InboxItem, type InboxQuery, type InboxSnapshot, type Message, type MuxProbe, type RegisterInput, type RootOptions, type SendInput, type SpawnInput, type SpawnResult, type Store, ack, assertDistinctFromPrimary, awaitReply, bumpLastSeen, decommission, deleteMessage, detectHarness, emit, ensureMarker, fail, gitWorktreeAdapter, inbox, injectInbox, install, listAgentDefs, listAgents, loadAgent, nextStep, paths, peek, probeMultiplexer, projectRoot, prune, realExec, realizeLaunch, register, resolveAgent, resolveAgentDef, resolveBody, resolvePrimaryRoot, resolveProjectLocalRoot, resolveRecipient, resolveRoot, resolveSelfId, selectSessionAdapter, send, spawn, spawnAndWake, toonList, toonObject, touch, watchMail };

package/dist/index.mjs

@@ -1,28 +1,4 @@
-import { A as detectHarness, C as resolveAgentDef, D as selectSessionAdapter, E as spawn, F as register, G as resolveProjectLocalRoot, H as ensureMarker, J as gitWorktreeAdapter, K as resolveRoot, L as resolveAgent, M as loadAgent, N as prune, O as probeMultiplexer, P as realExec, R as resolveRecipient, S as listAgentDefs, T as realizeSubagentInstruction, U as paths, V as touch, W as projectRoot, Y as resolvePrimaryRoot, _ as inbox, a as fail, b as send, c as toonObject, d as DispatchWaitingError, f as channel, g as deleteMessage, h as ack, i as emit, j as listAgents, k as bumpLastSeen, l as install, m as awaitReply, n as FileStore, o as nextStep, p as prep, q as assertDistinctFromPrimary, r as injectInbox, s as toonList, t as watchMail, u as collect, v as peek, w as realizeLaunch, x as decommission, y as resolveBody, z as resolveSelfId } from "./watch-BuYsdwhx.mjs";
-//#region src/wake/wake-path.ts
-/**
-* Select a wake path from the shipped matrix. Rule order: a `mux.mux === 'none'` caller can never
-* get **B** — it always falls through to the bounded poll. Claude Code + an observable background
-* task prefers **A-prime**. A live foreign session behind a verified mux prefers **B**. Otherwise
-* the portable default is **A-loop**.
-*/
-function selectWakePath(input) {
-	if (input.mux.mux === "none") return {
-		path: "A-loop",
-		why: "no multiplexer detected — bounded poll only, B is never available"
-	};
-	if (input.harness === "claude" && input.observable) return {
-		path: "A-prime",
-		why: "Claude Code + an observable background task — await via run_in_background"
-	};
-	if (input.dedicatedListener) return {
-		path: "B",
-		why: `a live foreign session behind a verified ${input.mux.mux} mux — ring the doorbell`
-	};
-	return {
-		path: "A-loop",
-		why: "portable default — bounded mail await cycle"
-	};
-}
-//#endregion
-export { DispatchWaitingError, FileStore, ack, assertDistinctFromPrimary, awaitReply, bumpLastSeen, channel, collect, decommission, deleteMessage, detectHarness, emit, ensureMarker, fail, gitWorktreeAdapter, inbox, injectInbox, install, listAgentDefs, listAgents, loadAgent, nextStep, paths, peek, prep, probeMultiplexer, projectRoot, prune, realExec, realizeLaunch, realizeSubagentInstruction, register, resolveAgent, resolveAgentDef, resolveBody, resolvePrimaryRoot, resolveProjectLocalRoot, resolveRecipient, resolveRoot, resolveSelfId, selectSessionAdapter, selectWakePath, send, spawn, toonList, toonObject, touch, watchMail };
+import { $ as resolveProjectLocalRoot, A as bumpLastSeen, D as selectSessionAdapter, E as spawnAndWake, F as loadAgent, I as prune, J as listAgentDefs, K as touch, L as realExec, N as detectHarness, P as listAgents, Q as projectRoot, T as spawn, U as resolveRecipient, V as resolveAgent, W as resolveSelfId, X as ensureMarker, Y as resolveAgentDef, Z as paths, _ as install, a as emit, c as toonList, d as deleteMessage, et as resolveRoot, f as inbox, g as send, h as resolveBody, i as injectInbox, l as toonObject, n as awaitReply, o as fail, p as peek, r as FileStore, s as nextStep, t as watchMail, u as ack, v as decommission, y as realizeLaunch, z as register } from "./watch-BZmEAqUo.mjs";
+import { probeMultiplexer } from "cyber-mux";
+import { assertDistinctFromPrimary, gitWorktreeAdapter, resolvePrimaryRoot } from "cyber-mux/worktree";
+export { FileStore, ack, assertDistinctFromPrimary, awaitReply, bumpLastSeen, decommission, deleteMessage, detectHarness, emit, ensureMarker, fail, gitWorktreeAdapter, inbox, injectInbox, install, listAgentDefs, listAgents, loadAgent, nextStep, paths, peek, probeMultiplexer, projectRoot, prune, realExec, realizeLaunch, register, resolveAgent, resolveAgentDef, resolveBody, resolvePrimaryRoot, resolveProjectLocalRoot, resolveRecipient, resolveRoot, resolveSelfId, selectSessionAdapter, send, spawn, spawnAndWake, toonList, toonObject, touch, watchMail };