@crouton-kit/crouter 0.3.11 → 0.3.12

package/dist/core/spawn.d.ts

@@ -1,217 +1,37 @@
-export interface SpawnAgentOptions {
-    /** First user message for the new agent session. */
-    prompt: string;
-    cwd: string;
-    /** crtr job_id injected as CRTR_JOB_ID env var in the pane. */
-    jobId: string;
-    /** If set, resume this Claude Code session with --fork-session (new session id). */
-    fork?: {
-        sessionId: string;
-    };
-    /** Max panes per tmux window before overflowing to a new window. */
-    maxPanesPerWindow: number;
-    /** Display name passed to the agent's `-n` flag; surfaces in pane title and resume picker. */
-    name?: string;
-    /** Persona appended via `--append-system-prompt` (subagent body). */
-    systemPrompt?: string;
-    /** Model pattern/id passed via `--model`. */
-    model?: string;
-    /** Tool allow-list passed to pi via `--tools`. */
-    tools?: string[];
-}
-export interface SpawnAgentResult {
-    status: 'spawned' | 'spawn-failed' | 'not-in-tmux';
-    /** tmux pane id of the spawned pane. */
-    paneId?: string;
-    /** How the pane was placed. */
-    placement?: 'split-window' | 'new-window';
-    message: string;
-}
+export declare function isInTmux(): boolean;
+export declare function shellQuote(s: string): string;
+/** Count panes in the current tmux window (0 outside tmux / on error). */
+export declare function countPanesInCurrentWindow(): number;
+/**
+ * Schedule a kill-pane on the *current* tmux pane after `delaySeconds`, detached
+ * so the caller can return normally before the pane dies. No-op outside tmux,
+ * when TMUX_PANE is unset, or when delaySeconds <= 0.
+ */
+export declare function scheduleKillCurrentPane(delaySeconds: number): boolean;
 export interface DetachOptions {
-    /** Inner command to run in the pane. If omitted, build the detected agent's
-     *  invocation around `<prompt>`. */
-    command?: string;
-    /** Full first user message for the new agent session (ignored when `command`
-     *  is set). No custom system prompt. */
-    prompt?: string;
+    /** Inner command to run in the new pane. */
+    command: string;
     cwd: string;
-    /** crtr job_id injected as CRTR_JOB_ID env var in the pane and used by the
-     *  `_fail` guard. Optional only when `failGuard` is false. */
+    /** Optional id injected as the CRTR_JOB_ID env var in the pane. */
     jobId?: string;
     /** Where to open the new pane. */
     placement: 'split-h' | 'split-v' | 'new-window';
-    /** Seconds to wait before killing the originating pane so the caller can finish. */
+    /** Seconds before killing the originating pane so the caller can finish. */
     killAfterSeconds: number;
-    /** Append `; crtr job _fail <jobId>` and inject CRTR_JOB_ID. Default true. */
-    failGuard?: boolean;
     /** Pin the new pane to this tmux pane: split-window splits it; new-window is
      *  inserted immediately after its window (-a -t <pane>). Without this, tmux
      *  uses the attached client's currently-focused pane — which drifts if the
      *  user switches windows between kickoff and spawn. */
     targetPane?: string;
-    /** Display name passed to the agent's `-n` flag; ignored when `command` is set
-     *  (caller controls the full argv in that mode). */
-    name?: string;
 }
 export interface DetachResult {
     status: 'spawned' | 'spawn-failed' | 'not-in-tmux';
     paneId?: string;
     message: string;
 }
