dsh-loop-engine-allinone 0.0.0-stage → 0.4.1

package/lib/types/engine-pi/rpc/client.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Strict-LF JSONL client for the Pi RPC subprocess (`pi --mode rpc`).
+ *
+ * The driver hands the client a process handle carrying its stdin/stdout/stderr
+ * (projected from the dsh subprocess seam, so the whole `pi` child is sandboxed
+ * by the harness). The client frames records on a bare `\n` only — not on
+ * Unicode separators — using a byte decoder, tolerates a trailing `\r`, and
+ * correlates command responses by the optional `id` field while dispatching
+ * every non-response line to a buffered event stream.
+ *
+ * @module dsh-loop-engine-allinone/engine-pi/rpc/client
+ */
+import type { ChildProcess } from 'node:child_process';
+import type { Readable, Writable } from 'node:stream';
+import type { PiCommand, PiEvent, PiImage, PiResponse } from './types.ts';
+/** A spawned Pi RPC process as the protocol transport needs it. */
+export interface PiProcess {
+    /** Child stdin (command JSON lines). */
+    readonly stdin: Writable;
+    /** Child stdout (response + event JSON lines). */
+    readonly stdout: Readable;
+    /** Child stderr (diagnostics; buffered and dropped). */
+    readonly stderr: Readable;
+    /** Register a single human-readable termination callback. */
+    onExit(handler: () => void): void;
+    /** Request process-tree termination. */
+    terminate(): void;
+}
+/** The exact argv/cwd/env the driver requests for one `pi --mode rpc` child. */
+export interface PiSpawnSpec {
+    /** The program plus its flags; `argv[0]` is the Pi CLI entrypoint. */
+    readonly argv: readonly string[];
+    readonly cwd: string;
+    readonly env: Record<string, string>;
+}
+/** Spawns one Pi RPC process over the given spec (the driver's spawn capability). */
+export type PiSpawnCapability = (spec: PiSpawnSpec) => PiProcess;
+/** Callback receiving every non-response event line. */
+export type PiEventHandler = (event: PiEvent) => void;
+/** Options for one `prompt` command. */
+export interface PiPromptOptions {
+    readonly streamingBehavior?: 'steer' | 'followUp';
+    /** Images sent with this prompt, as the protocol takes them. */
+    readonly images?: readonly PiImage[];
+}
+/** Project a `node:child_process` child onto the Pi protocol transport. */
+export declare function fromChildProcess(child: ChildProcess): PiProcess;
+/** Prompt the agent and stream its events. */
+export declare class PiRpcClient {
+    private readonly process;
+    private reqId;
+    private pending;
+    private readonly eventBuffer;
+    private eventWake;
+    private eventHandler;
+    private disposed;
+    private readonly decoder;
+    private buffer;
+    private readonly onStderr;
+    /** Whether this client was disposed or its process exited. */
+    get closed(): boolean;
+    /** Mount a client over an already-spawned Pi RPC process. */
+    constructor(process: PiProcess);
+    /**
+     * Create a client, spawning the Pi RPC child through the supplied capability
+     * (or the default node-runtime spawn when none is given).
+     * @param spec - the Pi CLI argv/cwd/env the child should run with.
+     * @param spawn - optional process-spawn capability (the subprocess seam);
+     *   absent falls back to the plain node child spawn.
+     * @returns the connected client.
+     */
+    static create(spec: PiSpawnSpec, spawn?: PiSpawnCapability): PiRpcClient;
+    /** Register the event dispatch handler. */
+    onEvent(handler: PiEventHandler): void;
+    /** Drop any events still buffered from a previous step (stateless per-step sessions). */
+    clearEvents(): void;
+    /** Start a fresh Pi session. */
+    newSession(): Promise<PiResponse>;
+    /** Prompt the agent and await the acceptance response. */
+    prompt(message: string, options?: PiPromptOptions): Promise<PiResponse>;
+    /** Abort the current agent operation. */
+    abort(): Promise<PiResponse>;
+    /** Query session stats. */
+    getSessionStats(): Promise<PiResponse>;
+    /** Send a command without awaiting its response (fire-and-forget). */
+    send(command: PiCommand): void;
+    /**
+     * Send a command and await the correlated response. Assigns a fresh `id`
+     * when the command carries none, so responses always round-trip.
+     */
+    request(command: PiCommand): Promise<PiResponse>;
+    /**
+     * Consume every buffered event as an async generator, waking as fresh lines
+     * arrive. The caller bounds the iteration by a terminal event; unmatched
+     * lines stay buffered for a later iteration.
+     */
+    events(): AsyncGenerator<PiEvent, void, void>;
+    /** Dispose the client and request child termination. */
+    dispose(): void;
+    /** Feed one chunk of stdout into the framing state machine. */
+    private feed;
+    /** Dispatch one parsed line to the pending map or the event queue. */
+    private dispatch;
+    /** Drain decoded stderr bytes (no-op consumer keeps the pipe flowing). */
+    private consumeStderr;
+}
+//# sourceMappingURL=client.d.ts.map

