0xray 3.4.2 → 3.4.3

package/dist/monitoring/nudge-watchdog.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Nudge Watchdog - Detects and breaks stuck AI patterns
+ *
+ * Monitors agent actions and detects common failure patterns:
+ * - think-loop: AI keeps outputting thinking tags but no progress
+ * - syntax-loop: AI keeps trying to fix same file/error multiple times
+ * - death-spiral: AI re-explains instead of fixing
+ * - tool-loop: Same tool called with similar args repeatedly
+ * - repair-failure: Processor indicates fix but error persists
+ *
+ * @module monitoring/nudge-watchdog
+ */
+import { EventEmitter } from "events";
+export interface NudgeConfig {
+    enabled: boolean;
+    think_loop_threshold: number;
+    syntax_loop_threshold: number;
+    tool_loop_threshold: number;
+    death_spiral_threshold: number;
+    cooldown_ms: number;
+}
+export type NudgeType = "think-loop" | "syntax-loop" | "death-spiral" | "tool-loop" | "repair-failure";
+export interface StuckPattern {
+    type: NudgeType;
+    count: number;
+    firstSeen: number;
+    lastSeen: number;
+    details: Record<string, unknown>;
+}
+export interface NudgeAction {
+    type: NudgeType;
+    message: string;
+    suggestion: string;
+    priority: number;
+}
+declare class NudgeWatchdog extends EventEmitter {
+    private config;
+    private patterns;
+    private lastNudgeTime;
+    private thinkTagCount;
+    private lastThinkTagTime;
+    private toolCallHistory;
+    private fixAttempts;
+    private explanationCount;
+    private codeChangeCount;
+    private listenersInitialized;
+    constructor(config?: Partial<NudgeConfig>);
+    private loadConfigFromFeatures;
+    start(): void;
+    stop(): void;
+    recordThinkTag(): void;
+    recordCodeChange(): void;
+    recordToolCall(tool: string, args: string): void;
+    recordFixAttempt(filePath: string, error: string): void;
+    recordExplanation(): void;
+    recordProcessorFix(filePath: string, fixed: boolean, errorPersisted: boolean): void;
+    private checkThinkLoop;
+    private checkToolLoop;
+    private checkSyntaxLoop;
+    private checkDeathSpiral;
+    private checkRepairFailure;
+    private checkCooldownAndNudge;
+    private triggerNudge;
+    getNudgeSuggestion(type: NudgeType, context?: Record<string, unknown>): string;
+    private hashArgs;
+    private isSimilarError;
+    private cleanupOldToolCalls;
+    reset(): void;
+    getStats(): {
+        thinkTags: number;
+        codeChanges: number;
+        explanations: number;
+        activePatterns: number;
+        lastNudgeAgo: number;
+    };
+    private log;
+}
+export declare const nudgeWatchdog: NudgeWatchdog;
+export declare function recordThinkTag(): void;
+export declare function recordCodeChange(): void;
+export declare function recordToolCall(tool: string, args: string): void;
+export declare function recordFixAttempt(filePath: string, error: string): void;
+export declare function recordExplanation(): void;
+export declare function getNudgeSuggestion(type: NudgeType, context?: Record<string, unknown>): string;
+export declare function getNudgeWatchdog(): NudgeWatchdog;
+export declare function recordProcessorFix(filePath: string, fixed: boolean, errorPersisted: boolean): void;
+export {};

package/dist/monitoring/test-auto-generation-monitor.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Test Auto-Generation Monitor
+ *
+ * Tracks and reports on test auto-generation activity.
+ * Provides metrics on test creation success/failure rates.
+ *
+ * @since 2026-02-22
+ */
+export interface TestGenerationMetrics {
+    totalFilesProcessed: number;
+    testsGenerated: number;
+    testsSkipped: number;
+    testsFailed: number;
+    startTime: number;
+    lastGenerationTime: number | null;
+}
+export interface TestGenerationEvent {
+    type: "generated" | "skipped" | "failed";
+    filePath: string;
+    testFile: string | null;
+    timestamp: number;
+    reason?: string;
+}
+declare class TestAutoGenerationMonitor {
+    private metrics;
+    private events;
+    private maxEvents;
+    private metricsFile;
+    constructor(metricsDir?: string);
+    /**
+     * Load metrics from disk if they exist
+     */
+    private loadMetrics;
+    /**
+     * Save metrics to disk
+     */
+    private saveMetrics;
+    /**
+     * Record a test generation event
+     */
+    recordEvent(event: TestGenerationEvent): void;
+    /**
+     * Get current metrics
+     */
+    getMetrics(): TestGenerationMetrics;
+    /**
+     * Get recent events
+     */
+    getRecentEvents(count?: number): TestGenerationEvent[];
+    /**
+     * Get success rate as percentage
+     */
+    getSuccessRate(): number;
+    /**
+     * Generate a status report
+     */
+    generateReport(): string;
+    /**
+     * Reset metrics (for testing)
+     */
+    reset(): void;
+}
+export declare const testAutoGenerationMonitor: TestAutoGenerationMonitor;
+export {};

