@sentropic/h2a-runtime 0.81.0

package/dist/delegate.d.ts

@@ -0,0 +1,406 @@
+/**
+ * `remote delegate <type> "<task>"` — P1 of cross-type agent delegation.
+ *
+ * Spawns a LIVE, INTERACTIVE agent (claude / codex / agy) in a DETACHED tmux
+ * session, PRIMED with the task, with the h2a MCP server in a side window (the
+ * existing `remote run --h2a` path) so the parent/master feedback loop works.
+ * Returns a job id (slug). The job is enrolled in the SAME registry as sessions
+ * with `role: "job"` (no second jobs.json), so `listLive` + the liveness guards
+ * + the atomic write are reused as-is.
+ *
+ * Isolation: by default, if the cwd is a git repo, each job runs in its OWN git
+ * worktree under `<cwd>/.remote/jobs/<jobId>/wt` — the single-writer guard only
+ * protects the conversation `.jsonl`, not the file tree, so concurrent jobs in
+ * the shared cwd would clobber each other. `--cwd` overrides; a non-repo cwd is
+ * used as-is.
+ *
+ * `--headless` is the run-once-exit variant (NOT drop-to-shell): it runs
+ * `claude -p` / `codex exec`, redirects stdout+stderr to `<dir>/output.log`,
+ * writes `<dir>/result.json {state,exitCode}`, then ENDS the tmux session.
+ *
+ * SECURITY: the task is passed as a SINGLE argv token — never concatenated into
+ * a shell string. The jobId / `--name` pass `assertSafeName` before becoming a
+ * tmux slug, a directory, or a filename.
+ */
+import type { JobState, RegistryEntry, RegistryTool } from "./registry.js";
+export type DelegateType = RegistryTool;
+export declare function assertSafeName(name: string): void;
+export declare function isDelegateType(value: string): value is DelegateType;
+/**
+ * The EXACT argv for the agent binary, by type and mode. Pure, exported for
+ * tests. The task is ALWAYS a single trailing token (no shell concat):
+ *  - interactive: the agent starts live, primed with the task as a positional
+ *    initial prompt (claude/codex/agy all accept a bare positional prompt);
+ *  - headless: a run-once-exit print mode — claude `-p`, codex `exec`. agy has
+ *    no confirmed headless mode (design R3), so headless agy throws.
+ *
+ * Returns `{ command, args }` where args ends with the task token.
+ */
+export declare function buildDelegateArgs(type: DelegateType, task: string, headless: boolean, model?: string, effort?: string): {
+    command: string;
+    args: string[];
+};
+/** Hard cap on auto-resume attempts before a throttled job is failed `rate-limited`. */
+export declare const THROTTLE_MAX_ATTEMPTS = 6;
+/** Backoff base (ms) for the resume schedule. */
+export declare const THROTTLE_BACKOFF_BASE_MS = 60000;
+/** Backoff cap (ms) for the resume schedule. */
+export declare const THROTTLE_BACKOFF_CAP_MS: number;
+/**
+ * The EXACT argv to RESUME a throttled HEADLESS job, by type. The job continues
+ * its prior conversation (rather than re-running from scratch) and re-prints to
+ * the same log, so a fresh success settles it `done`:
+ *  - claude: `-p --continue <task>` (print mode, continue the last conversation).
+ *  - codex:  `exec resume --last <task>` (resume the most recent rollout).
+ *  - agy:    no confirmed headless mode → throws (same as buildDelegateArgs).
+ *
+ * The task stays a single trailing token (no shell concat). Pure, exported for
+ * tests.
+ *
+ * TODO(phase-2, interactive): an INTERACTIVE throttled tmux job would instead be
+ * nudged via `send-keys` (guarded by an attached-pane check so we never type
+ * into a pane the user is driving). Not in this slice.
+ */
+export declare function buildThrottleResumeArgs(type: DelegateType, task: string): {
+    command: string;
+    args: string[];
+};
+/**
+ * Full-jitter exponential backoff delay for the throttle RESUME schedule —
+ * copied from the session-agent's `websocket-transport.ts` `jitteredDelay`
+ * (same formula, kept local so this module stays pure/dependency-free).
+ * Returns a random value in [0, min(cap, base * 2^attempt)]. `attempt` is
+ * 0-based (the FIRST throttle passes attempt 0). `rand` is injectable so tests
+ * pin the jitter. Pure, exported for tests.
+ */
+export declare function jitteredBackoffMs(attempt: number, baseMs?: number, capMs?: number, rand?: () => number): number;
+/**
+ * The CEILING of the full-jitter window for a given attempt: `min(cap, base *
+ * 2^attempt)`. Monotonic non-decreasing in `attempt`, capped at `capMs`. The
+ * jittered delay is always in `[0, ceiling]`. Pure, exported so tests can assert
+ * the schedule is monotonic + bounded without depending on the random draw.
+ */
+export declare function backoffCeilingMs(attempt: number, baseMs?: number, capMs?: number): number;
+/** Window over which throttle events are counted for the breaker (10 min). */
+export declare const AIMD_WINDOW_MS: number;
+/** ≥ this many throttles in the window trips the multiplicative decrease. */
+export declare const AIMD_TRIP_THRESHOLD = 2;
+/**
+ * The effective admission cap under AIMD. Pure.
+ *
+ *  - Count throttle events with `firstAt`/`at` within `[now - AIMD_WINDOW_MS, now]`.
+ *  - If that count ≥ AIMD_TRIP_THRESHOLD → HALVE the previous effective cap
+ *    (`Math.floor`), floored at 1 (never admit zero — a single slot keeps the
+ *    queue making progress so the breaker can observe recovery).
+ *  - Else (a clean pass) → ADDITIVELY restore +1, capped at `configuredCap`.
+ *  - Always clamped to `[1, configuredCap]` (never below 1, never above the
+ *    configured cap). A `configuredCap <= 0` returns 0 (a degenerate config
+ *    admits nothing — mirrors planNextStarts).
+ *
+ * `lastCap` is the effective cap from the PREVIOUS pass (defaults to
+ * `configuredCap` on the first pass — we start fully open). `recentThrottles` is
+ * the list of throttle-event timestamps (ISO or ms) the conductor tracks.
+ */
+export declare function aimdEffectiveCap(configuredCap: number, recentThrottles: ReadonlyArray<string | number>, now?: number, lastCap?: number): number;
+/** The next throttle bookkeeping for a job that just (re-)threw a rate-limit. */
+export type ThrottleStep = {
+    /** Mark/keep the job `throttled`; the conductor resumes it on `nextRetryAt`. */
+    action: "throttle";
+    attempts: number;
+    firstAt: string;
+    nextRetryAt: string;
+    signature?: string;
+} | {
+    /** The attempt cap is spent → fail the job with the rate-limited reason. */
+    action: "fail";
+    reason: "rate-limited";
+};
+/**
+ * Decide what to do with a HEADLESS LOCAL job whose latest finished run was
+ * classified as a transient rate-limit. PURE — no clock/registry/IO; the caller
+ * passes `now`, the prior `throttle` bookkeeping (undefined on the first hit),
+ * the matched `signature`, and a `delay` (a jittered backoff in ms, computed via
+ * `jitteredBackoffMs`).
+ *
+ *  - First/next throttle while `attempts < maxAttempts`: bump `attempts`,
+ *    preserve `firstAt`, schedule `nextRetryAt = now + delay`.
+ *  - When the NEXT attempt would exceed `maxAttempts` (i.e. prior attempts already
+ *    == maxAttempts): give up → `{action:"fail", reason:"rate-limited"}`.
+ *
+ * Exported for tests.
+ */
+export declare function planThrottleStep(opts: {
+    prior: {
+        attempts: number;
+        firstAt: string;
+    } | undefined;
+    nowMs: number;
+    delayMs: number;
+    signature?: string;
+    maxAttempts?: number;
+}): ThrottleStep;
+/**
+ * Is a `throttled` job DUE for resume right now (now >= nextRetryAt)? Pure,
+ * tolerant of a missing/unparseable `nextRetryAt` (treated as due — better to
+ * retry than to strand a job forever). Exported for tests.
+ */
+export declare function isThrottleResumeDue(throttle: {
+    nextRetryAt?: string;
+} | undefined, nowMs: number): boolean;
+/**
+ * Minutes-until-retry label for a `throttled` row (`jobs ls`), e.g. "retry in
+ * 3m" / "retry now". Pure, exported for tests. Rounds UP so "<1 min away" still
+ * reads as 1m rather than 0.
+ */
+export declare function throttleRetryLabel(throttle: {
+    nextRetryAt?: string;
+} | undefined, nowMs?: number): string;
+/**
+ * P2 — REMOTE delegation. Map a (type, task) to the control-plane session body
+ * for a delegated agent running in a Pod. The agent CLI is the session PROFILE
+ * (profiles claude/codex/agy launch the matching binary on the Pod), and the
+ * task rides the ALREADY-SAFE argv channel `startupArgs` — exactly the args that
+ * follow the binary, which the session-agent reads from `SESSION_STARTUP_ARGS`
+ * (a JSON array, never a `bash -lc` string). We reuse `buildDelegateArgs` and
+ * DROP its `command` (the profile already provides the binary): `args` is what
+ * trails it (the bare task token interactive, `-p <task>` / `exec <task>`
+ * headless). Pure, exported for tests.
+ *
+ * SECURITY: the task stays a single argv element through `startupArgs` → JSON →
+ * the agent's argv; it is NEVER concatenated into a shell string.
+ */
+export declare function buildRemoteDelegate(type: DelegateType, task: string, headless: boolean, model?: string, effort?: string): {
+    profile: DelegateType;
+    startupArgs: string[];
+};
+/**
+ * Default concurrency cap (Hermes `max_concurrent_children`), applied to BOTH
+ * local AND remote jobs: the shared RWX volume is mounted RW across all nodes
+ * (subPath per job — no CSI packing limit, design F3 correction), so remote is
+ * not sequential. A new `delegate` beyond `running` jobs is enrolled `pending`.
+ */
+export declare const DEFAULT_MAX_CONCURRENT = 16;
+/** Default / min / max spawn depth (Hermes `max_spawn_depth`, clamp 1–3). */
+export declare const DEFAULT_MAX_DEPTH = 1;
+export declare const MIN_MAX_DEPTH = 1;
+export declare const MAX_MAX_DEPTH = 3;
+/** The env channel carrying the REMAINING delegation depth into a job's agent. */
+export declare const DEPTH_ENV = "REMOTE_DELEGATE_DEPTH";
+/**
+ * Env channel carrying a delegated job's id INTO its agent process (H1). The
+ * local-tmux spawn stamps `REMOTE_JOB_ID=<jobId>` so the claude SessionStart/End
+ * hooks — which only receive claude's conversation uuid (`session_id`), never the
+ * job slug — can resolve the job and complete it. Without this, an interactive
+ * tmux job never advances past `running`.
+ */
+export declare const JOB_ID_ENV = "REMOTE_JOB_ID";
+/**
+ * Clamp a requested `--max-depth` into [1, 3] (à la Hermes). A missing /
+ * non-finite value falls back to the default (1). Pure, exported for tests.
+ */
+export declare function clampDepth(requested: number | undefined): number;
+/**
+ * The depth a job INHERITS from its parent, read off `REMOTE_DELEGATE_DEPTH`
+ * (decremented at each launch). When a `delegate` runs OUTSIDE a job (no env),
+ * the requested `--max-depth` is the budget. When it runs INSIDE a job, the
+ * inherited budget wins (a job cannot grant itself more than it was given).
+ * Pure, exported for tests; `env` is injectable.
+ *
+ * Returns the budget the CURRENT `delegate` may spend:
+ *  - no env (top-level): clamp(requestedMaxDepth).
+ *  - env present: the inherited value (already a remaining budget), clamped
+ *    to [0, 3] — 0 means "this job may not delegate further".
+ */
+export declare function inheritedDepthBudget(requestedMaxDepth: number | undefined, env?: Record<string, string | undefined>): number;
+/**
+ * May a `delegate` proceed given its current depth budget? A budget of 0 means
+ * the calling job has exhausted its delegation depth and must REFUSE. Pure.
+ */
+export declare function canDelegateAtDepth(budget: number): boolean;
+/**
+ * REMOTE depth clamp (YAGNI/safety): there is NO env channel carrying
+ * `REMOTE_DELEGATE_DEPTH` into a Pod (`createRemoteSession` only passes
+ * `startupArgs`, and the session-agent doesn't forward a depth budget), so a
+ * remote job could NOT enforce a budget even if we recorded one > 1. Until that
+ * channel exists we clamp a REMOTE job's recorded budget to AT MOST 1 — i.e. a
+ * job-in-a-Pod does not re-delegate. (Local jobs DO inherit the budget via the
+ * env, so they keep the full 1–3 range.) Pure, exported for tests.
+ */
+export declare function clampRemoteDepthBudget(budget: number): number;
+/**
+ * The depth value to PROPAGATE to a freshly launched job: the parent's budget
+ * minus one (never below 0), so the child knows how much further it may go.
+ * Returned as the string the env channel carries. Pure, exported for tests.
+ */
+export declare function childDepthEnvValue(parentBudget: number): string;
+/**
+ * Decide which `pending` jobs to START this pass, given the cap. Pure, the heart
+ * of the queue: count jobs currently occupying a slot (`running`), and admit
+ * `pending` jobs (oldest first — FIFO by `enrolledAt`) until `running` reaches
+ * the cap. Terminal jobs (done/failed) free their slot. Returns the ids to
+ * start, in admission order. Exported for tests.
+ *
+ * `cap <= 0` admits nothing (a degenerate config never starts work).
+ */
+export declare function planNextStarts(jobs: ReadonlyArray<Pick<RegistryEntry, "id" | "role" | "jobState" | "enrolledAt">>, cap: number): string[];
+/**
+ * Is there room to start a job RIGHT NOW (used by `delegate` to decide launch vs
+ * enqueue)? True when `running < cap`. Pure, exported for tests.
+ */
+export declare function hasFreeSlot(jobs: ReadonlyArray<Pick<RegistryEntry, "role" | "jobState">>, cap: number): boolean;
+/**
+ * The `track item new` argv that mirrors a delegated job as a child item under
+ * the workpackage `wpId`. PURE (no spawn): the caller resolves the track binary
+ * (realpath) and runs it best-effort. `--role item`, parented under the WP, with
+ * a stable title derived from the job. Exported for tests.
+ *
+ * SECURITY: jobId is assertSafeName-checked at delegate time; wpId/task ride
+ * structured argv (never a shell string).
+ */
+export declare function trackItemNewArgs(wpId: string, job: {
+    id: string;
+    task?: string;
+}): string[];
+/**
+ * The `track item realize` argv to close the mirror item when a job reaches a
+ * terminal state. We address the item by the same `job:<id>` ref we created it
+ * with. PURE; the caller runs it best-effort. Exported for tests.
+ */
+export declare function trackItemRealizeArgs(job: {
+    id: string;
+}): string[];
+export type TrackRunner = (args: ReadonlyArray<string>) => {
+    status: number | null;
+};
+/**
+ * Resolve the `track` binary to its REALPATH (some track versions have an
+ * entrypoint guard that breaks through the npm-global bin symlink — same note as
+ * config.ts PluginMcp). Returns `node <realpath>` argv, or undefined when track
+ * is not installed. Best-effort, exported for tests (the `which`+realpath are
+ * injectable).
+ */
+export declare function resolveTrackBin(which?: (bin: string) => string | undefined, realpath?: (p: string) => string): {
+    command: string;
+    prefix: string[];
+} | undefined;
+/**
+ * Best-effort track-mirror call: resolve `track`, run `track <args>` in `cwd`,
+ * swallow ANY failure (track absent/erroring must NEVER couple delivery to
+ * track). Returns whether it ran. The runner is injectable for tests.
+ */
+export declare function runTrackMirror(args: ReadonlyArray<string>, cwd: string, run?: TrackRunner): boolean;
+/** Per-job directory under the ORIGIN cwd (where worktree + logs live). */
+export declare function jobDir(originCwd: string, jobId: string): string;
+export type JobResult = {
+    state: "done" | "failed";
+    exitCode: number;
+};
+/**
+ * The terminal result a HEADLESS job wrote to `result.json` (run-once-exit), or
+ * undefined when absent / unreadable. Lets supervision reconcile a finished
+ * headless job (whose tmux session has ended) to its REAL state instead of the
+ * default "session-gone → failed". Pure-ish (reads one file), injectable read.
+ */
+export declare function readJobResult(originCwd: string, jobId: string, read?: (p: string) => string): JobResult | undefined;
+export type GitProbe = (cwd: string) => boolean;
+export type Runner = (cmd: string, args: ReadonlyArray<string>, cwd: string) => {
+    status: number | null;
+};
+export type ResolveCwdOpts = {
+    /** Explicit cwd override (`--cwd`): used as-is, no worktree. */
+    explicitCwd?: string;
+    isGitRepo?: GitProbe;
+    runGit?: Runner;
+    mkdir?: (p: string) => void;
+};
+export type ResolvedCwd = {
+    /** The directory the agent actually runs in. */
+    runCwd: string;
+    /** True when a dedicated git worktree was created for file-tree isolation. */
+    isolated: boolean;
+};
+/**
+ * Decide WHERE the job runs and create isolation if warranted:
+ *  - `--cwd <path>` → that path, as-is (caller owns isolation).
+ *  - else if the origin cwd is a git repo → a dedicated worktree at
+ *    `<originCwd>/.remote/jobs/<jobId>/wt` (so concurrent jobs never clobber the
+ *    working tree; the single-writer guard only protects the `.jsonl`).
+ *  - else → the origin cwd, as-is (non-repo: nothing to isolate cheaply).
+ *
+ * Throws if the worktree creation fails (we must NOT silently run in the shared
+ * cwd, which would defeat isolation).
+ */
+export declare function resolveJobCwd(originCwd: string, jobId: string, opts?: ResolveCwdOpts): ResolvedCwd;
+export type JobRow = {
+    id: string;
+    type: DelegateType;
+    state: JobState;
+    age: string;
+    cwd: string;
+    /**
+     * Extra per-state detail shown in the NOTE column — currently the throttle
+     * "retry in Xm" hint for `throttled` rows (empty otherwise). Reliability
+     * slice 1.
+     */
+    note: string;
+    /** Account label bound to this job via the pool (omitted when no pool binding). */
+    account?: string;
+    /** Remote session UUID (kind "remote" only) — use with `remote attach <session>`. */
+    session?: string;
+};
+/**
+ * The DISPLAY state of a job, reconciling its persisted `jobState` with live
+ * liveness: a job still marked `running`/`pending` whose tmux session is gone
+ * has crashed/finished → show `failed` (P1 has no headless-success poll in the
+ * pure layer; the headless result.json is surfaced by `jobs status`). A job
+ * already in a terminal state keeps it. Pure, exported for tests.
+ */
+export declare function reconcileJobState(entry: Pick<RegistryEntry, "jobState" | "endedAt">, live: boolean): JobState;
+/**
+ * P2 — CLUSTER reconciliation for REMOTE jobs (`kind:"remote"`). The registry
+ * reports a remote entry as `isLive` ALWAYS (it can't probe the cluster —
+ * registry.ts), so a delegated Pod that died/finished would stay "running"
+ * forever. Given the set of session ids the control-plane still lists
+ * (`listRemoteSessions`), this decides the transitions to apply: a remote job
+ * still in a non-terminal state whose `remoteId` is NOT in the live set has
+ * ended → `done` when it left a `result.json` (success/known exit), else
+ * `failed`. Jobs whose Pod is still listed, or already terminal, are untouched.
+ * Pure (the result read is injected), exported for tests.
+ */
+export declare function reconcileRemoteJobs(jobs: ReadonlyArray<RegistryEntry>, liveRemoteIds: ReadonlySet<string>, readResult: (job: RegistryEntry) => JobResult | undefined): Array<{
+    id: string;
+    to: JobState;
+}>;
+/**
+ * M2 — SWEEP stale jobs. A job stuck in a non-terminal `running` /
+ * `awaiting-decision`-ish state (we only persist `running`; awaiting-decision is
+ * a DISPLAY overlay, so a job awaiting a decision is `running` on disk) whose
+ * runtime signal was lost — NOT live AND no `result.json` AND older than
+ * `maxAgeMs` — would otherwise occupy a concurrency slot forever. This returns
+ * the ids to transition to `failed`. Bounds BOTH plain running jobs and ones
+ * showing awaiting-decision (same persisted `running`). `pending` jobs are NOT
+ * swept here (they were never launched — the conductor owns them). Terminal jobs
+ * are skipped. Pure (liveness + result presence injected), exported for tests.
+ */
+export declare function sweepStaleJobs(jobs: ReadonlyArray<RegistryEntry>, opts: {
+    isJobLive: (e: RegistryEntry) => boolean;
+    hasResult: (e: RegistryEntry) => boolean;
+    maxAgeMs: number;
+    nowMs?: number;
+}): string[];
+/**
+ * Build `jobs ls` rows from job entries + an injectable liveness probe. Pure,
+ * exported for tests. `nowMs` makes the age deterministic.
+ */
+export declare function buildJobRows(jobs: ReadonlyArray<RegistryEntry>, isJobLive: (e: RegistryEntry) => boolean, nowMs?: number, resolveAccountLabel?: (jobId: string) => string | undefined): JobRow[];
+/**
+ * M3 — advisory line for `jobs ls`: when there are QUEUED (`pending`) jobs but
+ * NO conductor running to drain them, warn the user (we do NOT self-heal — a
+ * one-shot `jobs ls` can't start the queue; only `jobs conduct` does). Returns
+ * undefined when there's nothing to warn about. Pure (the conductor-liveness
+ * probe is passed in), exported for tests.
+ */
+export declare function conductorAdvisory(jobs: ReadonlyArray<Pick<RegistryEntry, "role" | "jobState">>, conductorRunning: boolean): string | undefined;
+/** Render `jobs ls` rows as an aligned plain-text table. Pure. */
+export declare function renderJobsTable(rows: ReadonlyArray<JobRow>): string;
+//# sourceMappingURL=delegate.d.ts.map

package/dist/delegate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delegate.d.ts","sourceRoot":"","sources":["../src/delegate.ts"],"names":[],"mappings":"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"}