arbiter-ai 1.0.3 → 1.0.5

package/dist/index.js

@@ -1,10 +1,49 @@
 #!/usr/bin/env node
 // Main entry point for the Arbiter system
 // Ties together state, router, and TUI for the hierarchical AI orchestration system
+import fs from 'node:fs';
 import { Router } from './router.js';
 import { loadSession } from './session-persistence.js';
 import { createInitialState } from './state.js';
 import { checkGitignore, createTUI, showCharacterSelect, showForestIntro, showTitleScreen, } from './tui/index.js';
+import { getAllSprites } from './tui/animation-loop.js';
+import { TILE } from './tui/tileset.js';
+/**
+ * Get package.json version
+ */
+function getVersion() {
+    const pkgPath = new URL('../package.json', import.meta.url);
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+    return pkg.version;
+}
+/**
+ * Print help message and exit
+ */
+function printHelp() {
+    console.log(`
+arbiter - Hierarchical AI orchestration system
+
+  Consult with the Arbiter, a wise overseer who commands a
+  council of Orchestrators to tackle complex tasks. Each layer
+  extends Claude's context, keeping the work on track. Bring
+  a detailed markdown description of your requirements.
+
+USAGE
+  arbiter [options] [requirements-file]
+
+OPTIONS
+  -h, --help           Show this help message
+  -v, --version        Show version number
+  --resume             Resume from saved session (if <24h old)
+  --demo-animations    Run animation demo (skip intro screens and router)
+
+EXAMPLES
+  arbiter                   Start fresh session
+  arbiter ./SPEC.md         Start with requirements file (skip in-game prompt)
+  arbiter --resume          Resume previous session
+  arbiter --demo-animations Run animation demo
+`);
+}
 /**
  * Outputs session information to stderr for resume capability
  * Format per architecture doc:
@@ -19,6 +58,89 @@ function outputSessionInfo(state) {
     // Output to stderr so it doesn't interfere with TUI output
     process.stderr.write(`${JSON.stringify(sessionInfo)}\n`);
 }
+/**
+ * Helper function to create a delay promise
+ */
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Runs a demo sequence showing all animations
+ * Used when --demo-animations flag is passed
+ */
+async function runDemoSequence() {
+    // Wait for TUI to fully initialize and sprites to be registered
+    await delay(1500);
+    // Get all registered sprites
+    const sprites = getAllSprites();
+    const human = sprites.find((s) => s.id === 'human');
+    const arbiter = sprites.find((s) => s.id === 'arbiter');
+    const scroll = sprites.find((s) => s.id === 'scroll');
+    const spellbook = sprites.find((s) => s.id === 'spellbook');
+    const smoke = sprites.find((s) => s.id === 'smoke');
+    const demons = sprites.filter((s) => s.id.startsWith('demon-'));
+    if (!human || !arbiter || !scroll || !spellbook || !smoke) {
+        process.stderr.write('Demo: Failed to find required sprites\n');
+        process.exit(1);
+    }
+    // Demo entrance sequence - human walks in
+    await human.walk({ row: 2, col: 1 });
+    await delay(300);
+    // Human hops (surprised)
+    await human.hop(2);
+    await delay(300);
+    // Arbiter hops (notices visitor)
+    await arbiter.hop(2);
+    await delay(500);
+    // Demo scroll drop
+    await scroll.physicalSpawn();
+    await delay(500);
+    // Demo arbiter walks to scroll
+    await arbiter.walk({ row: 2, col: 3 });
+    await delay(300);
+    // Arbiter notices scroll (alarmed)
+    await arbiter.alarmed(1500);
+    await delay(500);
+    // Demo summon sequence - arbiter walks to fire for summoning
+    await arbiter.walk({ row: 3, col: 4 });
+    await delay(300);
+    // Spellbook appears
+    await spellbook.physicalSpawn();
+    await delay(500);
+    // Demo cauldron bubbling
+    smoke.startBubbling();
+    await delay(1000);
+    // Spawn demons one by one with magic effect
+    for (let i = 0; i < Math.min(3, demons.length); i++) {
+        await demons[i].magicSpawn();
+        await delay(500);
+    }
+    await delay(1500);
+    // Demo hopping while working
+    await arbiter.hop(4);
+    await delay(1000);
+    // Demo dismiss sequence
+    for (const demon of demons.filter((d) => d.visible)) {
+        await demon.magicDespawn();
+        await delay(300);
+    }
+    // Stop bubbling
+    smoke.stopBubbling();
+    await delay(500);
+    // Hide spellbook
+    spellbook.visible = false;
+    await delay(500);
+    // Walk back
+    await arbiter.walk({ row: 2, col: 3 });
+    await delay(500);
+    // Demo chat indicator
+    await arbiter.chatting(2000);
+    await delay(500);
+    // Demo complete - wait a moment then exit
+    await delay(2000);
+    // Exit cleanly
+    process.exit(0);
+}
 /**
  * Main application entry point
  * Creates and wires together all components of the Arbiter system
@@ -64,6 +186,44 @@ async function main() {
     try {
         // Parse CLI arguments
         const args = process.argv.slice(2);
+        // Handle --help flag (early exit)
+        if (args.includes('--help') || args.includes('-h')) {
+            printHelp();
+            process.exit(0);
+        }
+        // Handle --version flag (early exit)
+        if (args.includes('--version') || args.includes('-v')) {
+            console.log(getVersion());
+            process.exit(0);
+        }
+        // Handle --demo-animations flag (early exit)
+        const demoMode = args.includes('--demo-animations');
+        if (demoMode) {
+            // Demo mode: skip all intro screens and router initialization
+            // Go straight to main TUI with default character and run scripted animation demo
+            state = createInitialState();
+            // Set a requirements path to skip the requirements overlay prompt
+            state.requirementsPath = '/dev/null';
+            // Create TUI with default character
+            tui = createTUI(state, TILE.HUMAN_1);
+            // Wire TUI exit to shutdown
+            tui.onExit(() => {
+                shutdown(0);
+            });
+            // Start TUI (takes over terminal)
+            tui.start();
+            // Fire-and-forget the requirements ready callback (skips requirement selection)
+            tui.onRequirementsReady(() => {
+                // No-op since we're not starting the router
+            });
+            // Run demo sequence after TUI initializes
+            runDemoSequence();
+            // Keep the process running until demo completes
+            await new Promise(() => {
+                // This promise never resolves - demo will exit via process.exit(0)
+            });
+            return;
+        }
         const shouldResume = args.includes('--resume');
         // Handle --resume flag
         let savedSession = null;
@@ -74,7 +234,7 @@ async function main() {
             }
         }
         // Check for positional requirements file argument (first non-flag arg)
-        const positionalArgs = args.filter((arg) => !arg.startsWith('--'));
+        const positionalArgs = args.filter((arg) => !arg.startsWith('--') && !arg.startsWith('-'));
         const cliRequirementsFile = positionalArgs[0] || null;
         let selectedCharacter;
         if (savedSession) {

package/dist/router.d.ts

@@ -63,6 +63,7 @@ export declare class Router {
     private watchdogInterval;
     private arbiterMcpServer;
     private arbiterHooks;
+    private arbiterPollContext;
     private contextPollInterval;
     private crashCount;
     constructor(state: AppState, callbacks: RouterCallbacks);
@@ -77,7 +78,7 @@ export declare class Router {
     private startContextPolling;
     /**
      * Poll context for all active sessions
-     * Forks sessions and runs /context to get accurate values
+     * Uses paired pollers that share the same options as the sessions
      */
     private pollAllContexts;
     /**
@@ -127,17 +128,15 @@ export declare class Router {
     private createOrchestratorOptions;
     /**
      * Creates and starts the Arbiter session with MCP tools
+     * @param resumeSessionId - Optional session ID for resuming an existing session
      */
     private startArbiterSession;
     /**
      * Creates and starts an Orchestrator session
+     * @param number - The orchestrator number (I, II, III...)
+     * @param resumeSessionId - Optional session ID for resuming an existing session
      */
     private startOrchestratorSession;