package/dist/nucleus/autonomy-kernel.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Lead-dev plan builder — internal implementation for orchestrator + hooks.
+ * Config: features.json → multi_agent_orchestration (lead_dev_mode), NOT a separate surface.
+ */
+export declare const LEAD_DEV_RULES: readonly ["Phased plan + detailed todos; assign best subagent; monitor output; iterate fully", "Lead dev takes helm — loop test fix until complete; no permission pings", "Per-suite test triage after major changes; full suite only when individuals pass", "Lead stays main thread; subagents execute; update todos continuously", "Read all console and test output; triage fix rerun", "Never defer errors as pre-existing — add todo and resolve", "Resolve all errors before phase completion"];
+export declare const MANDATORY_MAJOR_CONSULTS: readonly ["researcher", "architect-tools", "code-review"];
+export type SubagentRoute = 'strategist' | 'architect-tools' | 'researcher' | 'backend-engineer' | 'frontend-engineer' | 'bug-triage' | 'code-review' | 'security-audit' | 'enforcer';
+export interface LeadDevTodo {
+    id: string;
+    task: string;
+    subagent: SubagentRoute;
+    status: 'pending' | 'in_progress' | 'completed';
+}
+export interface LeadDevPhase {
+    id: string;
+    name: string;
+    goal: string;
+    definitionOfDone: string;
+    todos: LeadDevTodo[];
+}
+export interface LeadDevPlan {
+    active: boolean;
+    rules: readonly string[];
+    codexTerms: [59, 67, 68, 69];
+    description: string;
+    complexity: number;
+    requiresPhasedPlan: boolean;
+    recommendedStrategy: string;
+    mandatoryConsults: string[];
+    phases: LeadDevPhase[];
+    testProtocol: {
+        perSuiteFirst: boolean;
+        fullSuiteGate: boolean;
+        hint: string;
+    };
+}
+export declare function isLeadDevModeActive(): boolean;
+export declare function routeSubagent(taskType: string): SubagentRoute;
+export declare function shouldFlagFullTestSuite(command: string): boolean;
+export declare function buildLeadDevPlan(description: string, taskTypes?: string[]): LeadDevPlan | null;
+export declare function buildSessionBootContext(): Record<string, unknown>;
+/** Persist plan for PreToolUse spawn_subagent gate */
+export declare function persistLeadDevPlan(plan: LeadDevPlan, projectRoot?: string): string;
+/** @deprecated Use isLeadDevModeActive */
+export declare const isAutonomyKernelActive: typeof isLeadDevModeActive;
+/** @deprecated Use buildLeadDevPlan */
+export declare const buildAutonomyIntake: typeof buildLeadDevPlan;
+export declare const AUTONOMY_RULES: readonly ["Phased plan + detailed todos; assign best subagent; monitor output; iterate fully", "Lead dev takes helm — loop test fix until complete; no permission pings", "Per-suite test triage after major changes; full suite only when individuals pass", "Lead stays main thread; subagents execute; update todos continuously", "Read all console and test output; triage fix rerun", "Never defer errors as pre-existing — add todo and resolve", "Resolve all errors before phase completion"];

package/dist/nucleus/default-plugins.d.ts

@@ -0,0 +1,17 @@
+/**
+ * DefaultPlugins — Phase 2C: centralized bootstrap for all knowledge-skill
+ * servers as SkillToolPlugin registrations.
+ *
+ * Exports registerDefaultPlugins() which is called once at boot to register
+ * all 24 knowledge-skill MCP servers (plus the researcher) as in-process
+ * plugin tools, making them dispatchable without MCP transport.
+ */
+export interface DefaultPluginsResult {
+    registered: number;
+    failed: string[];
+}
+/**
+ * Register all knowledge-skill servers as SkillToolPlugins.
+ * Called once at boot. Returns counts of registered and failed servers.
+ */
+export declare function registerDefaultPlugins(): Promise<DefaultPluginsResult>;

