agent-afk 5.335.1 → 5.336.0

package/dist/agent/lsp/async-mutex.d.ts

@@ -0,0 +1,13 @@
+export declare class AsyncMutex {
+    private _waiters;
+    private _locked;
+    get isLocked(): boolean;
+    acquire(): Promise<() => void>;
+    private _release;
+}
+export declare class MutexRegistry {
+    private readonly _map;
+    get(key: string): AsyncMutex;
+    get size(): number;
+    releaseIfIdle(key: string): void;
+}

package/dist/agent/lsp/client-handlers.d.ts

@@ -0,0 +1,58 @@
+import type { ServerDefinition } from './server-spec.js';
+export declare function answerServerRequest(definition: ServerDefinition, method: string, params: unknown): unknown;
+export declare const CLIENT_CAPABILITIES: {
+    readonly workspace: {
+        readonly applyEdit: true;
+        readonly workspaceEdit: {
+            readonly documentChanges: true;
+        };
+        readonly configuration: true;
+        readonly workspaceFolders: true;
+        readonly didChangeConfiguration: {
+            readonly dynamicRegistration: true;
+        };
+        readonly symbol: {
+            readonly dynamicRegistration: false;
+        };
+    };
+    readonly textDocument: {
+        readonly synchronization: {
+            readonly dynamicRegistration: false;
+            readonly didSave: false;
+            readonly willSave: false;
+        };
+        readonly definition: {
+            readonly dynamicRegistration: false;
+            readonly linkSupport: true;
+        };
+        readonly references: {
+            readonly dynamicRegistration: false;
+        };
+        readonly publishDiagnostics: {
+            readonly relatedInformation: false;
+            readonly versionSupport: true;
+        };
+        readonly rename: {
+            readonly dynamicRegistration: false;
+            readonly prepareSupport: true;
+        };
+        readonly codeAction: {
+            readonly dynamicRegistration: false;
+            readonly codeActionLiteralSupport: {
+                readonly codeActionKind: {
+                    readonly valueSet: readonly ["", "quickfix", "refactor", "source", "source.organizeImports"];
+                };
+            };
+        };
+        readonly documentSymbol: {
+            readonly dynamicRegistration: false;
+            readonly hierarchicalDocumentSymbolSupport: true;
+        };
+    };
+    readonly window: {
+        readonly workDoneProgress: true;
+    };
+    readonly general: {
+        readonly positionEncodings: readonly ["utf-16"];
+    };
+};

package/dist/agent/lsp/client-process.d.ts

@@ -0,0 +1,19 @@
+import { type ChildProcess } from 'node:child_process';
+export interface SpawnCommand {
+    readonly file: string;
+    readonly args: readonly string[];
+}
+export interface SpawnCommandDeps {
+    readonly platform?: NodeJS.Platform;
+    readonly execPath?: string;
+    readonly readFile?: (p: string) => string;
+    readonly lookup?: (bin: string, platform: NodeJS.Platform) => string | undefined;
+}
+export declare function buildSpawnCommand(command: string, args: readonly string[], deps?: SpawnCommandDeps): SpawnCommand;
+export declare function spawnServer(command: string, args: readonly string[], root: string): ChildProcess;
+export declare function exitPromise(proc: ChildProcess): Promise<void>;
+export declare function killServerTree(proc: ChildProcess, platform?: NodeJS.Platform): void;
+export declare function killServerTreeAndWait(proc: ChildProcess, timeoutMs: number, platform?: NodeJS.Platform): Promise<void>;
+export declare function killServerTreeSync(proc: ChildProcess, platform?: NodeJS.Platform): void;
+export declare function forceKillRoot(proc: ChildProcess): void;
+export declare function waitForExit(exited: Promise<void>, timeoutMs: number): Promise<void>;

package/dist/agent/lsp/client.d.ts

