dsh-loop-engine 1.0.0-rc10

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

@@ -0,0 +1,95 @@
+/**
+ * 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).
+ *
+ * @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;
+}
+/** A content block in a chunk/thought update; text is handled, others are ignored. */
+export type AcpContentBlock = AcpTextContent | {
+    readonly type: 'image' | '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'`). */
+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[];
+}
+/** 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 `session/request_permission` reverse-RPC params. */
+export interface AcpPermissionRequest {
+    readonly sessionId?: string;
+    readonly request?: unknown;
+}
+/** 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,123 @@
+/**
+ * Kimi Code loop Agent: drives one session through turn and step boundaries over
+ * a persistent `kimi acp` child (Agent Client Protocol over stdio), speaking one
+ * stateless `session/new` + `session/prompt` per dsh step. The dsh session log is
+ * the sole source of model context and the prompt is a pure serialization of the
+ * durable history, so the transcript stays Model-visible ⟺ logged. Kimi owns its
+ * system prompt and tools natively; the ACP child is spawned through the dsh
+ * subprocess seam (the only available privilege boundary) and tool approvals are
+ * answered from the session's dsh approval knobs.
+ *
+ * @module dsh-loop-engine/engine-kimi/agent
+ */
+import type { Agent, AgentCancelCause, AgentOptions, AgentStatus, CancelOptions, InboxTarget } from '@deepseek-ai/dsh-agent';
+import { Inbox } from '@deepseek-ai/dsh-agent';
+import type { Scope } from '@deepseek-ai/dsh-scope';
+import type { Session, SessionId, UserMessage } from '@deepseek-ai/dsh-session';
+import type { Context } from '@deepseek-ai/cordis';
+import type { ResolvedConfig } from './types.ts';
+import type { KimiSpawnCapability } from './process.ts';
+/** Provider route label used for logged header snapshots and message provenance. */
+export declare const PROVIDER = "kimi";
+/** Drives one session through turn and step boundaries on Kimi Code. */
+export declare class KimiAgent implements Agent {
+    private loopCtx;
+    readonly id: SessionId;
+    readonly options: AgentOptions;
+    readonly session: Session;
+    private readonly config;
+    private readonly spawn;
+    private readonly bin;
+    readonly inbox: Inbox;
+    private phase;
+    private activityDone;
+    /** The agent-scoped registration boundary; the lifecycle owner unwinds it after the driver exits. */
+    readonly scope: Scope;
+    readonly ctx: Context;
+    /** Fused dispatcher, built once in the constructor so hot-path dispatches never allocate. */
+    private readonly dispatch;
+    /** Whether this loop instance has appended its initial/resume request anchor. */
+    private requestHeaderLogged;
+    /** Lazily created ACP client, reused across steps and released on scope teardown. */
+    private acp;
+    /** The spawn spec the cached client was built from; a change forces a respawn. */
+    private lastSpec;
+    constructor(loopCtx: Context, id: SessionId, options: AgentOptions, session: Session, config: ResolvedConfig, spawn: KimiSpawnCapability, bin: string);
+    get status(): AgentStatus;
+    /** Commit a phase and publish its externally visible status transition. */
+    private setPhase;
+    send(message: UserMessage, target: InboxTarget, wakeup: boolean): void;
+    /**
+     * Queue a message for the next turn and wake the driver.
+     * @param input - the user message to deliver.
+     */
+    followup(input: UserMessage): void;
+    /**
+     * Queue a message for the running step and wake the driver.
+     * @param input - the user message to deliver.
+     */
+    steer(input: UserMessage): void;
+    /**
+     * Queue a message for the running step without waking the driver.
+     * @param input - the user message to deliver.
+     */
+    inject(input: UserMessage): void;
+    cancel(cause: AgentCancelCause, options?: CancelOptions): void;
+    /**
+     * Run a maintenance job while the agent is idle.
+     * @param job - the maintenance operation, receiving the phase abort signal.
+     * @returns the maintenance result.
+     */
+    runMaintenance<T>(job: (signal: AbortSignal) => Promise<T>): Promise<T>;
+    /**
+     * Start one driver, or latch its wake behind maintenance or an aborted
+     * activity. A wake sent while idle always opens its turn boundary, even
+     * when its message was cleared; only a latched replay is suppressed when
+     * the queue no longer holds the wake.
+     * @param wakeAfterAbort - the {@link send} classification, captured before
+     *   the inbox insertion so a reentrant cancel cannot reclassify it.
+     */
+    private wakeDriver;
+    whenIdle(): Promise<void>;
+    /** Report one failure at its live boundary, then preserve it for driver containment. */
+    private throwError;
+    private kick;
+    private preStep;
+    /**
+     * Scan the step's user messages for `/name` skill gestures, load each
+     * matching skill, and inject the rendered skill content into the message
+     * batch. This mirrors what dsh-tool-skill does for the in-process engine.
+     * @param messages - the current step's message batch.
+     * @param signal - cancellation signal (aborted loads are silently dropped).
+     * @returns the original batch when no skill was invoked, or an extended
+     *   batch with injected skill-content messages appended.
+     */
+    private injectSkills;
+    /** Open one turn before claiming its first proposed step. */
+    private turn;
+    /** Model label recorded in the request header for one lifecycle. */
+    private modelLabel;
+    /** Append the request header snapshot once per loop instance. */
+    private assertRequestHeader;
+    /** Whether two spawn specs describe the same `kimi acp` child. */
+    private specsEqual;
+    /** Return the cached ACP client, respawning when the spec or process changed. */
+    private acpClient;
+    /** Build the `kimi acp` argv/cwd/env for the persistent child. */
+    private spawnSpec;
+    /** Run one `kimi acp` step for the current session history and map the streamed updates. */
+    private step;
+    /** Per-step accumulation state for streamed assistant blocks and tool calls. */
+    private blocks;
+    private emittedToolCalls;
+    private toolText;
+    private blockRef;
+    private ensureBlock;
+    /** Append one streamed update's durable effect for the current step. */
+    private applyUpdate;
+    /** Append one live chunk and return its durable seq. */
+    private appendChunk;
+    /** Flush the accumulated assistant blocks into one durable assistant/message. */
+    private flushAssistant;
+}
+//# sourceMappingURL=agent.d.ts.map

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

@@ -0,0 +1,40 @@
+/**
+ * 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 (as far as the ACP prompt surface supports). 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.
+ *
+ * Kimi's slash commands are chiefly TUI controls (`/login`, `/provider`,
+ * `/settings`, `/sessions`, `/tasks`, …) that the ACP prompt surface does not
+ * expand the way an interactive TUI does; this bridge therefore registers the
+ * subset that are meaningful to forward to the engine (session/mode/status and
+ * the goal form). `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` stays: the managed block disables dsh's `command-goal`
+ * row for hosted engines, so the slot is free and the CLI's own goal mode
+ * takes it over.
+ *
+ * @module dsh-loop-engine/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 make sense to forward to the engine. */
+export declare const KIMI_COMMANDS: readonly CommandDefinition[];
+//# sourceMappingURL=commands.d.ts.map

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

@@ -0,0 +1,108 @@
+/**
+ * Kimi Code loop engine module: hosts the AgentFactory that drives every
+ * session 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.
+ * dsh-loop-engine constructs this factory when the Kimi engine is selected; 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/engine-kimi
+ */
+import { Service } from '@deepseek-ai/cordis';
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { AgentFactory, AgentHandle, CreateAgentOptions, ResumeAgentOptions } from '@deepseek-ai/dsh-agent';
+import type { KimiSpawnCapability } from './process.ts';
+import type { ResolvedConfig } from './types.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 alias for the `kimi` child (`-m`); 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;
+}
+/** Schema of the Kimi loop plugin configuration. */
+export declare const Config: z<Config>;
+/** Host-face ctx key for the Kimi loop service. */
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        agentLoopKimi: KimiLoop;
+    }
+}
+/**
+ * Concrete AgentFactory and driver service of the Kimi loop. Creation and
+ * resume follow the registry factory contract and the shared publication
+ * transaction: prepare, run setup, then publish through both registries,
+ * announce, and emit `agent/session-start`.
+ */
+export declare class KimiLoop extends Service implements AgentFactory {
+    /** Services the loop resolves through its own fiber; blessed identically to the package-level entry inject. */
+    static inject: string[];
+    /** Validated configuration owned by the loop plugin. */
+    readonly config: ResolvedConfig;
+    private readonly ownership;
+    /** Plain holder prevents Cordis from re-tracing the factory's dependency context through a caller shadow. */
+    private readonly runtime;
+    /** One-shot spawn capability handed to every agent, sandboxed by the subprocess seam. */
+    readonly spawn: KimiSpawnCapability;
+    constructor(ctx: Context, config: Config);
+    /**
+     * Construct the driver, scope, and one memoized reverse teardown for a new
+     * agent. The teardown is registered with the factory and the owner fiber
+     * BEFORE publication, so a mid-setup unload rolls everything back; `signal`
+     * fuses caller cancellation with lifecycle teardown for setup awaits.
+     */
+    private prepare;
+    /** Prepare one Agent around an acquired Session, run setup, and publish it. */
+    private setupAndPublish;
+    /**
+     * Create an agent and session under one caller-supplied identity, owned by
+     * the accessing fiber. When a persistence backend is mounted, the session's
+     * durable identity is stored before publication.
+     * @param ownerCtx - caller context that structurally owns the lifecycle.
+     * @param options - identities, session seed/metadata, loop options, setup, and cancellation.
+     * @returns the published handle.
+     */
+    createAgent(ownerCtx: Context, options: CreateAgentOptions): Promise<AgentHandle>;
+    /**
+     * Take a fresh session's write ownership when persistence is mounted.
+     * Nothing is appended here: the constructor seed (which never re-emits
+     * through `session/event`) is stored by {@link appendUnstoredSuffix} at the
+     * publication commit point, so a failed or cancelled setup closes an
+     * unmaterialized handle and leaves no stored residue — the same id can be
+     * created again.
+     * @param session - the unpublished session to store.
+     * @param signal - optional cancellation forwarded to the backend create.
+     * @returns the owned handle and stored cursor, or `undefined` without a backend.
+     */
+    private createStoredSession;
+    /**
+     * Durably store the session events appended since the last stored cursor.
+     * Pre-publication appends (constructor seed markers, setup-window events)
+     * never re-emit through `session/event`, so publication must flush them
+     * through the handle before live events start routing into it.
+     * @param stored - the session's owned handle and stored cursor, if any.
+     * @param session - the unpublished session whose suffix is stored.
+     */
+    private appendUnstoredSuffix;
+    /**
+     * Resume an owned agent from the configured persistence service.
+     * @param ownerCtx - caller context that owns load, setup, and the live lifecycle.
+     * @param options - persisted identity, loop options, setup, and cancellation.
+     * @returns the published handle.
+     */
+    resume(ownerCtx: Context, options: ResumeAgentOptions): Promise<AgentHandle>;
+    /** Resume through an explicit persistence service. */
+    private resumeWith;
+}
+//# sourceMappingURL=loop.d.ts.map

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

@@ -0,0 +1,71 @@
+/**
+ * Mapping from Kimi Code `--output-format stream-json` records to dsh
+ * session-log events. Kimi emits one JSON object per stdout line, discriminated
+ * by a `role` field (verified against the 0.28.1 CLI):
+ *   - `{ "role": "assistant", "content": "<text>" }`
+ *   - `{ "role": "assistant", "tool_calls": [{ "type": "function",
+ *       "id": "call_…", "function": { "name": "Bash", "arguments": "<json>" } }] }`
+ *   - `{ "role": "tool", "tool_call_id": "call_…", "content": "<text>" }`
+ *   - `{ "role": "meta", "type": "session.resume_hint", … }` (discarded)
+ * Thinking and tool progress go to stderr, never the JSONL, so this module has no
+ * usage or reasoning projection. The module is pure: it parses a raw stdout
+ * buffer and returns plain record projections the agent folds into the log.
+ *
+ * @module dsh-loop-engine/engine-kimi/mapping
+ */
+import type { ToolResultMessage } from '@deepseek-ai/dsh-llm';
+/** One normalized Kimi tool-call record. */
+export interface KimiToolCall {
+    /** The tool invocation id (`call_…`), correlated with the later `tool` record. */
+    readonly id: string;
+    /** The tool name. */
+    readonly name: string;
+    /** The raw arguments JSON string, passed verbatim. */
+    readonly arguments: string;
+}
+/** One parsed Kimi stream-json record (partial, tolerant of unknown fields). */
+export interface KimiRecord {
+    readonly role?: unknown;
+    readonly type?: unknown;
+    readonly content?: unknown;
+    readonly tool_calls?: unknown;
+    readonly tool_call_id?: unknown;
+    readonly is_error?: unknown;
+    readonly isError?: unknown;
+    readonly error?: unknown;
+}
+/** Record role discriminant used by the step loop. */
+export type KimiRecordRole = 'assistant' | 'tool' | 'meta' | 'unknown';
+/**
+ * Parse a `kimi --output-format stream-json` stdout buffer into records.
+ * Lines are bare-`\n` delimited; blank lines and non-JSON lines are dropped.
+ * @param stdout - the child's full stdout text.
+ * @returns the parsed records, in order.
+ */
+export declare function parseKimiRecords(stdout: string): KimiRecord[];
+/** Classify one record's role. */
+export declare function roleOf(record: KimiRecord): KimiRecordRole;
+/**
+ * The joined text of one record's `content` field. Handles both the string
+ * form (`"content": "<text>"`) and an array form (`[{ "type": "text", "text": … }]`)
+ * defensively; any other shape renders empty.
+ * @param record - the parsed record.
+ * @returns the joined body text.
+ */
+export declare function recordContentText(record: KimiRecord): string;
+/**
+ * Normalize an assistant record's `tool_calls` array. Each entry keeps its id,
+ * name, and a verbatim argument string (the wire already serializes arguments
+ * as JSON text; absent args render `{}`).
+ * @param record - the parsed assistant record.
+ * @returns the normalized tool calls, in order.
+ */
+export declare function assistantToolCalls(record: KimiRecord): readonly KimiToolCall[];
+/**
+ * Surface a `tool` record as a durable tool-result message, or `undefined` when
+ * the record is not a correlatable tool result (missing `role: tool` or no id).
+ * @param record - the parsed record.
+ * @returns the dsh tool-result message, or `undefined`.
+ */
+export declare function toolResultMessage(record: KimiRecord): ToolResultMessage | undefined;
+//# sourceMappingURL=mapping.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/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,61 @@
+/**
+ * Kimi CLI process projection. The driver locates the `kimi` executable, builds
+ * the `-p --output-format stream-json` argv for one step, and projects the dsh
+ * subprocess seam handle onto a minimal transport the agent can read to
+ * completion. Kimi has no host permission callback and no `--tools` pruning
+ * flag in `-p` mode, so the whole child is spawned through the seam — the only
+ * available privilege boundary (the seam's OS sandbox, default read-only) — and
+ * every step is a fresh one-shot child because `-p` is inherently stateless.
+ *
+ * @module dsh-loop-engine/engine-kimi/process
+ */
+import type { Readable, Writable } from 'node:stream';
+import type { SubprocessHandle, SubprocessSpawnSpec } from '@deepseek-ai/dsh-subprocess';
+/** The exact argv/cwd/env the driver requests for one `kimi -p` child. */
+export interface KimiSpawnSpec {
+    /** The program plus its flags; `argv[0]` is the Kimi CLI executable. */
+    readonly argv: readonly string[];
+    readonly cwd: string;
+    readonly env: Record<string, string>;
+    /** Cancellation: the seam escalates process-tree termination when it fires. */
+    readonly signal?: AbortSignal;
+}
+/** A spawned Kimi process as the agent's transport needs it. */
+export interface KimiProcess {
+    /** Child stdin (JSON-RPC request frames). */
+    readonly stdin: Writable;
+    /** Child stdout (the `session/update` notification frames). */
+    readonly stdout: Readable;
+    /** Child stderr (diagnostics; drained and dropped). */
+    readonly stderr: Readable;
+    /** Resolves when the child closes. */
+    readonly done: Promise<unknown>;
+    /** Request process-tree termination. */
+    terminate(): void;
+}
+/** Spawns one Kimi child over the given spec (the driver's spawn capability). */
+export type KimiSpawnCapability = (spec: KimiSpawnSpec) => KimiProcess;
+/** 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
+ * (Kimi owns model selection natively via its own config).
+ * @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/skills.d.ts

@@ -0,0 +1,57 @@
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * @module dsh-loop-engine/engine-kimi/skills
+ */
+import type { SkillCandidate, SkillDefinition, SkillLookupOptions, SkillProvider, 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 implements SkillProvider {
+    private readonly control;
+    readonly name = "kimi";
+    constructor(control: SkillProviderControl);
+    list(options: SkillLookupOptions): Promise<readonly SkillCandidate[]>;
+    get(candidate: SkillCandidate, _options: SkillLookupOptions): Promise<SkillDefinition | undefined>;
+    /** One merged `agents-md` candidate for a ranked file set. */
+    private agentsCandidate;
+    /** Collect every skill in one skills directory, both kimi layouts. */
+    private collectSkillsDir;
+    /** One parsed skill as a ranked candidate. */
+    private skillCandidate;
+    /** Parse one SKILL.md file, or `undefined` when it is unreadable or invalid. */
+    private tryParse;
+}
+export default KimiSkillProvider;
+//# sourceMappingURL=skills.d.ts.map

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

@@ -0,0 +1,23 @@
+/**
+ * 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 non-interactive `-p` surface already auto-approves tool
+ * calls. It also exposes no `--tools` pruning flag in `-p` mode, so there is no
+ * per-driver permission lever to pin. The driver therefore spawns the whole
+ * `kimi -p` 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).
+ *
+ * @module dsh-loop-engine/engine-kimi/types
+ */
+/** Driver configuration after defaults and load-time validation. */
+export interface ResolvedConfig {
+    /** Model alias the `kimi` child is launched with (`--model`); Kimi native config owns the model when omitted. */
+    readonly model: string | undefined;
+    /** Explicit environment entries layered over the credential-scrubbed parent environment. */
+    readonly env: Record<string, string>;
+    /** Kimi CLI executable; `'kimi'` resolves through PATH when not pinned to an absolute path. */
+    readonly bin: string;
+}
+//# sourceMappingURL=types.d.ts.map