package/dist/nucleus/govern-http.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Nucleus HTTP Adapter — semantic convenience surface (Phase 0)
+ *
+ * IMPORTANT: MCP is the new standard (just as Dynamo is the established standard
+ * for the external governance signal). The canonical way for agents to call the
+ * nucleus is the first-class MCP tools (`govern_proposals`, `govern_reflection`)
+ * exposed by the governance MCP server (which already supports stdio + Streamable
+ * HTTP transport on /mcp and already delegates to the same GovernanceService).
+ *
+ * This module provides the *direct semantic convenience adapter*:
+ * - Pure `handleGovernRequest(body)` → returns the raw GovernanceResponse object.
+ * - Optional tiny Express app with `POST /govern` (and /health).
+ * - No full MCP JSON-RPC protocol overhead — ideal for curl, CI, simple bridges,
+ *   or anything that just wants the decision without speaking MCP.
+ *
+ * It reuses the exact same kernel (getGovernanceService + types) as the MCP path.
+ * Zero impact on the federation or existing MCP surfaces.
+ *
+ * Design goals:
+ * - Framework-agnostic pure handler (usable by Express, Fastify, raw http, tests, or in-process).
+ * - Only frameworkLogger.
+ * - Follows the thin-wrapper style of APITrigger.
+ *
+ * Usage (embeddable / in-process):
+ *   import { handleGovernRequest } from './nucleus/govern-http.js';
+ *   const result = await handleGovernRequest(req.body);
+ *
+ * Usage (standalone):
+ *   NUCLEUS_PORT=8787 node dist/nucleus/govern-http.js
+ */
+import express from 'express';
+import type { GovernanceResponse } from '../governance/governance-types.js';
+export interface GovernHTTPConfig {
+    path?: string;
+    apiKey?: string;
+    enabled?: boolean;
+    port?: number;
+}
+/**
+ * Pure handler. Can be used by any HTTP server (Express, Fastify, raw http, etc.)
+ * or called directly in tests / in-process.
+ */
+export declare function handleGovernRequest(body: unknown, options?: {
+    requireExternalDynamo?: boolean;
+}): Promise<GovernanceResponse>;
+/**
+ * Minimal Express app (prototype only).
+ * Mirrors the shape and logging discipline of APITrigger.
+ */
+export declare class GovernHTTPAdapter {
+    private app;
+    private config;
+    private initialized;
+    constructor(config?: GovernHTTPConfig);
+    initialize(): Promise<void>;
+    getApp(): express.Application;
+    listen(): Promise<void>;
+    shutdown(): void;
+}

package/dist/nucleus/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * xray Nucleus — barrel export
+ *
+ * Import from here for the stable nucleus surface:
+ *   import { handleGovernRequest, governSingle } from './nucleus/index.js';
+ */
+export { handleGovernRequest, governSingle, getGovernanceService, GovernHTTPAdapter, NUCLEUS_VERSION, NUCLEUS_DESCRIPTION, } from './kernel.js';
+export type { GovernHTTPConfig } from './govern-http.js';
+export type { GovernanceRequest, GovernanceResponse, GovernanceProposal, GovernanceVote, GovernanceResult, GovernanceContext, GovernOptions, ProposalType, } from '../governance/governance-types.js';
+export { pluginRegistry, } from './plugin-registry.js';
+export type { SkillPlugin, SkillToolPlugin, SkillProposalArgs, SkillPluginResult, ToolDefinition, } from './plugin-registry.js';
+export { scoreComplexity, routeToAgent, scoreAndRoute } from './thin-dispatch.js';
+export type { ComplexityMetrics, ComplexityScore, ComplexityLevel, ComplexityThresholds, } from './thin-dispatch.js';
+export { NUCLEUS_THIN_DISPATCH_VERSION } from './thin-dispatch.js';
+export { LEAD_DEV_RULES, isLeadDevModeActive, buildLeadDevPlan, buildSessionBootContext, shouldFlagFullTestSuite, } from './autonomy-kernel.js';
+export { registerDefaultPlugins } from './default-plugins.js';
+export type { DefaultPluginsResult } from './default-plugins.js';

package/dist/nucleus/kernel.d.ts

