dsh-loop-engine 1.0.0-rc6 → 1.0.0-rc8

package/lib/invariant.js

@@ -1,9 +1,8 @@
 // src/settings.ts
 import z from "@deepseek-ai/schemastery";
-import { settingsNamespace } from "@deepseek-ai/dsh-settings";
-var LOOP_ENGINE_IDS = ["in-process", "claude-code", "codex", "pi"];
+var LOOP_ENGINE_IDS = ["in-process", "claude-code", "codex", "pi", "kimi"];
 var LOOP_ENGINE_SETTINGS_SCHEMA = z.object({
-  engine: z.union([z.const("in-process"), z.const("claude-code"), z.const("codex"), z.const("pi")]).default("in-process"),
+  engine: z.union([z.const("in-process"), z.const("claude-code"), z.const("codex"), z.const("pi"), z.const("kimi")]).default("in-process"),
   showInComposer: z.boolean().default(true)
 });
 
@@ -18,6 +17,8 @@ function renderManagedBlock(engine) {
     `${MANAGED_BLOCK_BEGIN}${engine} --`,
     "- id: agent-loop",
     "  disabled: true",
+    "- id: command-goal",
+    "  disabled: true",
     END_MARKER_LINE
   ].join("\n");
 }

package/lib/types/client/LoopEngineBadge.d.ts

@@ -9,7 +9,7 @@
  * @module dsh-loop-engine/client/badge
  */
 import type { JSX } from 'react';