@@ -0,0 +1,54 @@
+import type { ServerSpec } from './server-spec.js';
+import { type SyncResult } from './document-sync.js';
+import { DiagnosticsStore } from './diagnostics-store.js';
+export type LspFailureKind = 'timeout' | 'aborted' | 'exited' | 'spawn' | 'response';
+export declare class LspClientError extends Error {
+    readonly kind: LspFailureKind;
+    constructor(kind: LspFailureKind, message: string);
+}
+export interface RequestOptions {
+    readonly timeoutMs?: number;
+    readonly signal?: AbortSignal;
+}
+export interface FileSync extends SyncResult {
+    readonly uri: string;
+}
+export declare const DISPOSE_EXIT_TIMEOUT_MS = 3000;
+export declare class LspClient {
+    readonly spec: ServerSpec;
+    readonly root: string;
+    private readonly proc;
+    private readonly conn;
+    private readonly docs;
+    readonly diagnostics: DiagnosticsStore;
+    private dead;
+    private readonly exitListeners;
+    private readonly deathWaiters;
+    private inFlight;
+    private lastActivity;
+    private disposing;
+    private holds;
+    private initialized;
+    private readonly exited;
+    private readonly docUses;
+    private constructor();
+    hold(): () => void;
+    private setRef;
+    static start(spec: ServerSpec, root: string, opts?: RequestOptions): Promise<LspClient>;
+    private initialize;
+    get alive(): boolean;
+    get pendingRequests(): number;
+    get lastActivityAt(): number;
+    onExit(cb: () => void): () => void;
+    request<R = unknown>(method: string, params: unknown, opts?: RequestOptions): Promise<R>;
+    notify(method: string, params: unknown): void;
+    syncFile(filePath: string, content?: string): Promise<FileSync | null>;
+    useDocument(uri: string): () => void;
+    closeOthers(uri: string): void;
+    get openDocuments(): string[];
+    get pid(): number | undefined;
+    dispose(): Promise<void>;
+    private doDispose;
+    private touch;
+    private markDead;
+}

package/dist/agent/lsp/diagnostics-store.d.ts

@@ -0,0 +1,17 @@
+export interface PublishedDiagnostics {
+    readonly uri: string;
+    readonly version?: number;
+    readonly diagnostics: readonly unknown[];
+    readonly seq: number;
+}
+export declare const UNVERSIONED_SETTLE_MS = 200;
+export declare class DiagnosticsStore {
+    private readonly settleMs;
+    private seqCounter;
+    private readonly latest;
+    private readonly waiters;
+    constructor(settleMs?: number);
+    get seq(): number;
+    record(params: unknown): void;
+    waitFor(uri: string, version: number | undefined, afterSeq: number, timeoutMs: number, signal?: AbortSignal): Promise<PublishedDiagnostics | null>;
+}

package/dist/agent/lsp/document-sync.d.ts

@@ -0,0 +1,20 @@
+export interface SyncNotification {
+    readonly method: 'textDocument/didOpen' | 'textDocument/didChange';
+    readonly params: unknown;
+}
+export interface SyncResult {
+    readonly version: number;
+    readonly changed: boolean;
+    readonly notification: SyncNotification | null;
+}
+export declare class DocumentSync {
+    private readonly docs;
+    private readonly versions;
+    version(uri: string): number | undefined;
+    openUris(): string[];
+    closeAllExcept(keep: ReadonlySet<string>): Array<{
+        readonly method: 'textDocument/didClose';
+        readonly params: unknown;
+    }>;
+    sync(uri: string, languageId: string, text: string): SyncResult;
+}

package/dist/agent/lsp/install.d.ts

@@ -0,0 +1,14 @@
+import type { EnsureInstalledResult, EnsureInstalledFn } from './server-spec.js';
+import { type GrantStore } from './install.grants.js';
+import { type NpmExecFn } from './install.npm.js';
+export interface InstallDeps {
+    grantStore?: GrantStore;
+    execFn?: NpmExecFn;
+    ledgerPath?: string;
+    platform?: string;
+    locateCli?: () => string | undefined;
+    inFlightMap?: Map<string, Promise<EnsureInstalledResult>>;
+}
+export declare function inFlightKey(language: string, interactive: boolean): string;
+export declare function createEnsureInstalled(deps?: InstallDeps): EnsureInstalledFn;
+export declare const ensureServerInstalled: EnsureInstalledFn;