@@ -0,0 +1,51 @@
+/**
+ * xray Nucleus — the callable governance kernel (Phase 1.1 facade)
+ *
+ * This is the primary, stable import surface for the v3 nucleus.
+ *
+ * Consumers (bridges, custom tools, the MCP governance server, future self-proposal
+ * engines, CLI, etc.) should import from here rather than reaching into
+ * governance-service.ts, govern-http.ts, or postprocessor internals directly.
+ *
+ * Goals:
+ * - Single place to import the core "govern" capability + supporting types.
+ * - Zero risk to the 41-server federation or existing bridges.
+ * - Easy to tree-shake / split later (e.g. "nucleus/core", "nucleus/http").
+ * - Documents the public kernel contract.
+ *
+ * Current surface (Phase 1.1):
+ * - handleGovernRequest: the pure semantic convenience handler (direct JSON in/out)
+ * - getGovernanceService: the underlying singleton (for advanced / in-process use)
+ * - Governance types
+ * - MetamorphosisEngine interface (for PostProcessor lifecycle integration)
+ *
+ * MCP remains the canonical standard surface (see governance.server.ts).
+ * The direct HTTP adapter (govern-http.ts) is a convenience on top of this kernel.
+ *
+ * Anti-goals (for this file):
+ * - No new business logic
+ * - No side effects on import
+ * - Does not pull in the full 25 knowledge-skill servers (dynamic via pluginRegistry only)
+ */
+import type { GovernOptions, GovernanceContext, GovernanceRequest, GovernanceResponse } from '../governance/governance-types.js';
+import { handleGovernRequest } from './govern-http.js';
+export { handleGovernRequest };
+export type { GovernHTTPConfig } from './govern-http.js';
+export { getGovernanceService } from '../governance/governance-service.js';
+export type { GovernanceRequest, GovernanceResponse, GovernanceProposal, GovernanceVote, GovernanceResult, GovernanceContext, GovernOptions, ProposalType, } from '../governance/governance-types.js';
+export type { MetamorphosisEngine, MetamorphosisProposal, } from '../types/metamorphosis.js';
+export { GovernHTTPAdapter } from './govern-http.js';
+export { pluginRegistry } from './plugin-registry.js';
+export type { SkillPlugin, SkillToolPlugin, SkillProposalArgs, SkillPluginResult } from './plugin-registry.js';
+/**
+ * High-level kernel description for introspection / docs.
+ */
+export declare const NUCLEUS_VERSION = "0.1.0";
+export declare const NUCLEUS_DESCRIPTION: string;
+/**
+ * Quick helper for the common case: govern a single proposal and get the overall decision.
+ * (Thin wrapper — real power users should use handleGovernRequest directly for batch + full response.)
+ */
+export declare function governSingle(proposal: Omit<GovernanceRequest['proposals'][0], 'id'> & {
+    id?: string;
+}, context?: GovernanceContext, options?: GovernOptions): Promise<GovernanceResponse>;

package/dist/nucleus/plugin-registry.d.ts