package/lib/types/engine-pi/rpc/mapping.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Maps Pi RPC messages and end-of-execution events to dsh session-log events.
+ * Token-level streaming deltas are folded inline by the driver's step loop
+ * (they carry live progress); this module projects the end-state items — a
+ * completed tool call, a completed tool execution, and a finished turn's usage
+ * — into the durable `tool/call`, `tool/result`, and usage events.
+ *
+ * @module dsh-loop-engine-allinone/engine-pi/rpc/mapping
+ */
+import type { TokenUsage, ToolResultMessage } from '@deepseek-ai/dsh-llm';
+import type { PiUsage } from './types.ts';
+/** Map one Pi usage snapshot to dsh TokenUsage. */
+export declare function mapUsage(usage: PiUsage): TokenUsage;
+/**
+ * Derive the compact transcript text of a Pi content block, joining nested
+ * text segments so the durable tool-result block carries the read model text.
+ * @param content - the result payload (e.g. `{ content: [{ type, text }, ...] }`).
+ * @returns the joined text.
+ */
+export declare function resultText(content: unknown): string;
+/** Map a completed Pi tool-execution end event to the durable tool/result message. */
+export declare function mapToolResult(ev: {
+    toolCallId: string;
+    result: unknown;
+    isError: boolean;
+}): ToolResultMessage;
+/** Map the identity of a Pi message tool call or execution start to a durable tool/call. */
+export declare function mapToolCall(ev: {
+    callId: string;
+    name: string;
+    arguments: unknown;
+}): {
+    callId: string;
+    name: string;
+    arguments: string;
+};
+//# sourceMappingURL=mapping.d.ts.map

package/lib/types/engine-pi/rpc/types.d.ts