package/dist/agent/lsp/install.footprint.d.ts

@@ -0,0 +1,5 @@
+export interface LspLanguageFootprint {
+    readonly language: string;
+    readonly bytes: number;
+}
+export declare function getLspInstallFootprint(serversDir?: string): Promise<LspLanguageFootprint[]>;

package/dist/agent/lsp/install.grants.d.ts

@@ -0,0 +1,10 @@
+export interface LspInstallGrant {
+    readonly language: string;
+    readonly packages: readonly string[];
+    readonly grantedAt: string;
+}
+export interface GrantStore {
+    hasGrant(language: string): Promise<boolean>;
+    persistGrant(language: string, packages: readonly string[]): Promise<void>;
+}
+export declare function createGrantStore(grantsPath?: string): GrantStore;

package/dist/agent/lsp/install.npm.d.ts

@@ -0,0 +1,21 @@
+export type NpmInstallResult = {
+    readonly ok: true;
+} | {
+    readonly ok: false;
+    readonly reason: string;
+};
+export type NpmExecFn = (file: string, args: readonly string[], options: {
+    timeout: number;
+    signal?: AbortSignal;
+}) => Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+export declare const MAX_FAILURE_REASON_CHARS = 500;
+export declare function sanitizeFailureReason(message: string): string;
+export interface NpmCommand {
+    readonly file: string;
+    readonly args: readonly string[];
+}
+export declare function resolveNpmCommand(platform?: string, locateCli?: () => string | undefined, execPath?: string): NpmCommand | undefined;
+export declare function runNpmInstall(language: string, packages: readonly string[], signal?: AbortSignal, execFn?: NpmExecFn, platform?: string, locateCli?: () => string | undefined): Promise<NpmInstallResult>;

package/dist/agent/lsp/pool.d.ts

@@ -0,0 +1,30 @@
+import { LspClient } from './client.js';
+import type { ServerSpec } from './server-spec.js';
+export declare const ABANDONED_START_GRACE_MS = 1000;
+export declare const DEFAULT_LSP_IDLE_SHUTDOWN_MS = 300000;
+export declare function getIdleShutdownMs(): number;
+export interface AcquireOptions {
+    readonly signal?: AbortSignal;
+    readonly timeoutMs?: number;
+}
+export interface LspServerPoolOptions {
+    readonly idleShutdownMs?: number;
+    readonly abandonedStartGraceMs?: number;
+    readonly startClient?: (spec: ServerSpec, root: string) => Promise<LspClient>;
+}
+export declare function poolKey(spec: ServerSpec, root: string): string;
+export declare class LspServerPool {
+    private readonly opts;
+    private readonly entries;
+    private spawnCount;
+    constructor(opts?: LspServerPoolOptions);
+    get spawned(): number;
+    get size(): number;
+    acquire(spec: ServerSpec, root: string, opts?: AcquireOptions): Promise<LspClient>;
+    private createEntry;
+    private waitForStart;
+    private scheduleIdle;
+    private evict;
+    disposeAll(): Promise<void>;
+}
+export declare function getLspPool(): LspServerPool;

package/dist/agent/lsp/query.d.ts

@@ -0,0 +1,18 @@
+import { LspClient, type FileSync } from './client.js';
+import { type LspServerPool } from './pool.js';
+import type { PublishedDiagnostics } from './diagnostics-store.js';
+import type { ServerSpec } from './server-spec.js';
+export interface PooledQueryOptions {
+    readonly root: string;
+    readonly timeoutMs: number;
+    readonly signal?: AbortSignal;
+    readonly pool?: LspServerPool;
+}
+export interface QueryContext {
+    readonly client: LspClient;
+    readonly sync: FileSync;
+    readonly seqBeforeSync: number;
+    remainingMs(): number;
+}
+export declare function withPooledFile<T>(spec: ServerSpec, filePath: string, content: string, opts: PooledQueryOptions, fn: (ctx: QueryContext) => Promise<T>): Promise<T>;
+export declare function awaitSyncDiagnostics(ctx: QueryContext, signal?: AbortSignal): Promise<PublishedDiagnostics | null>;

