@jungjaehoon/mama-core 2.4.1 → 4.1.0

package/dist/runtime/drivers/codex-thread-registry.d.ts

@@ -0,0 +1,63 @@
+import { type Stats } from 'node:fs';
+export interface CodexThreadRecord {
+    version: 1;
+    sessionKey: string;
+    keyHash: string;
+    threadId: string;
+    model: string;
+    cwd: string;
+    systemPromptFingerprint: string;
+    mcpConfigFingerprint: string;
+    createdAt: string;
+    lastUsedAt: string;
+}
+export type CodexThreadRecordInput = Omit<CodexThreadRecord, 'version' | 'keyHash' | 'createdAt' | 'lastUsedAt'>;
+interface CodexThreadRegistryOptions {
+    rootDir: string;
+    fileSystem?: Partial<CodexThreadRegistryFileSystem>;
+    platform?: NodeJS.Platform;
+}
+interface CodexThreadRegistryFileSystem {
+    open(path: string, flags: number, mode?: number): number;
+    close(descriptor: number): void;
+    stat(descriptor: number): Stats;
+    chmod(descriptor: number, mode: number): void;
+    sync(descriptor: number): void;
+    read(descriptor: number): string;
+    write(descriptor: number, value: string): void;
+    lstat(path: string): Stats | undefined;
+    mkdir(path: string): void;
+    rename(source: string, destination: string, validateBoundary: () => void): void;
+    unlink(path: string, validateBoundary: () => void): void;
+    userId(): number | undefined;
+}
+export declare function fingerprintText(value: string): string;
+export declare class CodexThreadRegistry {
+    private readonly rootDir;
+    private readonly parentDir;
+    private readonly fileSystem;
+    private readonly platform;
+    constructor(options: CodexThreadRegistryOptions);
+    load(sessionKey: string): CodexThreadRecord | undefined;
+    save(input: CodexThreadRecordInput): CodexThreadRecord;
+    remove(sessionKey: string): void;
+    private recordPath;
+    private withRootDirectory;
+    private withDirectory;
+    private assertBoundary;
+    private assertDirectoryIdentity;
+    private openRecordForRead;
+    private ensureSafeRecord;
+    private assertRecordIdentity;
+    private assertRecordPathNotSymlink;
+    private assertOpenedRecordPath;
+    private ensureTrustedParent;
+    private directoryOpenFlags;
+    private recordReadFlags;
+    private recordWriteFlags;
+    private withDescriptor;
+    private syncDirectory;
+    private removeTemporaryFileBestEffort;
+}
+export {};
+//# sourceMappingURL=codex-thread-registry.d.ts.map

package/dist/runtime/drivers/codex-thread-registry.js