@@ -0,0 +1,249 @@
+/**
+ * Pi RPC protocol type definitions. A minimal subset of the upstream
+ * `pi --mode rpc` protocol, covering only what the driver needs: the commands
+ * it sends (`new_session`, `prompt`, `abort`, `get_session_stats`), the
+ * response envelope, and the streaming events it maps into the durable dsh
+ * session log. Types only — no runtime code.
+ *
+ * The protocol is strict LF (`\n`) JSONL: records are delimited only by a bare
+ * `\n` (a trailing `\r` is tolerated), and Unicode separators such as U+2028 /
+ * U+2029 are ordinary characters inside JSON strings — so a generic line reader
+ * that treats them as newlines is not compliant.
+ *
+ * @module dsh-loop-engine-allinone/engine-pi/rpc/types
+ */
+/** Optional per-command correlation id; echoed back on the response. */
+export interface PiCommandCorrelation {
+    readonly id?: number;
+}
+/** Start a fresh Pi session (the driver issues one per dsh step). */
+export interface PiNewSessionCommand extends PiCommandCorrelation {
+    readonly type: 'new_session';
+    readonly parentSession?: string;
+}
+/** Send a user prompt to the agent and begin streaming events. */
+export interface PiPromptCommand extends PiCommandCorrelation {
+    readonly type: 'prompt';
+    readonly message: string;
+    readonly images?: readonly PiImage[];
+    readonly streamingBehavior?: 'steer' | 'followUp';
+}
+/** Abort the current agent operation. */
+export interface PiAbortCommand extends PiCommandCorrelation {
+    readonly type: 'abort';
+}
+/** Query session stats (usage/cost fallback when a message carries none). */
+export interface PiGetSessionStatsCommand extends PiCommandCorrelation {
+    readonly type: 'get_session_stats';
+}
+/** Every command the client can send. */
+export type PiCommand = PiNewSessionCommand | PiPromptCommand | PiAbortCommand | PiGetSessionStatsCommand;
+/** Message attachment (images) accepted by `prompt`. */
+export interface PiImage {
+    readonly type: 'image';
+    readonly data: string;
+    readonly mimeType: string;
+}
+/** Successful or failed command response. */
+export interface PiResponse {
+    readonly type: 'response';
+    readonly command?: string;
+    readonly success: boolean;
+    readonly error?: string;
+    readonly id?: number;
+    readonly data?: unknown;
+}
+/** Session statistics returned by `get_session_stats`. */
+export interface PiSessionStats {
+    readonly tokens?: {
+        readonly input?: number;
+        readonly output?: number;
+        readonly cacheRead?: number;
+        readonly cacheWrite?: number;
+        readonly total?: number;
+    };
+    readonly contextUsage?: {
+        readonly tokens?: number | null;
+        readonly contextWindow?: number;
+        readonly percent?: number | null;
+    };
+}
+/** Provider-reported token usage attached to messages and updates. */
+export interface PiUsage {
+    readonly input?: number;
+    readonly output?: number;
+    readonly cacheRead?: number;
+    readonly cacheWrite?: number;
+    readonly totalTokens?: number;
+}
+/** A content block of a Pi message. */
+export type PiContent = {
+    readonly type: 'text';
+    readonly text: string;
+} | {
+    readonly type: 'thinking';
+    readonly thinking: string;
+} | {
+    readonly type: 'toolCall';
+    readonly id: string;
+    readonly name: string;
+    readonly arguments: unknown;
+};
+/** One role-tagged Pi message. */
+export interface PiMessage {
+    readonly role: 'user' | 'assistant' | 'toolResult' | 'system';
+    readonly content: string | readonly PiContent[];
+    readonly usage?: PiUsage;
+    readonly isError?: boolean;
+    /**
+     * Pi's own verdict on the turn this assistant message belongs to
+     * (`stop`, `toolUse`, `length`, `error`, …). Absent on the messages that
+     * state none — user and tool-result messages — so it is only read on the
+     * assistant message a `turn_end`/`message_end` carries.
+     */
+    readonly stopReason?: string;
+    /**
+     * Pi's failure text, accompanying `stopReason: 'error'`: the reason the turn
+     * did not produce a reply (an unregistered `api`, a refused connection, …).
+     * This is the only place that reason exists — pi's RPC `response` envelope
+     * reports command success, not turn outcome.
+     */
+    readonly errorMessage?: string;
+    readonly toolCallId?: string;
+    readonly toolName?: string;
+    readonly timestamp?: number;
+    readonly id?: string;
+}
+/** A tool result as carried by `turn_end.toolResults`. */
+export interface PiToolResult {
+    readonly role: 'toolResult';
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly content: readonly PiContent[];
+    readonly isError?: boolean;
+    readonly usage?: PiUsage;
+}
+/** The `assistantMessageEvent` delta union of `message_update`. */
+export type PiAssistantMessageEvent = {
+    readonly type: 'text_start';
+    readonly contentIndex: number;
+} | {
+    readonly type: 'text_delta';
+    readonly contentIndex: number;
+    readonly delta: string;
+} | {
+    readonly type: 'text_end';
+    readonly contentIndex: number;
+    readonly content?: string;
+} | {
+    readonly type: 'thinking_start';
+    readonly contentIndex: number;
+} | {
+    readonly type: 'thinking_delta';
+    readonly contentIndex: number;
+    readonly delta: string;
+} | {
+    readonly type: 'thinking_end';
+    readonly contentIndex: number;
+    readonly thinking?: string;
+} | {
+    readonly type: 'toolcall_start';
+    readonly contentIndex: number;
+    readonly id: string;
+    readonly toolName: string;
+} | {
+    readonly type: 'toolcall_delta';
+    readonly contentIndex: number;
+    readonly delta: string;
+} | {
+    readonly type: 'toolcall_end';
+    readonly contentIndex: number;
+    readonly toolCall: {
+        readonly id: string;
+        readonly name: string;
+        readonly arguments: unknown;
+    };
+};
+/** An `extension_ui_request` (dialog or fire-and-forget). */
+export interface PiExtensionUiRequest {
+    readonly type: 'extension_ui_request';
+    readonly id: string;
+    readonly method: 'select' | 'confirm' | 'input' | 'editor' | 'notify' | 'setStatus' | 'setWidget' | 'setTitle' | 'set_editor_text';
+    readonly title?: string;
+    readonly options?: readonly string[];
+    readonly message?: string;
+    readonly [key: string]: unknown;
+}
+/** A tool-execution event (start / update / end). */
+export type PiToolExecutionEvent = {
+    readonly type: 'tool_execution_start';
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly args: unknown;
+} | {
+    readonly type: 'tool_execution_update';
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly args: unknown;
+    readonly partialResult: unknown;
+} | {
+    readonly type: 'tool_execution_end';
+    readonly toolCallId: string;
+    readonly toolName: string;
+    readonly result: unknown;
+    readonly isError: boolean;
+};
+/** Every agent event the driver consumes or ignores. */
+export type PiEvent = {
+    readonly type: 'response';
+} & PiResponse | {
+    readonly type: 'agent_start';
+} | {
+    readonly type: 'agent_end';
+    readonly messages?: readonly PiMessage[];
+    readonly willRetry?: boolean;
+} | {
+    readonly type: 'agent_settled';
+} | {
+    readonly type: 'turn_start';
+} | {
+    readonly type: 'turn_end';
+    readonly message?: PiMessage;
+    readonly toolResults?: readonly PiToolResult[];
+} | {
+    readonly type: 'message_start';
+    readonly message: PiMessage;
+} | {
+    readonly type: 'message_update';
+    readonly usage?: PiUsage;
+    readonly assistantMessageEvent: PiAssistantMessageEvent;
+} | {
+    readonly type: 'message_end';
+    readonly message: PiMessage;
+} | PiToolExecutionEvent | {
+    readonly type: 'compaction_start';
+    readonly reason?: string;
+} | {
+    readonly type: 'compaction_end';
+    readonly reason?: string;
+    readonly aborted?: boolean;
+    readonly willRetry?: boolean;
+    readonly result?: unknown;
+} | {
+    readonly type: 'auto_retry_start';
+    readonly attempt?: number;
+} | {
+    readonly type: 'auto_retry_end';
+    readonly success?: boolean;
+    readonly attempt?: number;
+    readonly finalError?: string;
+} | {
+    readonly type: 'queue_update';
+    readonly steering?: readonly string[];
+    readonly followUp?: readonly string[];
+} | {
+    readonly type: 'bash_execution_update';
+    readonly id?: string;
+    readonly delta?: string;
+} | PiExtensionUiRequest;
+//# sourceMappingURL=types.d.ts.map

