@aragon-agent/cli 0.6.38 → 0.6.40

package/dist/exec/threads/gate.js

@@ -0,0 +1,81 @@
+/**
+ * The admission gate: how many threads may hold a request in flight
+ * (headless-threads-and-lifecycle-hooks section 2.3.5).
+ *
+ * ASCII ONLY - `src/exec/**` is inside the glyph scanner's scope.
+ *
+ * A COUNTING SEMAPHORE WITH THREE RULES, and no fourth:
+ *   - `acquire` resolves when a slot is free, FIFO;
+ *   - `release` frees one slot, once;
+ *   - `close` makes every waiter (and every later acquirer) throw, so a process
+ *     that is shutting down cannot be parked behind a slot that will never come.
+ *
+ * WHY FIFO RATHER THAN "WHOEVER ASKS NEXT": a caller that opened eight tenants in
+ * order expects them served in order. Preemption would let a noisy tenant starve a
+ * quiet one forever, and the slot is released at REQUEST granularity (not thread
+ * granularity), so fairness is cheap here.
+ *
+ * IT DOES NOT KNOW WHAT A REQUEST IS. The holder decides when to release; the gate
+ * only counts. That is what keeps this file 100 lines instead of a scheduler.
+ */
+export class GateClosedError extends Error {
+    constructor(message = 'The admission gate is closed; no further requests are admitted.') {
+        super(message);
+        this.name = 'GateClosedError';
+    }
+}
+export function createAdmissionGate(options) {
+    const limit = Math.max(1, Math.trunc(options.limit));
+    /** Who holds a slot, so a double release is detectable rather than silent. */
+    const holders = new Set();
+    let waiters = [];
+    let closed = false;
+    const admit = (threadId) => {
+        holders.add(threadId);
+    };
+    /** Hand the next queued waiter the slot that was just freed. */
+    const pump = () => {
+        while (holders.size < limit && waiters.length > 0) {
+            const next = waiters.shift();
+            if (!next)
+                return;
+            admit(next.threadId);
+            next.resolve();
+        }
+    };
+    return {
+        acquire(threadId) {
+            if (closed)
+                return Promise.reject(new GateClosedError());
+            if (holders.has(threadId)) {
+                // ONE SLOT PER THREAD, NOT PER REQUEST. A thread can only ever have one
+                // request in flight (its source hands out one prompt at a time), so a second
+                // acquire for the same id is a re-entrant call, not a second request.
+                return Promise.resolve();
+            }
+            if (holders.size < limit) {
+                admit(threadId);
+                return Promise.resolve();
+            }
+            return new Promise((resolve, reject) => {
+                waiters.push({ threadId, resolve, reject });
+            });
+        },
+        release(threadId) {
+            if (!holders.delete(threadId)) {
+                throw new Error(`release("${threadId}") without a matching acquire`);
+            }
+            pump();
+        },
+        close() {
+            if (closed)
+                return;
+            closed = true;
+            const parked = waiters;
+            waiters = [];
+            for (const waiter of parked)
+                waiter.reject(new GateClosedError());
+        },
+        inUse: () => holders.size,
+    };
+}

package/dist/exec/threads/identity.d.ts

@@ -0,0 +1,36 @@
+/** The thread mode's own name for its first thread. Not configurable. */
+export declare const DEFAULT_THREAD_ID = "main";
+/**
+ * THE WIRE CODES, spelled exactly as section 4.2's ack table spells them (`thread_id_invalid`).
+ * A caller switches on these strings; renaming them is a protocol change, not a refactor.
+ */
+export type ThreadIdProblem = 'thread_id_invalid' | 'thread_id_too_long';
+export type ThreadSessionIdResult = {
+    ok: true;
+    threadId: string;
+    sessionId: string;
+    derived: boolean;
+} | {
+    ok: false;
+    code: ThreadIdProblem;
+};
+export interface ThreadIdentityInput {
+    threadId: string;
+    /** The process-level `--session-id` (or `plan.id`); the base of every derived id. */
+    baseSessionId: string;
+    /** `thread_open{sessionId}`, already trimmed. */
+    explicitSessionId?: string;
+    /** `--no-save-session`. Kept as a parameter so the caller states the intent once. */
+    saving: boolean;
+}
+export declare function isValidThreadId(threadId: string): boolean;
+/**
+ * Resolve the session id a thread writes.
+ *
+ * THE THREE CASES, in the order the design fixes them:
+ *   1. an explicit `sessionId` wins, and must be a legal session id;
+ *   2. the DEFAULT thread reuses the process id unchanged, so `--session-id` keeps
+ *      meaning what it meant before this feature existed;
+ *   3. any other thread derives `${base}-${threadId}`.
+ */
+export declare function resolveThreadIdentity(input: ThreadIdentityInput): ThreadSessionIdResult;