-    /**
-     * Resume an existing Orchestrator session
-     * Similar to startOrchestratorSession but uses resume option and skips introduction
-     */
-    private resumeOrchestratorSession;
     /**
      * Send a message to the Arbiter
      */

package/dist/router.js

@@ -11,6 +11,49 @@ function sleep(ms) {
 // Retry constants for crash recovery
 const MAX_RETRIES = 3;
 const RETRY_DELAYS = [1000, 2000, 4000]; // 1s, 2s, 4s exponential backoff
+/**
+ * Creates a query and a paired context poller that uses the same options.
+ * This ensures context polling always matches the session's actual configuration.
+ *
+ * @param prompt - Initial prompt for the session
+ * @param options - Options used to create the session (will also be used for polling)
+ * @returns Tuple of [query generator, context polling function]
+ */
+function createQueryWithPoller(prompt, options) {
+    const q = query({ prompt, options });
+    const pollContext = async (sessionId) => {
+        try {
+            const pollQuery = query({
+                prompt: '/context',
+                options: {
+                    ...options,
+                    resume: sessionId,
+                    forkSession: true, // Fork to avoid polluting main session
+                },
+            });
+            let percent = null;
+            for await (const msg of pollQuery) {
+                // /context output comes through as user message with the token info
+                if (msg.type === 'user') {
+                    const content = msg.message?.content;
+                    if (typeof content === 'string') {
+                        // Match: **Tokens:** 18.4k / 200.0k (9%)
+                        const match = content.match(/\*\*Tokens:\*\*\s*([0-9.]+)k\s*\/\s*200\.?0?k\s*\((\d+)%\)/i);
+                        if (match) {
+                            percent = parseInt(match[2], 10);
+                        }
+                    }
+                }
+            }
+            return percent;
+        }
+        catch (_error) {
+            // Silently fail - context polling is best-effort
+            return null;
+        }
+    };
+    return [q, pollContext];
+}
 // Arbiter's allowed tools: MCP tools + read-only exploration
 const ARBITER_ALLOWED_TOOLS = [
     'mcp__arbiter-tools__spawn_orchestrator',
@@ -55,45 +98,6 @@ import { createOrchestratorHooks, ORCHESTRATOR_SYSTEM_PROMPT, } from './orchestr
 const MAX_CONTEXT_TOKENS = 200000;
 // Context polling interval (1 minute)
 const CONTEXT_POLL_INTERVAL_MS = 60_000;
-/**
- * Poll context usage by forking a session and running /context
- * Uses forkSession: true to avoid polluting the main conversation
- * Note: This does clutter resume history - no workaround found yet
- *
- * @param sessionId - The session ID to fork and check
- * @returns Context percentage (0-100) or null if polling failed
- */
-async function pollContextForSession(sessionId) {
-    try {
-        const q = query({
-            prompt: '/context',
-            options: {
-                resume: sessionId,
-                forkSession: true, // Fork to avoid polluting main session
-                permissionMode: 'bypassPermissions',
-            },
-        });
-        let percent = null;
-        for await (const msg of q) {
-            // /context output comes through as user message with the token info
-            if (msg.type === 'user') {
-                const content = msg.message?.content;
-                if (typeof content === 'string') {
-                    // Match: **Tokens:** 18.4k / 200.0k (9%)
-                    const match = content.match(/\*\*Tokens:\*\*\s*([0-9.]+)k\s*\/\s*200\.?0?k\s*\((\d+)%\)/i);
-                    if (match) {
-                        percent = parseInt(match[2], 10);
-                    }
-                }
-            }
-        }
-        return percent;
-    }
-    catch (_error) {
-        // Silently fail - context polling is best-effort
-        return null;
-    }
-}
 /**
  * Formats an SDK message for debug logging
  * Returns a human-readable string representation of the message
@@ -263,6 +267,8 @@ export class Router {
     arbiterMcpServer = null;
     // Store Arbiter hooks for session resumption
     arbiterHooks = null;
+    // Paired context poller for Arbiter (uses same options as session)
+    arbiterPollContext = null;
     // Context polling timer - polls /context once per minute via session forking
     contextPollInterval = null;
     // Track crash recovery attempts for TUI display
@@ -295,12 +301,12 @@ export class Router {
     }
     /**
      * Poll context for all active sessions
-     * Forks sessions and runs /context to get accurate values
+     * Uses paired pollers that share the same options as the sessions
      */
     async pollAllContexts() {
-        // Poll Arbiter context
-        if (this.state.arbiterSessionId) {
-            const arbiterPercent = await pollContextForSession(this.state.arbiterSessionId);
+        // Poll Arbiter context using paired poller
+        if (this.state.arbiterSessionId && this.arbiterPollContext) {
+            const arbiterPercent = await this.arbiterPollContext(this.state.arbiterSessionId);
             if (arbiterPercent !== null) {
                 updateArbiterContext(this.state, arbiterPercent);
                 this.callbacks.onDebugLog?.({
@@ -310,10 +316,11 @@ export class Router {
                 });
             }
         }
-        // Poll Orchestrator context if active
+        // Poll Orchestrator context using paired poller
         let orchPercent = null;
-        if (this.currentOrchestratorSession?.sessionId) {
-            orchPercent = await pollContextForSession(this.currentOrchestratorSession.sessionId);
+        const orchSession = this.currentOrchestratorSession;
+        if (orchSession?.sessionId && orchSession.pollContext) {
+            orchPercent = await orchSession.pollContext(orchSession.sessionId);
             if (orchPercent !== null) {
                 updateOrchestratorContext(this.state, orchPercent);
                 this.callbacks.onDebugLog?.({
@@ -330,13 +337,11 @@ export class Router {
      * Resume from a previously saved session
      */
     async resumeFromSavedSession(saved) {
-        // Set arbiter session ID so startArbiterSession uses resume
-        this.state.arbiterSessionId = saved.arbiterSessionId;
-        // Start arbiter (it will use the session ID for resume)
-        await this.startArbiterSession();
+        // Start arbiter with resume session ID
+        await this.startArbiterSession(saved.arbiterSessionId);
         // If there was an active orchestrator, resume it too
         if (saved.orchestratorSessionId && saved.orchestratorNumber) {
-            await this.resumeOrchestratorSession(saved.orchestratorSessionId, saved.orchestratorNumber);
+            await this.startOrchestratorSession(saved.orchestratorNumber, saved.orchestratorSessionId);
         }
         // Start context polling
         this.startContextPolling();
@@ -488,6 +493,7 @@ export class Router {
             hooks: this.arbiterHooks ?? undefined,
             abortController: this.arbiterAbortController ?? new AbortController(),
             permissionMode: 'bypassPermissions',
+            settingSources: ['project'], // Load CLAUDE.md for project context
             allowedTools: [...ARBITER_ALLOWED_TOOLS],
             ...(resumeSessionId ? { resume: resumeSessionId } : {}),
         };
@@ -505,6 +511,7 @@ export class Router {
             hooks,
             abortController,
             permissionMode: 'bypassPermissions',
+            settingSources: ['project'], // Load CLAUDE.md for project context
             allowedTools: [...ORCHESTRATOR_ALLOWED_TOOLS],
             outputFormat: {
                 type: 'json_schema',
@@ -515,8 +522,9 @@ export class Router {
     }
     /**
      * Creates and starts the Arbiter session with MCP tools
+     * @param resumeSessionId - Optional session ID for resuming an existing session
      */
-    async startArbiterSession() {
+    async startArbiterSession(resumeSessionId) {
         // Notify that we're waiting for Arbiter
         this.callbacks.onWaitingStart?.('arbiter');
         // Create abort controller for this session
@@ -554,12 +562,12 @@ export class Router {
         const hooks = createArbiterHooks(arbiterHooksCallbacks);
         this.arbiterHooks = hooks;
         // Create options using helper
-        const options = this.createArbiterOptions(this.state.arbiterSessionId ?? undefined);
-        // Note: The Arbiter session runs continuously.
-        // We'll send messages to it and process responses in a loop.
-        // Create initial prompt - reference requirements file if provided
-        const initialPrompt = this.state.requirementsPath
-            ? `@${this.state.requirementsPath}
+        const options = this.createArbiterOptions(resumeSessionId);
+        // Choose prompt based on whether resuming or starting fresh
+        const prompt = resumeSessionId
+            ? '[System: Session resumed. Continue where you left off.]'
+            : this.state.requirementsPath
+                ? `@${this.state.requirementsPath}
 
 A Scroll of Requirements has been presented.
 
@@ -578,23 +586,28 @@ Your task now is to achieve COMPLETE UNDERSTANDING before any work begins. This
 Only when we have achieved 100% alignment on vision, scope, and approach - only when you could explain this task to an Orchestrator with complete confidence - only then do we proceed.
 
 Take your time. This phase determines everything that follows.`
-            : 'Speak, mortal.';
-        this.arbiterQuery = query({
-            prompt: initialPrompt,
-            options,
-        });
+                : 'Speak, mortal.';
+        const [arbiterQuery, pollContext] = createQueryWithPoller(prompt, options);
+        this.arbiterQuery = arbiterQuery;
+        this.arbiterPollContext = pollContext;
+        // Store session ID if resuming (will be updated from init message if new)
+        if (resumeSessionId) {
+            this.state.arbiterSessionId = resumeSessionId;
+        }
         // Process the initial response
         await this.processArbiterMessages(this.arbiterQuery);
     }
     /**
      * Creates and starts an Orchestrator session
+     * @param number - The orchestrator number (I, II, III...)
+     * @param resumeSessionId - Optional session ID for resuming an existing session
      */
-    async startOrchestratorSession(number) {
-        // Clean up any existing orchestrator before spawning new one (hard abort)
+    async startOrchestratorSession(number, resumeSessionId) {
+        // Clean up any existing orchestrator before spawning/resuming
         this.cleanupOrchestrator();
         // Notify that we're waiting for Orchestrator
         this.callbacks.onWaitingStart?.('orchestrator');
-        // Increment orchestrator count
+        // Set orchestrator count
         this.orchestratorCount = number;
         // Generate unique ID for this orchestrator
         const orchId = `orch-${Date.now()}`;
@@ -630,113 +643,31 @@ Take your time. This phase determines everything that follows.`
         const hooks = createOrchestratorHooks(orchestratorCallbacks, 
         // Context percent getter - returns state value (updated by polling)
         (_sessionId) => this.state.currentOrchestrator?.contextPercent || 0);
-        // Create options using helper (no resume for initial session)
-        const options = this.createOrchestratorOptions(hooks, abortController);
-        // Create the orchestrator query
-        const orchestratorQuery = query({
-            prompt: 'Introduce yourself and await instructions from the Arbiter.',
-            options,
-        });
-        // Create the full OrchestratorSession object
-        this.currentOrchestratorSession = {
-            id: orchId,
-            number,
-            sessionId: '', // Will be set when we get the init message
-            query: orchestratorQuery,
-            abortController,
-            toolCallCount: 0,
-            queue: [],
-            lastActivityTime: Date.now(),
-            hooks,
-        };
-        // Set up TUI-facing orchestrator state before processing
-        // We'll update the session ID when we get the init message
-        setCurrentOrchestrator(this.state, {
-            id: orchId,
-            sessionId: '', // Will be set when we get the init message
-            number,
-        });
-        // Switch mode
-        setMode(this.state, 'arbiter_to_orchestrator');
-        this.callbacks.onModeChange('arbiter_to_orchestrator');
-        // Notify about orchestrator spawn (for tile scene demon spawning)
-        this.callbacks.onOrchestratorSpawn?.(number);
-        // Update context display to show orchestrator (initially at 0%)
-        this.callbacks.onContextUpdate(this.state.arbiterContextPercent, this.state.currentOrchestrator?.contextPercent ?? null);
-        // Start watchdog timer
-        this.startWatchdog();
-        // Process orchestrator messages
-        await this.processOrchestratorMessages(this.currentOrchestratorSession.query);
-    }
-    /**
-     * Resume an existing Orchestrator session
-     * Similar to startOrchestratorSession but uses resume option and skips introduction
-     */
-    async resumeOrchestratorSession(sessionId, number) {
-        // Clean up any existing orchestrator before resuming
-        this.cleanupOrchestrator();
-        // Notify that we're waiting for Orchestrator
-        this.callbacks.onWaitingStart?.('orchestrator');
-        // Restore orchestrator count
-        this.orchestratorCount = number;
-        // Generate unique ID for this orchestrator
-        const orchId = `orch-${Date.now()}`;
-        // Create abort controller for this session
-        const abortController = new AbortController();
-        // Create callbacks for hooks
-        const orchestratorCallbacks = {
-            onContextUpdate: (_sessionId, _percent) => {
-                // Context is now tracked via periodic polling (pollAllContexts)
-                // This callback exists for hook compatibility but is unused
-            },
-            onToolUse: (tool) => {
-                // Increment tool count on the session
-                if (this.currentOrchestratorSession) {
-                    this.currentOrchestratorSession.toolCallCount++;
-                    const newCount = this.currentOrchestratorSession.toolCallCount;
-                    // Update state and notify callback
-                    updateOrchestratorTool(this.state, tool, newCount);
-                    this.callbacks.onToolUse(tool, newCount);
-                    // Log tool use to debug (logbook) with orchestrator context
-                    const conjuringLabel = `Conjuring ${toRoman(number)}`;
-                    this.callbacks.onDebugLog?.({
-                        type: 'tool',
-                        speaker: conjuringLabel,
-                        text: `[Tool] ${tool}`,
-                        details: { tool, count: newCount },
-                    });
-                }
-            },
-        };
-        // Create hooks for tool use tracking
-        // Context is now tracked via polling, not hooks
-        const hooks = createOrchestratorHooks(orchestratorCallbacks, 
-        // Context percent getter - returns state value (updated by polling)
-        (_sessionId) => this.state.currentOrchestrator?.contextPercent || 0);
-        // Create options using helper with resume
-        const options = this.createOrchestratorOptions(hooks, abortController, sessionId);
-        // Create the orchestrator query with a continuation prompt (not introduction)
-        const orchestratorQuery = query({
-            prompt: '[System: Session resumed. Continue where you left off.]',
-            options,
-        });
+        // Create options using helper
+        const options = this.createOrchestratorOptions(hooks, abortController, resumeSessionId);
+        // Choose prompt based on whether resuming or starting fresh
+        const prompt = resumeSessionId
+            ? '[System: Session resumed. Continue where you left off.]'
+            : 'Introduce yourself and await instructions from the Arbiter.';
+        // Create the orchestrator query with paired context poller
+        const [orchestratorQuery, pollContext] = createQueryWithPoller(prompt, options);
         // Create the full OrchestratorSession object
-        // Note: sessionId is already known from the saved session
         this.currentOrchestratorSession = {
             id: orchId,
             number,
-            sessionId: sessionId, // Already known, don't set to empty string
+            sessionId: resumeSessionId ?? '', // Known if resuming, will be set from init message if new
             query: orchestratorQuery,
             abortController,
             toolCallCount: 0,
             queue: [],
             lastActivityTime: Date.now(),
             hooks,
+            pollContext,
         };
         // Set up TUI-facing orchestrator state
         setCurrentOrchestrator(this.state, {
             id: orchId,
-            sessionId: sessionId,
+            sessionId: resumeSessionId ?? '',
             number,
         });
         // Switch mode

package/dist/tui/animation-loop.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Animation loop module for managing sprite animations
+ *
+ * This module provides a centralized animation tick system that manages
+ * a collection of sprites and updates them at ~60fps. It tracks actual
+ * delta time between ticks for smooth animations regardless of system load.
+ */
+import { Sprite } from './sprite.js';
+/**
+ * Register a sprite with the animation loop
+ *
+ * Once registered, the sprite's tick() method will be called
+ * on each animation frame with the elapsed time delta.
+ *
+ * @param sprite - The sprite to register
+ */
+export declare function registerSprite(sprite: Sprite): void;
+/**
+ * Unregister a sprite from the animation loop
+ *
+ * The sprite will no longer receive tick updates.
+ *
+ * @param id - The unique ID of the sprite to unregister
+ */
+export declare function unregisterSprite(id: string): void;
+/**
+ * Get a sprite by ID
+ *
+ * @param id - The unique ID of the sprite to retrieve
+ * @returns The sprite if found, or undefined if not registered
+ */
+export declare function getSprite(id: string): Sprite | undefined;
+/**
+ * Get all registered sprites
+ *
+ * @returns An array of all currently registered sprites
+ */
+export declare function getAllSprites(): Sprite[];
+/**
+ * Start the animation loop
+ *
+ * Runs at ~60fps (16ms interval) but tracks actual delta time
+ * for smooth animations. If the loop is already running, this
+ * function has no effect.
+ */
+export declare function startAnimationLoop(): void;
+/**
+ * Stop the animation loop
+ *
+ * Halts the animation tick. Sprites remain registered and can
+ * be resumed by calling startAnimationLoop() again.
+ */
+export declare function stopAnimationLoop(): void;
+/**
+ * Check if animation loop is running
+ *
+ * @returns true if the animation loop is currently active
+ */
+export declare function isAnimationLoopRunning(): boolean;
+/**
+ * Check if any registered sprite has an active animation
+ *
+ * @returns true if at least one sprite has a non-null animation
+ */
+export declare function hasActiveAnimations(): boolean;