package/lib/types/engine-pi/skills.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Pi skill provider: exposes the Pi CLI's instruction files and skills as DSH
+ * skills.
+ *
+ * Pi reads per-directory context files (`AGENTS.md`, or `CLAUDE.md`,
+ * preferring `AGENTS.override.md` where one exists) from the session cwd up to
+ * the git root, plus a global `AGENTS.md` under the pi config directory
+ * (`PI_CODING_AGENT_DIR` or `~/.pi/agent`), and installs skills from
+ * `skills/` directories (`~/.pi/agent/skills/` and project `.pi/skills/`
+ * walking up). Each context-file set is surfaced as one user-invocable
+ * `agents-md` skill whose body is the concatenated file contents; every found
+ * `SKILL.md` catalog entry is surfaced under its own name, so the dsh
+ * skill-injection seam (`/name` gestures) can carry them into the prompt.
+ *
+ * `.agents/skills` roots are deliberately not scanned here: dsh's own
+ * `skill-filesystem` provider already exposes them through the same registry
+ * in the web profile. Pi settings/CLI/package skills are only discoverable
+ * through a running `pi --mode rpc` probe, which the engine does not perform
+ * at composition time — the filesystem subset above is authoritative for the
+ * web menu.
+ *
+ * The discovery algorithm itself lives in {@link AgentsMdSkillProvider}; this
+ * module supplies only Pi's locations and ranks.
+ *
+ * @module dsh-loop-engine-allinone/engine-pi/skills
+ */
+import { AgentsMdSkillProvider } from '../driver-core/agents-md-skill-provider.ts';
+import type { SkillProviderControl } from '../skills.ts';
+/**
+ * Resolve the pi config directory, honoring the `PI_CODING_AGENT_DIR`
+ * environment override and falling back to `~/.pi/agent`.
+ * @returns the absolute pi config directory.
+ */
+export declare function piAgentDir(): string;
+/**
+ * Skill provider that discovers context files and skills from pi's standard
+ * locations:
+ *   - project context files between the cwd and the git root (plus
+ *     `~/.pi/agent/AGENTS.md`) — surfaced as one `agents-md` skill;
+ *   - project `.pi/skills/` and user `~/.pi/agent/skills/` — each `SKILL.md`
+ *     entry surfaced under its own name.
+ */
+export declare class PiSkillProvider extends AgentsMdSkillProvider {
+    constructor(control: SkillProviderControl);
+}
+export default PiSkillProvider;
+//# sourceMappingURL=skills.d.ts.map