package/dist/exec/threads/identity.js

@@ -0,0 +1,67 @@
+/**
+ * `threadId` -> session id derivation (headless-threads-and-lifecycle-hooks
+ * section 2.3.6).
+ *
+ * ASCII ONLY - `src/exec/**` is inside the glyph scanner's scope.
+ *
+ * PURE. No disk, no clock, no session lock: this module answers "which file would
+ * this thread write" and "is the answer even legal", so the registry can refuse a
+ * `thread_open` BEFORE a controller is constructed. That ordering is the point -
+ * a half-built controller whose session file could not be acquired is a leak with
+ * no owner (section 2.3.4, step 1).
+ *
+ * NEVER TRUNCATE. A derived id that is too long is REJECTED, not clipped: two long
+ * thread ids that both clipped to the same 64 characters would share one file, and
+ * "two conversations write one file" is the exact defect this feature exists to
+ * remove.
+ */
+import { isValidSessionId } from '../../session/store.js';
+import { THREAD_LIMITS } from './limits.js';
+/** `[a-z0-9][a-z0-9_-]{0,31}` - deliberately narrower than a session id. */
+const THREAD_ID_RE = /^[a-z0-9][a-z0-9_-]{0,31}$/;
+/** The thread mode's own name for its first thread. Not configurable. */
+export const DEFAULT_THREAD_ID = 'main';
+export function isValidThreadId(threadId) {
+    return threadId.length <= THREAD_LIMITS.maxThreadIdLength && THREAD_ID_RE.test(threadId);
+}
+/**
+ * Resolve the session id a thread writes.
+ *
+ * THE THREE CASES, in the order the design fixes them:
+ *   1. an explicit `sessionId` wins, and must be a legal session id;
+ *   2. the DEFAULT thread reuses the process id unchanged, so `--session-id` keeps
+ *      meaning what it meant before this feature existed;
+ *   3. any other thread derives `${base}-${threadId}`.
+ */
+export function resolveThreadIdentity(input) {
+    if (!isValidThreadId(input.threadId)) {
+        return { ok: false, code: 'thread_id_invalid' };
+    }
+    if (input.explicitSessionId !== undefined) {
+        if (!isValidSessionId(input.explicitSessionId)) {
+            return { ok: false, code: 'thread_id_invalid' };
+        }
+        return {
+            ok: true,
+            threadId: input.threadId,
+            sessionId: input.explicitSessionId,
+            derived: false,
+        };
+    }
+    if (input.threadId === DEFAULT_THREAD_ID) {
+        // `plan.id` IS ALREADY LEGAL and already means "this run's conversation", so
+        // re-deriving it would silently rename every existing session on upgrade.
+        return { ok: true, threadId: input.threadId, sessionId: input.baseSessionId, derived: false };
+    }
+    const derived = `${input.baseSessionId}-${input.threadId}`;
+    if (!isValidSessionId(derived)) {
+        // A length overflow is the only cause that is not the threadId's own fault (the
+        // threadId was checked above), and the two need different advice: shorten the
+        // base, versus pick another name.
+        return {
+            ok: false,
+            code: derived.length > 64 ? 'thread_id_too_long' : 'thread_id_invalid',
+        };
+    }
+    return { ok: true, threadId: input.threadId, sessionId: derived, derived: true };
+}

package/dist/exec/threads/interrupt.d.ts