-import type { SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client';
+import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
 import type { InjectFace } from '@deepseek-ai/dsh-client-ui-slots';
 import type { LoopEngineState } from './store.ts';
 import type { en } from './locales.ts';

package/lib/types/client/LoopEngineComposerSelect.d.ts

@@ -13,7 +13,7 @@
  * @module dsh-loop-engine/client/composer
  */
 import { type JSX } from 'react';
-import type { SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client';
+import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
 import type { InjectFace } from '@deepseek-ai/dsh-client-ui-slots';
 import type { LoopEngineStore, LoopEngineState } from './store.ts';
 import type { en } from './locales.ts';

package/lib/types/client/LoopEngineSection.d.ts

@@ -12,7 +12,7 @@
  * @module dsh-loop-engine/client
  */
 import { type JSX } from 'react';
-import type { SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client';
+import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
 import type { InjectFace } from '@deepseek-ai/dsh-client-ui-slots';
 import type { LoopEngineStore, LoopEngineState } from './store.ts';
 import type { en } from './locales.ts';

package/lib/types/client/index.d.ts

@@ -5,7 +5,7 @@
  * Export discipline: packages/client/AGENTS.md.
  * @module dsh-loop-engine/client
  */
-import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+import type { Context as ClientContext } from '@deepseek-ai/cordis';
 import { type LoopEngineKey } from './locales.ts';
 export type { LoopEngineSectionInjected, LoopEngineSectionProps } from './LoopEngineSection.tsx';
 export type { LoopEngineBadgeInjected, LoopEngineBadgeProps } from './LoopEngineBadge.tsx';

package/lib/types/client/locales.d.ts

@@ -16,6 +16,8 @@ export interface LoopEngineKey {
     engineCodex: string;
     /** Option label: the Pi CLI driver. */
     enginePi: string;
+    /** Option label: the Kimi Code CLI driver. */
+    engineKimi: string;
     /** Settings toggle: show the engine picker in the chat page composer. */
     showInComposerLabel: string;
     /** Unavailable-state message. */
@@ -32,6 +34,8 @@ export interface LoopEngineKey {
     confirmAction: string;
     /** Cancel action label. */
     cancelAction: string;
+    /** Accessible close-button label of the confirmation dialog. */
+    closeLabel: string;
     /** Notice shown while the Claude Code engine owns the slot: model selection is native. */
     claudeModelNotice: string;
 }

package/lib/types/client/store.d.ts

@@ -3,7 +3,8 @@
  * and the store publishes a render-safe snapshot plus the write path.
  * @module dsh-loop-engine/client/store
  */
-import type { SettingsScope, SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client';
+import type { SettingsScope } from '@deepseek-ai/dsh-client-ui-settings/client';
+import type { SnapshotStore } from '@deepseek-ai/dsh-client-store';
 import type { LoopEngineId } from '../settings.ts';
 /** State rendered by the loop engine section. */
 export interface LoopEngineState {

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

@@ -12,6 +12,8 @@ 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';
+/** Provider route label used for logged header snapshots and message provenance. */
+export declare const PROVIDER = "claude-code";
 /** Drives one session through turn and step boundaries on Claude Code. */
 export declare class ClaudeCodeAgent implements Agent {
     private loopCtx;

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

@@ -70,12 +70,34 @@ export declare class ClaudeCodeLoop extends Service implements AgentFactory {
     private setupAndPublish;
     /**
      * Create an agent and session under one caller-supplied identity, owned by
-     * the accessing fiber.
+     * 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.
@@ -83,7 +105,7 @@ export declare class ClaudeCodeLoop extends Service implements AgentFactory {
      * @returns the published handle.
      */
     resume(ownerCtx: Context, options: ResumeAgentOptions): Promise<AgentHandle>;
-    /** Resume through an explicit persistence handle. */
+    /** Resume through an explicit persistence service. */
     private resumeWith;
 }
 //# sourceMappingURL=loop.d.ts.map

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

@@ -8,11 +8,11 @@
  */
 import type { BetaMessage, BetaRawMessageStreamEvent, BetaUsage } from '@anthropic-ai/sdk/resources/beta/messages/messages.mjs';
 import type { MessageParam } from '@anthropic-ai/sdk/resources';
-import { CallId, type ContentBlock, type StreamChunk, type TokenUsage, type ToolResultMessage } from '@deepseek-ai/dsh-llm';
+import { ToolCallId, type ContentBlock, type StreamChunk, type TokenUsage, type ToolResultMessage } from '@deepseek-ai/dsh-llm';
 /** One tool invocation surfaced from a Claude Code assistant message. */
 export interface MappedToolCall {
     /** SDK tool_use id, reused as the dsh call-id so results pair. */
-    readonly callId: CallId;
+    readonly callId: ToolCallId;
     /** Tool name exactly as the SDK reported it. */
     readonly name: string;
     /** Raw JSON arguments string as the SDK produced them. */
@@ -63,7 +63,7 @@ export declare function mapToolResults(message: MessageParam): ToolResultMessage
 export declare function mapUsage(usage: BetaUsage): TokenUsage;
 /** Per-block-index tool-call identity captured at `content_block_start`, reused by `input_json_delta`. */
 export interface StreamToolCall {
-    readonly callId: CallId;
+    readonly callId: ToolCallId;
     readonly name: string;
 }
 /**

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

@@ -17,6 +17,8 @@ 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';
+/** Provider route label used for logged header snapshots and message provenance. */
+export declare const PROVIDER = "codex";
 /** Drives one session through turn and step boundaries on Codex. */
 export declare class CodexAgent implements Agent {
     private loopCtx;

package/lib/types/engine-codex/appserver/mapping.d.ts

@@ -8,7 +8,7 @@
  * @module dsh-loop-engine/engine-codex/appserver/mapping
  */
 import type { TokenUsage, ToolResultMessage } from '@deepseek-ai/dsh-llm';
-import { CallId } from '@deepseek-ai/dsh-llm';
+import { ToolCallId } from '@deepseek-ai/dsh-llm';
 /** Map app-server turn usage to dsh TokenUsage. */
 export declare function mapUsage(usage: {
     inputTokens: number;
@@ -25,7 +25,7 @@ export declare function mapCommandExecution(item: {
     status?: string;
 }): {
     call: {
-        callId: CallId;
+        callId: ToolCallId;
         name: string;
         arguments: string;
     };
@@ -38,7 +38,7 @@ export declare function mapFileChange(item: {
     status?: string;
 }): {
     call: {
-        callId: CallId;
+        callId: ToolCallId;
         name: string;
         arguments: string;
     };
@@ -58,7 +58,7 @@ export declare function mapMcpToolCall(item: {
     };
 }): {
     call: {
-        callId: CallId;
+        callId: ToolCallId;
         name: string;
         arguments: string;
     };

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

@@ -73,12 +73,34 @@ export declare class CodexLoop extends Service implements AgentFactory {
     private setupAndPublish;
     /**
      * Create an agent and session under one caller-supplied identity, owned by
-     * the accessing fiber.
+     * 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.
@@ -86,7 +108,7 @@ export declare class CodexLoop extends Service implements AgentFactory {
      * @returns the published handle.
      */
     resume(ownerCtx: Context, options: ResumeAgentOptions): Promise<AgentHandle>;
-    /** Resume through an explicit persistence handle. */
+    /** Resume through an explicit persistence service. */
     private resumeWith;
 }
 //# sourceMappingURL=loop.d.ts.map

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

@@ -0,0 +1,76 @@
+/**
+ * JSON-RPC client for the `kimi acp` subprocess (Agent Client Protocol over
+ * stdio).
+ *
+ * The driver hands the client a process handle carrying its stdin/stdout/stderr
+ * (projected from the dsh subprocess seam). The client frames JSON-RPC 2.0
+ * records on a bare `\n` (via a byte decoder, tolerating a trailing `\r`),
+ * correlates request responses by `id`, dispatches every `session/update`
+ * notification to a buffered event stream, and answers the reverse-RPC
+ * `session/request_permission` requests the agent publishes. The child is
+ * long-lived (one per factory) and stepped over via `newSession` + `prompt`.
+ *
+ * @module dsh-loop-engine/engine-kimi/acp/client
+ */
+import type { KimiProcess, KimiSpawnCapability, KimiSpawnSpec } from '../process.ts';
+import { type AcpFrame, type AcpUpdate } from './types.ts';
+/** How the client answers one `session/request_permission`. */
+export type AcpPermissionHandler = (request: AcpFrame) => boolean | Promise<boolean>;
+/** Callback receiving every non-response event line. */
+export type AcpUpdateHandler = (update: AcpUpdate) => void;
+/**
+ * ACP client over one `kimi acp` child. Created once per driver scope and reused
+ * across steps, matching the Pi RPC client's lifecycle.
+ */
+export declare class AcpClient {
+    private readonly process;
+    private readonly pending;
+    private readonly updateBuffer;
+    private updateWake;
+    private updateHandler;
+    private permissionHandler;
+    private sealed;
+    private nextId;
+    private readonly decoder;
+    private buffer;
+    /** Whether this client was sealed or its process exited. */
+    get closed(): boolean;
+    /** Mount a client over an already-spawned `kimi acp` process. */
+    constructor(process: KimiProcess);
+    /**
+     * Create a client, spawning the `kimi acp` child through the supplied
+     * capability (or the default node spawn when none is given).
+     * @param spec - the `kimi acp` argv/cwd/env the child should run with.
+     * @param spawn - optional process-spawn capability (the subprocess seam).
+     * @returns the connected client.
+     */
+    static create(spec: KimiSpawnSpec, spawn?: KimiSpawnCapability): AcpClient;
+    /** Register the event dispatch handler. */
+    onUpdate(handler: AcpUpdateHandler): void;
+    /** Register the permission-approval handler (reverse-RPC answers). */
+    onPermission(handler: AcpPermissionHandler): void;
+    /** Send one request and await the correlated response. */
+    request(method: string, params: unknown): Promise<unknown>;
+    /** Send a notification (no correlated response awaited). */
+    notify(method: string, params: unknown): void;
+    /** Open the protocol handshake. */
+    initialize(): Promise<unknown>;
+    /** Start a fresh ACP session and resolve to its session id. */
+    newSession(cwd: string): Promise<string>;
+    /** Prompt the agent in a session and resolve when the turn completes. */
+    prompt(sessionId: string, text: string): Promise<unknown>;
+    /** Cancel the active turn in a session (fire-and-forget). */
+    cancel(sessionId: string): void;
+    /** Answer a pending `session/request_permission`. */
+    respondPermission(id: number, approved: boolean): void;
+    /** Consume every buffered update as an async generator. */
+    updates(): AsyncGenerator<AcpUpdate, void, void>;
+    /** Seal the client and request child termination. */
+    dispose(): void;
+    private feed;
+    /** Dispatch one parsed line: a response, an update notification, or a reverse-RPC request. */
+    private dispatch;
+    private settle;
+    private handlePermission;
+}
+//# sourceMappingURL=client.d.ts.map

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

@@ -0,0 +1,44 @@
+/**
+ * Maps `kimi acp` `session/update` events to dsh session-log projections.
+ *
+ * Kimi streams incremental assistant text (`agent_message_chunk`), incremental
+ * thinking (`agent_thought_chunk`), a tool-call announcement (`tool_call`) and its
+ * progress/result stream (`tool_call_update`). This module is pure: it classifies
+ * an update, extracts chunk deltas, and projects the tool-call identity/result so
+ * the agent can fold them into the durable log. Content blocks use the observed
+ * kimi `{ type: 'content', content: { type: 'text', text } }` nesting; unknown
+ * block types are ignored.
+ *
+ * @module dsh-loop-engine/engine-kimi/acp/mapping
+ */
+import type { ToolResultMessage } from '@deepseek-ai/dsh-llm';
+import type { AcpContentBlock, AcpToolCallExt, AcpToolCallStreamExt, AcpUpdate } from './types.ts';
+/** Whether the update is an incremental assistant text chunk. */
+export declare function isTextChunk(update: AcpUpdate): update is AcpUpdate & {
+    readonly sessionUpdate: 'agent_message_chunk';
+    readonly content: AcpContentBlock;
+};
+/** Whether the update is an incremental thinking chunk. */
+export declare function isThoughtChunk(update: AcpUpdate): update is AcpUpdate & {
+    readonly sessionUpdate: 'agent_thought_chunk';
+    readonly content: AcpContentBlock;
+};
+/** Whether the update announces a tool call. */
+export declare function isToolCall(update: AcpUpdate): update is AcpToolCallExt;
+/** Whether the update streams a tool call's progress/result. */
+export declare function isToolCallUpdate(update: AcpUpdate): update is AcpToolCallStreamExt;
+/** The delta text of a text/thinking chunk. */
+export declare function chunkDelta(update: AcpUpdate): string;
+/** The raw tool-call id (+ content index) as the wire carries it. */
+export declare function toolCallIdOf(update: AcpUpdate): string;
+/** The tool display name (`title`). */
+export declare function toolCallName(update: AcpUpdate): string;
+/** Whether a tool stream status is settled (no longer streaming). */
+export declare function isToolSettledStatus(status: string): boolean;
+/** Whether a tool stream status denotes a failure. */
+export declare function isToolErrorStatus(status: string): boolean;
+/** Join the observed `{ type: 'content', content: { type: 'text', text } }` blocks. */
+export declare function toolContentText(update: AcpToolCallExt | AcpToolCallStreamExt): string;
+/** Project a completed tool call to a durable tool/result message. */
+export declare function toolResult(callId: string, text: string, isError: boolean): ToolResultMessage;
+//# sourceMappingURL=mapping.d.ts.map

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