@agenthippo-ai/agenthippo 0.1.0

package/out/cli/pack-loader.js

@@ -0,0 +1,376 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePackPath = resolvePackPath;
+exports.listAvailablePacks = listAvailablePacks;
+exports.loadAgentPack = loadAgentPack;
+exports.getDefaultConfig = getDefaultConfig;
+exports.getEnvDefaultModel = getEnvDefaultModel;
+exports.getApiConfig = getApiConfig;
+exports.getFileAccess = getFileAccess;
+/**
+ * Agent Pack Loader
+ *
+ * Loads and validates agent packs from the filesystem.
+ */
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const yaml = __importStar(require("js-yaml"));
+const branding_1 = require("../branding");
+// -----------------------------------------------------------------------------
+// Constants
+// -----------------------------------------------------------------------------
+function getEnvVar(primary, legacy) {
+    return process.env[primary] ?? (legacy ? process.env[legacy] : undefined);
+}
+const AGENTHIPPO_HOME = process.env.AGENTHIPPO_HOME || path.join(os.homedir(), branding_1.AGENTIDE_DIR_NAME);
+const USER_AGENTS_DIR = path.join(AGENTHIPPO_HOME, 'agents');
+const AGENTS_SUBDIR = 'agents';
+// -----------------------------------------------------------------------------
+// Pack Resolution
+// -----------------------------------------------------------------------------
+/**
+ * Resolve a pack path with version support.
+ *
+ * Resolution order:
+ * 1. Check for current.txt pointer → use that version
+ * 2. Check if basePath itself has agent.yaml → flat structure
+ * 3. Auto-detect version directories (semver-like: X.Y.Z) → use latest
+ */
+function resolveVersionedPath(basePath) {
+    if (!fs.existsSync(basePath)) {
+        return undefined;
+    }
+    // 1. Check for current.txt version pointer
+    const currentFile = path.join(basePath, 'current.txt');
+    if (fs.existsSync(currentFile)) {
+        const version = fs.readFileSync(currentFile, 'utf-8').trim();
+        const versionPath = path.join(basePath, version);
+        if (fs.existsSync(versionPath)) {
+            return versionPath;
+        }
+    }
+    // 2. Flat structure - agent.yaml directly in basePath
+    const flatManifest = path.join(basePath, 'agent.yaml');
+    if (fs.existsSync(flatManifest)) {
+        return basePath;
+    }
+    // 3. Auto-detect version directories (look for semver-like: X.Y.Z or X.Y.Z-xxx)
+    try {
+        const entries = fs.readdirSync(basePath, { withFileTypes: true });
+        const versionDirs = entries
+            .filter(e => e.isDirectory() && /^\d+\.\d+\.\d+/.test(e.name))
+            .map(e => e.name)
+            .sort((a, b) => {
+            // Sort by semver (descending - latest first)
+            const [aMajor, aMinor, aPatch] = a.split('.').map(n => parseInt(n, 10) || 0);
+            const [bMajor, bMinor, bPatch] = b.split('.').map(n => parseInt(n, 10) || 0);
+            if (bMajor !== aMajor) {
+                return bMajor - aMajor;
+            }
+            if (bMinor !== aMinor) {
+                return bMinor - aMinor;
+            }
+            return bPatch - aPatch;
+        });
+        // Use latest version that has agent.yaml
+        for (const version of versionDirs) {
+            const versionPath = path.join(basePath, version);
+            const manifestPath = path.join(versionPath, 'agent.yaml');
+            if (fs.existsSync(manifestPath)) {
+                return versionPath;
+            }
+        }
+    }
+    catch {
+        // Ignore read errors
+    }
+    return undefined;
+}
+/**
+ * Find an agent pack by name or path.
+ *
+ * Search order:
+ * 1. Explicit path (absolute or relative to cwd)
+ * 2. Direct folder in cwd: ./<name> (convenience for development)
+ * 3. Local agents folder: ./agents/<name> (in cwd, for development)
+ * 4. Workspace branding folder: <workspace>/<brand>/agents/<name>
+ * 5. User agent library: ~/<brand>/agents/<name>
+ *
+ * @param nameOrPath - Pack name or path
+ * @param workspaceRoot - Workspace root directory (for workspace-local packs)
+ */
+function resolvePackPath(nameOrPath, workspaceRoot) {
+    // 1. Explicit path (absolute or relative to cwd)
+    // This handles both absolute paths and relative paths like "./myagent" or "../agents/myagent"
+    if (path.isAbsolute(nameOrPath) || nameOrPath.startsWith('./') || nameOrPath.startsWith('../')) {
+        const resolvedPath = path.isAbsolute(nameOrPath) ? nameOrPath : path.resolve(process.cwd(), nameOrPath);
+        if (fs.existsSync(resolvedPath)) {
+            try {
+                if (fs.statSync(resolvedPath).isDirectory()) {
+                    return resolveVersionedPath(resolvedPath) ?? resolvedPath;
+                }
+            }
+            catch {
+                // Ignore stat errors, fall back to raw path.
+            }
+            return resolvedPath;
+        }
+        // If explicit path doesn't exist, don't fall through to other search locations
+        return undefined;
+    }
+    // From here, nameOrPath is just a name (e.g., "joker1"), not a path
+    // Search in standard locations in priority order
+    // 2. Direct folder in cwd: ./<name> (convenience for development)
+    const cwdDirectPath = path.join(process.cwd(), nameOrPath);
+    const cwdDirectResolved = resolveVersionedPath(cwdDirectPath);
+    if (cwdDirectResolved) {
+        return cwdDirectResolved;
+    }
+    // 3. Local agents folder: ./agents/<name> (in cwd, for development)
+    const localAgentsPath = path.join(process.cwd(), AGENTS_SUBDIR, nameOrPath);
+    const localResolved = resolveVersionedPath(localAgentsPath);
+    if (localResolved) {
+        return localResolved;
+    }
+    // 4. Workspace branding folder: <workspace>/<brand>/agents/<name>
+    if (workspaceRoot) {
+        const workspacePackPath = path.join(workspaceRoot, branding_1.AGENTIDE_DIR_NAME, AGENTS_SUBDIR, nameOrPath);
+        const resolved = resolveVersionedPath(workspacePackPath);
+        if (resolved) {
+            return resolved;
+        }
+    }
+    // 5. User agent library: ~/<brand>/agents/<name>
+    const ualPath = path.join(USER_AGENTS_DIR, nameOrPath);
+    const resolved = resolveVersionedPath(ualPath);
+    if (resolved) {
+        return resolved;
+    }
+    return undefined;
+}
+/**
+ * List packs from a directory.
+ */
+function listPacksFromDir(agentsDir, source) {
+    const packs = [];
+    if (!fs.existsSync(agentsDir)) {
+        return packs;
+    }
+    const entries = fs.readdirSync(agentsDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        if (entry.name.startsWith('.')) {
+            continue;
+        }
+        const packPath = path.join(agentsDir, entry.name);
+        const resolvedPath = resolveVersionedPath(packPath);
+        if (!resolvedPath) {
+            continue;
+        }
+        // Extract version from resolved path
+        let version;
+        if (resolvedPath !== packPath) {
+            version = path.basename(resolvedPath);
+        }
+        packs.push({
+            name: entry.name,
+            path: resolvedPath,
+            version,
+            source,
+        });
+    }
+    return packs;
+}
+/**
+ * List all available agent packs.
+ *
+ * @param workspaceRoot - Workspace root to search for workspace-local packs
+ * @returns Array of packs from both workspace and user library
+ */
+function listAvailablePacks(workspaceRoot) {
+    const packs = [];
+    const seen = new Set();
+    // 1. Workspace-local packs (higher priority)
+    if (workspaceRoot) {
+        const workspaceAgentsDir = path.join(workspaceRoot, branding_1.AGENTIDE_DIR_NAME, AGENTS_SUBDIR);
+        const workspacePacks = listPacksFromDir(workspaceAgentsDir, 'workspace');
+        for (const pack of workspacePacks) {
+            packs.push(pack);
+            seen.add(pack.name);
+        }
+    }
+    // 2. User library packs (skip if already in workspace)
+    const userPacks = listPacksFromDir(USER_AGENTS_DIR, 'user-library');
+    for (const pack of userPacks) {
+        if (!seen.has(pack.name)) {
+            packs.push(pack);
+        }
+    }
+    return packs;
+}
+// -----------------------------------------------------------------------------
+// Pack Loading
+// -----------------------------------------------------------------------------
+/**
+ * Load an agent pack from the filesystem.
+ *
+ * @param nameOrPath - Pack name or path
+ * @param workspaceRoot - Workspace root for finding workspace-local packs
+ */
+async function loadAgentPack(nameOrPath, workspaceRoot) {
+    const packPath = resolvePackPath(nameOrPath, workspaceRoot);
+    if (!packPath) {
+        const isExplicitPath = path.isAbsolute(nameOrPath) || nameOrPath.startsWith('./') || nameOrPath.startsWith('../');
+        const searchedLocations = isExplicitPath
+            ? [path.resolve(process.cwd(), nameOrPath)]
+            : [
+                `${process.cwd()}/${nameOrPath}`,
+                `${process.cwd()}/agents/${nameOrPath}`,
+                workspaceRoot ? `${workspaceRoot}/${branding_1.AGENTIDE_DIR_NAME}/agents/${nameOrPath}` : null,
+                `${USER_AGENTS_DIR}/${nameOrPath}`,
+            ].filter(Boolean);
+        throw new Error(`Agent pack not found: ${nameOrPath}\n  Searched: ${searchedLocations.join(', ')}`);
+    }
+    // Load manifest
+    const manifestPath = path.join(packPath, 'agent.yaml');
+    if (!fs.existsSync(manifestPath)) {
+        throw new Error(`Missing agent.yaml in pack: ${packPath}`);
+    }
+    const manifestContent = fs.readFileSync(manifestPath, 'utf-8');
+    const manifest = yaml.load(manifestContent);
+    // Validate manifest
+    validateManifest(manifest, manifestPath);
+    const normalizedManifest = normalizeManifestForRuntime(manifest);
+    // Load system prompt
+    let systemPrompt = '';
+    const systemPromptPath = path.join(packPath, 'AGENTS.md');
+    if (fs.existsSync(systemPromptPath)) {
+        systemPrompt = fs.readFileSync(systemPromptPath, 'utf-8');
+    }
+    // Load rules
+    const rules = [];
+    return {
+        manifest: normalizedManifest,
+        packPath,
+        systemPrompt,
+        rules,
+    };
+}
+function normalizeManifestForRuntime(manifest) {
+    const rawEngine = manifest.spec.engine?.trim() ?? '';
+    const normalizedEngine = rawEngine.toLowerCase();
+    if (rawEngine !== normalizedEngine) {
+        return {
+            ...manifest,
+            spec: {
+                ...manifest.spec,
+                engine: normalizedEngine,
+            },
+        };
+    }
+    return manifest;
+}
+/**
+ * Validate a pack manifest.
+ */
+function validateManifest(manifest, sourcePath) {
+    const errors = [];
+    if (!manifest.metadata?.name) {
+        errors.push('Missing metadata.name');
+    }
+    if (!manifest.metadata?.version) {
+        errors.push('Missing metadata.version');
+    }
+    if (!manifest.spec?.engine?.trim()) {
+        errors.push('Missing spec.engine');
+    }
+    const normalizedEngine = manifest.spec?.engine?.trim().toLowerCase();
+    if (normalizedEngine === 'custom') {
+        errors.push('Invalid spec.engine: use the concrete custom engine id (for example, openclaw), not "custom"');
+    }
+    if (manifest.spec?.cheapModel !== undefined && typeof manifest.spec.cheapModel !== 'string') {
+        errors.push('Invalid spec.cheapModel: must be a string when provided');
+    }
+    if (errors.length > 0) {
+        throw new Error(`Invalid agent manifest at ${sourcePath}:\n  - ${errors.join('\n  - ')}`);
+    }
+}
+/**
+ * Get default engine and model when no pack is specified.
+ */
+function getDefaultConfig() {
+    const rawEngine = (getEnvVar('AGENTHIPPO_DEFAULT_ENGINE', 'AGENTIDE_DEFAULT_ENGINE') || 'claude').trim().toLowerCase();
+    return {
+        engine: rawEngine,
+        model: getEnvVar('AGENTHIPPO_DEFAULT_MODEL', 'AGENTIDE_DEFAULT_MODEL') || 'claude-sonnet-4-5-20250929',
+    };
+}
+/**
+ * Returns the env-configured default model without a hardcoded fallback.
+ * Used after custom engine manifest defaults so AGENTHIPPO_DEFAULT_MODEL only
+ * wins when no request, pack, or manifest model is available.
+ */
+function getEnvDefaultModel() {
+    return getEnvVar('AGENTHIPPO_DEFAULT_MODEL', 'AGENTIDE_DEFAULT_MODEL')?.trim() || undefined;
+}
+/**
+ * Get API configuration from environment.
+ */
+function getApiConfig() {
+    const litellmApiKey = getEnvVar('AGENTHIPPO_LITELLM_API_KEY', 'AGENTIDE_LITELLM_API_KEY');
+    const litellmBaseUrl = getEnvVar('AGENTHIPPO_LITELLM_BASE_URL', 'AGENTIDE_LITELLM_BASE_URL');
+    const anthropicApiKey = process.env.ANTHROPIC_API_KEY || process.env.CLAUDE_API_KEY;
+    const openaiApiKey = process.env.OPENAI_API_KEY;
+    const apiKey = litellmApiKey || anthropicApiKey || openaiApiKey;
+    const useLiteLLM = Boolean(litellmApiKey && litellmBaseUrl);
+    return {
+        apiKey,
+        baseUrl: litellmBaseUrl,
+        useLiteLLM,
+    };
+}
+/**
+ * Get file access mode from pack manifest.
+ */
+function getFileAccess(pack) {
+    return pack?.manifest.spec.permissions?.fileAccess ?? 'workspace-write';
+}

