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

package/lib/types/engine-kimi/acp/types.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Agent Client Protocol (ACP) wire types for the `kimi acp` driver.
+ *
+ * Kimi exposes the ACP adapter over stdio (JSON-RPC 2.0). The driver speaks a
+ * minimal, stable subset that a normal agent flow needs: initialize, session/new,
+ * session/prompt, session/cancel, plus the `session/update` notifications carrying
+ * incremental assistant text (`agent_message_chunk`), thinking
+ * (`agent_thought_chunk`), and tool calls (`tool_call` / `tool_call_update`).
+ * Tool-approval arrives as the reverse-RPC `session/request_permission`, which the
+ * client must answer. Shapes below are the live-record deltas observed against the
+ * 0.28.1 CLI; content blocks re-use a `{ type, text }` text shape (and tolerate
+ * other block types by ignoring them). The image block is modelled for the
+ * OUTGOING side — the bytes a dsh step delivers as an ACP image block.
+ *
+ * @module dsh-loop-engine/engine-kimi/acp/types
+ */
+/** A text content block in an ACP update (the observed kimi shape). */
+export interface AcpTextContent {
+    readonly type: 'text';
+    readonly text: string;
+}
+/** One tool-call content block: the observed kimi `{ type: 'content', content }` nesting. */
+export interface AcpToolContentBlock {
+    readonly type: 'content';
+    readonly content: AcpTextContent;
+}
+/** An image content block, as ACP/MCP spells it (base64 bytes + media type). */
+export interface AcpImageContent {
+    readonly type: 'image';
+    /** Base64-encoded image bytes. */
+    readonly data: string;
+    /** The image's own media type. */
+    readonly mimeType: string;
+}
+/** A content block in a chunk/thought update; text is handled, others are ignored. */
+export type AcpContentBlock = AcpTextContent | AcpImageContent | {
+    readonly type: 'resource_link' | 'audio' | string;
+    readonly [key: string]: unknown;
+};
+/** One `session/update` notification (partial; the discriminator is `sessionUpdate`). */
+export interface AcpUpdate {
+    readonly sessionUpdate: string;
+    readonly [key: string]: unknown;
+}
+/**
+ * A tool-call announcement (`sessionUpdate: 'tool_call'`).
+ *
+ * Measured against kimi 0.28.x: an announcement carries the call's identity
+ * (`toolCallId`/`title`/`kind`) and an empty content card, but **never** its
+ * input — `rawInput` only ever arrives on a later `tool_call_update` (the
+ * execution-start frame).
+ */
+export interface AcpToolCallExt extends AcpUpdate {
+    readonly sessionUpdate: 'tool_call';
+    readonly toolCallId: string;
+    readonly title: string;
+    readonly kind: string;
+    readonly status: string;
+    readonly content?: readonly AcpToolContentBlock[];
+    /** The call's real input; absent on the announcement (see above). */
+    readonly rawInput?: unknown;
+}
+/** A tool-call progress/result stream (`sessionUpdate: 'tool_call_update'`). */
+export interface AcpToolCallStreamExt extends AcpUpdate {
+    readonly sessionUpdate: 'tool_call_update';
+    readonly toolCallId: string;
+    readonly status: string;
+    readonly content?: readonly AcpToolContentBlock[];
+    /** The call's real input, first present on the execution-start frame. */
+    readonly rawInput?: unknown;
+    /** The tool's raw structured output, present once the call settles. */
+    readonly rawOutput?: unknown;
+}
+/** One option the agent offers for a `session/request_permission`. */
+export interface AcpPermissionOption {
+    /** Opaque id the client sends back in `outcome.optionId` (the only field the agent reads). */
+    readonly optionId: string;
+    /** Human-readable label for the option. */
+    readonly name?: string;
+    /** Option class: `allow_once` / `allow_always` / `reject_once` / `reject_always`. */
+    readonly kind?: string;
+}
+/** The `session/request_permission` reverse-RPC params. */
+export interface AcpPermissionRequest {
+    readonly sessionId?: string;
+    /** Every option the agent will accept an answer for; empty means no answerable choice. */
+    readonly options?: readonly AcpPermissionOption[];
+    /** The tool call the prompt belongs to (presentation/correlation only). */
+    readonly toolCall?: unknown;
+}
+/**
+ * Terminal outcome of a permission request: the option the client picked, or
+ * `cancelled` when it had no answer to give.
+ */
+export type AcpPermissionOutcome = {
+    readonly outcome: 'selected';
+    readonly optionId: string;
+} | {
+    readonly outcome: 'cancelled';
+};
+/** The `session/request_permission` result the agent expects (ACP `RequestPermissionResponse`). */
+export interface AcpPermissionResponse {
+    readonly outcome: AcpPermissionOutcome;
+}
+/** Result of a completed `session/prompt` request (opaque; the turn ended). */
+export interface AcpPromptResult {
+    readonly [key: string]: unknown;
+}
+/** The id-scoped response to a request (result or error). */
+export interface AcpResponse {
+    readonly id: number;
+    readonly result?: unknown;
+    readonly error?: {
+        readonly code: number;
+        readonly message: string;
+    };
+}
+/** A JSON-RPC request/notification frame on the wire. */
+export interface AcpFrame {
+    readonly jsonrpc: '2.0';
+    readonly id?: number;
+    readonly method?: string;
+    readonly params?: unknown;
+    readonly result?: unknown;
+    readonly error?: {
+        readonly code: number;
+        readonly message: string;
+    };
+}
+/** Guards toolkit: is the frame a `session/update` notification carrying an update. */
+export declare function isUpdateFrame(frame: AcpFrame): frame is AcpFrame & {
+    readonly method: 'session/update';
+    readonly params: {
+        readonly sessionId: string;
+        readonly update: AcpUpdate;
+    };
+};
+/** Guards toolkit: is the frame a reverse-RPC request needing an approval answer. */
+export declare function isPermissionRequestFrame(frame: AcpFrame): frame is AcpFrame & {
+    readonly id: number;
+    readonly method: 'session/request_permission';
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,24 @@
+/**
+ * Kimi Code's ACP dialect's loop Agent: the shared ACP body with the dialect in `./profile.ts`.
+ *
+ * The class is this engine's published driver shape (and the seam a
+ * kimi-specific behaviour would land on); the dialect itself — argv, protocol
+ * version, model selection, session handshake — lives in `./profile.ts`, which
+ * imports no host service so it can be exercised by `scripts/probe/smoke-acp.ts`
+ * against the real CLI.
+ *
+ * @module dsh-loop-engine-allinone/engine-kimi/agent
+ */
+import type { AgentOptions } from '@deepseek-ai/dsh-agent';
+import type { Session, SessionId } from '@deepseek-ai/dsh-session';
+import type { Context } from '@deepseek-ai/cordis';
+import type { AcpResolvedConfig } from '../driver-acp/profile.ts';
+import type { AcpSpawnCapability } from '../driver-acp/transport.ts';
+import { AcpEngineAgent } from '../driver-acp/agent.ts';
+import { kimiProfile } from './profile.ts';
+export { kimiProfile };
+/** Kimi Code's ACP dialect's loop Agent: the shared ACP body with the profile's dialect. */
+export declare class KimiAgent extends AcpEngineAgent {
+    constructor(loopCtx: Context, id: SessionId, options: AgentOptions, session: Session, config: AcpResolvedConfig, spawn: AcpSpawnCapability, bin?: string);
+}
+//# sourceMappingURL=agent.d.ts.map

package/lib/types/engine-kimi/commands.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Kimi Code slash-command bridge.
+ *
+ * The dsh `commands` runtime executes a registered command locally — the line is
+ * consumed and never reaches the model — so a command whose real processing
+ * lives inside the Kimi engine must forward the raw line back to the agent, which
+ * Kimi then expands natively. Registering the built-ins keeps them visible in
+ * the dsh web slash menu; unregistered `/lines` pass through as user text, but
+ * the menu would hide the engine's command surface.
+ *
+ * The list below is exactly what the `kimi acp` command surface implements
+ * (verified against kimi 0.28.1, both by driving `session/prompt` directly and
+ * by reading the `available_commands_update` the child publishes): `compact`,
+ * `status`, `usage`, `mcp`, `tasks`, `help`. Everything else Kimi's TUI offers
+ * (`/login`, `/provider`, `/settings`, `/sessions`, `/clear`, `/plan`, …) is a
+ * TUI control the ACP surface does not implement — forwarding one answers
+ * `Unknown ACP command: /name.` — so none of them is registered. `skill:`
+ * commands are already carried by the dsh skill injection seam and Kimi's own
+ * shorthand, so they are not duplicated here.
+ *
+ * `model` is deliberately absent even though the CLI has it: the dsh web
+ * client owns a `/model` contribution, and a same-named host command makes
+ * `ui-commands` throw the whole command menu source away, leaving only the
+ * skill group. `/goal` is absent too: the ACP surface implements no `/goal`, so
+ * registering one would only answer with an unknown-command error. Hosted
+ * sessions have no dsh `/goal` either — the engine preset they join strips the
+ * `command-goal` row (`src/preset.ts`, `STRIPPED_ROWS`) — so the command is
+ * simply not part of their menu.
+ *
+ * @module dsh-loop-engine-allinone/engine-kimi/commands
+ */
+import type { CommandDefinition, CommandInvocation, CommandResult } from '../commands.ts';
+/**
+ * Build the forwarding handler for one Kimi slash command: it re-delivers the
+ * full `/<name> [args]` line to the receiving agent as a plain user message,
+ * where the engine expands it. `rawInput` already carries the separator
+ * whitespace and any arguments.
+ * @param name - the command name without the leading slash.
+ * @returns the command handler.
+ */
+export declare function forwardKimiCommand(name: string): (invocation: CommandInvocation) => CommandResult;
+/** Kimi Code's built-in slash commands that the ACP surface implements. */
+export declare const KIMI_COMMANDS: readonly CommandDefinition[];
+//# sourceMappingURL=commands.d.ts.map

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

@@ -0,0 +1,62 @@
+/**
+ * Kimi Code loop engine module: drives every session it is handed through a
+ * persistent `kimi acp` child (Agent Client Protocol over stdio), speaking one
+ * stateless `session/new` + `session/prompt` 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. Kimi has no host approval callback, so
+ * tool approvals surfaced by ACP (`session/request_permission`) are answered from
+ * the session's dsh approval knobs (an `ask` policy degrades to denial); the whole
+ * child is spawned through the dsh subprocess seam — the only available privilege
+ * boundary — and the sandbox stance follows the session's durable permission knobs
+ * as the subprocess provider resolves them (default read-only).
+ *
+ * @module dsh-loop-engine-allinone/engine-kimi
+ */
+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 { KimiAgent } from './agent.ts';
+import { AcpEngineRuntime } from '../driver-acp/runtime.ts';
+/** Grace in milliseconds for Kimi process-tree termination. */
+export declare const KIMI_DISPOSE_GRACE_MS = 3000;
+/** Deployment-owned configuration for the Kimi loop plugin. */
+export interface Config {
+    /** Model sent per ACP session (`session/set_model`) when the session selects none; Kimi native config owns the model when omitted. */
+    model?: string;
+    /** Explicit environment entries passed to the `kimi` child. */
+    env?: Record<string, string>;
+    /** Kimi CLI executable; `'kimi'` resolves through PATH when not pinned to an absolute path. */
+    bin?: string;
+    /**
+     * Idle window in milliseconds before a session's `kimi acp` child is shut
+     * down, spawned again by the next step. Omitted or non-positive keeps the
+     * child for the session's whole life.
+     */
+    childIdleMs?: number;
+}
+/** Schema of the Kimi loop plugin configuration. */
+export declare const Config: z<Config>;
+/** Host-face ctx key this engine's runtime is registered under. */
+export declare const KIMI_ENGINE_LABEL = "agentLoopKimi";
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        agentLoopKimi: KimiLoop;
+    }
+}
+/**
+ * Creation/resume machinery for the Kimi Code 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.
+ *
+ * Everything below the dialect is the shared ACP runtime
+ * (`driver-acp/runtime.ts`): kimi contributes its profile, which is its argv and
+ * its `KIMI_MODEL_*` endpoint handover.
+ */
+export declare class KimiLoop extends AcpEngineRuntime<KimiAgent> {
+    constructor(ctx: Context, config: Config);
+    /** Construct the Kimi ACP driver for one prepared session. */
+    protected buildAgent(loopCtx: Context, id: SessionId, options: AgentOptions, session: Session): KimiAgent;
+}
+//# sourceMappingURL=loop.d.ts.map