package/lib/types/engine-pi/types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Public types of the Pi loop driver. Types only — no runtime code.
+ *
+ * Pi carries no native permission system ("runs with the permissions of the
+ * user"), so the declarative stance this driver resolves is a sandbox mode plus
+ * the tool set the process is allowed to use; the rest of the driver then
+ * either wraps the whole `pi --mode rpc` child in the dsh subprocess sandbox or
+ * prunes its `--tools` accordingly.
+ *
+ * @module dsh-loop-engine-allinone/engine-pi/types
+ */
+/** Pi sandbox stances the driver can resolve, mapped from the dsh session knobs. */
+export type PiSandboxMode = 'read-only' | 'workspace-write' | 'danger-full-access';
+/** Driver configuration after defaults and load-time validation. */
+export interface ResolvedConfig {
+    /** Pinned sandbox mode; `undefined` follows the session's dsh permission knobs per query. */
+    readonly sandboxMode: PiSandboxMode | undefined;
+    /** LLM provider the `pi` RPC process is launched with (`--provider`), when the session selects no model. */
+    readonly provider: string | undefined;
+    /** Fallback model pattern for the `pi` RPC process (`--model`), used when the session selects none. */
+    readonly model: string | undefined;
+    /** Thinking/reasoning level for the model (`--model <id>:<level>` or set at runtime). */
+    readonly thinkingLevel: string | undefined;
+    /** Explicit environment entries layered over the credential-scrubbed parent environment. */
+    readonly env: Record<string, string>;
+    /**
+     * An EXTERNAL Pi CLI entrypoint to run instead of this package's bundled
+     * `@earendil-works/pi-coding-agent`, or `undefined` to keep the bundled copy.
+     *
+     * Pi's CLI is a Node script either way, so the driver always runs the
+     * resolved entrypoint under the current node — the only thing a pinned path
+     * changes is which script that is.
+     */
+    readonly bin: string | undefined;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/engine-qoderclicn/agent.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Qoder CN agent: one `qoderclicn -p … --output-format stream-json` child per
+ * dsh step, with the durable session log as the sole source of model context.
+ *
+ * The whole engine-specific surface is {@link QoderclicnAgent.runStep}: serialize
+ * the transcript, spawn, decode the NDJSON dialect, and let the shared sink write
+ * the durable log. Everything else — the turn loop, the inbox, cancellation, the
+ * step rotation, the tool-call/result pairing — is inherited from
+ * {@link CliHostedAgent}.
+ *
+ * ## Why one child per step
+ *
+ * Qoder's `-p` is inherently one-shot: it answers and exits. That suits this
+ * plugin's model exactly, because the plugin is stateless by design — every step
+ * replays the durable transcript as the prompt, so nothing is lost by not
+ * carrying a session across steps, and nothing leaks between them either. The
+ * cost is process startup per step, which is what `capabilities.sessionResume`
+ * describes rather than hides.
+ *
+ * @module dsh-loop-engine-allinone/engine-qoderclicn/agent
+ */
+import type { AgentOptions } from '@deepseek-ai/dsh-agent';
+import type { Session, SessionId, UserMessage } from '@deepseek-ai/dsh-session';
+import type { Context } from '@deepseek-ai/cordis';
+import type { HostedEngineId } from '../engine-registry.ts';
+import { CliHostedAgent } from '../driver-cli/cli-agent.ts';
+import type { SinkPosition } from '../driver-cli/session-sink.ts';
+import type { CliSpawnCapability } from '../driver-cli/transport.ts';
+/** Deployment-resolved configuration for the Qoder engine. */
+export interface ResolvedQoderclicnConfig {
+    /** Pinned executable, when the deployment named one. */
+    readonly bin: string | undefined;
+    /** Explicit environment entries layered over the scrubbed parent environment. */
+    readonly env: Record<string, string>;
+    /** Pinned model, when the deployment named one. */
+    readonly model: string | undefined;
+    /** Pinned permission mode, overriding the session's knobs. */
+    readonly permissionMode: string | undefined;
+}
+/** The engine id this driver registers under. */
+export declare const QODERCLICN_ENGINE: HostedEngineId;
+/**
+ * Drives one session through turn and step boundaries on Qoder CN.
+ *
+ * Named for the engine rather than generically so a stack trace says which
+ * driver failed; the shared machinery it inherits is what makes the class this
+ * small.
+ */
+export declare class QoderclicnAgent extends CliHostedAgent {
+    private readonly config;
+    private readonly spawn;
+    constructor(loopCtx: Context, id: SessionId, options: AgentOptions, session: Session, config: ResolvedQoderclicnConfig, spawn: CliSpawnCapability);
+    protected runStep(messages: readonly UserMessage[], position: SinkPosition, signal: AbortSignal): Promise<{
+        kind: 'completed';
+    } | null>;
+    /** Resolve the permission mode for this step: the pin wins, else the session's knobs. */
+    private permissionMode;
+}
+//# sourceMappingURL=agent.d.ts.map

package/lib/types/engine-qoderclicn/loop.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Qoder CN loop engine module: drives every session it is handed through one
+ * `qoderclicn -p --output-format stream-json` child per dsh step, with the
+ * durable session log as the sole source of model context. The router routes a
+ * session here on the plugin's own engine record, else its agent preset; this
+ * module is a library, not a Cordis plugin entry.
+ *
+ * Qoder's CLI has a permission-mode switch but no channel this driver can
+ * forward a human approval question through, so the effective boundary is the
+ * dsh subprocess sandbox the whole child is spawned under (default read-only)
+ * plus the mode mapped in `./process.ts`.
+ *
+ * @module dsh-loop-engine-allinone/engine-qoderclicn
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { AgentOptions } from '@deepseek-ai/dsh-agent';
+import type { Session, SessionId } from '@deepseek-ai/dsh-session';
+import { CliEngineRuntime } from '../driver-cli/cli-loop.ts';
+import { QoderclicnAgent, type ResolvedQoderclicnConfig } from './agent.ts';
+/** Deployment-owned configuration for the Qoder CN engine. */
+export interface Config {
+    /** Model for the CLI (`--model`); Qoder's own configuration owns the model when omitted. */
+    model?: string;
+    /** Explicit environment entries passed to the child. */
+    env?: Record<string, string>;
+    /** The `qoderclicn` executable; PATH (and the CLI's own install dir) when not pinned. */
+    bin?: string;
+    /** Pinned permission mode, overriding the session's dsh permission knobs. */
+    permissionMode?: string;
+}
+/** Schema of the Qoder CN engine configuration. */
+export declare const Config: z<Config>;
+/** Host-face ctx key this engine's runtime is registered under. */
+export declare const QODERCLICN_ENGINE_LABEL = "agentLoopQoderclicn";
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        agentLoopQoderclicn: QoderclicnLoop;
+    }
+}
+/**
+ * Creation/resume machinery for the Qoder CN engine. The process-wide
+ * AgentFactory slot belongs to the router, which delegates each session to the
+ * engine its preset names; this class is that engine's driver, not a plugin.
+ */
+export declare class QoderclicnLoop extends CliEngineRuntime<ResolvedQoderclicnConfig, QoderclicnAgent> {
+    constructor(ctx: Context, config: Config);
+    /** Construct the Qoder driver for one prepared session. */
+    protected buildAgent(loopCtx: Context, id: SessionId, options: AgentOptions, session: Session): QoderclicnAgent;
+}
+//# sourceMappingURL=loop.d.ts.map