package/dist/agent/lsp/registry.d.ts

@@ -0,0 +1,12 @@
+import type { ResolveServerFn, ServerDefinition } from './server-spec.js';
+export declare function getServerDefinitions(): readonly ServerDefinition[];
+export declare function definitionForFile(filePath: string): ServerDefinition | undefined;
+export declare function detectProjectLanguages(root: string): ServerDefinition[];
+export interface RegistryDeps {
+    readonly fsStat: (p: string) => boolean;
+    readonly pathLookup: (binName: string) => string | undefined;
+    readonly definitions?: readonly ServerDefinition[];
+}
+export declare function resolveServerWith(deps: RegistryDeps): ResolveServerFn;
+export declare function findOnPath(binName: string, platform?: NodeJS.Platform): string | undefined;
+export declare const resolveServer: ResolveServerFn;

package/dist/agent/lsp/server-spec.d.ts

@@ -0,0 +1,53 @@
+export interface NpmInstallRecipe {
+    readonly kind: 'npm';
+    readonly packages: readonly string[];
+}
+export type InstallRecipe = NpmInstallRecipe;
+export interface ServerDefinition {
+    readonly language: string;
+    readonly languageIds: Readonly<Record<string, string>>;
+    readonly rootMarkers: readonly string[];
+    readonly binName: string;
+    readonly args: readonly string[];
+    readonly install?: InstallRecipe;
+    readonly initializationOptions?: unknown;
+    readonly settings?: Readonly<Record<string, unknown>>;
+}
+export interface ServerSpec {
+    readonly definition: ServerDefinition;
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly source: 'afk-install' | 'path' | 'override';
+}
+export type ResolveResult = {
+    readonly kind: 'resolved';
+    readonly spec: ServerSpec;
+    readonly root: string;
+} | {
+    readonly kind: 'missing';
+    readonly definition: ServerDefinition;
+    readonly root: string;
+} | {
+    readonly kind: 'unsupported';
+};
+export type ResolveServerFn = (filePath: string, sessionRoot?: string) => Promise<ResolveResult>;
+export interface InstallContext {
+    readonly interactive: boolean;
+    readonly askConsent?: (prompt: string) => Promise<boolean>;
+    readonly signal?: AbortSignal;
+}
+export type EnsureInstalledResult = {
+    readonly kind: 'installed';
+    readonly command: string;
+    readonly freshInstall: boolean;
+} | {
+    readonly kind: 'declined';
+} | {
+    readonly kind: 'refused-unattended';
+} | {
+    readonly kind: 'no-recipe';
+} | {
+    readonly kind: 'failed';
+    readonly reason: string;
+};
+export type EnsureInstalledFn = (definition: ServerDefinition, ctx: InstallContext) => Promise<EnsureInstalledResult>;

package/dist/agent/lsp/typescript-default.d.ts

@@ -0,0 +1,5 @@
+import type { ServerDefinition, ServerSpec } from './server-spec.js';
+export declare const DEFAULT_LSP_CMD: readonly ["typescript-language-server", "--stdio"];
+export declare const TYPESCRIPT_SERVER_DEFINITION: ServerDefinition;
+export declare function typescriptSpecFromCommand(cmd: readonly string[]): ServerSpec;
+export declare function typescriptRootFor(filePath: string): string;

package/dist/agent/plugins/load-entrypoints.d.ts

@@ -1,6 +1,17 @@
 import type { SdkPluginConfig } from '../types/sdk-types.js';
 import type { HarnessHookEvent, HookHandler, HookRegistry, RegisterOptions } from '../hooks.js';