@@ -0,0 +1,29 @@
+import type { ExecStopReason } from '../events.js';
+/** Everything the owner needs from a running thread run. Kept structural on purpose. */
+export interface InterruptFanout {
+    /** Stop every open thread's request, keeping each thread's own settle path. */
+    interruptAll(signo: number): void;
+    /** Resolves once every opened thread has closed. */
+    drained(): Promise<void>;
+}
+export interface ProcessInterruptPort {
+    /** Install the ONE process-level terminator. Called once by `executeThreads`. */
+    install(): void;
+    /**
+     * The same fan-out a real signal performs, without a signal: the `interrupt` frame
+     * and `--max-duration` both need it, and both must produce the same shutdown.
+     */
+    requestInterrupt(signo: number): void;
+    /** True once a reason has been recorded; `executeThreads` reads it for `result`. */
+    signo(): number | null;
+}
+export interface InterruptOwnerDeps {
+    fanout: InterruptFanout;
+    /** Write the process `result` (idempotent; the emitter's `done` latch guards it). */
+    ensureResult: (stopReason: ExecStopReason) => void;
+    /** Test injection. Production is `process.exit`. */
+    exit?: (code: number) => void;
+    /** Test injection. Production is `setSignalTerminator`. */
+    setTerminator?: (fn: (signo: number) => void) => void;
+}
+export declare function createInterruptOwner(deps: InterruptOwnerDeps): ProcessInterruptPort;

package/dist/exec/threads/interrupt.js

@@ -0,0 +1,79 @@
+/**
+ * The ONE owner of the process-level signal, and the fan-out to every thread
+ * (headless-threads-and-lifecycle-hooks section 2.3.8a; review P0-1).
+ *
+ * ASCII ONLY - `src/exec/**` is inside the glyph scanner's scope.
+ *
+ * WHY THIS EXISTS AT ALL. `ExecRunner.attach()` ends with `installTerminator()`, and
+ * that installs into `logging/install.ts`'s SINGLE process-wide slot. With N runners
+ * the last one to attach wins, so Ctrl-C would abort one controller and leave the
+ * others running - and a second signal would run `process.exit` from inside a runner,
+ * which writes no `result` at all. Both are silent in single-thread use and fatal in
+ * multi-tenant use, so ownership is lifted out here and made a TYPE:
+ *
+ *   - thread runners receive `installSignalTerminator: false` (they install nothing);
+ *   - `executeThreads` calls `install()` EXACTLY ONCE;
+ *   - the terminator fans out through the registry, never through a controller.
+ *
+ * THE ORDER OF THE LAST THREE STATEMENTS IS THE CONTRACT: settle the threads, write
+ * `result`, and only then exit. That is the same "persist first, announce second"
+ * discipline `exec/index.ts` already follows, applied to the exit code.
+ */
+import { setSignalTerminator } from '../../logging/install.js';
+export function createInterruptOwner(deps) {
+    const exit = deps.exit ?? ((code) => process.exit(code));
+    const setTerminator = deps.setTerminator ?? setSignalTerminator;
+    let signo = null;
+    let settled = false;
+    /**
+     * The hard exit: `result` first, then leave.
+     *
+     * `try/finally`, NOT A SEQUENCE: `ensureResult` builds the aggregate from every thread's
+     * account, and anything it touches can throw on a half-disposed runtime. Leaving the
+     * process alive because the exit code could not be written would be the worst of both
+     * outcomes - no `result` AND no exit - so the exit is unconditional.
+     */
+    const exitHard = (signal) => {
+        try {
+            deps.ensureResult('interrupted');
+        }
+        finally {
+            exit(128 + signal);
+        }
+    };
+    const begin = (signal) => {
+        if (settled) {
+            // A WEDGED SETTLE IS ALWAYS ONE MORE CTRL-C AWAY FROM ENDING - the property the
+            // single-run path already has - but `result` is attempted first, so "at least one
+            // result line" is structural instead of hopeful. `settled` alone is the test: it is
+            // set by the first signal, so "a later signal" and "a second one" are the same fact
+            // and a timing window would only be a second, weaker copy of it.
+            exitHard(signal);
+            return;
+        }
+        settled = true;
+        signo = signal;
+        deps.fanout.interruptAll(signal);
+        // ASYNCHRONOUS ON PURPOSE: the terminator itself must return to the event loop so
+        // the aborts and the settle can run. Nothing awaits this promise; the exit at the
+        // end of it is the completion signal.
+        // THE CHAIN CANNOT LEAVE THE PROCESS WEDGED (review P1). Every step is fallible -
+        // `drained()` rejects when a thread's controller throws while closing, and
+        // `ensureResult` walks every account - and an unhandled rejection here would be turned
+        // into `handleFatal` by `logging/install.ts`, i.e. exit 1 with NO `result` line on
+        // stdout. The failure path does the same two things as the success path.
+        void deps.fanout
+            .drained()
+            .then(() => deps.ensureResult('interrupted'), () => deps.ensureResult('interrupted'))
+            .then(() => exit(128 + signal), () => exit(128 + signal));
+    };
+    return {
+        install() {
+            setTerminator((signal) => begin(signal));
+        },
+        requestInterrupt(signal) {
+            begin(signal);
+        },
+        signo: () => signo,
+    };
+}