@@ -0,0 +1,433 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexThreadRegistry = void 0;
+exports.fingerprintText = fingerprintText;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const nodeFileSystem = {
+    open(path, flags, mode) {
+        return mode === undefined ? (0, node_fs_1.openSync)(path, flags) : (0, node_fs_1.openSync)(path, flags, mode);
+    },
+    close: node_fs_1.closeSync,
+    stat: node_fs_1.fstatSync,
+    chmod: node_fs_1.fchmodSync,
+    sync: node_fs_1.fsyncSync,
+    read(descriptor) {
+        return (0, node_fs_1.readFileSync)(descriptor, 'utf8');
+    },
+    write(descriptor, value) {
+        (0, node_fs_1.writeFileSync)(descriptor, value, { encoding: 'utf8' });
+    },
+    lstat(path) {
+        return (0, node_fs_1.lstatSync)(path, { throwIfNoEntry: false });
+    },
+    mkdir(path) {
+        (0, node_fs_1.mkdirSync)(path, { mode: 0o700 });
+    },
+    rename(source, destination, validateBoundary) {
+        validateBoundary();
+        (0, node_fs_1.renameSync)(source, destination);
+    },
+    unlink(path, validateBoundary) {
+        validateBoundary();
+        (0, node_fs_1.unlinkSync)(path);
+    },
+    userId() {
+        return process.getuid?.();
+    },
+};
+function fingerprintText(value) {
+    return (0, node_crypto_1.createHash)('sha256').update(value, 'utf8').digest('hex');
+}
+function requireObject(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new Error('Codex thread registry record must be a JSON object');
+    }
+    return value;
+}
+function requireString(record, property) {
+    const value = record[property];
+    if (typeof value !== 'string') {
+        throw new Error(`Codex thread registry property ${property} must be a string`);
+    }
+    return value;
+}
+function parseRecord(value) {
+    const record = requireObject(value);
+    if (record.version !== 1) {
+        throw new Error(`Unsupported Codex thread registry schema version: ${String(record.version)}`);
+    }
+    return {
+        version: 1,
+        sessionKey: requireString(record, 'sessionKey'),
+        keyHash: requireString(record, 'keyHash'),
+        threadId: requireString(record, 'threadId'),
+        model: requireString(record, 'model'),
+        cwd: requireString(record, 'cwd'),
+        systemPromptFingerprint: requireString(record, 'systemPromptFingerprint'),
+        mcpConfigFingerprint: requireString(record, 'mcpConfigFingerprint'),
+        createdAt: requireString(record, 'createdAt'),
+        lastUsedAt: requireString(record, 'lastUsedAt'),
+    };
+}
+class CodexThreadRegistry {
+    rootDir;
+    parentDir;
+    fileSystem;
+    platform;
+    constructor(options) {
+        this.rootDir = (0, node_path_1.resolve)(options.rootDir);
+        this.parentDir = (0, node_path_1.dirname)(this.rootDir);
+        if (this.parentDir === this.rootDir) {
+            throw new Error('Codex thread registry directory must have a parent directory');
+        }
+        this.fileSystem = { ...nodeFileSystem, ...options.fileSystem };
+        this.platform = options.platform ?? process.platform;
+        this.withRootDirectory(() => undefined, true);
+    }
+    load(sessionKey) {
+        const keyHash = fingerprintText(sessionKey);
+        const path = this.recordPath(keyHash);
+        return this.withRootDirectory((root) => {
+            const descriptor = this.openRecordForRead(path, root);
+            if (descriptor === undefined) {
+                this.assertBoundary(root);
+                return undefined;
+            }
+            const source = this.withDescriptor(descriptor, () => {
+                const identity = this.fileSystem.stat(descriptor);
+                this.ensureSafeRecord(identity);
+                this.assertBoundary(root);
+                this.assertOpenedRecordPath(path, identity);
+                this.fileSystem.chmod(descriptor, 0o600);
+                this.assertBoundary(root);
+                this.assertOpenedRecordPath(path, identity);
+                return this.fileSystem.read(descriptor);
+            });
+            let parsed;
+            try {
+                parsed = JSON.parse(source);
+            }
+            catch (error) {
+                const detail = error instanceof Error ? error.message : String(error);
+                throw new Error(`Invalid JSON in Codex thread registry record: ${detail}`);
+            }
+            const record = parseRecord(parsed);
+            if (record.sessionKey !== sessionKey || record.keyHash !== keyHash) {
+                throw new Error('Codex thread registry key/digest mismatch');
+            }
+            return record;
+        });
+    }
+    save(input) {
+        const keyHash = fingerprintText(input.sessionKey);
+        const path = this.recordPath(keyHash);
+        const existing = this.load(input.sessionKey);
+        const now = new Date().toISOString();
+        const record = {
+            version: 1,
+            sessionKey: input.sessionKey,
+            keyHash,
+            threadId: input.threadId,
+            model: input.model,
+            cwd: input.cwd,
+            systemPromptFingerprint: input.systemPromptFingerprint,
+            mcpConfigFingerprint: input.mcpConfigFingerprint,
+            createdAt: existing?.createdAt ?? now,
+            lastUsedAt: now,
+        };
+        const temporaryPath = `${path}.${process.pid}.${(0, node_crypto_1.randomUUID)()}.tmp`;
+        this.withRootDirectory((root) => {
+            let temporaryCreated = false;
+            let renamed = false;
+            let temporaryIdentity;
+            try {
+                const descriptor = this.fileSystem.open(temporaryPath, this.recordWriteFlags(), 0o600);
+                temporaryCreated = true;
+                this.withDescriptor(descriptor, () => {
+                    temporaryIdentity = this.fileSystem.stat(descriptor);
+                    this.ensureSafeRecord(temporaryIdentity);
+                    this.assertRecordIdentity(temporaryPath, temporaryIdentity);
+                    this.fileSystem.chmod(descriptor, 0o600);
+                    this.fileSystem.write(descriptor, `${JSON.stringify(record)}\n`);
+                    this.fileSystem.sync(descriptor);
+                });
+                this.assertBoundary(root);
+                this.fileSystem.rename(temporaryPath, path, () => {
+                    this.assertBoundary(root);
+                    if (temporaryIdentity === undefined) {
+                        throw new Error('Codex thread registry temporary file identity was not captured');
+                    }
+                    this.assertRecordIdentity(temporaryPath, temporaryIdentity);
+                });
+                renamed = true;
+                this.assertBoundary(root);
+                this.syncDirectory(root.root.descriptor);
+            }
+            catch (error) {
+                if (temporaryCreated && !renamed) {
+                    this.removeTemporaryFileBestEffort(temporaryPath, root);
+                }
+                throw error;
+            }
+        });
+        return record;
+    }
+    remove(sessionKey) {
+        const path = this.recordPath(fingerprintText(sessionKey));
+        this.withRootDirectory((root) => {
+            const descriptor = this.openRecordForRead(path, root);
+            if (descriptor === undefined) {
+                this.assertBoundary(root);
+                return;
+            }
+            this.withDescriptor(descriptor, () => {
+                const identity = this.fileSystem.stat(descriptor);
+                this.ensureSafeRecord(identity);
+                this.assertBoundary(root);
+                this.assertRecordIdentity(path, identity);
+                this.fileSystem.unlink(path, () => {
+                    this.assertBoundary(root);
+                    this.assertRecordIdentity(path, identity);
+                });
+                this.assertBoundary(root);
+            });
+            this.syncDirectory(root.root.descriptor);
+        });
+    }
+    recordPath(keyHash) {
+        return (0, node_path_1.join)(this.rootDir, `${keyHash}.json`);
+    }
+    withRootDirectory(operation, syncParent = false) {
+        return this.withDirectory(this.parentDir, 'parent', (parent) => {
+            this.ensureTrustedParent(parent.identity);
+            let created = false;
+            if (this.fileSystem.lstat(this.rootDir) === undefined) {
+                this.assertDirectoryIdentity(this.parentDir, parent.identity, 'parent');
+                try {
+                    this.fileSystem.mkdir(this.rootDir);
+                    created = true;
+                }
+                catch (error) {
+                    if (errorCode(error) !== 'EEXIST') {
+                        throw error;
+                    }
+                }
+                this.assertDirectoryIdentity(this.parentDir, parent.identity, 'parent');
+            }
+            return this.withDirectory(this.rootDir, 'registry', (root) => {
+                this.fileSystem.chmod(root.descriptor, 0o700);
+                const boundary = { parent, root };
+                this.assertBoundary(boundary);
+                if (created || syncParent) {
+                    this.syncDirectory(parent.descriptor);
+                }
+                return operation(boundary);
+            });
+        });
+    }
+    withDirectory(path, label, operation) {
+        const before = this.fileSystem.lstat(path);
+        if (before === undefined) {
+            throw new Error(`Codex thread registry ${label} directory does not exist`);
+        }
+        if (before.isSymbolicLink()) {
+            throw new Error(`Codex thread registry ${label} directory must not be a symbolic link`);
+        }
+        let descriptor;
+        try {
+            descriptor = this.fileSystem.open(path, this.directoryOpenFlags());
+        }
+        catch (error) {
+            if (errorCode(error) === 'ELOOP' || this.fileSystem.lstat(path)?.isSymbolicLink()) {
+                throw new Error(`Codex thread registry ${label} directory must not be a symbolic link`, {
+                    cause: error,
+                });
+            }
+            throw error;
+        }
+        return this.withDescriptor(descriptor, () => {
+            const identity = this.fileSystem.stat(descriptor);
+            if (!identity.isDirectory()) {
+                throw new Error(`Codex thread registry ${label} path must be a directory`);
+            }
+            if (!sameIdentity(before, identity)) {
+                throw new Error(`Codex thread registry ${label} directory identity changed during open`);
+            }
+            this.assertDirectoryIdentity(path, identity, label);
+            return operation({ descriptor, identity });
+        });
+    }
+    assertBoundary(boundary) {
+        this.assertDirectoryIdentity(this.parentDir, boundary.parent.identity, 'parent');
+        this.assertDirectoryIdentity(this.rootDir, boundary.root.identity, 'registry');
+    }
+    assertDirectoryIdentity(path, expected, label) {
+        const current = this.fileSystem.lstat(path);
+        if (current === undefined) {
+            throw new Error(`Codex thread registry ${label} directory disappeared during operation`);
+        }
+        if (current.isSymbolicLink()) {
+            throw new Error(`Codex thread registry ${label} directory must not be a symbolic link`);
+        }
+        if (!current.isDirectory() || !sameIdentity(current, expected)) {
+            throw new Error(`Codex thread registry ${label} directory identity changed during operation`);
+        }
+    }
+    openRecordForRead(path, boundary) {
+        try {
+            const before = this.fileSystem.lstat(path);
+            if (before === undefined) {
+                this.assertBoundary(boundary);
+                return undefined;
+            }
+            this.ensureSafeRecord(before);
+            const descriptor = this.fileSystem.open(path, this.recordReadFlags());
+            try {
+                const identity = this.fileSystem.stat(descriptor);
+                this.ensureSafeRecord(identity);
+                if (this.platform === 'win32' && !sameIdentity(before, identity)) {
+                    throw new Error('Codex thread registry record identity changed during open');
+                }
+                this.assertOpenedRecordPath(path, identity);
+                return descriptor;
+            }
+            catch (error) {
+                try {
+                    this.fileSystem.close(descriptor);
+                }
+                catch {
+                    // Descriptor cleanup cannot replace the validation failure.
+                }
+                throw error;
+            }
+        }
+        catch (error) {
+            if (errorCode(error) === 'ENOENT') {
+                this.assertBoundary(boundary);
+                return undefined;
+            }
+            if (errorCode(error) === 'ELOOP' || this.fileSystem.lstat(path)?.isSymbolicLink()) {
+                throw new Error('Codex thread registry record must not be a symbolic link', {
+                    cause: error,
+                });
+            }
+            throw error;
+        }
+    }
+    ensureSafeRecord(stats) {
+        if (stats.isSymbolicLink()) {
+            throw new Error('Codex thread registry record must not be a symbolic link');
+        }
+        if (!stats.isFile()) {
+            throw new Error('Codex thread registry record must be a regular file');
+        }
+    }
+    assertRecordIdentity(path, expected) {
+        const current = this.fileSystem.lstat(path);
+        if (current === undefined) {
+            throw new Error('Codex thread registry record disappeared during operation');
+        }
+        if (current.isSymbolicLink()) {
+            throw new Error('Codex thread registry record must not be a symbolic link');
+        }
+        if (!current.isFile() || !sameIdentity(current, expected)) {
+            throw new Error('Codex thread registry record identity changed during operation');
+        }
+    }
+    assertRecordPathNotSymlink(path) {
+        if (this.fileSystem.lstat(path)?.isSymbolicLink()) {
+            throw new Error('Codex thread registry record must not be a symbolic link');
+        }
+    }
+    assertOpenedRecordPath(path, expected) {
+        if (this.platform === 'win32') {
+            this.assertRecordIdentity(path, expected);
+            return;
+        }
+        this.assertRecordPathNotSymlink(path);
+    }
+    ensureTrustedParent(stats) {
+        if (this.platform === 'win32') {
+            // Node's Stats uid/mode do not describe Windows ACL trust. The caller must place the
+            // registry under an ACL-protected parent; descriptor/path identity and reparse-point
+            // validation enforce the topology guarantees that Node exposes portably.
+            return;
+        }
+        if ((stats.mode & 0o022) !== 0) {
+            throw new Error('Codex thread registry parent directory must not be group/world writable');
+        }
+        const userId = this.fileSystem.userId();
+        if (userId === undefined) {
+            throw new Error('Codex thread registry cannot validate the parent directory owner UID');
+        }
+        if (stats.uid !== userId && stats.uid !== 0) {
+            throw new Error('Codex thread registry parent directory has an untrusted owner UID');
+        }
+    }
+    directoryOpenFlags() {
+        if (this.platform === 'win32') {
+            return node_fs_1.constants.O_RDONLY;
+        }
+        return node_fs_1.constants.O_RDONLY | node_fs_1.constants.O_NOFOLLOW | node_fs_1.constants.O_DIRECTORY;
+    }
+    recordReadFlags() {
+        return this.platform === 'win32'
+            ? node_fs_1.constants.O_RDONLY
+            : node_fs_1.constants.O_RDONLY | node_fs_1.constants.O_NOFOLLOW;
+    }
+    recordWriteFlags() {
+        const common = node_fs_1.constants.O_WRONLY | node_fs_1.constants.O_CREAT | node_fs_1.constants.O_EXCL;
+        return this.platform === 'win32' ? common : common | node_fs_1.constants.O_NOFOLLOW;
+    }
+    withDescriptor(descriptor, operation) {
+        let result;
+        try {
+            result = operation();
+        }
+        catch (error) {
+            try {
+                this.fileSystem.close(descriptor);
+            }
+            catch {
+                // Descriptor cleanup cannot replace the original operation failure.
+            }
+            throw error;
+        }
+        this.fileSystem.close(descriptor);
+        return result;
+    }
+    syncDirectory(descriptor) {
+        try {
+            this.fileSystem.sync(descriptor);
+        }
+        catch (error) {
+            const code = errorCode(error);
+            const unsupportedOnWindows = this.platform === 'win32' && (code === 'EINVAL' || code === 'ENOTSUP' || code === 'EBADF');
+            if (!unsupportedOnWindows) {
+                throw error;
+            }
+        }
+    }
+    removeTemporaryFileBestEffort(path, boundary) {
+        try {
+            this.fileSystem.unlink(path, () => this.assertBoundary(boundary));
+        }
+        catch {
+            // Cleanup cannot replace the original write/durability failure.
+        }
+    }
+}
+exports.CodexThreadRegistry = CodexThreadRegistry;
+function sameIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}
+function errorCode(error) {
+    if (typeof error !== 'object' || error === null || !('code' in error)) {
+        return undefined;
+    }
+    const code = error.code;
+    return typeof code === 'string' ? code : undefined;
+}
+//# sourceMappingURL=codex-thread-registry.js.map