package/lib/types/engine-kimi/model-handover.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Kimi Code's dialect for a dsh endpoint: the `KIMI_MODEL_*` environment
+ * variables of Kimi's own built-in env-model path.
+ *
+ * Kimi Code (the `kimi acp` child) reads these four variables while loading its
+ * configuration (`applyEnvModelConfig`, kimi's own `config/env-model.ts`): when
+ * `KIMI_MODEL_NAME` is set it defines one provider and one model alias from the
+ * quartet and points `defaultModel` at that alias. That is what makes a dsh
+ * model the child's default WITHOUT touching `~/.kimi-code/config.toml` — the
+ * whole handover is environment.
+ *
+ * The one translation is the provider `type` Kimi understands
+ * (`kimi` | `anthropic` | `openai`) versus dsh's wire-protocol name. A dsh
+ * protocol with no equivalent in that set is NOT guessed: the variable is
+ * omitted, so Kimi falls back to its own `kimi` default against dsh's base URL
+ * and fails loud on the request if that endpoint does not speak it.
+ *
+ * @module dsh-loop-engine-allinone/engine-kimi/model-handover
+ */
+import type { DshModelHandover } from '../driver-core/model-handover.ts';
+/**
+ * Translate one dsh endpoint handover into the environment entries that point
+ * the `kimi acp` child at it.
+ *
+ * The credential value is carried in the child's environment (the only place a
+ * spawner outside this process can read it) and never returned anywhere else —
+ * no caller logs this object.
+ * @param handover - the resolved dsh endpoint for the session's selection.
+ * @returns the `KIMI_MODEL_*` entries to layer over the child's environment.
+ */
+export declare function kimiModelEnv(handover: DshModelHandover): Record<string, string>;
+//# sourceMappingURL=model-handover.d.ts.map

package/lib/types/engine-kimi/permission.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Tool-approval mapping for the `kimi acp` driver.
+ *
+ * Kimi's ACP adapter surfaces tool/permission decisions as the reverse-RPC
+ * `session/request_permission`, which the client must answer. The dsh harness
+ * has no interactive approval callback in the unattended runtime, so the fold
+ * mirrors the codex/Pi bridges: an `ask` approval policy degrades to a denial
+ * (the only safe answer when no human is present), and anything else
+ * (`never`, or knob-less) auto-approves the tool. A full-access sandbox mode
+ * also auto-approves; a `workspace-write` stance is still auto-approved here
+ * because Kimi's own permission gating (`--permission`/session policy) is what
+ * bounds the tool — the ACP approval is the host's gate, and the dsh
+ * `approval/policy` knob is its signal.
+ *
+ * @module dsh-loop-engine-allinone/engine-kimi/permission
+ */
+import type { PermissionEvent } from '../driver-core/permission-knobs.ts';
+/**
+ * Whether the driver should answer `session/request_permission` with approval for
+ * one query. An `ask` policy denies (fail-closed — no human is present in the
+ * unattended runtime); anything else (`never`, or knob-less) auto-approves. The
+ * sandbox stance is not consulted: Kimi's own tool policy bounds what a tool does,
+ * and the ACP approval is the host's gate, signalled by `approval/policy`.
+ * @param events - the durable session log.
+ * @returns whether tool requests are approved.
+ */
+export declare function resolveToolApproval(events: readonly PermissionEvent[]): boolean;
+//# sourceMappingURL=permission.d.ts.map

package/lib/types/engine-kimi/process.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Kimi CLI process projection: where the executable is, and the argv that
+ * launches its ACP server.
+ *
+ * The transport itself is shared (`driver-acp/transport.ts`); what is kimi's own
+ * is the RESOLUTION — kimi ships as a plain executable installed under its own
+ * home (`<KIMI_CODE_HOME>/bin/kimi[.exe]`), with PATH as the fallback — and the
+ * single `acp` subcommand that starts its Agent Client Protocol server on stdio.
+ *
+ * The `Kimi*` type names are this engine's published spelling of the shared
+ * transport types, kept as aliases rather than restated: a change to the seam
+ * cannot then reach one engine and miss another.
+ *
+ * @module dsh-loop-engine-allinone/engine-kimi/process
+ */
+import type { SubprocessHandle, SubprocessSpawnSpec } from '@deepseek-ai/dsh-subprocess';
+import type { AcpProcess, AcpSpawnCapability, AcpSpawnSpec } from '../driver-acp/transport.ts';
+/** The exact argv/cwd/env the driver requests for one `kimi acp` child. */
+export type KimiSpawnSpec = AcpSpawnSpec;
+/** A spawned Kimi process as the agent's transport needs it. */
+export type KimiProcess = AcpProcess;
+/** Spawns one Kimi child over the given spec (the driver's spawn capability). */
+export type KimiSpawnCapability = AcpSpawnCapability;
+/** Resolve the Kimi home directory from `KIMI_CODE_HOME` or the current user's home. */
+export declare function kimiHomeDir(): string;
+/**
+ * Resolve the Kimi CLI executable. An explicit config path wins; otherwise this
+ * probes the standard `<kimi home>/bin/kimi[.exe]` location and falls back to
+ * `'kimi'` (resolved through PATH by the spawner).
+ * @param configBin - an operator-pinned absolute path (or `'kimi'`), if any.
+ * @returns the executable to spawn as `argv[0]`.
+ */
+export declare function kimiBinResolver(configBin?: string): string;
+/**
+ * Build the persistent `kimi acp` argv. The ACP child stays alive across steps
+ * and is spoken to over JSON-RPC on stdio — the prompt is a request body, not an
+ * argv positional — so there is no command-line length ceiling and no model flag:
+ * a model is selected per ACP session through `session/set_model`, not argv.
+ * @param bin - the Kimi executable.
+ * @returns the argv, `argv[0]` being the executable.
+ */
+export declare function kimiAcpArgv(bin: string): string[];
+/** Project the driver's spawn request onto the dsh subprocess seam. */
+export declare function kimiSubprocessSpec(spec: KimiSpawnSpec, graceMs: number): SubprocessSpawnSpec;
+/** Project a dsh subprocess handle onto the Kimi process transport. */
+export declare function fromSubprocess(handle: SubprocessHandle): KimiProcess;
+//# sourceMappingURL=process.d.ts.map

package/lib/types/engine-kimi/profile.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Kimi Code's ACP driver: the shared ACP body plus kimi's own dialect.
+ *
+ * Kimi was the engine the shared body grew out of, so its dialect is the
+ * baseline: `kimi acp`, protocol version 1, `session/set_model` for model
+ * selection, and the one thing no other engine has — a translation of a dsh
+ * endpoint handover into the `KIMI_MODEL_*` environment its own env-model path
+ * reads.
+ *
+ * The dialect lives here, apart from the driver class in `./agent.ts`, so it
+ * imports no host service: `scripts/probe/smoke-acp.ts` exercises THIS profile
+ * (argv, protocol version, model selection, handover) against the real CLI.
+ *
+ * @module dsh-loop-engine-allinone/engine-kimi/profile
+ */
+import type { AcpEngineProfile } from '../driver-acp/profile.ts';
+/** Kimi Code's ACP dialect, as the shared driver reads it. */
+export declare function kimiProfile(bin: string): AcpEngineProfile;
+//# sourceMappingURL=profile.d.ts.map

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

@@ -0,0 +1,52 @@
+/**
+ * Kimi Code skill provider: exposes the Kimi CLI's instruction files and skills
+ * as DSH skills.
+ *
+ * Kimi reads per-directory `AGENTS.md` files from the session cwd up to the git
+ * root, and installs skills from `skills/` directories — the user-level
+ * `$KIMI_CODE_HOME/skills/` (default `~/.kimi-code/skills/`) and the
+ * project-level `.kimi-code/skills/` (walking up to the git root). 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.
+ *
+ * Unlike pi and Codex, Kimi has no user-level instruction file: its user
+ * install root holds only the skills catalog.
+ *
+ * The generic `~/.agents/skills/` and `.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. Kimi built-in Skills are
+ * shipped inside the CLI and cannot be read from a stable on-disk location, so
+ * the filesystem subset above is authoritative for the web menu. Note the
+ * shared {@link parseSkillFile} mirrors the agents-skill frontmatter
+ * (`name`/`description`/`whenToUse`/`disable-model-invocation`); Kimi's own
+ * `disableModelInvocation`/`type` fields are not translated, so a `type: flow`
+ * skill is surfaced as model-invocable.
+ *
+ * The discovery algorithm itself lives in {@link AgentsMdSkillProvider}; this
+ * module supplies only Kimi's locations and ranks.
+ *
+ * @module dsh-loop-engine-allinone/engine-kimi/skills
+ */
+import { AgentsMdSkillProvider } from '../driver-core/agents-md-skill-provider.ts';
+import type { SkillProviderControl } from '../skills.ts';
+/**
+ * Resolve the Kimi config directory, honoring the `KIMI_CODE_HOME` environment
+ * override and falling back to `~/.kimi-code`.
+ * @returns the absolute Kimi config directory.
+ */
+export declare function kimiAgentDir(): string;
+/**
+ * Skill provider that discovers context files and skills from Kimi's standard
+ * locations:
+ *   - project `AGENTS.md` files between the cwd and the git root — surfaced as
+ *     one `agents-md` skill;
+ *   - project `.kimi-code/skills/` and user `~/.kimi-code/skills/` — each
+ *     `SKILL.md` entry surfaced under its own name.
+ */
+export declare class KimiSkillProvider extends AgentsMdSkillProvider {
+    constructor(control: SkillProviderControl);
+}
+export default KimiSkillProvider;
+//# sourceMappingURL=skills.d.ts.map

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

@@ -0,0 +1,25 @@
+/**
+ * Public types of the Kimi Code loop driver. Types only — no runtime code.
+ *
+ * Kimi Code (`kimi`) has no host approval callback ("runs with the permissions
+ * of the user"), and its ACP surface already answers tool approvals through the
+ * shared fold. It exposes no `--tools` pruning flag on this surface either, so
+ * there is no per-driver permission lever to pin: the driver spawns the whole
+ * `kimi acp` child through the dsh subprocess seam — the only available privilege
+ * boundary — and the sandbox stance follows the session's durable permission
+ * knobs as the subprocess provider resolves them (default read-only).
+ *
+ * {@link ResolvedConfig} is the shared ACP configuration under this engine's
+ * published name: kimi, grok and MiniMax Code resolve the same four facts, so the
+ * shape lives once in `driver-acp/profile.ts` instead of three times here.
+ *
+ * @module dsh-loop-engine-allinone/engine-kimi/types
+ */
+import type { AcpResolvedConfig } from '../driver-acp/profile.ts';
+/**
+ * Driver configuration after defaults and load-time validation: the model the
+ * session selects when it has none, the child's environment, the executable, and
+ * the idle window after which the ACP child is released.
+ */
+export type ResolvedConfig = AcpResolvedConfig;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,24 @@
+/**
+ * MiniMax Code's loop Agent: the shared ACP body with the dialect in `./profile.ts`.
+ *
+ * The class is this engine's published driver shape (and the seam a
+ * minimaxcode-specific behaviour would land on); the dialect itself — argv, protocol
+ * version, model selection, session handshake — lives in `./profile.ts`, which
+ * imports no host service so it can be exercised by `scripts/probe/smoke-acp.ts`
+ * against the real CLI.
+ *
+ * @module dsh-loop-engine-allinone/engine-minimaxcode/agent
+ */
+import type { AgentOptions } from '@deepseek-ai/dsh-agent';
+import type { Session, SessionId } from '@deepseek-ai/dsh-session';
+import type { Context } from '@deepseek-ai/cordis';
+import type { AcpResolvedConfig } from '../driver-acp/profile.ts';
+import type { AcpSpawnCapability } from '../driver-acp/transport.ts';
+import { AcpEngineAgent } from '../driver-acp/agent.ts';
+import { minimaxcodeProfile } from './profile.ts';
+export { minimaxcodeProfile };
+/** MiniMax Code's loop Agent: the shared ACP body with the profile's dialect. */
+export declare class MinimaxcodeAgent extends AcpEngineAgent {
+    constructor(loopCtx: Context, id: SessionId, options: AgentOptions, session: Session, config: AcpResolvedConfig, spawn: AcpSpawnCapability, bin?: string);
+}
+//# sourceMappingURL=agent.d.ts.map

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

@@ -0,0 +1,83 @@
+/**
+ * MiniMax Code loop engine module: drives every session it is handed through a
+ * persistent `mcode acp` child (Agent Client Protocol over stdio), speaking one
+ * stateless `session/new` + `session/prompt` 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.
+ *
+ * The engine's SUBSCRIPTION is what this driver is for: the plugin never logs in
+ * and never touches credentials — the user runs `mcode login --region …` once and
+ * `mcode provider use token-plan` to spend the M Plan allowance, and the region
+ * reaches the child as the environment variable the CLI reads
+ * ({@link Config.region}).
+ *
+ * Everything below the dialect is the shared ACP runtime
+ * (`driver-acp/runtime.ts`).
+ *
+ * @module dsh-loop-engine-allinone/engine-minimaxcode
+ */
+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 type { AcpResolvedConfig } from '../driver-acp/profile.ts';
+import { AcpEngineRuntime } from '../driver-acp/runtime.ts';
+import { MinimaxcodeAgent } from './agent.ts';
+/** Deployment-owned configuration for the MiniMax Code engine. */
+export interface Config {
+    /** Model sent per ACP session (`session/set_config_option`) when the session selects none. */
+    model?: string;
+    /**
+     * Explicit environment entries passed to the child.
+     *
+     * Usually empty on purpose: MiniMax Code reads its own region-scoped
+     * credentials from `~/.minimax`. Setting the region variable here is rejected
+     * when it disagrees with {@link Config.region}, so the one knob that owns the
+     * region is always unambiguous.
+     */
+    env?: Record<string, string>;
+    /** The `mcode` entrypoint (an absolute path), resolved from the npm prefixes then PATH when not pinned. */
+    bin?: string;
+    /**
+     * The account region the child runs under (`cn` or `global`, default `cn`).
+     *
+     * It is a real deployment fact rather than a preference: the CLI's login
+     * endpoint and its stored credentials are BOTH region-scoped, so a child told
+     * the wrong region cannot see the account the user signed in with. It travels in
+     * the environment variable the registry row names
+     * (`region.envVar`, measured as `MAVIS_REGION` — NOT `MCODE_REGION`, which is
+     * inert on this path).
+     */
+    region?: string;
+    /** Idle window in milliseconds before a session's ACP child is shut down; zero or less keeps it. */
+    childIdleMs?: number;
+}
+/** Schema of the MiniMax Code engine configuration. */
+export declare const Config: z<Config>;
+/**
+ * Resolve the driver configuration at the plugin config boundary.
+ * @param config - the deployment's knobs.
+ * @returns the configuration the shared ACP runtime consumes.
+ * @throws when the deployment pins a region the CLI does not accept, or pins one
+ *   in `env` that contradicts {@link Config.region}.
+ */
+export declare function resolveConfig(config: Config): AcpResolvedConfig;
+/** Host-face ctx key this engine's runtime is registered under. */
+export declare const MINIMAXCODE_ENGINE_LABEL = "agentLoopMinimaxcode";
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        agentLoopMinimaxcode: MinimaxcodeLoop;
+    }
+}
+/**
+ * Creation/resume machinery for the MiniMax Code 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 MinimaxcodeLoop extends AcpEngineRuntime<MinimaxcodeAgent> {
+    constructor(ctx: Context, config: Config);
+    /** Construct the MiniMax Code ACP driver for one prepared session. */
+    protected buildAgent(loopCtx: Context, id: SessionId, options: AgentOptions, session: Session): MinimaxcodeAgent;
+}
+//# sourceMappingURL=loop.d.ts.map