package/dist/exec/threads/limits.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Structural bounds for thread multiplexing (headless-threads-and-lifecycle-hooks
+ * section 4.3).
+ *
+ * ASCII ONLY - `src/exec/**` is inside the glyph scanner's scope.
+ *
+ * STRUCTURE, NOT POLICY. These are what one process can physically carry; the
+ * user-tunable ceilings (`--max-open-threads`, `--thread-concurrency`) live in
+ * `exec/options.ts` and are clamped against the numbers below. `limits.ts` is
+ * structural and the flag parser is policy - the split every other subsystem in
+ * this package already follows (`team`, `todo`, `proc`, `input`).
+ */
+import type { ExecStopReason } from '../events.js';
+export declare const THREAD_LIMITS: {
+    /** The hard ceiling on simultaneously open threads, including `main`. */
+    readonly maxOpenThreads: 8;
+    /** `--max-open-threads`' default. Four controllers fit in one process comfortably. */
+    readonly defaultMaxOpenThreads: 4;
+    /** `--thread-concurrency`' default: how many threads may hold a request in flight. */
+    readonly defaultConcurrency: 2;
+    /**
+     * A threadId's own length ceiling. `SESSION_ID_RE` allows 64 characters for a
+     * session id, and a derived id is `${base}-${threadId}`, so the thread half has
+     * to leave room for the base. 32 is what the design fixed and what the README
+     * documents.
+     */
+    readonly maxThreadIdLength: 32;
+    /**
+     * How many requests one thread may serve before it must be reopened. A guard, not
+     * a policy: a per-request `RequestScope` is discarded on every settlement, so this
+     * only bounds the thread's own cumulative bookkeeping.
+     */
+    readonly maxRequestsPerThread: 100000;
+};
+export type ThreadLimits = typeof THREAD_LIMITS;
+/**
+ * WHY THE THREAD STOPPED. A closed set, disjoint from `ExecStopReason` on purpose:
+ * adding members to that union breaks every exhaustive `switch` downstream, and a
+ * thread's reason is a different question from the run's reason (section 2.3.8).
+ */
+export type ExecThreadEndReason = 
+/** The caller closed it (settle), or the caller's input ended. */
+'closed'
+/** `thread_close{mode:'abort'}`, or a process-level interrupt. */
+ | 'aborted'
+/** `--max-duration` fired while this thread had work in flight. */
+ | 'timeout'
+/** Preflight failed, the agent threw, or open failed after `opened`. */
+ | 'error';
+/**
+ * The ONLY mapping from a thread reason to the process-level union (section 2.3.8b).
+ *
+ * `aborted` maps to `interrupted` because a process-level interrupt is the only way
+ * a thread reaches that reason; a caller's own `thread_close{abort}` leaves the
+ * PROCESS reason alone, which is why `decideProcessOutcome` reads the interrupt box
+ * rather than this table for that case.
+ */
+export declare const PROCESS_REASON_FOR_THREAD: Readonly<Record<ExecThreadEndReason, ExecStopReason>>;

package/dist/exec/threads/limits.js

@@ -0,0 +1,35 @@
+export const THREAD_LIMITS = {
+    /** The hard ceiling on simultaneously open threads, including `main`. */
+    maxOpenThreads: 8,
+    /** `--max-open-threads`' default. Four controllers fit in one process comfortably. */
+    defaultMaxOpenThreads: 4,
+    /** `--thread-concurrency`' default: how many threads may hold a request in flight. */
+    defaultConcurrency: 2,
+    /**
+     * A threadId's own length ceiling. `SESSION_ID_RE` allows 64 characters for a
+     * session id, and a derived id is `${base}-${threadId}`, so the thread half has
+     * to leave room for the base. 32 is what the design fixed and what the README
+     * documents.
+     */
+    maxThreadIdLength: 32,
+    /**
+     * How many requests one thread may serve before it must be reopened. A guard, not
+     * a policy: a per-request `RequestScope` is discarded on every settlement, so this
+     * only bounds the thread's own cumulative bookkeeping.
+     */
+    maxRequestsPerThread: 100_000,
+};
+/**
+ * The ONLY mapping from a thread reason to the process-level union (section 2.3.8b).
+ *
+ * `aborted` maps to `interrupted` because a process-level interrupt is the only way
+ * a thread reaches that reason; a caller's own `thread_close{abort}` leaves the
+ * PROCESS reason alone, which is why `decideProcessOutcome` reads the interrupt box
+ * rather than this table for that case.
+ */
+export const PROCESS_REASON_FOR_THREAD = {
+    closed: 'end_turn',
+    aborted: 'interrupted',
+    timeout: 'timeout',
+    error: 'error',
+};