package/out/cli/run-custom-engine-runner.js

@@ -0,0 +1,318 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCustomEngineRunnerMain = runCustomEngineRunnerMain;
+const node_readline_1 = require("node:readline");
+const node_url_1 = require("node:url");
+const path = __importStar(require("node:path"));
+/** Must stay self-contained — this file is embedded and run from ~/.agent-hippo/cache/cli/. */
+const AGENTHIPPO_MCP_SERVERS_ENV = 'AGENTHIPPO_MCP_SERVERS';
+function parseInlineMcpServers(raw) {
+    if (!raw?.trim()) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+function emitEvent(obj) {
+    process.stdout.write(`${JSON.stringify(obj)}\n`);
+}
+const runtime = {
+    logger: {
+        info: () => { },
+        warn: () => { },
+        error: () => { },
+    },
+};
+/** Apply the engine entry's directory to cwd + NODE_PATH so its node_modules resolve. */
+function applyEngineDir(entryPath) {
+    const engineDir = path.dirname(entryPath);
+    process.chdir(engineDir);
+    const engineNodeModules = path.join(engineDir, 'node_modules');
+    const existingNodePath = process.env.NODE_PATH?.trim();
+    process.env.NODE_PATH = existingNodePath
+        ? `${engineNodeModules}${path.delimiter}${existingNodePath}`
+        : engineNodeModules;
+}
+/** Import the engine module and instantiate the exported engine (must provide run(turn)). */
+async function loadEngine(entryPath, engineExport) {
+    const mod = (await import((0, node_url_1.pathToFileURL)(entryPath).href));
+    const exported = (engineExport ? (mod[engineExport] ?? mod.default?.[engineExport]) : undefined) ??
+        mod.default;
+    const EngineClass = typeof exported === 'function' ? exported : null;
+    const engine = EngineClass ? new EngineClass() : exported;
+    if (!engine || typeof engine.run !== 'function') {
+        throw new Error('Engine export must provide run(turn)');
+    }
+    return engine;
+}
+/**
+ * Build a CustomEngineTurn from an env map (shared by one-shot and persistent modes).
+ *
+ * ENGINE CONTRACT: in persistent mode a single warm worker serves many chat sessions, and its
+ * process.env is frozen at first spawn (the *first* turn's secrets/session keys). Per-turn values
+ * arrive here in `env` (the worker's per-turn `run` message), never on process.env. Engines must
+ * therefore read all per-turn state from `turn.env`/`turn.routing`/`turn.session` and never from
+ * `process.env` directly, or they will see the spawn-time values for the worker's whole lifetime
+ * and cross-wire sessions.
+ */
+function buildTurn(env, emitter, signal) {
+    const entryPath = env.AGENTHIPPO_ENGINE_ENTRY?.trim() ?? '';
+    const engineDir = path.dirname(entryPath);
+    const message = env.AGENTHIPPO_MESSAGE ?? '';
+    const workspaceRoot = env.AGENTHIPPO_WORKSPACE_ROOT ?? process.cwd();
+    const modelId = env.AGENTHIPPO_MODEL_ID ?? 'auto';
+    const sessionKey = env.AGENTHIPPO_CONVERSATION_KEY?.trim()
+        || env.AGENTIDE_CHAT_SESSION_ID?.trim()
+        || env.AGENTHIPPO_CHAT_SESSION_ID?.trim()
+        || 'runner';
+    const chatSessionId = env.AGENTIDE_CHAT_SESSION_ID?.trim()
+        || env.AGENTHIPPO_CHAT_SESSION_ID?.trim()
+        || sessionKey;
+    const contextSessionId = env.AGENTHIPPO_CONTEXT_SESSION_ID?.trim() || chatSessionId;
+    const mcpServers = parseInlineMcpServers(env[AGENTHIPPO_MCP_SERVERS_ENV]);
+    return {
+        message,
+        modelId,
+        workspaceRoot,
+        additionalDirectories: [],
+        permissions: { fileAccess: 'full' },
+        env: { ...env },
+        routing: {
+            useLiteLLM: env.AGENTHIPPO_USE_LITELLM === 'true',
+            ...(env.AGENTHIPPO_API_KEY ? { apiKey: env.AGENTHIPPO_API_KEY } : {}),
+            ...(env.AGENTHIPPO_BASE_URL ? { baseUrl: env.AGENTHIPPO_BASE_URL } : {}),
+            ...(env.AGENTHIPPO_OPENAI_BASE_URL ? { openaiBaseUrl: env.AGENTHIPPO_OPENAI_BASE_URL } : {}),
+        },
+        session: {
+            key: sessionKey,
+            chatSessionId,
+            contextSessionId,
+            isEphemeral: env.AGENTHIPPO_IS_EPHEMERAL === 'true',
+            engineHomeDir: env.AGENTHIPPO_ENGINE_HOME?.trim() || engineDir,
+            engineSessionDir: env.AGENTHIPPO_ENGINE_SESSION_DIR?.trim() || engineDir,
+            nativeSessionId: env.AGENTHIPPO_NATIVE_SESSION_ID?.trim() || undefined,
+            contextFilePath: env.AGENTHIPPO_CONTEXT_EXPORT_PATH?.trim() || undefined,
+            terminalLogPath: env.AGENTHIPPO_TERMINAL_LOG_PATH?.trim() || undefined,
+            attachmentsDir: env.AGENTHIPPO_ATTACHMENTS_DIR?.trim() || undefined,
+        },
+        agent: { id: env.AGENTHIPPO_ACTIVE_AGENT ?? 'default' },
+        ...(mcpServers ? { mcpServers } : {}),
+        emitter,
+        runtime,
+        signal,
+    };
+}
+/**
+ * One-shot mode (strategy "node-subprocess"): build one turn from process.env, run, exit.
+ * Parent sets AGENTHIPPO_* env vars before spawn.
+ */
+async function runOnce() {
+    const entryPath = process.env.AGENTHIPPO_ENGINE_ENTRY?.trim();
+    if (!entryPath) {
+        emitEvent({ type: 'error', message: 'AGENTHIPPO_ENGINE_ENTRY is required' });
+        return 1;
+    }
+    applyEngineDir(entryPath);
+    let doneEmitted = false;
+    const emitter = {
+        async text(delta) { emitEvent({ type: 'text', delta }); },
+        async thinking(delta) { emitEvent({ type: 'thinking', delta }); },
+        async toolStart(toolName, input, toolCallId) { emitEvent({ type: 'toolStart', toolName, input, toolCallId }); },
+        async toolEnd(toolName, toolCallId, result, isError) { emitEvent({ type: 'toolEnd', toolName, toolCallId, result, isError }); },
+        async progress(msg) { emitEvent({ type: 'progress', message: msg }); },
+        async error(msg) { emitEvent({ type: 'error', message: msg }); },
+        async done() {
+            // Engines call done(); runner also calls done() after run — emit at most once.
+            if (doneEmitted) {
+                return;
+            }
+            doneEmitted = true;
+            emitEvent({ type: 'done' });
+        },
+        async question() {
+            return { selected: [], freeText: null, declined: true };
+        },
+    };
+    try {
+        const engine = await loadEngine(entryPath, process.env.AGENTHIPPO_ENGINE_EXPORT?.trim());
+        if (process.env.AGENTHIPPO_CUSTOM_ENGINE_PROBE === 'import') {
+            emitEvent({ type: 'probe', ok: true });
+            return 0;
+        }
+        const turn = buildTurn(process.env, emitter);
+        const result = await engine.run(turn);
+        if (result?.nativeSessionId) {
+            emitEvent({ type: 'nativeSessionId', nativeSessionId: result.nativeSessionId });
+        }
+        await emitter.done();
+        return 0;
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        emitEvent({ type: 'error', message: msg });
+        return 1;
+    }
+}
+/**
+ * Persistent mode (strategy "persistent-worker"): load the engine once (SDK stays warm),
+ * then serve turns from stdin NDJSON requests, tagging each event with its run id so the
+ * host can multiplex concurrent turns. The host recycles this child on failure.
+ */
+async function runPersistent() {
+    const entryPath = process.env.AGENTHIPPO_ENGINE_ENTRY?.trim();
+    if (!entryPath) {
+        emitEvent({ type: 'error', message: 'AGENTHIPPO_ENGINE_ENTRY is required' });
+        process.exit(1);
+    }
+    applyEngineDir(entryPath);
+    let engine;
+    try {
+        engine = await loadEngine(entryPath, process.env.AGENTHIPPO_ENGINE_EXPORT?.trim());
+    }
+    catch (err) {
+        emitEvent({ type: 'error', message: err instanceof Error ? err.message : String(err) });
+        process.exit(1);
+    }
+    const controllers = new Map();
+    const makeEmitter = (id) => {
+        const emit = (event) => emitEvent({ id, event });
+        let doneEmitted = false;
+        return {
+            async text(delta) { emit({ type: 'text', delta }); },
+            async thinking(delta) { emit({ type: 'thinking', delta }); },
+            async toolStart(toolName, input, toolCallId) { emit({ type: 'toolStart', toolName, input, toolCallId }); },
+            async toolEnd(toolName, toolCallId, result, isError) { emit({ type: 'toolEnd', toolName, toolCallId, result, isError }); },
+            async progress(msg) { emit({ type: 'progress', message: msg }); },
+            async error(msg) { emit({ type: 'error', message: msg }); },
+            async done() {
+                if (doneEmitted) {
+                    return;
+                }
+                doneEmitted = true;
+                emit({ type: 'done' });
+            },
+            async question() {
+                return { selected: [], freeText: null, declined: true };
+            },
+        };
+    };
+    const handleRun = async (id, runEnv) => {
+        const controller = new AbortController();
+        controllers.set(id, controller);
+        const emitter = makeEmitter(id);
+        try {
+            // Build the turn purely from this turn's runEnv — it is a complete environment
+            // (host buildRunnerChildEnv spreads process.env + the per-turn block). Do NOT merge
+            // the worker's process.env or mutate it: a warm worker serves many chat sessions, and
+            // per-session keys (AGENTHIPPO_NATIVE_SESSION_ID/CONVERSATION_KEY) are only present for
+            // sessions that have them, so leaking them across turns cross-wires Cursor sessions.
+            const turn = buildTurn(runEnv, emitter, controller.signal);
+            const result = await engine.run(turn);
+            await emitter.done();
+            // Terminal control message — sent after the engine fully settles so nativeSessionId
+            // is captured even though engines call done() mid-run.
+            emitEvent({ type: 'result', id, nativeSessionId: result?.nativeSessionId });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            emitEvent({ id, event: { type: 'error', message } });
+            emitEvent({ type: 'failed', id, message });
+        }
+        finally {
+            controllers.delete(id);
+        }
+    };
+    const rl = (0, node_readline_1.createInterface)({ input: process.stdin });
+    rl.on('line', line => {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            return;
+        }
+        let req;
+        try {
+            req = JSON.parse(trimmed);
+        }
+        catch {
+            return;
+        }
+        if (req.type === 'run' && typeof req.id === 'string') {
+            void handleRun(req.id, req.env ?? {});
+        }
+        else if (req.type === 'abort' && typeof req.id === 'string') {
+            controllers.get(req.id)?.abort();
+        }
+        else if (req.type === 'shutdown') {
+            rl.close();
+        }
+    });
+    rl.on('close', () => {
+        for (const controller of controllers.values()) {
+            controller.abort();
+        }
+        process.exit(0);
+    });
+    emitEvent({ type: 'ready' });
+}
+/**
+ * Exported one-shot entry. NOTE: this is always one-shot regardless of AGENTHIPPO_RUNNER_MODE —
+ * persistent mode is selected only by the module-bottom dispatch below (the real CLI entrypoint),
+ * not by this function. Callers that import this module get one-shot behavior from this export.
+ */
+async function runCustomEngineRunnerMain() {
+    return runOnce();
+}
+// Module-level dispatch is the actual entrypoint: the mode is fixed at spawn by the env var the
+// host sets, so importing this module for its export still runs the correct loop for that mode.
+if (process.env.AGENTHIPPO_RUNNER_MODE === 'persistent') {
+    void runPersistent();
+}
+else {
+    void runCustomEngineRunnerMain().then(code => { process.exit(code); }, err => {
+        emitEvent({ type: 'error', message: err instanceof Error ? err.message : String(err) });
+        process.exit(1);
+    });
+}