oh-my-opencode 4.9.2 → 4.11.0

package/dist/features/claude-code-plugin-loader/types.d.ts

@@ -1,237 +1 @@
-/**
- * Claude Code Plugin Types
- *
- * Type definitions for Claude Code plugin system compatibility.
- * Based on https://code.claude.com/docs/en/plugins-reference
- */
-export type PluginScope = "user" | "project" | "local" | "managed";
-/**
- * Plugin installation entry in installed_plugins.json
- */
-export interface PluginInstallation {
-    scope: PluginScope;
-    installPath: string;
-    version: string;
-    installedAt: string;
-    lastUpdated: string;
-    gitCommitSha?: string;
-    isLocal?: boolean;
-    /**
-     * Claude Code records this on project/local-scoped installations.
-     * Absolute path (or `~`-prefixed) of the project the plugin was installed for.
-     * Used to filter project/local plugins that do not belong to the current cwd.
-     */
-    projectPath?: string;
-}
-/**
- * Installed plugins database v1 (legacy)
- * plugins stored as direct objects
- */
-export interface InstalledPluginsDatabaseV1 {
-    version: 1;
-    plugins: Record<string, PluginInstallation>;
-}
-/**
- * Installed plugins database v2
- * plugins stored as arrays keyed by plugin identifier
- */
-export interface InstalledPluginsDatabaseV2 {
-    version: 2;
-    plugins: Record<string, PluginInstallation[]>;
-}
-/**
- * Installed plugins database v3 entry (current Claude Code format)
- * A flat array of plugin entries, each containing name and marketplace fields
- * used to construct the plugin key as "name@marketplace".
- */
-export interface InstalledPluginEntryV3 {
-    name: string;
-    marketplace: string;
-    scope: PluginScope;
-    version: string;
-    installPath: string;
-    lastUpdated: string;
-    gitCommitSha?: string;
-    /**
-     * Claude Code records this on project/local-scoped installations.
-     * Absolute path (or `~`-prefixed) of the project the plugin was installed for.
-     */
-    projectPath?: string;
-}
-/**
- * Installed plugins database structure
- * Located at ~/.claude/plugins/installed_plugins.json
- *
- * Supports three formats:
- * - v1: { version: 1, plugins: Record<string, PluginInstallation> }
- * - v2: { version: 2, plugins: Record<string, PluginInstallation[]> }
- * - v3: InstalledPluginEntryV3[] (flat array, current Claude Code format)
- */
-export type InstalledPluginsDatabase = InstalledPluginsDatabaseV1 | InstalledPluginsDatabaseV2 | InstalledPluginEntryV3[];
-/**
- * Plugin author information
- */
-export interface PluginAuthor {
-    name?: string;
-    email?: string;
-    url?: string;
-}
-/**
- * Plugin manifest (plugin.json)
- * Located at <plugin_root>/.claude-plugin/plugin.json
- */
-export interface PluginManifest {
-    name: string;
-    version?: string;
-    description?: string;
-    author?: PluginAuthor;
-    homepage?: string;
-    repository?: string;
-    license?: string;
-    keywords?: string[];
-    commands?: string | string[];
-    agents?: string | string[];
-    skills?: string | string[];
-    hooks?: string | HooksConfig;
-    mcpServers?: string | McpServersConfig;
-    lspServers?: string | LspServersConfig;
-    outputStyles?: string | string[];
-}
-/**
- * Hooks configuration
- */
-export type HookEntry = {
-    type: "command";
-    command?: string;
-} | {
-    type: "prompt";
-    prompt?: string;
-} | {
-    type: "agent";
-    agent?: string;
-} | {
-    type: "http";
-    url: string;
-    headers?: Record<string, string>;
-    allowedEnvVars?: string[];
-    timeout?: number;
-};
-export interface HookMatcher {
-    matcher?: string;
-    hooks: HookEntry[];
-}
-export interface HooksConfig {
-    hooks?: {
-        PreToolUse?: HookMatcher[];
-        PostToolUse?: HookMatcher[];
-        PostToolUseFailure?: HookMatcher[];
-        PermissionRequest?: HookMatcher[];
-        UserPromptSubmit?: HookMatcher[];
-        Notification?: HookMatcher[];
-        Stop?: HookMatcher[];
-        SubagentStart?: HookMatcher[];
-        SubagentStop?: HookMatcher[];
-        SessionStart?: HookMatcher[];
-        SessionEnd?: HookMatcher[];
-        PreCompact?: HookMatcher[];
-    };
-}
-/**
- * MCP servers configuration in plugin
- */
-export interface PluginMcpServer {
-    command?: string;
-    args?: string[];
-    env?: Record<string, string>;
-    cwd?: string;
-    url?: string;
-    type?: "stdio" | "http" | "sse";
-    disabled?: boolean;
-}
-export interface McpServersConfig {
-    mcpServers?: Record<string, PluginMcpServer>;
-}
-/**
- * LSP server configuration
- */
-export interface LspServerConfig {
-    command: string;
-    args?: string[];
-    extensionToLanguage: Record<string, string>;
-    transport?: "stdio" | "socket";
-    env?: Record<string, string>;
-    initializationOptions?: Record<string, unknown>;
-    settings?: Record<string, unknown>;
-    workspaceFolder?: string;
-    startupTimeout?: number;
-    shutdownTimeout?: number;
-    restartOnCrash?: boolean;
-    maxRestarts?: number;
-    loggingConfig?: {
-        args?: string[];
-        env?: Record<string, string>;
-    };
-}
-export interface LspServersConfig {
-    [language: string]: LspServerConfig;
-}
-/**
- * Loaded plugin with all resolved components
- */
-export interface LoadedPlugin {
-    name: string;
-    version: string;
-    scope: PluginScope;
-    installPath: string;
-    manifest?: PluginManifest;
-    pluginKey: string;
-    commandsDir?: string;
-    agentsDir?: string;
-    skillsDir?: string;
-    hooksPath?: string;
-    mcpPath?: string;
-    lspPath?: string;
-}
-/**
- * Plugin load result with all components
- */
-export interface PluginLoadResult {
-    plugins: LoadedPlugin[];
-    errors: PluginLoadError[];
-}
-export interface PluginLoadError {
-    pluginKey: string;
-    installPath: string;
-    error: string;
-}
-/**
- * Claude settings from ~/.claude/settings.json
- */
-export interface ClaudeSettings {
-    enabledPlugins?: Record<string, boolean>;
-    [key: string]: unknown;
-}
-/**
- * Plugin loader options
- */
-export interface PluginLoaderOptions {
-    /**
-     * Override the plugins home directory for testing.
-     * If not provided, uses CLAUDE_PLUGINS_HOME env var or ~/.claude/plugins
-     */
-    pluginsHomeOverride?: string;
-    /**
-     * Override plugin manifest loading for testing.
-     * Return null to force plugin name derivation from the plugin key.
-     */
-    loadPluginManifestOverride?: (installPath: string) => PluginManifest | null;
-    /**
-     * Override enabled plugins from oh-my-opencode config.
-     * Key format: "pluginName@marketplace" (e.g., "shell-scripting@claude-code-workflows")
-     * Value: true = enabled, false = disabled
-     *
-     * This takes precedence over ~/.claude/settings.json enabledPlugins
-     */
-    enabledPluginsOverride?: Record<string, boolean>;
-    anthropicProvider?: string;
-}
+export * from "@oh-my-opencode/claude-code-compat-core/claude-code-plugin-loader/types";

