cyberlegion 1.0.0 → 1.2.0

package/dist/index.d.mts

@@ -25,9 +25,13 @@ interface AgentRecord {
   /** Absent for a standing record (a human/owner principal — no claude/cursor/codex harness). */
   harness?: Harness;
   cwd: string;
+  /** `primaryRoot` is the primary checkout of the repository the worktree belongs to, recorded by
+   * spawn — the one place to find git's registration of a worktree whose directory is gone. Absent
+   * on a registered session and on records from before it was recorded. */
   worktree?: {
     root: string;
     branch?: string;
+    primaryRoot?: string;
   } | null;
   /** 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. */
@@ -220,9 +224,10 @@ export declare function resolveAgent(store: Store, ref: string): AgentRecord;
 export declare function bumpLastSeen(ctx: IdContext, id: string): void;
 /** Refresh this session's own last-seen if it is registered — best-effort, never throws. */
 export declare function touch(ctx: IdContext): void;
-/** 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). */
+/** Mark agents whose session is gone as exited. 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. */
 export declare function prune(ctx: IdContext): AgentRecord[];
 //#endregion
 //#region src/agentdef/resolve.d.ts
@@ -265,6 +270,9 @@ interface RealizeLaunchOptions {
   effort?: string;
   /** Overrides def.harness when present; falls back to 'claude' when neither is set. */
   harness?: Harness;
+  /** The model ids `cursor-agent models` lists, for carrying a cursor effort as a flat model id.
+   * Called only for a cursor launch with both a model and an effort; absent, nothing is listed. */
+  listCursorModels?: () => readonly string[];
 }
 interface RealizedLaunch {
   harness: Harness;
@@ -273,8 +281,9 @@ interface RealizedLaunch {
    * harness default applies. */
   model?: string;
   effort?: string;
-  /** An effort asked for that the launch cannot carry — cursor with no model — so the caller can warn
-   * and report it rather than let it drop silently. The launch runs at the harness default instead. */
+  /** An effort asked for that the launch cannot carry — cursor with no model, or with no listed
+   * `<model>-<level>` id — so the caller can warn and report it rather than let it drop silently.
+   * The launch runs without the effort instead. */
   effortNotApplied?: string;
   /** The def's instructions, for a harness whose CLI cannot take them (cursor): `unit spawn` writes
    * them in front of the brief instead. Absent when the command carries them, or there are none. */
@@ -282,7 +291,7 @@ interface RealizedLaunch {
 }
 /** Build the harness launch invocation for a def — explicit `model`/`effort`/`harness` win over the
  * def's own tags, which win over the harness default. The def's effort and instructions each go
- * through the harness's own control (see `modelAndEffortArgs`, `instructionArgs`). */
+ * through the harness's own control (see `cursorModel`, `modelAndEffortArgs`, `instructionArgs`). */
 export declare function realizeLaunch(def: AgentDef, opts?: RealizeLaunchOptions): RealizedLaunch;
 //#endregion
 //#region src/decommission.d.ts
@@ -324,7 +333,7 @@ interface DecommissionResult {
 export declare function decommission(ctx: IdContext, input: DecommissionInput): DecommissionResult;
 //#endregion
 //#region src/runtime/inject-inbox.d.ts
-type HookEvent = 'SessionStart' | 'PostToolUse';
+type HookEvent = 'SessionStart';
 interface InjectPayload {
   hookSpecificOutput: {
     hookEventName: HookEvent;
@@ -343,15 +352,19 @@ interface InjectPayload {
 export declare function injectInbox(ctx: IdContext, event: string): InjectPayload | null;
 //#endregion
 //#region src/install.d.ts
-type InstallStatus = 'registered' | 'already present';
+type RetiredEvent = 'PostToolUse';
+type InstallStatus = 'registered' | 'already present' | 'provided by plugin' | 'removed project hook';
 interface InstallResult {
   harness: Harness;
-  event: HookEvent;
+  event: HookEvent | RetiredEvent;
   vendorEvent: string;
   file: string;
   status: InstallStatus;
 }
-/** Register the surfacing hook into one harness's config, idempotently. */
+/**
+ * Make sure the surfacing hook fires for one harness, idempotently: leave it to the plugin where the
+ * 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[];
 //#endregion
 //#region src/message.d.ts
@@ -642,6 +655,47 @@ export declare function startService<T extends {
   unit: string;
 }>(ctx: ServiceContext, projectRef: string, name: string, input: StartInput<T>): Promise<StartResult<T>>;
 //#endregion
+//#region src/console/trust.d.ts
+interface TrustOptions {
+  /** Time between screen reads. */
+  pollMs?: number;
+  /** How long to watch for the harness to show a prompt or settle without one. */
+  timeoutMs?: number;
+  /** Equal reads in a row that count as settled. */
+  stableReads?: number;
+  /** Blank reads in a row, from the first, after which the screen is taken as unreadable. */
+  blankReads?: number;
+  /** Wait after the prompt appears before the first key: Claude Code ignores keys pressed right after
+   * its dialog opens. */
+  keyDelayMs?: number;
+  /** Reads allowed for each move to take effect, and for the prompt to clear at the end. */
+  attempts?: number;
+  sleep?: (ms: number) => Promise<void>;
+}
+type TrustOutcome =
+/** The harness settled on a screen with no trust prompt. */
+{
+  state: 'none';
+} |
+/** The screen never settled within the timeout; there is no evidence of a prompt either way. */
+{
+  state: 'unsettled';
+} |
+/** The prompt was on screen and the accept keys cleared it. */
+{
+  state: 'accepted';
+} |
+/** The prompt is on screen and spawn left it for a person. */
+{
+  state: 'needs-human';
+  message: string;
+} |
+/** The accept keys were sent and the prompt is still on screen. */
+{
+  state: 'stuck';
+  message: string;
+};
+//#endregion
 //#region src/session.d.ts
 interface SpawnInput {
   harness?: string;
@@ -699,13 +753,23 @@ export declare function spawn(ctx: IdContext, input: SpawnInput): SpawnResult;
  * 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.
+ *
+ * Before the ring, the harness's folder-trust prompt is answered (`answerTrustPrompt`), with or
+ * without `--no-wake`: a unit stuck at that prompt never reads its brief, and the doorbell typed into
+ * it would answer it wrongly (Claude Code's focused option is "No, exit"). A worktree spawn made the
+ * folder from the caller's own repository, so its prompt is accepted. A `--cwd` folder was not made
+ * here, so its prompt is left for a person. A prompt left showing either way rings nothing and is
+ * reported as `trustBlocked`, a failure the caller must surface, not a best-effort warning.
  */
 export declare function spawnAndWake(ctx: IdContext, input: SpawnInput, options?: {
   noWake?: boolean;
   nudgeOpts?: NudgeOptions;
+  trustOpts?: TrustOptions;
 }): Promise<SpawnResult & {
   rung: boolean;
   warning?: string;
+  trust: TrustOutcome['state'];
+  trustBlocked?: string;
 }>;
 //#endregion
 //#region src/store/file-store.d.ts