package/dist/runtime/drivers/persistent-cli-adapter.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Persistent CLI Adapter - Wraps PersistentClaudeProcess with ClaudeCLIWrapper interface
+ *
+ * WHY THIS EXISTS:
+ * - PersistentClaudeProcess uses stream-json for efficient multi-turn conversations
+ * - AgentLoop expects ClaudeCLIWrapper interface (prompt, setSessionId, setSystemPrompt)
+ * - This adapter bridges the two, enabling drop-in replacement
+ *
+ * KEY OPTIMIZATION:
+ * - Tool results sent via stdin (tool_result message)
+ * - Claude context preserved without re-sending full history
+ * - System prompt sent only once at process start
+ */
+import { EventEmitter } from 'events';
+import type { ClaudeCLIWrapperOptions, PromptCallbacks, PromptResult, ToolUseBlock } from './claude-cli-wrapper.js';
+import { type IModelRunner, type PromptOptions, type RunnerMetrics, type SessionPolicyStatus } from './types.js';
+export type { ClaudeCLIWrapperOptions, PromptCallbacks, PromptResult, ToolUseBlock };
+/**
+ * PersistentCLIAdapter - Drop-in replacement for ClaudeCLIWrapper
+ *
+ * Implements the same interface but uses persistent CLI processes under the hood.
+ * This enables efficient multi-turn conversations without re-sending system prompts.
+ */
+export declare class PersistentCLIAdapter extends EventEmitter implements IModelRunner {
+    readonly backendType: "claude";
+    /**
+     * The CLI's own delegation: `Agent` with `run_in_background: true`. The parent stream
+     * carries the spawn (`system/task_started` plus the launch tool_result that names the
+     * child), the child's tool calls, its final text, and the completion notification, so a
+     * spawn IS observable - PersistentClaudeProcess maps them and this adapter re-emits them
+     * as `subagent` events with the same shape the Codex runner uses.
+     */
+    readonly supportsNativeSubagents = true;
+    private options;
+    private processPool;
+    private channelKey;
+    private currentProcess;
+    private currentProcessChannelKey;
+    private pendingToolResults;
+    private lastToolUseBlocks;
+    /** Processes whose subagent stream events are already wired to this adapter. */
+    private readonly wiredProcesses;
+    private readonly initializedProcesses;
+    private _requestCount;
+    private _failureCount;
+    private _totalLatencyMs;
+    private _lastRequestAt;
+    constructor(options: ClaudeCLIWrapperOptions);
+    /**
+     * Send a prompt to Claude
+     *
+     * This method:
+     * 1. Gets or creates a persistent process for this channel
+     * 2. Sends the message via stdin
+     * 3. Parses the response from stdout
+     * 4. Returns PromptResult compatible with ClaudeCLIWrapper
+     */
+    prompt(content: string, callbacks?: PromptCallbacks, options?: PromptOptions): Promise<PromptResult>;
+    /**
+     * Re-emit one process's background-Agent stream events as runner-level events.
+     *
+     * `subagent` carries the SAME shape the Codex runner emits, so
+     * `attachSubagentWake` works unchanged. A completion the CLI answered with its own
+     * follow-up turn is emitted as `subagentObserved` instead: that turn IS the owner
+     * reacting, and a host wake on top of it would be a second turn for one child.
+     */
+    private wireSubagentEvents;
+    /**
+     * Send a tool result back to Claude
+     *
+     * This is a new method not in ClaudeCLIWrapper that enables efficient tool loops.
+     * Instead of rebuilding the full history, we send just the tool result.
+     */
+    sendToolResult(toolUseId: string, result: string, isError?: boolean, callbacks?: PromptCallbacks): Promise<PromptResult>;
+    /**
+     * Queue a tool result to be sent with the next message
+     *
+     * Use this when you want to collect multiple tool results before continuing.
+     */
+    queueToolResult(toolUseId: string, result: string, isError?: boolean): void;
+    /**
+     * Check if there are pending tool results
+     */
+    hasPendingToolResults(): boolean;
+    /**
+     * Get the last tool use blocks from the most recent response
+     */
+    getLastToolUseBlocks(): ToolUseBlock[];
+    /**
+     * Get current session ID
+     */
+    getSessionId(): string;
+    /**
+     * Create a new session (creates new process)
+     */
+    resetSession(sessionId?: string): void;
+    /**
+     * Set session ID (for channel-specific conversations)
+     *
+     * Note: This creates a new channel key, effectively switching channels.
+     * The old process is kept alive for potential reuse.
+     * Callers should use resetSession() if the old process is no longer needed to avoid orphan processes.
+     *
+     * @deprecated - per-call sessionId via prompt() options; this mutates shared adapter state
+     */
+    setSessionId(sessionId: string): void;
+    /**
+     * Set system prompt
+     *
+     * IMPORTANT: This only affects new processes. Existing processes keep their prompt.
+     * To apply a new system prompt, call resetSession() after setSystemPrompt().
+     *
+     * @deprecated - mutates shared spawn state; pass systemPrompt per prompt() call
+     */
+    setSystemPrompt(prompt: string): void;
+    /**
+     * Get current options (for debugging)
+     */
+    getOptions(): ClaudeCLIWrapperOptions;
+    getSessionPolicyStatus(options: PromptOptions): SessionPolicyStatus;
+    /**
+     * Check if the adapter has a live process ready to accept prompts.
+     */
+    isHealthy(): boolean;
+    /**
+     * Collect runtime metrics.
+     */
+    getMetrics(): RunnerMetrics;
+    /**
+     * Gracefully stop all processes (IModelRunner.stop).
+     */
+    stop(): void;
+    /**
+     * Stop all processes (cleanup) — legacy name, delegates to stop().
+     */
+    stopAll(): void;
+    /**
+     * Check if the adapter is in persistent mode (always true for this adapter)
+     */
+    isPersistent(): boolean;
+    /**
+     * Get the current process state
+     */
+    getProcessState(): string;
+    /**
+     * Get number of active processes in the pool
+     */
+    getActiveProcessCount(): number;
+}
+/**
+ * Factory function to create a ClaudeCLIWrapper-compatible adapter
+ *
+ * Usage:
+ *   const wrapper = createPersistentCLIAdapter({ sessionId: 'discord-channel-123' });
+ *   const result = await wrapper.prompt('Hello!');
+ *
+ * Each adapter instance maintains its own process pool. Processes are not shared across adapter instances.
+ */
+export declare function createPersistentCLIAdapter(options: ClaudeCLIWrapperOptions): PersistentCLIAdapter;
+//# sourceMappingURL=persistent-cli-adapter.d.ts.map