package/dist/exec/threads/outcome.d.ts

@@ -0,0 +1,47 @@
+/**
+ * THE ONE PLACE A PROCESS-LEVEL STOP REASON AND EXIT CODE ARE DECIDED
+ * (headless-threads-and-lifecycle-hooks section 2.3.8b, I-T11).
+ *
+ * ASCII ONLY - `src/exec/**` is inside the glyph scanner's scope.
+ *
+ * WHY THIS FILE HAS TO EXIST. Without threads, `ExecRunner.exitCode()` is the only
+ * arbiter: one runner, one `stopReason`, one number. With N threads there are N
+ * runners, each with its own opinion, and `result` can only be written once. Letting
+ * each runner decide would make the reported outcome depend on which thread happened
+ * to finish last - the least reproducible failure mode there is.
+ *
+ * `ExecStopReason` IS UNCHANGED. `error` is the member this round reuses to say "every
+ * thread failed"; adding a member would break every exhaustive `switch` downstream.
+ */
+import type { ExecStopReason } from '../events.js';
+import type { ThreadAccount } from './aggregate.js';
+export interface ProcessOutcomeInput {
+    /** The signal that arrived, or `null`. Set by the one process-level terminator. */
+    interrupt: {
+        signo: number;
+    } | null;
+    /** Any thread ended with `reason: 'timeout'`. */
+    timedOut: boolean;
+    /** The writer's `caller_not_reading`, which is process-level by nature. */
+    hardLimited: boolean;
+    accounts: readonly ThreadAccount[];
+}
+export interface ProcessOutcome {
+    stopReason: ExecStopReason;
+    exitCode: number;
+}
+/**
+ * Priority is ORDERED; the first hit wins.
+ *
+ * `hardLimited` leads because the caller cannot read the answer at all: reporting
+ * `end_turn` to a pipe nobody is draining would be a lie the next `write()` could not
+ * correct. `interrupt` follows because the user's intent outranks a budget. Then the
+ * clock, and only then the per-thread verdicts.
+ *
+ * THE PARAMETER IS `facts`, NOT `input`: this package has a static scanner
+ * (`paste-frames.test.ts`) that flags anything named `input` being appended to a string -
+ * a heuristic for a raw-keystroke bug that fires on any `.input` access near a string
+ * concatenation. Renaming the bag is cheaper and clearer than teaching the scanner an
+ * exception.
+ */
+export declare function decideProcessOutcome(facts: ProcessOutcomeInput): ProcessOutcome;

package/dist/exec/threads/outcome.js

@@ -0,0 +1,26 @@
+/**
+ * Priority is ORDERED; the first hit wins.
+ *
+ * `hardLimited` leads because the caller cannot read the answer at all: reporting
+ * `end_turn` to a pipe nobody is draining would be a lie the next `write()` could not
+ * correct. `interrupt` follows because the user's intent outranks a budget. Then the
+ * clock, and only then the per-thread verdicts.
+ *
+ * THE PARAMETER IS `facts`, NOT `input`: this package has a static scanner
+ * (`paste-frames.test.ts`) that flags anything named `input` being appended to a string -
+ * a heuristic for a raw-keystroke bug that fires on any `.input` access near a string
+ * concatenation. Renaming the bag is cheaper and clearer than teaching the scanner an
+ * exception.
+ */
+export function decideProcessOutcome(facts) {
+    if (facts.hardLimited)
+        return { stopReason: 'error', exitCode: 1 };
+    if (facts.interrupt)
+        return { stopReason: 'interrupted', exitCode: 128 + facts.interrupt.signo };
+    if (facts.timedOut)
+        return { stopReason: 'timeout', exitCode: 3 };
+    const allFailed = facts.accounts.length > 0 && facts.accounts.every((a) => a.isError);
+    if (allFailed)
+        return { stopReason: 'error', exitCode: 1 };
+    return { stopReason: 'end_turn', exitCode: 0 };
+}