+import type { StateStore } from '../state/state-store.js';
+import type { SendInput, SendToSessionResult } from '../peer/send.js';
+import type { PresenceRecord } from '../awareness/presence.js';
 export type PluginApi = Pick<typeof import('../../skills/skill-registry.js'), 'registerSkill' | 'listSkills' | 'getSkill'> & Pick<typeof import('../../skills/_lib/prompt-loader.js'), 'loadSkillPrompts'> & Pick<typeof import('../../config/env.js'), 'env'> & Pick<typeof import('../subagent.js'), 'SubagentManager'> & Pick<typeof import('../subagent/result.js'), 'describeFailure'> & Pick<typeof import('../tools/skill-bridge.js'), 'discoverPluginSkillBodies'> & Pick<typeof import('../facets/index.js'), 'getOrDeriveFacet' | 'listSessionIds' | 'deriveSessionFacet' | 'loadStoredSession'> & Pick<typeof import('../../paths.js'), 'getAgentFrameworkDir' | 'getSkillsDir' | 'getSessionsDir'> & {
+    stateGet?: (namespace: string, key: string) => ReturnType<StateStore['get']>;
+    statePut?: (namespace: string, key: string, value: unknown, opts?: Parameters<StateStore['put']>[3]) => ReturnType<StateStore['put']>;
+    stateCas?: (namespace: string, key: string, expectedVersion: number, value: unknown, opts?: Parameters<StateStore['cas']>[4]) => ReturnType<StateStore['cas']>;
+    stateDel?: (namespace: string, key: string) => ReturnType<StateStore['del']>;
+    stateInsertIfAbsent?: (namespace: string, key: string, value: unknown, opts?: Parameters<StateStore['insertIfAbsent']>[3]) => ReturnType<StateStore['insertIfAbsent']>;
+    stateQuery?: (namespace: string, opts?: Parameters<StateStore['query']>[1]) => ReturnType<StateStore['query']>;
+    listSessions?: () => Promise<PresenceRecord[]>;
+    sendToSession?: (input: Omit<SendInput, 'from'>) => Promise<SendToSessionResult>;
     registerHook?: (event: HarnessHookEvent, handler: HookHandler, options?: RegisterOptions) => () => void;
 };
 export declare const registerPluginHook: NonNullable<PluginApi['registerHook']>;
@@ -10,5 +21,6 @@ export type LoadEntrypointsOptions = {
     importer?: (specifier: string) => Promise<unknown>;
     onError?: (plugin: SdkPluginConfig, error: unknown) => void;
     pluginApi?: PluginApi;
+    buildPluginApi?: (pluginName: string | null, plugin: SdkPluginConfig) => PluginApi | undefined;
 };
 export declare function loadPluginEntrypoints(plugins: readonly SdkPluginConfig[], opts?: LoadEntrypointsOptions): Promise<void>;

package/dist/agent/plugins/plugin-runtime-api.d.ts

@@ -0,0 +1,6 @@
+import { makeDefaultStateStore } from '../providers/shared/provider-stores.js';
+import type { PluginApi } from './load-entrypoints.js';
+export declare function getOrCreateDefaultStateStore(factory?: () => ReturnType<typeof makeDefaultStateStore>): ReturnType<typeof makeDefaultStateStore>;
+export declare function _resetDefaultStateStore(): void;
+export declare function buildStateApiClosures(pluginId?: string, factory?: () => ReturnType<typeof makeDefaultStateStore>): Pick<Required<PluginApi>, 'stateGet' | 'statePut' | 'stateCas' | 'stateDel' | 'stateInsertIfAbsent' | 'stateQuery'>;
+export declare function buildPeerApiClosures(): Pick<Required<PluginApi>, 'listSessions' | 'sendToSession'>;

package/dist/agent/plugins/plugin-session-context.d.ts

@@ -0,0 +1,3 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+export declare const pluginSessionContext: AsyncLocalStorage<string | undefined>;
+export declare function runWithPluginSessionContext<T>(sessionId: string | undefined, fn: () => T): T;

package/dist/agent/session/manager-shutdown-config.d.ts