-export declare function isInTmux(): boolean;
-export declare function shellQuote(s: string): string;
-/** Coding-agent CLIs crtr knows how to spawn as a sibling worker. */
-export type AgentKind = 'claude' | 'pi';
-/**
- * Detect which coding-agent CLI is hosting the current crtr process so spawns
- * launch a matching sibling. pi exports `PI_CODING_AGENT=true` into its tool
- * subprocess environment; Claude Code exports `CLAUDECODE` /
- * `CLAUDE_CODE_SESSION_ID`. Defaults to claude when no signal is present
- * (preserves prior behavior).
- */
-export declare function detectAgentKind(): AgentKind;
 /**
- * Normalize a `--model` value for the target agent CLI.
- *
- * Subagent frontmatter uses Claude Code's bare aliases (`sonnet`, `opus`,
- * `haiku`, optionally with a `:thinking` suffix). The `claude` CLI resolves
- * those natively, but `pi` maps a bare alias to its default provider —
- * `amazon-bedrock` — which most users have not authenticated, so the spawn
- * dies with "No API key found for amazon-bedrock". These aliases name Anthropic
- * models, so under pi we pin them to the `anthropic/` provider (preserving any
- * `:thinking` suffix). Values that already carry a `provider/` prefix or are
- * concrete model ids are passed through untouched.
- */
-export declare function normalizeModelForKind(model: string, kind: AgentKind): string;
-export interface AgentCommandOptions {
-    /** First user message delivered to the new agent session. */
-    prompt: string;
-    /** Display name (`-n`); surfaces in the pane title and resume picker. */
-    name?: string;
-    /** Fork an existing session into a fresh one rather than starting clean. */
-    fork?: {
-        sessionId: string;
-    };
-    /** Persona/system prompt appended to the agent's default (`--append-system-prompt`).
-     *  Used to apply a subagent definition's body. */
-    systemPrompt?: string;
-    /** Model pattern/id passed via `--model` (both claude and pi). */
-    model?: string;
-    /** Tool allow-list. Passed to pi via `--tools`; ignored for claude, whose
-     *  tool names and gating flag differ. */
-    tools?: string[];
-}
-/**
- * Build the agent-CLI invocation (no job wrapper) for the given kind.
- *
- *   claude: `claude [-n <name>] [--resume <id> --fork-session] \
- *            --dangerously-skip-permissions <prompt>`
- *   pi:     `pi [-n <name>] [--fork <id>] <prompt>`
- *
- * pi has no permission popups, so it needs no skip-permissions flag.
- */
-export declare function buildAgentCommand(opts: AgentCommandOptions, kind?: AgentKind): string;
-export interface AgentPrintArgv {
-    cmd: string;
-    args: string[];
-}
-/**
- * Argv for a non-interactive print-mode run.
- *
- *   claude: `claude [-n <name>] [--resume <id> --fork-session] -p \
- *            --dangerously-skip-permissions <prompt>`
- *   pi:     `pi [-n <name>] [--fork <id>] -p <prompt>`
- *
- * Returned as a cmd + args array so callers can spawn without a shell.
- */
-export declare function buildAgentPrintArgv(opts: AgentCommandOptions, kind?: AgentKind): AgentPrintArgv;
-/** Same as buildAgentPrintArgv but rendered as a single shell-quoted string. */
-export declare function buildAgentPrintCommand(opts: AgentCommandOptions, kind?: AgentKind): string;
-export interface HeadlessRunResult {
-    status: 'done' | 'failed';
-    /** Captured stdout on success; stdout+stderr (or an error message) on failure. */
-    output: string;
-    exitCode: number | null;
-}
-/**
- * Run the agent headlessly and resolve once it exits. A blocking caller awaits
- * this. stdout is captured as the result; a non-zero exit yields status
- * 'failed' with the combined output.
- */
-export declare function runAgentHeadless(opts: {
-    prompt: string;
-    name?: string;
-    cwd: string;
-    systemPrompt?: string;
-    model?: string;
-    tools?: string[];
-}): Promise<HeadlessRunResult>;
-export interface HeadlessDetachResult {
-    status: 'spawned' | 'spawn-failed';
-    pid?: number;
-    message: string;
-}
-/**
- * Launch a headless agent detached (background). Its print output is captured
- * and delivered to the job via `crtr job submit`; a non-zero exit marks the job
- * failed. Returns immediately with the wrapper pid (recorded for crash
- * detection). No tmux required.
- */
-export declare function spawnHeadlessDetached(opts: {
-    prompt: string;
-    name?: string;
-    cwd: string;
-    jobId: string;
-    systemPrompt?: string;
-    model?: string;
-    tools?: string[];
-}): HeadlessDetachResult;
-export declare function countPanesInCurrentWindow(): number;
-/**
- * Find a window in the current tmux session with fewer than `maxPanesPerWindow`
- * panes AND where every existing pane hosts an agent (claude or pi) as its
- * foreground process. Prefers the active window so the spawned pane is visible
- * to the user; otherwise falls back to the first other eligible window. Returns
- * the tmux window id (e.g. `@5`) to pass via `-t`, or null if no window qualifies.
- *
- * Windows holding non-agent panes (dashboards, log tails, idle shells, editors,
- * REPLs, etc.) are skipped so spawning never disrupts those workflows. A pane
- * qualifies as long as an agent comm is among its foreground commands —
- * co-resident helpers like `caffeinate` don't disqualify it.
- */
-export declare function findWindowWithSpace(maxPanesPerWindow: number): string | null;
-/**
- * Schedule a kill-pane on the *current* tmux pane after `delaySeconds`, detached
- * so the caller can return normally before the pane dies. No-op outside tmux
- * or when TMUX_PANE is unset.
- *
- * Used by `crtr job submit` (kill_pane=true) so a reviewer agent can self-close
- * its pane after delivering its verdict, and by `spawnAndDetach` for handoff
- * self-kill.
- */
-export declare function scheduleKillCurrentPane(delaySeconds: number): boolean;
-/**
- * Fire-and-forget: launch an interactive agent in a new pane (or window),
- * then schedule the originating pane to be killed after `killAfterSeconds`.
- *
- * No custom system prompt — the task is delivered as the first user message.
- * Returns as soon as the new pane is up; does NOT wait for the agent to finish.
+ * Fire-and-forget: launch `opts.command` in a new pane (or window), then
+ * schedule the originating pane to be killed after `killAfterSeconds`. Returns
+ * as soon as the new pane is up; does NOT wait for the command to finish.
  */
 export declare function spawnAndDetach(opts: DetachOptions): DetachResult;
-/** Originating pane id + session id of the host (pi/claude) crtr runs under. */
-export declare function originContext(): {
-    pane: string;
-    sessionId: string;
-} | null;
-/** Deterministic subagent session name for an originating pane id (e.g. `%5`). */
-export declare function subagentSessionName(pane: string): string;
-/**
- * Async sibling spawn. Launches an interactive agent (claude or pi, per
- * detectAgentKind) in the dedicated subagent session, progressively filling
- * windows up to `maxPanesPerWindow` before creating a new window. Returns
- * immediately with the pane id; the parent stays alive. Focus is never
- * switched — the user jumps to the subagent session with Alt-o.
- *
- * If `fork` is set, forks the host session into a fresh one.
- */
-export declare function spawnAgent(opts: SpawnAgentOptions): SpawnAgentResult;