package/dist/exec/threads/registry.d.ts

@@ -0,0 +1,81 @@
+import { DEFAULT_THREAD_ID } from './identity.js';
+import type { AdmissionGate } from './gate.js';
+import type { ThreadAccount } from './aggregate.js';
+import type { ExecThreadEndReason } from './limits.js';
+import { type ThreadRuntime } from './runtime.js';
+import { type ThreadSource } from './thread-source.js';
+import type { BridgeInputFrame, BridgeThreadCloseFrame, BridgeThreadListFrame, BridgeThreadOpenFrame } from '../bridge/protocol.js';
+import type { BridgeServer } from '../bridge/server.js';
+import type { SessionLockHandle } from '../../session/store.js';
+/** One thread as `thread_list` reports it. */
+export interface ThreadSummary {
+    threadId: string;
+    sessionId: string;
+    state: 'opening' | 'open' | 'closing' | 'closed';
+    requests: number;
+    turns: number;
+    inFlight: boolean;
+}
+export interface ThreadRuntimeFactoryInput {
+    threadId: string;
+    sessionId: string;
+    sessionFile: string | null;
+    lock: SessionLockHandle | null;
+    /**
+     * The queue this thread serves. The runtime needs it at construction time, not at
+     * `run()`: `runner.attachBridge(server, source)` happens in `open()`, and the bridge
+     * channel is what carries every receipt a caller correlates (section 2.3.4 step 5).
+     */
+    source: ThreadSource;
+}
+export interface ThreadRegistryDeps {
+    /** The process-level `--session-id` (or the generated one); every derived id's base. */
+    baseSessionId: string;
+    saving: boolean;
+    maxOpenThreads: number;
+    gate: AdmissionGate;
+    /** Constructs one thread. Supplied by `executeThreads`, which owns writer/emitter. */
+    makeRuntime: (input: ThreadRuntimeFactoryInput) => ThreadRuntime;
+    /** One outbound frame. The writer stamps `seq`. */
+    write: (event: Record<string, unknown>) => void;
+    /** Opens a session lock, or returns `null` when it is taken. */
+    acquireLock?: (sessionId: string) => SessionLockHandle | null;
+    /** Where a thread's session file lives; `null` under `--no-save-session`. */
+    sessionFileFor?: (sessionId: string) => string | null;
+    /**
+     * Called exactly once, after the first thread's runtime is open and BEFORE its
+     * `thread_state{opened}` is written. That is where `executeThreads` emits `system/init`,
+     * which must be the first line of the stream.
+     */
+    onFirstOpen?: () => void;
+}
+export interface ThreadRegistry {
+    /** Open the default thread (`main`) and resolve once it is usable. */
+    openDefault(): Promise<void>;
+    handleOpen(frame: BridgeThreadOpenFrame): void;
+    handleClose(frame: BridgeThreadCloseFrame): void;
+    handleList(frame: BridgeThreadListFrame): void;
+    /** A `prompt` for one thread. Queues while it opens; refuses when it is gone. */
+    deliverPrompt(threadId: string, text: string, frameId: string | undefined): void;
+    /** A control frame for one thread's server. */
+    deliverControl(threadId: string, frame: BridgeInputFrame): void;
+    serverFor(threadId: string): BridgeServer | undefined;
+    runtimeFor(threadId: string): ThreadRuntime | undefined;
+    ids(): string[];
+    summaries(): ThreadSummary[];
+    /** `interrupt{threadId}`: refused, and the refusal is the whole behaviour (AC-34). */
+    rejectThreadedInterrupt(threadId: string, frameId: string | undefined): void;
+    /** Every source finishes (the `end` frame, EOF). */
+    finishAll(): void;
+    /** Resolves once every thread record is `closed`. */
+    drained(): Promise<void>;
+    /** Process-level shutdown. Returns the accounts in OPEN ORDER. */
+    closeAll(reason: ExecThreadEndReason): Promise<ThreadAccount[]>;
+    interruptAll(signo: number): void;
+    timeoutAll(): void;
+    accounts(): ThreadAccount[];
+    /** Threads that are not `closed` yet. */
+    openCount(): number;
+}
+export declare function createThreadRegistry(deps: ThreadRegistryDeps): ThreadRegistry;
+export { DEFAULT_THREAD_ID };