package/dist/features/claude-code-session-state/state.d.ts

@@ -1,5 +1,6 @@
 export declare const subagentSessions: Set<string>;
 export declare const syncSubagentSessions: Set<string>;
+export declare const handedBackSyncSessions: Set<string>;
 export declare function setMainSession(id: string | undefined): void;
 export declare function getMainSessionID(): string | undefined;
 export declare function registerAgentName(name: string): void;

package/dist/features/claude-tasks/types.d.ts

@@ -1,9 +1,9 @@
 import { z } from "zod";
 export declare const TaskStatusSchema: z.ZodEnum<{
+    deleted: "deleted";
+    completed: "completed";
     pending: "pending";
     in_progress: "in_progress";
-    completed: "completed";
-    deleted: "deleted";
 }>;
 export type TaskStatus = z.infer<typeof TaskStatusSchema>;
 export declare const TaskSchema: z.ZodObject<{
@@ -11,10 +11,10 @@ export declare const TaskSchema: z.ZodObject<{
     subject: z.ZodString;
     description: z.ZodString;
     status: z.ZodEnum<{
+        deleted: "deleted";
+        completed: "completed";
         pending: "pending";
         in_progress: "in_progress";
-        completed: "completed";
-        deleted: "deleted";
     }>;
     activeForm: z.ZodOptional<z.ZodString>;
     blocks: z.ZodArray<z.ZodString>;

package/dist/features/hook-message-injector/sdk-message-lookup.d.ts

@@ -1,6 +1,13 @@
-import type { PluginInput } from "@opencode-ai/plugin";
 import type { StoredMessage, ToolPermission } from "./types";
-export type OpencodeClient = PluginInput["client"];
+export type OpencodeClient = {
+    readonly session: {
+        readonly messages: (input: {
+            readonly path: {
+                readonly id: string;
+            };
+        }) => Promise<unknown>;
+    };
+};
 export interface SDKMessage {
     readonly id?: string;
     readonly info?: {

package/dist/features/mcp-oauth/callback-server.d.ts

@@ -1,19 +1 @@
-import { setTimeout as setNativeTimeout } from "node:timers";
-export type OAuthCallbackResult = {
-    code: string;
-    state: string;
-};
-export type CallbackServer = {
-    port: number;
-    waitForCallback: () => Promise<OAuthCallbackResult>;
-    close: () => Promise<void>;
-};
-export type CallbackServerTimerHandle = ReturnType<typeof setNativeTimeout>;
-export type CallbackServerTimer = {
-    readonly setTimeout: (callback: () => void, delayMs: number) => CallbackServerTimerHandle;
-    readonly clearTimeout: (handle: CallbackServerTimerHandle) => void;
-};
-export declare function findAvailablePort(startPort?: number): Promise<number>;
-export declare function startCallbackServer(startPort?: number, options?: {
-    readonly timer?: CallbackServerTimer;
-}): Promise<CallbackServer>;
+export * from "@oh-my-opencode/mcp-client-core/mcp-oauth/callback-server";

package/dist/features/mcp-oauth/dcr.d.ts

@@ -1,34 +1 @@
-export type ClientRegistrationRequest = {
-    redirect_uris: string[];
-    client_name: string;
-    grant_types: ["authorization_code", "refresh_token"];
-    response_types: ["code"];
-    token_endpoint_auth_method: "none" | "client_secret_post";
-};
-export type ClientCredentials = {
-    clientId: string;
-    clientSecret?: string;
-};
-export type ClientRegistrationStorage = {
-    getClientRegistration: (serverIdentifier: string) => ClientCredentials | null;
-    setClientRegistration: (serverIdentifier: string, credentials: ClientCredentials) => void;
-};
-export type DynamicClientRegistrationOptions = {
-    registrationEndpoint?: string | null;
-    serverIdentifier?: string;
-    clientName: string;
-    redirectUris: string[];
-    tokenEndpointAuthMethod: "none" | "client_secret_post";
-    clientId?: string | null;
-    storage: ClientRegistrationStorage;
-    fetch?: DcrFetch;
-};
-export type DcrFetch = (input: string, init?: {
-    method?: string;
-    headers?: Record<string, string>;
-    body?: string;
-}) => Promise<{
-    ok: boolean;
-    json: () => Promise<unknown>;
-}>;
-export declare function getOrRegisterClient(options: DynamicClientRegistrationOptions): Promise<ClientCredentials | null>;
+export * from "@oh-my-opencode/mcp-client-core/mcp-oauth/dcr";

package/dist/features/mcp-oauth/discovery.d.ts

@@ -1,8 +1 @@
-export interface OAuthServerMetadata {
-    authorizationEndpoint: string;
-    tokenEndpoint: string;
-    registrationEndpoint?: string;
-    resource: string;
-}
-export declare function discoverOAuthServerMetadata(resource: string): Promise<OAuthServerMetadata>;
-export declare function resetDiscoveryCache(): void;
+export * from "@oh-my-opencode/mcp-client-core/mcp-oauth/discovery";

package/dist/features/mcp-oauth/oauth-authorization-flow.d.ts

@@ -1,26 +1 @@
-export type OAuthCallbackResult = {
-    code: string;
-    state: string;
-};
-export declare function generateCodeVerifier(): string;
-export declare function generateCodeChallenge(verifier: string): string;
-export declare function buildAuthorizationUrl(authorizationEndpoint: string, options: {
-    clientId: string;
-    redirectUri: string;
-    codeChallenge: string;
-    state: string;
-    scopes?: string[];
-    resource?: string;
-}): string;
-export declare function startCallbackServer(port: number): Promise<OAuthCallbackResult>;
-export declare function runAuthorizationCodeRedirect(options: {
-    authorizationEndpoint: string;
-    callbackPort: number;
-    clientId: string;
-    redirectUri: string;
-    scopes?: string[];
-    resource?: string;
-}): Promise<{
-    code: string;
-    verifier: string;
-}>;
+export * from "@oh-my-opencode/mcp-client-core/mcp-oauth/oauth-authorization-flow";

package/dist/features/mcp-oauth/provider.d.ts

@@ -1,30 +1 @@
-import type { OAuthTokenData } from "./storage";
-import type { OAuthServerMetadata } from "./discovery";
-import type { ClientCredentials } from "./dcr";
-import { buildAuthorizationUrl, generateCodeChallenge, generateCodeVerifier, startCallbackServer } from "./oauth-authorization-flow";
-export type McpOAuthProviderOptions = {
-    serverUrl: string;
-    clientId?: string;
-    scopes?: string[];
-};
-export declare class McpOAuthProvider {
-    private readonly serverUrl;
-    private readonly configClientId;
-    private readonly scopes;
-    private storedCodeVerifier;
-    private storedClientInfo;
-    private callbackPort;
-    constructor(options: McpOAuthProviderOptions);
-    tokens(): OAuthTokenData | null;
-    saveTokens(tokenData: OAuthTokenData): boolean;
-    clientInformation(): ClientCredentials | null;
-    redirectUrl(): string;
-    saveCodeVerifier(verifier: string): void;
-    codeVerifier(): string | null;
-    redirectToAuthorization(metadata: OAuthServerMetadata): Promise<{
-        code: string;
-    }>;
-    login(): Promise<OAuthTokenData>;
-    refresh(refreshToken: string): Promise<OAuthTokenData>;
-}
-export { generateCodeVerifier, generateCodeChallenge, buildAuthorizationUrl, startCallbackServer };
+export * from "@oh-my-opencode/mcp-client-core/mcp-oauth/provider";

package/dist/features/mcp-oauth/refresh-mutex.d.ts

@@ -1,26 +1 @@
-import type { OAuthTokenData } from "./storage";
-/**
- * Execute a token refresh with per-server mutual exclusion.
- *
- * If a refresh is already in progress for the given server, this will
- * return the same promise to all concurrent callers. Once the refresh
- * completes (success or failure), the lock is released.
- *
- * @param serverUrl - The OAuth server URL (used as mutex key)
- * @param refreshFn - The actual refresh operation to execute
- * @returns Promise that resolves to the new token data
- */
-export declare function withRefreshMutex(serverUrl: string, refreshFn: () => Promise<OAuthTokenData>): Promise<OAuthTokenData>;
-/**
- * Check if a refresh is currently in progress for a server.
- *
- * @param serverUrl - The OAuth server URL
- * @returns true if a refresh operation is active
- */
-export declare function isRefreshInProgress(serverUrl: string): boolean;
-/**
- * Get the number of servers currently undergoing token refresh.
- *
- * @returns Number of active refresh operations
- */
-export declare function getActiveRefreshCount(): number;
+export * from "@oh-my-opencode/mcp-client-core/mcp-oauth/refresh-mutex";

package/dist/features/mcp-oauth/resource-indicator.d.ts

@@ -0,0 +1 @@
+export * from "@oh-my-opencode/mcp-client-core/mcp-oauth/resource-indicator";

package/dist/features/mcp-oauth/schema.d.ts

@@ -0,0 +1 @@
+export * from "@oh-my-opencode/mcp-client-core/mcp-oauth/schema";

package/dist/features/mcp-oauth/step-up.d.ts

@@ -1,8 +1 @@
-export interface StepUpInfo {
-    requiredScopes: string[];
-    error?: string;
-    errorDescription?: string;
-}
-export declare function parseWwwAuthenticate(header: string): StepUpInfo | null;
-export declare function mergeScopes(existing: string[], required: string[]): string[];
-export declare function isStepUpRequired(statusCode: number, headers: Record<string, string>): StepUpInfo | null;
+export * from "@oh-my-opencode/mcp-client-core/mcp-oauth/step-up";

package/dist/features/mcp-oauth/storage.d.ts

@@ -1,17 +1 @@
-export interface OAuthTokenData {
-    accessToken: string;
-    refreshToken?: string;
-    expiresAt?: number;
-    clientInfo?: {
-        clientId: string;
-        clientSecret?: string;
-    };
-}
-type TokenStore = Record<string, OAuthTokenData>;
-export declare function getMcpOauthStoragePath(): string;
-export declare function loadToken(serverHost: string, resource: string): OAuthTokenData | null;
-export declare function saveToken(serverHost: string, resource: string, token: OAuthTokenData): boolean;
-export declare function deleteToken(serverHost: string, resource: string): boolean;
-export declare function listTokensByHost(serverHost: string): TokenStore;
-export declare function listAllTokens(): TokenStore;
-export {};
+export * from "@oh-my-opencode/mcp-client-core/mcp-oauth/storage";

package/dist/features/monitor/batcher.d.ts

@@ -0,0 +1,36 @@
+import type { OutputBatch, OutputLine } from "./types";
+export type TimerHandle = ReturnType<typeof setTimeout> | number | {
+    unref?(): void;
+};
+export interface SchedulerDeps {
+    setTimer(fn: () => void, delayMs: number): TimerHandle;
+    clearTimer(handle: TimerHandle): void;
+    now(): number;
+}
+export interface MonitorBatcherOptions {
+    batchMaxLines: number;
+    batchMaxBytes: number;
+    flushIntervalMs: number;
+    scheduler?: SchedulerDeps;
+}
+export declare class MonitorBatcher {
+    private readonly batchMaxLines;
+    private readonly batchMaxBytes;
+    private readonly flushIntervalMs;
+    private readonly scheduler;
+    private readonly lines;
+    private batchCallback;
+    private batchSeq;
+    private pendingBytes;
+    private firstPendingAt;
+    private timer;
+    private destroyed;
+    constructor(opts: MonitorBatcherOptions);
+    push(line: OutputLine): void;
+    flushNow(): void;
+    onBatch(cb: (batch: OutputBatch) => void): void;
+    pendingCount(): number;
+    destroy(): void;
+    private startTimer;
+    private clearTimer;
+}

package/dist/features/monitor/envelope.d.ts

@@ -0,0 +1,9 @@
+import type { MonitorCounters, OutputBatch } from "./types";
+export declare function formatMonitorBatch(record: {
+    id: string;
+    label: string;
+    command: string;
+    status: string;
+    exitCode?: number;
+    signal?: string;
+}, batch: OutputBatch, counters: MonitorCounters): string;

package/dist/features/monitor/filter.d.ts

@@ -0,0 +1,10 @@
+export interface MonitorFilterResult {
+    filter: {
+        matches(text: string): boolean;
+    } | null;
+    error?: string;
+    pattern?: string;
+}
+export declare function createMonitorFilter(pattern: string | undefined, opts: {
+    patternMaxLength: number;
+}): MonitorFilterResult;

package/dist/features/monitor/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export { MonitorManager, createMonitorManager } from "./manager";

package/dist/features/monitor/line-stream.d.ts

@@ -0,0 +1,29 @@
+export interface DecodedLine {
+    text: string;
+    rawText: string;
+    truncated?: boolean;
+    binary?: boolean;
+}
+export type LineStreamResult = {
+    lines: DecodedLine[];
+    binarySuppressedBytes: number;
+};
+export declare function stripAnsi(text: string): string;
+export declare class LineStream {
+    private readonly lineMaxBytes;
+    private readonly binaryThreshold;
+    private readonly decoder;
+    private pending;
+    private truncating;
+    constructor(opts: {
+        lineMaxBytes: number;
+        binaryThreshold?: number;
+    });
+    feed(chunk: Uint8Array): LineStreamResult;
+    flush(): LineStreamResult;
+    private isBinaryChunk;
+    private consumeChunk;
+    private consumeBytes;
+    private emitPendingLine;
+    private createLine;
+}

package/dist/features/monitor/manager-internals.d.ts

@@ -0,0 +1,65 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { MonitorConfig } from "../../config/schema/monitor";
+import { registerManagerForCleanup, unregisterManagerForCleanup } from "../background-agent/process-cleanup";
+import { log } from "../../shared";
+import type { InternalPromptDispatchArgs, PromptAsyncInput, PromptDispatchClient } from "../../shared/prompt-async-gate/types";
+import { MonitorBatcher, type SchedulerDeps } from "./batcher";
+import { createMonitorPipeline } from "./pipeline";
+import { spawnMonitoredProcess, type MonitoredProcess } from "./process";
+import { MonitorRingBuffer } from "./ring-buffer";
+import type { MonitorId, MonitorRecord, OutputBatch } from "./types";
+export type MonitorPipeline = ReturnType<typeof createMonitorPipeline>;
+export type MonitorPromptClient = PromptDispatchClient & InternalPromptDispatchArgs<PromptAsyncInput>["client"];
+export interface MonitorInjector {
+    queueBatch(record: MonitorRecord, batch: OutputBatch): void;
+    flushMonitor(monitorId: string): Promise<void>;
+}
+export interface InternalMonitorState {
+    record: MonitorRecord;
+    process: MonitoredProcess;
+    ring: MonitorRingBuffer;
+    batcher: MonitorBatcher;
+    pipeline: MonitorPipeline;
+    injector: MonitorInjector;
+    stopped: boolean;
+}
+export interface MonitorManagerDeps {
+    randomId?: () => MonitorId;
+    isBackgroundSession?: (sessionId: string) => boolean;
+    spawnMonitoredProcess?: typeof spawnMonitoredProcess;
+    createInjector?: (record: MonitorRecord, scheduleFlush: (monitorId: string, delayMs: number, operation: () => Promise<void>) => void) => MonitorInjector;
+    scheduler?: SchedulerDeps;
+    registerManagerForCleanup?: typeof registerManagerForCleanup;
+    unregisterManagerForCleanup?: typeof unregisterManagerForCleanup;
+    log?: typeof log;
+}
+export interface MonitorManagerOptions {
+    pluginContext: Pick<PluginInput, "client" | "directory">;
+    config?: Partial<MonitorConfig>;
+    deps?: MonitorManagerDeps;
+}
+export declare const DEFAULT_MONITOR_CONFIG: {
+    max_monitors_per_session: number;
+    max_runtime_ms: number;
+    batch_max_lines: number;
+    batch_max_bytes: number;
+    flush_interval_ms: number;
+    ring_max_lines: number;
+    line_max_bytes: number;
+    pattern_max_length: number;
+};
+export declare const MONITOR_OUTPUT_PENDING_RETRY_MS = 1000;
+export declare const MONITOR_OUTPUT_ACCEPTED_MESSAGE_SKEW_MS = 5000;
+export declare const MONITOR_OUTPUT_USER_MESSAGE_IN_PROGRESS_WINDOW_MS = 2000;
+export declare const MONITOR_OUTPUT_POST_DISPATCH_HOLD_MS = 250;
+export declare function createEmptyCounters(): {
+    totalLines: number;
+    matchedLines: number;
+    unmatchedLines: number;
+    droppedMatched: number;
+    droppedUnmatched: number;
+    bytesDropped: number;
+    lastSequence: number;
+};
+export declare function createRealScheduler(): SchedulerDeps;
+export declare function createMonitorId(): MonitorId;

package/dist/features/monitor/manager.d.ts

@@ -0,0 +1,35 @@
+import { type MonitorManagerDeps, type MonitorManagerOptions } from "./manager-internals";
+import type { MonitorId, MonitorManager as MonitorManagerContract, MonitorManagerEvent, MonitorOutputQuery, MonitorOutputResult, MonitorRecord, MonitorStartOpts } from "./types";
+export type { MonitorManagerDeps, MonitorManagerOptions };
+export declare class MonitorManager implements MonitorManagerContract {
+    private readonly options;
+    private readonly monitors;
+    private readonly monitorsByParentSession;
+    private readonly scheduledFlushTimers;
+    private readonly config;
+    private readonly scheduler;
+    private readonly registerCleanup;
+    private readonly unregisterCleanup;
+    private readonly logger;
+    private shutdownTriggered;
+    constructor(options: MonitorManagerOptions);
+    start(opts: MonitorStartOpts): Promise<MonitorRecord>;
+    stop(id: MonitorId): Promise<void>;
+    list(sessionId: string): MonitorRecord[];
+    get(id: MonitorId): MonitorRecord | undefined;
+    getOutput(id: MonitorId, opts: MonitorOutputQuery): MonitorOutputResult;
+    stopSessionMonitors(sessionId: string): Promise<void>;
+    handleEvent(event: MonitorManagerEvent): void;
+    shutdown(): Promise<void>;
+    private createId;
+    private scheduleFlush;
+    private clearScheduledFlush;
+    private addMonitor;
+    private assertSessionCapacity;
+    private isBackgroundSession;
+    private isTerminalStatus;
+    private removeMonitor;
+    private enforceTerminalRetention;
+    private flushSessionMonitors;
+}
+export declare function createMonitorManager(options: MonitorManagerOptions): MonitorManager;