package/lib/types/engine-minimaxcode/process.d.ts

@@ -0,0 +1,53 @@
+/**
+ * MiniMax Code process projection: where the `mcode` entrypoint is, and the argv
+ * that starts its ACP server.
+ *
+ * Measured facts this file encodes (MiniMax Code 0.6.12 on this fork's reference
+ * host):
+ *
+ *   - the ACP server is `mcode acp` (`--help`: "Run MiniMax Code as an Agent
+ *     Client Protocol server over stdio");
+ *   - the CLI is distributed as the npm package `@minimax-ai/code`, whose own
+ *     entrypoint is `cli.js`. A global install leaves `mcode.cmd` / `mcode.ps1` /
+ *     `mcode` shims on PATH and NO `mcode.exe`, so spawning the bare name fails
+ *     with `ENOENT` under node's spawn — the measured failure this resolver exists
+ *     to avoid. The package entrypoint is therefore preferred, and a `.cmd` that is
+ *     all a machine has is launched through the command interpreter
+ *     (`driver-acp/executable.ts`);
+ *   - the account REGION is a first-class fact (`mcode login --region cn|global`,
+ *     credentials under `~/.minimax/auth/prod/<region>/…`), so the region travels
+ *     in the child's environment rather than as an argv flag — `mcode acp` takes
+ *     none. The variable is `MAVIS_REGION`, MEASURED as the one this surface
+ *     honours (`MCODE_REGION` is inert here); it is named by the registry row and
+ *     resolved by `./loop.ts`, never spelled in this file.
+ *
+ * @module dsh-loop-engine-allinone/engine-minimaxcode/process
+ */
+/** Grace in milliseconds for MiniMax Code process-tree termination. */
+export declare const MINIMAXCODE_DISPOSE_GRACE_MS = 3000;
+/** The npm package that ships the CLI. */
+export declare const MINIMAXCODE_NPM_PACKAGE = "@minimax-ai/code";
+/** The package-relative entrypoint that starts the CLI. */
+export declare const MINIMAXCODE_ENTRYPOINT = "cli.js";
+/**
+ * Resolve the MiniMax Code entrypoint.
+ *
+ * Order: an explicit config path; the package entrypoint under the npm prefixes
+ * this machine is likely to have; a PATH lookup that honours `PATHEXT`; and
+ * finally the bare name, which the spawner resolves.
+ * @param configBin - an operator-pinned path (or a bare name), if any.
+ * @param env - the environment to read the npm prefix hints from.
+ * @returns the executable (or `.js` entrypoint) to spawn.
+ */
+export declare function mcodeBinResolver(configBin?: string, env?: NodeJS.ProcessEnv): string;
+/**
+ * Build the argv that starts `mcode acp`.
+ *
+ * A `.js` entrypoint runs under the current node; a `.cmd` shim goes through
+ * `cmd.exe`; a real executable is spawned as itself (see
+ * `driver-acp/executable.ts`).
+ * @param bin - the resolved entrypoint.
+ * @returns the argv, `argv[0]` being the program to launch.
+ */
+export declare function mcodeAcpArgv(bin: string): string[];
+//# sourceMappingURL=process.d.ts.map