ladder-mcp 1.1.0 → 1.1.4

package/CHANGELOG.md

@@ -4,6 +4,75 @@ All notable changes to Ladder_mcp are documented here. Format loosely follows
 [Keep a Changelog](https://keepachangelog.com/); this project uses
 [Semantic Versioning](https://semver.org/).
 
+## [1.1.4] - 2026-06-28
+
+Make the live-progress line worth watching.
+
+### Changed
+
+- Live progress now shows a readable content **preview** of the streamed
+  `message`/`thought` text (whitespace collapsed, code-point-safe truncation with
+  an ellipsis) instead of a bare `(N chars)` counter.
+- Progress emission is throttled to at most one update per ~1.2s, so the single
+  progress line stops flickering and each line stays readable. `tool_call`,
+  `tool_update`, and `plan` events remain immediate and flush any pending preview
+  first to preserve order.
+- The two per-transport coalescers (CLI and ACP) are unified into one shared
+  `createProgressCoalescer` in `src/progress.ts`; the duplicated `COALESCE_*`
+  constants are gone.
+
+### Notes
+
+- Kimi CLI 0.20.1 does not stream thinking to stderr during `-p` runs, so live
+  `thought` progress is not available on the CLI transport (documented in code).
+  The ACP transport already emits `thought`, which now gets the preview treatment.
+
+## [1.1.3] - 2026-06-28
+
+Bugfix: analysis-mode `kimi_code` was broken against Kimi CLI 0.20.1.
+
+### Fixed
+
+- `kimi_code` without `edit: true` (the default analysis mode) crashed against
+  Kimi CLI 0.20.1 with `Cannot combine --prompt with --plan`. `buildKimiArgs` no
+  longer passes `--plan` in `-p` prompt mode (the CLI rejects it, along with
+  `--auto`/`-y`).
+
+### Changed
+
+- Because Kimi 0.20.1 has no `-p`-compatible read-only flag, the `edit: false`
+  analysis-only contract is now enforced at the prompt level: `runKimi` prepends
+  a read-only guard (`applyReadOnlyGuard`) when `edit` is not `true`. This is
+  advisory (the model is instructed not to edit) rather than a hard CLI
+  guarantee; the `edit` parameter description documents the change.
+
+## [1.1.2] - 2026-06-28
+
+Live-progress and cancellation reliability for `kimi_code`.
+
+### Added
+
+- The CLI transport now surfaces the running action: `stream-json` `tool_calls`
+  records emit immediate `tool_call` progress events (e.g. `Read src/types.ts`)
+  and `plan` records emit `plan` events, matching the ACP transport. A CLI job
+  no longer looks idle while it works.
+
+### Fixed
+
+- Cancelling a `kimi_code` call now actually kills the underlying `kimi.exe`
+  process in every mode (foreground CLI, background CLI, foreground ACP).
+  Previously only background ACP honored cancellation; the others leaked the
+  child until the timeout fired. `runKimi` accepts an `AbortSignal`, skips
+  spawning when already aborted, and kills the process tree on abort.
+- The ACP client is hardened against a `close()`-before-`start()` race, and an
+  aborted ACP run now reports `Kimi cancelled` instead of a raw exit code.
+
+### Changed
+
+- `kimi_code`'s `transport` and `background` parameter descriptions now explain
+  the cli/acp trade-off and where to read the full progress log, so agents pick
+  a mode deliberately.
+
 ## [1.1.0] - 2026-06-28
 
 Breaking tool-surface redesign: the MCP tool list is now an intent-first set of

package/README.md

@@ -6,7 +6,7 @@ client like Claude Code can run codebase analysis, native sessions, API
 queries, ACP chat, background tasks, and CLI admin/diagnostics — all on Windows
 without hardcoded POSIX assumptions.
 
-> Status: **v1.0.1** ([npm](https://www.npmjs.com/package/ladder-mcp)).
+> Status: **v1.1.4** ([npm](https://www.npmjs.com/package/ladder-mcp)).
 > Supported platform is **Windows 11 only**.
 
 ## Requirements
@@ -19,7 +19,7 @@ without hardcoded POSIX assumptions.
 ## Quick start (from npm)
 
 You don't need to clone or build — the package is published on npm and your MCP
-client launches it via `npx`.
+client launches it via `npx`, or you can install the package directly.
 
 **Claude Code (one command):**
 
@@ -50,7 +50,16 @@ Then in Claude Code run `/mcp` (should show `kimi-code: connected`) and call
 Prefer a global install? `npm install -g ladder-mcp`, then use `ladder-mcp` as the
 command instead of `npx -y ladder-mcp`.
 
-To let Kimi Code itself host this server, use the `kimi_generate_mcp_config`
+Or install locally into your project:
+
+```bash
+npm install ladder-mcp
+```
+
+Then point your MCP config at `./node_modules/.bin/ladder-mcp` (or use
+`npx -y ladder-mcp`, which resolves the locally installed copy when available).
+
+To let Kimi Code itself host this server, use the `kimi_setup`
 tool to produce/merge a `.kimi-code/mcp.json` entry.
 
 ## Build from source (contributors)
@@ -63,26 +72,23 @@ npm run build      # compiles src/ -> dist/ (tests excluded)
 Quick checks:
 
 ```bash
-npm test           # vitest (50 tests)
+npm test           # vitest (163 tests)
 npm run typecheck  # tsc --noEmit (incl. tests)
 npm run dev        # run the server from source via tsx
 ```
 
 ## Tools
 
-**Core (v1)** — `kimi_analyze`, `kimi_query`, `kimi_verify`, `kimi_resume`,
-`kimi_list_sessions`, `kimi_status`
-
-**CLI admin & capabilities** — `kimi_capabilities`, `kimi_doctor`,
-`kimi_provider_list`, `kimi_export_session`, `kimi_visualize_session`
-
-**ACP (chat over stdio)** — `kimi_chat`, `kimi_acp_sessions`, `kimi_cancel`
+**Core (v1.1)** — `kimi_code`, `kimi_ask`, `kimi_sessions`, `kimi_tasks`,
+`kimi_status`, `kimi_setup`
 
-**Background tasks** — `kimi_task_status`, `kimi_task_output`, `kimi_task_cancel`
-(set `background=true` on `kimi_chat`)
+`kimi_code` supports both the native CLI transport (default) and the ACP
+JSON-RPC transport (`transport: 'acp'`); set `background=true` to track long
+work as a background task.
 
-**Kimi-hosted config & desktop (read-only)** — `kimi_generate_mcp_config`,
-`kimi_desktop_status`, `kimi_budget_probe`
+**Experimental (off by default)** — `kimi_export_session`,
+`kimi_visualize_session`, `kimi_desktop_status`, `kimi_budget_probe`. Enable
+with the environment variable `LADDER_EXPERIMENTAL=1`.
 
 ## Safety boundaries
 

package/dist/index.js

@@ -61,9 +61,9 @@ server.tool('kimi_code', 'Agentic work in a repository: analyze and edit files.
     work_dir: z.string().describe('Absolute path to the codebase root directory.'),
     session_id: z.string().optional().describe('Explicit Kimi session id to resume.'),
     new_session: z.boolean().optional().describe('Start fresh instead of continuing the last session. Default: false.'),
-    edit: z.boolean().optional().describe('Allow file modifications. Default: false (analysis-only intent).'),
-    background: z.boolean().optional().describe('Track as a long-running background task.'),
-    transport: z.enum(['cli', 'acp']).optional().describe("Transport: 'cli' edits in-process; 'acp' uses JSON-RPC. Default: 'cli'."),
+    edit: z.boolean().optional().describe('Allow file modifications. Default: false (analysis-only intent). On Kimi 0.20.1 this is prompt-enforced (advisory): when false/omitted the prompt is prefixed with a read-only guard, but the CLI itself provides no hard read-only flag for -p mode.'),
+    background: z.boolean().optional().describe('Track as a long-running background task. Every progress event (including each action) is appended to the task log, readable via kimi_tasks — the full accumulating transcript, unlike the single overwriting live-progress line of a foreground call.'),
+    transport: z.enum(['cli', 'acp']).optional().describe("How the server drives Kimi. Both edit files and resume sessions; they differ in robustness and live-progress detail. 'cli' (default): one-shot process, most robust on Windows, but live progress is coarse — only streaming-output volume, no per-action lines. 'acp': persistent JSON-RPC session that emits granular live progress (tool calls, plan steps) and supports interactive permission prompts, but is heavier and more fragile. Prefer 'cli' for plain codegen/analysis; choose 'acp' when you need to watch each action live or handle mid-run prompts."),
     session_mode: z.enum(['new', 'load', 'resume']).optional().describe("ACP session mode when transport='acp'. Default: inferred from session_id/new_session."),
     detail_level: z.enum(['summary', 'normal', 'detailed']).optional(),
     max_output_tokens: z.number().optional(),
@@ -89,6 +89,7 @@ server.tool('kimi_code', 'Agentic work in a repository: analyze and edit files.
                     maxOutputChars: maxChars(max_output_tokens),
                     includeThinking: includeThinkingValue,
                     onProgress: appendReporter(append),
+                    signal: _signal,
                 });
                 if (!result.ok)
                     throw new Error(result.error ?? 'CLI code task failed');
@@ -106,6 +107,7 @@ server.tool('kimi_code', 'Agentic work in a repository: analyze and edit files.
             maxOutputChars: maxChars(max_output_tokens),
             includeThinking: includeThinkingValue,
             onProgress: createMcpProgressReporter(extra),
+            signal: extra?.signal,
         });
         if (!result.ok)
             return textResponse(`Error: ${result.error}`, true);
@@ -135,7 +137,7 @@ server.tool('kimi_code', 'Agentic work in a repository: analyze and edit files.
         });
         return textResponse(JSON.stringify(task, null, 2));
     }
-    const result = await runAcp(undefined, createMcpProgressReporter(extra));
+    const result = await runAcp(extra?.signal, createMcpProgressReporter(extra));
     return textResponse(JSON.stringify(result, null, 2), !result.ok);
 });
 server.tool('kimi_ask', 'Stateless question or independent review. Text only, no repo, no edits.', {

package/dist/kimi-runner.js

@@ -2,7 +2,7 @@ import { spawn } from 'node:child_process';
 import * as path from 'node:path';
 import { clampTimeout } from './transports/acp.js';
 import { buildKimiEnv, resolveKimiPaths } from './environment.js';
-import { createStallWatchdog, makeEvent } from './progress.js';
+import { createProgressCoalescer, createStallWatchdog } from './progress.js';
 const MAX_CAPTURE_CHARS = 16 * 1024 * 1024;
 const MAX_FAILURE_STREAM_CHARS = 2_000;
 // Append to a captured stream while enforcing a hard ceiling so a runaway CLI cannot
@@ -22,11 +22,21 @@ export function buildKimiArgs(config) {
     else if (config.continueLast) {
         args.push('-C');
     }
-    if (config.edit !== true) {
-        args.push('--plan');
-    }
+    // Kimi CLI 0.20.1 rejects combining --plan with -p/--prompt (non-interactive
+    // prompt mode), and the other restriction flags (--auto, -y) are also
+    // incompatible. For edit:false / omitted edit we therefore pass no restriction
+    // flag and rely on the prompt/system to avoid edits.
     return args;
 }
+const READ_ONLY_GUARD = '[READ-ONLY ANALYSIS MODE] Do not create, modify, or delete any files, directories, or repository state. Only read, analyze, explain, and report.';
+// Prepends a read-only guard to the prompt when edit mode is not explicitly
+// enabled. Kimi CLI 0.20.1 has no -p-compatible read-only flag, so this is the
+// only available enforcement mechanism for the analysis-only contract.
+export function applyReadOnlyGuard(prompt, edit) {
+    if (edit === true)
+        return prompt;
+    return `${READ_ONLY_GUARD}\n\n${prompt}`;
+}
 function contentToText(content) {
     if (typeof content === 'string')
         return content;
@@ -52,6 +62,46 @@ function contentToText(content) {
         return '[non-text]';
     }).join('');
 }
+// The Kimi CLI emits tool calls on `role:assistant` records as a `tool_calls`
+// array shaped like OpenAI function calls. Extract a concise "Action target"
+// string so CLI runs can surface the current action as an immediate progress
+// event, matching the ACP transport behavior.
+function extractCliToolTarget(argsJson) {
+    if (!argsJson)
+        return undefined;
+    try {
+        const parsed = JSON.parse(argsJson);
+        const value = parsed.path ?? parsed.skill ?? parsed.command;
+        if (typeof value === 'string' && value.trim()) {
+            const trimmed = value.trim();
+            return trimmed.length > 80 ? `${trimmed.slice(0, 80)}…` : trimmed;
+        }
+    }
+    catch {
+        // Ignore malformed argument JSON.
+    }
+    return undefined;
+}
+function formatCliToolCall(toolCall) {
+    if (!toolCall || typeof toolCall !== 'object')
+        return undefined;
+    const tc = toolCall;
+    let name;
+    let args;
+    if (tc.function && typeof tc.function === 'object') {
+        const fn = tc.function;
+        name = typeof fn.name === 'string' ? fn.name : undefined;
+        args = typeof fn.arguments === 'string' ? fn.arguments : undefined;
+    }
+    else {
+        name = typeof tc.name === 'string' ? tc.name : undefined;
+        args = typeof tc.arguments === 'string' ? tc.arguments : undefined;
+    }
+    if (!name)
+        return undefined;
+    const target = extractCliToolTarget(args);
+    return target ? `${name} ${target}` : name;
+}
 function extractResumeHint(record) {
     if (record.role !== 'meta')
         return undefined;
@@ -116,32 +166,6 @@ export function truncateAtBoundary(text, maxChars) {
     const cutPoint = Math.max(slice.lastIndexOf('\n## '), slice.lastIndexOf('\n\n'), Math.floor(maxChars * 0.8));
     return `${slice.slice(0, cutPoint).trimEnd()}\n\n---\nOutput truncated (${text.length.toLocaleString()} chars exceeded ${maxChars.toLocaleString()} char budget). Use kimi_resume with the same session for follow-up questions.`;
 }
-const COALESCE_MS = 750;
-const COALESCE_CHARS = 400;
-function createStreamCoalescer(reporter) {
-    let count = 0;
-    let timer;
-    const flush = () => {
-        if (timer) {
-            clearTimeout(timer);
-            timer = undefined;
-        }
-        if (count > 0) {
-            reporter(makeEvent('message', `streaming output… (${count} chars)`));
-            count = 0;
-        }
-    };
-    const add = (text) => {
-        count += text.length;
-        if (count >= COALESCE_CHARS) {
-            flush();
-        }
-        else if (!timer) {
-            timer = setTimeout(flush, COALESCE_MS);
-        }
-    };
-    return { add, flush, stop: flush };
-}
 function killProcessTree(pid) {
     if (!pid)
         return;
@@ -166,9 +190,17 @@ export function runKimi(config) {
             error: 'Kimi CLI binary was not found on PATH or at ~/.kimi-code/bin/kimi.exe.',
         });
     }
+    if (config.signal?.aborted) {
+        return Promise.resolve({
+            ok: false,
+            text: '',
+            error: 'Kimi cancelled',
+        });
+    }
+    const guardedPrompt = applyReadOnlyGuard(config.prompt, config.edit);
     return new Promise((resolve) => {
         let settled = false;
-        const proc = spawn(paths.binaryPath, buildKimiArgs(config), {
+        const proc = spawn(paths.binaryPath, buildKimiArgs({ ...config, prompt: guardedPrompt }), {
             env: buildKimiEnv(),
             stdio: ['ignore', 'pipe', 'pipe'],
             windowsHide: true,
@@ -178,18 +210,29 @@ export function runKimi(config) {
         let stderr = '';
         let timedOut = false;
         let streamBuffer = '';
-        const coalescer = config.onProgress ? createStreamCoalescer(config.onProgress) : undefined;
+        const coalescer = config.onProgress ? createProgressCoalescer(config.onProgress) : undefined;
         const watchdog = config.onProgress ? createStallWatchdog(config.onProgress) : undefined;
+        let onAbort;
         const finish = (result) => {
             if (settled)
                 return;
             settled = true;
             clearTimeout(timer);
-            coalescer?.flush();
             coalescer?.stop();
             watchdog?.stop();
+            config.signal?.removeEventListener('abort', onAbort);
             resolve(result);
         };
+        onAbort = () => {
+            killProcessTree(proc.pid);
+            finish({ ok: false, text: '', error: 'Kimi cancelled' });
+        };
+        config.signal?.addEventListener('abort', onAbort, { once: true });
+        // Cover the race where the signal is already aborted right after registration.
+        if (config.signal?.aborted) {
+            onAbort();
+            return;
+        }
         let timer = setTimeout(() => {
             timedOut = true;
             killProcessTree(proc.pid);
@@ -213,10 +256,23 @@ export function runKimi(config) {
                     continue;
                 try {
                     const record = JSON.parse(line);
-                    if (record.role === 'assistant') {
+                    if (record.type === 'plan') {
+                        const text = contentToText(record.content).trim();
+                        if (text)
+                            coalescer?.add('plan', text);
+                    }
+                    else if (record.role === 'assistant') {
                         const text = contentToText(record.content);
                         if (text.trim())
-                            coalescer?.add(text);
+                            coalescer?.add('message', text);
+                        const toolCalls = record.tool_calls;
+                        if (Array.isArray(toolCalls)) {
+                            for (const toolCall of toolCalls) {
+                                const toolText = formatCliToolCall(toolCall);
+                                if (toolText)
+                                    coalescer?.add('tool_call', toolText);
+                            }
+                        }
                     }
                 }
                 catch {
@@ -224,7 +280,12 @@ export function runKimi(config) {
                 }
             }
         });
-        proc.stderr?.on('data', (chunk) => { stderr = appendCapped(stderr, chunk.toString('utf-8'), MAX_CAPTURE_CHARS); });
+        proc.stderr?.on('data', (chunk) => {
+            // Kimi CLI 0.20.1 does not stream thinking to stderr incrementally during a
+            // -p run; stderr is empty until process exit. We therefore do not emit live
+            // `thought` progress events here and keep the existing end-of-run capture.
+            stderr = appendCapped(stderr, chunk.toString('utf-8'), MAX_CAPTURE_CHARS);
+        });
         proc.on('error', (err) => {
             finish({ ok: false, text: '', error: err instanceof Error ? err.message : String(err) });
         });

package/dist/progress.js

@@ -21,6 +21,77 @@ export function makeEvent(kind, text) {
 export function formatProgressLine(event) {
     return `[${clockFromIso(event.at)}] ${KIND_GLYPH[event.kind]} ${event.kind}: ${event.text}`;
 }
+export const DEFAULT_DWELL_MS = 1_200;
+export const PREVIEW_MAX_CHARS = 90;
+export const TAIL_MAX_CHARS = 120;
+function sliceByCodePoints(text, maxChars) {
+    return [...text].slice(-maxChars).join('');
+}
+function collapseWhitespace(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+function formatPreview(tail, maxChars) {
+    const preview = collapseWhitespace(tail);
+    if (preview.length === 0)
+        return '';
+    const codePoints = [...preview];
+    if (codePoints.length <= maxChars)
+        return preview;
+    return `…${codePoints.slice(-maxChars).join('').trimStart()}`;
+}
+// Coalesces high-frequency `message`/`thought` streaming text into a single
+// watchable preview line, emitted at most once per `dwellMs`. Action events
+// (`tool_call`, `tool_update`, `plan`) are forwarded immediately, after flushing
+// any pending preview so ordering is preserved.
+export function createProgressCoalescer(reporter, options) {
+    const dwellMs = options?.dwellMs ?? DEFAULT_DWELL_MS;
+    const previewMaxChars = options?.previewMaxChars ?? PREVIEW_MAX_CHARS;
+    const tailMaxChars = options?.tailMaxChars ?? TAIL_MAX_CHARS;
+    const tails = { message: '', thought: '' };
+    let timer;
+    const emitTails = () => {
+        for (const kind of ['message', 'thought']) {
+            const tail = tails[kind];
+            if (!tail)
+                continue;
+            const text = formatPreview(tail, previewMaxChars);
+            tails[kind] = '';
+            if (text)
+                reporter(makeEvent(kind, text));
+        }
+    };
+    const flush = () => {
+        if (timer) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+        emitTails();
+    };
+    const schedule = () => {
+        if (timer)
+            return;
+        timer = setTimeout(() => {
+            timer = undefined;
+            emitTails();
+        }, dwellMs);
+        timer.unref?.();
+    };
+    const appendTail = (kind, text) => {
+        tails[kind] = sliceByCodePoints(tails[kind] + text, tailMaxChars);
+    };
+    const add = (kind, text) => {
+        if (kind === 'tool_call' || kind === 'tool_update' || kind === 'plan') {
+            flush();
+            reporter(makeEvent(kind, text));
+            return;
+        }
+        if (kind === 'message' || kind === 'thought') {
+            appendTail(kind, text);
+            schedule();
+        }
+    };
+    return { add, flush, stop: flush };
+}
 export function createStallWatchdog(reporter, stallMs = DEFAULT_STALL_MS) {
     let timer;
     let stopped = false;

package/dist/transports/acp.js

@@ -4,7 +4,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { buildKimiEnv, resolveKimiPaths } from '../environment.js';
 import { VERSION } from '../version.js';
-import { createStallWatchdog, makeEvent } from '../progress.js';
+import { createProgressCoalescer, createStallWatchdog } from '../progress.js';
 const MAX_ACP_FRAME_BYTES = 8 * 1024 * 1024;
 const MAX_ACP_HEADER_BYTES = 16 * 1024;
 const MAX_ACP_METADATA_BYTES = 100 * 1024;
@@ -232,6 +232,8 @@ export class AcpClient extends EventEmitter {
     start() {
         if (this.proc)
             return;
+        if (this.closing)
+            throw new Error('ACP client is closing');
         const binary = resolveKimiPaths().binaryPath;
         if (!binary)
             throw new Error('Kimi CLI binary was not found on PATH or at ~/.kimi-code/bin/kimi.exe.');
@@ -310,10 +312,11 @@ export class AcpClient extends EventEmitter {
         return this.updates.join('').trim();
     }
     close() {
-        if (!this.proc || this.closing)
+        if (this.closing)
             return;
         this.closing = true;
-        killProcessTree(this.proc.pid);
+        if (this.proc)
+            killProcessTree(this.proc.pid);
     }
     handleMessages(chunk) {
         let messages;
@@ -548,43 +551,6 @@ function extractSessionId(value, fallback) {
     }
     return fallback;
 }
-const COALESCE_MS = 750;
-const COALESCE_CHARS = 400;
-// Streams of message/thought tokens are far too chatty to forward one event per
-// chunk. Accumulate character counts and emit a single summarized event at most
-// every COALESCE_MS or whenever the accumulated text exceeds COALESCE_CHARS.
-// tool_call / tool_call_update / plan events are forwarded immediately.
-function createCoalescingReporter(reporter) {
-    const counts = { message: 0, thought: 0 };
-    let timer;
-    const flush = () => {
-        if (timer) {
-            clearTimeout(timer);
-            timer = undefined;
-        }
-        for (const kind of ['message', 'thought']) {
-            if (counts[kind] > 0) {
-                reporter(makeEvent(kind, `${kind === 'message' ? 'streaming output' : 'thinking'}… (${counts[kind]} chars)`));
-                counts[kind] = 0;
-            }
-        }
-    };
-    const add = (kind, text) => {
-        if (kind !== 'message' && kind !== 'thought') {
-            flush();
-            reporter(makeEvent(kind, text));
-            return;
-        }
-        counts[kind] += text.length;
-        if (counts[kind] >= COALESCE_CHARS) {
-            flush();
-        }
-        else if (!timer) {
-            timer = setTimeout(flush, COALESCE_MS);
-        }
-    };
-    return { add, flush, stop: flush };
-}
 export async function runAcpPrompt(options) {
     if (options.signal?.aborted)
         return { ok: false, text: '', error: 'ACP prompt was aborted before start.' };
@@ -602,7 +568,7 @@ export async function runAcpPrompt(options) {
     let watchdog;
     let onNotification;
     if (options.onProgress) {
-        coalescer = createCoalescingReporter(options.onProgress);
+        coalescer = createProgressCoalescer(options.onProgress);
         watchdog = createStallWatchdog(options.onProgress);
         onNotification = (message) => {
             watchdog?.ping();
@@ -665,12 +631,14 @@ export async function runAcpPrompt(options) {
         return { ok: true, text: text || '(empty ACP response from Kimi)', sessionId, metadata };
     }
     catch (error) {
-        return { ok: false, text: '', error: error instanceof Error ? error.message : String(error) };
+        const message = options.signal?.aborted
+            ? 'Kimi cancelled'
+            : error instanceof Error ? error.message : String(error);
+        return { ok: false, text: '', error: message };
     }
     finally {
         if (onNotification)
             client.off('notification', onNotification);
-        coalescer?.flush();
         coalescer?.stop();
         watchdog?.stop();
         options.signal?.removeEventListener('abort', abort);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ladder-mcp",
-  "version": "1.1.0",
+  "version": "1.1.4",
   "description": "Windows-first MCP bridge for Kimi Code CLI v24",
   "license": "MIT",
   "type": "module",