@@ -0,0 +1,132 @@
+/**
+ * PluginRegistry — Phase 1.2 dynamic skill loading + Phase 3 generic tool dispatch
+ *
+ * Allows skills to be registered after boot, loaded from config, or discovered
+ * at runtime. Wraps the existing in-process-skill-registry for backward compat.
+ *
+ * Phase 3 extension: SkillToolPlugin interface for multi-tool skills (knowledge-skill
+ * servers). Each server registers as a SkillToolPlugin, exposing arbitrary tools
+ * that can be dispatched via callSkillTool().
+ *
+ * Goals:
+ * - New skills can be registered post-boot via register()
+ * - Skills are discoverable by name without importing server constructors
+ * - Default set loads automatically from the existing 3 governance skills
+ * - Multi-tool skills can be registered and dispatched via callSkillTool()
+ * - Backward compatible: callInProcessSkill still works as before
+ */
+export interface SkillPlugin {
+    /** Unique skill name (e.g. "code-review", "security-audit") */
+    name: string;
+    /** Handler that processes proposals */
+    analyzeProposal(args: SkillProposalArgs): Promise<SkillPluginResult>;
+}
+/**
+ * Metadata describing a tool exposed by a SkillToolPlugin.
+ */
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    inputSchema?: Record<string, unknown>;
+}
+/**
+ * Extended plugin interface for knowledge-skill servers that expose multiple tools.
+ * Each tool is a named function that accepts arbitrary args.
+ */
+export interface SkillToolPlugin {
+    /** Unique skill name (e.g. "code-review", "api-design") */
+    name: string;
+    /** Dispatch a named tool with arbitrary args */
+    callTool(toolName: string, args: Record<string, unknown>): Promise<unknown>;
+    /** Optional: list tool definitions for dynamic discovery */
+    listTools?(): ToolDefinition[];
+}
+export interface SkillProposalArgs {
+    proposalTitle?: string;
+    proposalDescription?: string;
+    evidence?: string[];
+    proposalType?: string;
+}
+export interface SkillPluginResult {
+    content: Array<{
+        type: string;
+        text: string;
+    }>;
+}
+type SkillHandler = (args: SkillProposalArgs) => Promise<SkillPluginResult>;
+declare class PluginRegistryImpl {
+    private skills;
+    /** Phase 3: multi-tool skill plugins (knowledge-skill servers) */
+    private toolPlugins;
+    private initialized;
+    /**
+     * Register a skill plugin. Can be called after boot.
+     */
+    register(skill: SkillPlugin): void;
+    /**
+     * Register a multi-tool skill plugin (knowledge-skill server).
+     * Tools can be dispatched via callSkillTool().
+     */
+    registerToolPlugin(skill: SkillToolPlugin): void;
+    /**
+     * Call a named tool on a registered multi-tool skill plugin.
+     */
+    callSkillTool(skillName: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Check if a tool plugin is registered.
+     */
+    hasToolPlugin(name: string): boolean;
+    /**
+     * List all registered tool plugin names.
+     */
+    listToolPlugins(): string[];
+    /**
+     * Get a registered tool plugin by name for introspection.
+     */
+    getToolPlugin(name: string): SkillToolPlugin | undefined;
+    /**
+     * List tool definitions for a registered tool plugin.
+     * Returns empty array if plugin not found or does not expose listTools().
+     */
+    listSkillTools(skillName: string): ToolDefinition[];
+    /**
+     * Convenience: register a server as a SkillToolPlugin.
+     * Wraps a server with named tools into the SkillToolPlugin interface.
+     */
+    registerServer(server: {
+        name: string;
+        tools: ToolDefinition[];
+        callTool: (toolName: string, args: Record<string, unknown>) => Promise<unknown>;
+    }): void;
+    /**
+     * Get a skill handler by name. Falls back to the in-process registry
+     * for the built-in governance skills (code-review, security-audit, researcher).
+     */
+    get(name: string): SkillHandler | undefined;
+    /**
+     * Check if a skill is registered (either in the plugin registry or the built-in registry).
+     */
+    has(name: string): boolean;
+    /**
+     * List all registered skill names (plugins + built-in).
+     */
+    list(): string[];
+    /**
+     * Call a skill by name. Delegates to the plugin registry first,
+     * then falls back to the built-in in-process registry.
+     */
+    callSkill(name: string, args: SkillProposalArgs): Promise<SkillPluginResult>;
+    /**
+     * Initialize with default governance skills. Called once at boot.
+     * The 3 governance skills are always available via the built-in registry.
+     */
+    initializeDefaults(): void;
+    /**
+     * Reset the registry for testing. Removes all registered plugins
+     * (built-in governance skills remain available via fallback).
+     */
+    resetForTest(): void;
+}
+/** Singleton plugin registry */
+export declare const pluginRegistry: PluginRegistryImpl;
+export {};

package/dist/nucleus/thin-dispatch.d.ts

@@ -0,0 +1,33 @@
+/**
+ * xray Nucleus — thinDispatch (Phase 1E)
+ *
+ * Stable nucleus surface for complexity scoring and agent routing.
+ * Wraps ComplexityAnalyzer; delegates routing to complexity-core utilities.
+ *
+ * Import from here or from delegation/index.ts (which re-exports these).
+ */
+import { ComplexityMetrics, ComplexityScore, ComplexityLevel, ComplexityThresholds } from "../delegation/complexity-core.js";
+export type { ComplexityMetrics, ComplexityScore, ComplexityLevel, ComplexityThresholds };
+export declare const NUCLEUS_THIN_DISPATCH_VERSION = "0.1.0";
+/**
+ * Score the complexity of an operation given its description and context.
+ * Primary entry point for thinDispatch complexity scoring in the nucleus.
+ */
+export declare function scoreComplexity(operation: string, context: unknown, thresholds?: ComplexityThresholds): ComplexityScore;
+/**
+ * Route a complexity score / level to the appropriate agent type.
+ * Uses core complexity-core mappings (tier → agent).
+ */
+export declare function routeToAgent(scoreOrLevel: number | ComplexityScore, level?: ComplexityLevel): string;
+/**
+ * Convenience: score first, then route — one call.
+ */
+export declare function scoreAndRoute(operation: string, context: unknown, thresholds?: ComplexityThresholds): {
+    score: ComplexityScore;
+    agent: string;
+    memoryRouting?: {
+        providerId: string;
+        adjustedScore: number;
+        signals: string[];
+    };
+};

package/dist/orchestrator/agent-spawn-governor.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Agent Spawn Governor
+ *
+ * Critical governance component that prevents infinite agent spawning
+ * and enforces spawn limits across the multi-agent orchestration system.
+ *
+ * @since 2026-01-23
+ */
+export interface SpawnContext {
+    agentType: string;
+    parentAgent?: string;
+    operation?: string;
+    triggeredBy?: string;
+    sessionId?: string;
+    priority?: "high" | "medium" | "low";
+}
+export interface SpawnRecord {
+    id: string;
+    agentType: string;
+    parentAgent?: string | undefined;
+    timestamp: number;
+    status: "active" | "completed" | "failed" | "terminated";
+    context: SpawnContext;
+}
+export interface SpawnLimits {
+    perAgentType: Record<string, number>;
+    totalConcurrent: number;
+    spawnRateLimit: {
+        maxPerMinute: number;
+        windowMs: number;
+    };
+    memoryLimit: {
+        maxMemoryMB: number;
+        emergencyThresholdMB: number;
+        cleanupIntervalMs: number;
+    };
+}
+export interface SpawnAuthorization {
+    authorized: boolean;
+    trackingId?: string;
+    reason?: string;
+    warnings?: string[];
+}
+export declare class AgentSpawnGovernor {
+    private limits;
+    private activeAgents;
+    private spawnHistory;
+    private readonly maxHistorySize;
+    private readonly cleanupInterval;
+    private readonly persistenceTimeout;
+    private readonly maxRetries;
+    private readonly retryDelay;
+    private cleanupTimer?;
+    private memoryMonitorInterval?;
+    private authorizationQueue;
+    private isProcessingAuthorization;
+    private getDefaultLimits;
+    private readonly defaultLimits;
+    constructor(limits?: Partial<SpawnLimits>, autoStart?: boolean);
+    private startPeriodicCleanup;
+    private startMemoryMonitoring;
+    private checkMemoryBudget;
+    private emergencyMemoryCleanup;
+    private aggressiveCleanup;
+    private deepCleanupContexts;
+    private sanitizeContext;
+    /**
+     * Authorize a new agent spawn
+     */
+    authorizeSpawn(context: SpawnContext): Promise<SpawnAuthorization>;
+    private processNextAuthorization;
+    private performAuthorization;
+    private checkAgentLimitsWithRetry;
+    private getTotalActiveWithRetry;
+    private registerSpawnWithRetry;
+    private handleAuthorizationError;
+    private categorizeError;
+    private emergencyCleanup;
+    /**
+     * Complete an agent spawn (mark as completed)
+     */
+    completeSpawn(trackingId: string, result?: boolean): Promise<void>;
+    /**
+     * Fail an agent spawn
+     */
+    failSpawn(trackingId: string, error?: Error): Promise<void>;
+    /**
+     * Terminate an agent spawn (force stop)
+     */
+    terminateSpawn(trackingId: string, reason?: string): Promise<void>;
+    /**
+     * Get current active count for agent type
+     */
+    getActiveCount(agentType: string): number;
+    /**
+     * Get total active agents system-wide
+     */
+    getTotalActive(): number;
+    /**
+     * Get spawn statistics
+     */
+    getSpawnStats(): {
+        perAgentType: Record<string, {
+            active: number;
+            total: number;
+        }>;
+        totalActive: number;
+        totalHistory: number;
+    };
+    /**
+     * Emergency: Terminate all active agents
+     */
+    emergencyShutdown(reason?: string): Promise<void>;
+    private registerSpawn;
+    private checkSpawnRateLimit;
+    private detectInfiniteSpawn;
+    private getRecentSpawns;
+    private findRecord;
+    private generateTrackingId;
+    private cleanupOldRecords;
+    private withTimeout;
+    private withRetry;
+    start(): void;
+    destroy(): void;
+}
+export declare const agentSpawnGovernor: AgentSpawnGovernor;