@@ -4,4 +4,4 @@ export interface BillingStreamSource {
     getPendingChildBillingStreams(): readonly Promise<void>[];
 }
 export declare function pendingChildBillingStreams(...sources: ReadonlyArray<BillingStreamSource | undefined>): readonly Promise<void>[];
-export declare function managerShutdownConfig(manager: SubagentManager, composeExecutor?: BillingStreamSource): Pick<AgentConfig, 'drainSubagents' | 'getPendingChildTerminalWrites' | 'getPendingChildBillingStreams'>;
+export declare function managerShutdownConfig(manager: SubagentManager, composeExecutor?: BillingStreamSource, drainTimeoutMs?: number): Pick<AgentConfig, 'drainSubagents' | 'getPendingChildTerminalWrites' | 'getPendingChildBillingStreams'>;

package/dist/agent/subagent/result.d.ts

@@ -5,6 +5,7 @@ import { type CappedHandoff } from './capped-handoff.js';
 import { type Signal } from '../signal-block.js';
 export type SubagentStatus = 'idle' | 'running' | 'succeeded' | 'failed' | 'cancelled';
 export declare const STREAM_INCOMPLETE = "stream_incomplete";
+export declare function isTerminalStopReason(s: string | undefined): boolean;
 export declare function isIncompleteStopReason(stopReason: string | undefined): boolean;
 export declare function annotateIfIncomplete(content: string, stopReason: string | undefined): string;
 export declare function incompleteToolResultFields(stopReason: string | undefined): {

package/dist/agent/tools/handlers/lsp-diagnostics.d.ts

@@ -5,6 +5,6 @@ export interface LspDiagnostic {
     col: number;
 }
 export declare function isLspDiagnosticsEnabled(): boolean;
-export declare function queryLspDiagnostics(filePath: string, serverCmd?: readonly string[]): Promise<LspDiagnostic[]>;
+export declare function queryLspDiagnostics(filePath: string, serverCmd?: readonly string[], signal?: AbortSignal): Promise<LspDiagnostic[]>;
 export declare function formatDiagnostics(filePath: string, diags: LspDiagnostic[]): string;
-export declare function appendLspDiagnostics(filePath: string, serverCmd?: readonly string[]): Promise<string>;
+export declare function appendLspDiagnostics(filePath: string, serverCmd?: readonly string[], signal?: AbortSignal): Promise<string>;

package/dist/agent/tools/handlers/lsp-shared.d.ts

@@ -1,10 +1,4 @@
-import type { ChildProcess } from 'node:child_process';
-export declare function encodeMessage(obj: unknown): Buffer;
-export declare function killProc(proc: ChildProcess): void;
-export declare function parseMessages(buf: Buffer): {
-    messages: unknown[];
-    remaining: Buffer;
-};
-export declare function languageIdForExt(ext: string): string | undefined;
+export declare function lspFailureMessage(err: unknown, timeoutMessage: string): string;
+export declare function readLspSource(filePath: string, timeoutMs: number, signal?: AbortSignal): Promise<string>;
 export declare function getTimeoutMs(): number;
 export declare function getSymbolsTimeoutMs(): number;

package/dist/agent/tools/handlers/lsp-symbols.d.ts

@@ -1,4 +1,5 @@
 import type { ToolHandlerContext } from '../types.js';
+import { DEFAULT_LSP_CMD } from '../../lsp/typescript-default.js';
 export interface LspLocation {
     filePath: string;
     line: number;
@@ -9,7 +10,7 @@ export interface LspSymbolResult {
     error?: string;
 }
 export type SymbolSubcommand = 'definition' | 'references';
-export declare const DEFAULT_LSP_CMD: readonly ["typescript-language-server", "--stdio"];
+export { DEFAULT_LSP_CMD };
 export declare function parseLocation(raw: unknown): LspLocation | null;
 export declare function isLspSymbolsEnabled(): boolean;
 export declare function queryLspSymbol(filePath: string, subcommand: SymbolSubcommand, line: number, col: number, rootDir?: string, serverCmd?: readonly string[], signal?: AbortSignal): Promise<LspSymbolResult>;

package/dist/agent/tools/skill-bridge.d.ts

@@ -32,4 +32,7 @@ export interface PluginSkillBody {
 export declare function discoverPluginSkillBodies(pluginConfigs?: SdkPluginConfig[], opts?: CollectSkillEntriesOptions): Map<string, PluginSkillBody>;
 export declare function discoverPluginAgents(pluginConfigs?: SdkPluginConfig[], warn?: (message: string) => void): RegisteredAgent[];
 export declare function scanAllPluginRoots(opts?: CollectSkillEntriesOptions): SdkPluginConfig[];
-export declare function ensurePluginEntrypointsLoaded(): Promise<void>;
+export interface EnsurePluginEntrypointsOptions {
+    stateStore?: import('../state/state-store.js').StateStore;
+}
+export declare function ensurePluginEntrypointsLoaded(opts?: EnsurePluginEntrypointsOptions): Promise<void>;

package/dist/agent/tools/subagent/child-config.d.ts

@@ -58,4 +58,15 @@ export interface BuildChildConfigResult {
     childModelSource: ChildModelSource;
     modelFallback: ForkSubagentOptions['modelFallback'];
 }
+export declare function buildChildConfigWithoutNesting(args: BuildChildConfigArgs): {
+    childConfig: AgentConfig;
+    childModel: string;
+    childWriteCapable: boolean;
+    childSideEffectFree: boolean;
+    resolvedAccess: import("../../agents/types.js").ResolvedAgentToolAccess | undefined;
+    effectiveAllowedTools: string[] | undefined;
+    effectiveReadOnlyBash: boolean;
+    childModelSource: ChildModelSource;
+};
+export declare function completeChildConfigNesting(args: BuildChildConfigArgs, pre: ReturnType<typeof buildChildConfigWithoutNesting>, nestingCwd: string | undefined): BuildChildConfigResult;
 export declare function buildChildConfig(args: BuildChildConfigArgs): BuildChildConfigResult;

package/dist/cli/commands/update.d.ts

@@ -1,3 +1,3 @@
 import { Command } from 'commander';
-export declare function resolveNpmCli(execPath?: string, existsFn?: (p: string) => boolean, realpathFn?: (p: string) => string): string | undefined;
+export { resolveNpmCli } from '../../utils/npm-cli.js';
 export declare function registerUpdateCommand(program: Command): void;

package/dist/cli/health-rail.d.ts

@@ -1,8 +1,10 @@
 import type { BackgroundAgentRegistry } from '../agent/background-registry.js';
+import type { ProcessJobRegistry } from '../agent/shell-jobs/process-jobs.js';
 import type { SessionStats } from './slash/types.js';
 export interface HealthRailOptions {
     stream?: NodeJS.WriteStream;
     backgroundRegistry?: BackgroundAgentRegistry;
+    processJobs?: ProcessJobRegistry;
     getExtraRows: () => number;
     getForegroundAgentCounts?: () => {
         active: number;
@@ -12,6 +14,7 @@ export interface HealthRailOptions {
 export declare class HealthRail {
     private readonly stream;
     private readonly registry;
+    private readonly processJobs;
     private readonly getExtraRows;
     private readonly getForegroundAgentCounts;
     private started;
@@ -24,6 +27,7 @@ export declare class HealthRail {
     private preResizePaintedRow;
     private totalBgSubsEver;
     private totalFgSubsEver;
+    private totalProcsEver;
     constructor(opts: HealthRailOptions);
     setRowCountChangeHandler(handler: (rows: number) => void): void;
     start(): void;

package/dist/cli/health-rail.format.d.ts

@@ -4,6 +4,8 @@ export interface HealthRailFields {
     toolCalls: number;
     activeSubs: number;
     totalSubs: number;
+    activeProcs: number;
+    totalProcs: number;
     contextRatio: number;
 }
 export declare function formatHealthRail(fields: HealthRailFields, maxWidth: number): string;