@love-moon/ai-sdk 0.13.3 → 0.15.0

package/dist/providers/kimi-print-session.js

@@ -6,6 +6,7 @@ import { EventEmitter } from "node:events";
 import readline from "node:readline";
 import { KIMI_CLI_PRINT_VARIANT as KIMI_PRINT_PROVIDER_VARIANT } from "../built-in-backends.js";
 import { appendContextFilesToPrompt } from "../context-files.js";
+import { assertKimiClearReply } from "./kimi-slash-commands.js";
 import { PROVIDER_MEDIA_CAPABILITIES, UNSUPPORTED_MEDIA_CAPABILITIES, buildKimiContent, } from "../media-adapters.js";
 import { assertMediaCapabilities, defaultPromptForMedia, resolveTurnMedia, } from "../media-input.js";
 import { emitLog, getBoundedEnvInt, loadEnvConfig, normalizeLogger, noteToolFinished, noteToolStarted, parseCommandParts, proxyToEnv, sanitizeForLog, withActiveTool, } from "../shared.js";
@@ -272,6 +273,7 @@ export class KimiPrintSession extends EventEmitter {
             capabilities: {
                 // Kimi Code's `--prompt` CLI is unverified for slash commands.
                 compact: this.cliMode !== "prompt",
+                clear: this.cliMode !== "prompt",
                 media: this.cliMode === "prompt"
                     ? UNSUPPORTED_MEDIA_CAPABILITIES
                     : PROVIDER_MEDIA_CAPABILITIES[KIMI_PRINT_PROVIDER_VARIANT],
@@ -505,6 +507,33 @@ export class KimiPrintSession extends EventEmitter {
             metadata: turnResult.metadata,
         };
     }
+    /**
+     * Native `/clear`: kimi-cli's built-in slash command, answered locally without
+     * a model call. Print mode spawns a child per turn, so nothing is torn down;
+     * the `--session` id stays the same and only its context file rotates.
+     *
+     * @param {Record<string, unknown>} [request]
+     * @param {{ onProgress?: Function }} [options]
+     * @returns {Promise<import("../shared.js").ClearResult>}
+     */
+    async runClear(request = {}, { onProgress = null } = {}) {
+        if (this.cliMode === "prompt") {
+            throw createTurnError("Kimi prompt mode does not support /clear", { reason: "unsupported_clear" });
+        }
+        if (this.pendingHistorySeed) {
+            return { clear: { status: "noop" }, usage: null, metadata: {} };
+        }
+        const turnResult = await this.runTurn("/clear", { onProgress, suppressReply: true });
+        // Print mode exits 0 even when the model call fails, so only kimi-cli's
+        // fixed reply is trusted.
+        assertKimiClearReply(turnResult.text);
+        this.history = [];
+        return {
+            clear: { status: "cleared", sessionId: this.sessionId || undefined },
+            usage: turnResult.usage,
+            metadata: turnResult.metadata,
+        };
+    }
     async runTurn(promptText, { useInitialImages = false, media: mediaInput, contextFiles, onProgress = null, jsonSchema = null, suppressReply = false } = {}) {
         if (this.closeRequested || this.closed) {
             throw this.createSessionClosedError();

package/dist/providers/kimi-slash-commands.d.ts

@@ -0,0 +1 @@
+export function assertKimiClearReply(reply: any): void;

package/dist/providers/kimi-slash-commands.js

@@ -0,0 +1,23 @@
+/**
+ * kimi-cli answers `/clear` itself, without calling the model, with a fixed
+ * line (see kimi_cli/soul/slash.py). Both kimi modes verify that line before
+ * reporting success: if a kimi version ever stops treating `/clear` as a
+ * built-in, the text reaches the model as an ordinary turn — which grows the
+ * context instead of clearing it — and we must fail loudly rather than tell the
+ * user their context is gone.
+ *
+ * Kept in one place so the two modes cannot drift apart, in either direction.
+ */
+const KIMI_CLEAR_ACK = /context has been cleared/i;
+function createClearFailedError(message) {
+    const error = new Error(message);
+    error.reason = "clear_failed";
+    return error;
+}
+export function assertKimiClearReply(reply) {
+    const text = String(reply || "");
+    if (KIMI_CLEAR_ACK.test(text)) {
+        return;
+    }
+    throw createClearFailedError(`Kimi clear failed${text.trim() ? `: ${text.trim()}` : ""}`);
+}

package/dist/providers/opencode-sdk-session.d.ts

@@ -80,6 +80,7 @@ export class OpencodeSdkSession extends EventEmitter<[never]> {
         currentTurnStatus: any;
         capabilities: {
             compact: boolean;
+            clear: boolean;
             media: Readonly<{
                 image: "native";
             }>;
@@ -208,9 +209,57 @@ export class OpencodeSdkSession extends EventEmitter<[never]> {
      * @param {{ onProgress?: Function }} [options]
      * @returns {Promise<import("../shared.js").CompactResult>}
      */
-    runCompact(request?: import("../shared.js").CompactRequest, { onProgress }?: {
-        onProgress?: Function;
-    }): Promise<import("../shared.js").CompactResult>;
+    /**
+     * Native clear: create a new session on the SAME opencode server (the server
+     * process and its event stream stay up); the old session is left untouched on
+     * disk, exactly like the boot path's `session.create`.
+     */
+    runClear(): Promise<{
+        clear: {
+            status: string;
+            sessionId?: undefined;
+        };
+        usage: null;
+        metadata: {};
+    } | {
+        clear: {
+            status: string;
+            sessionId: any;
+        };
+        usage: null;
+        metadata: {};
+    }>;
+    runCompact(request?: {}, { onProgress }?: {
+        onProgress?: null | undefined;
+    }): Promise<{
+        compact: {
+            status: string;
+            instructionsApplied: boolean;
+        };
+        usage: null;
+        metadata: {};
+    } | {
+        compact: {
+            status: string;
+            instructionsApplied: boolean;
+        };
+        usage: {
+            total: number | undefined;
+            input: number | undefined;
+            output: number | undefined;
+            reasoning: number | undefined;
+            cache: {
+                read: number | undefined;
+                write: number | undefined;
+            };
+        } | null;
+        metadata: {
+            providerID: any;
+            modelID: any;
+            source: string;
+            sessionId: any;
+        };
+    }>;
     runTurn(promptText: any, { useInitialImages, media: mediaInput, contextFiles, onProgress, jsonSchema }?: {
         useInitialImages?: boolean | undefined;
         onProgress?: null | undefined;

package/dist/providers/opencode-sdk-session.js

@@ -231,7 +231,7 @@ export class OpencodeSdkSession extends EventEmitter {
             resumeReady: Boolean(this.sessionId),
             manualResume: null,
             currentTurnStatus: this.getCurrentTurnStatus(),
-            capabilities: { compact: true, media: PROVIDER_MEDIA_CAPABILITIES[OPENCODE_PROVIDER_VARIANT] },
+            capabilities: { compact: true, clear: true, media: PROVIDER_MEDIA_CAPABILITIES[OPENCODE_PROVIDER_VARIANT] },
             pid: this.transport.pid || undefined,
         };
     }
@@ -1227,6 +1227,38 @@ export class OpencodeSdkSession extends EventEmitter {
      * @param {{ onProgress?: Function }} [options]
      * @returns {Promise<import("../shared.js").CompactResult>}
      */
+    /**
+     * Native clear: create a new session on the SAME opencode server (the server
+     * process and its event stream stay up); the old session is left untouched on
+     * disk, exactly like the boot path's `session.create`.
+     */
+    async runClear() {
+        if (this.closeRequested) {
+            throw this.createSessionClosedError();
+        }
+        if (this.currentTurn) {
+            throw createTurnError("Opencode turn already running", {
+                reason: "turn_already_running",
+            });
+        }
+        if (this.pendingHistorySeed || (!this.resumeSessionId && !this.sessionId && this.history.length === 0)) {
+            return { clear: { status: "noop" }, usage: null, metadata: {} };
+        }
+        await this.boot();
+        if (typeof this.client?.session?.create !== "function") {
+            throw new Error("Opencode session create API is unavailable");
+        }
+        const session = await this.requestOrThrow(this.client.session.create({}, { throwOnError: true, responseStyle: "data" }));
+        this.applySessionInfo(session);
+        // A later re-boot must not reattach to the session we walked away from.
+        this.resumeSessionId = "";
+        this.history = [];
+        return {
+            clear: { status: "cleared", sessionId: this.sessionId || undefined },
+            usage: null,
+            metadata: {},
+        };
+    }
     async runCompact(request = {}, { onProgress = null } = {}) {
         if (this.closeRequested) {
             throw this.createSessionClosedError();

package/dist/resume/claude.d.ts

@@ -24,5 +24,13 @@ export function listSessions(options?: {}): Promise<{
     cwd: any;
     title: string | null;
     updatedAt: any;
+    preview: {
+        firstUserMessage: string | null;
+        firstReply: string | null;
+        lastMessage: {
+            role: any;
+            text: string | null;
+        } | null;
+    };
 }[]>;
 export const BACKEND: "claude";

package/dist/resume/claude.js

@@ -3,7 +3,7 @@ import { promises as fsp } from "node:fs";
 import path from "node:path";
 import readline from "node:readline";
 import { resolveClaudeConfigDirs } from "../manager/paths.js";
-import { buildResumeContext, isExistingDirectory, normalizeSessionId, normalizeSessionTitle, pathExists, readJsonlHeadEntries, resolveSessionRunDirectory, } from "./shared.js";
+import { buildResumeContext, buildSessionPreview, isExistingDirectory, normalizeSessionId, normalizeSessionTitle, pathExists, readJsonlHeadEntries, readJsonlTailEntries, resolveSessionRunDirectory, } from "./shared.js";
 export const BACKEND = "claude";
 export function buildCliArgs(sessionId) {
     const normalizedSessionId = normalizeSessionId(sessionId);
@@ -156,12 +156,14 @@ export async function listSessions(options = {}) {
     const sessions = [];
     for (const candidate of selected) {
         const entries = await readJsonlHeadEntries(candidate.sessionFilePath);
+        const tailEntries = await readJsonlTailEntries(candidate.sessionFilePath);
         sessions.push({
             sessionId: candidate.sessionId,
             sessionFilePath: candidate.sessionFilePath,
             cwd: extractHeadCwd(entries),
             title: extractClaudeTitle(entries),
             updatedAt: candidate.updatedAt,
+            preview: buildSessionPreview(extractClaudeMessages(entries), extractClaudeMessages(tailEntries)),
         });
     }
     return sessions;
@@ -174,6 +176,31 @@ function extractHeadCwd(entries) {
     }
     return null;
 }
+/**
+ * User/assistant text messages. Tool calls, tool results, meta entries and
+ * wrapped slash-command output (<command-name>, <local-command-stdout>) are skipped.
+ */
+function extractClaudeMessages(entries) {
+    const messages = [];
+    for (const entry of entries) {
+        if ((entry?.type !== "user" && entry?.type !== "assistant") || entry?.isMeta === true) {
+            continue;
+        }
+        const content = entry?.message?.content;
+        const text = typeof content === "string"
+            ? content
+            : Array.isArray(content)
+                ? content
+                    .filter((item) => item?.type === "text" && typeof item.text === "string")
+                    .map((item) => item.text)
+                    .join("\n")
+                : "";
+        if (text.trim() && !text.trim().startsWith("<")) {
+            messages.push({ role: entry.type, text });
+        }
+    }
+    return messages;
+}
 function extractClaudeTitle(entries) {
     for (const entry of entries) {
         if (entry?.type !== "user" || entry?.isMeta === true) {

package/dist/resume/codex.d.ts

@@ -24,5 +24,13 @@ export function listSessions(options?: {}): Promise<{
     cwd: string | null;
     title: string | null;
     updatedAt: number;
+    preview: {
+        firstUserMessage: string | null;
+        firstReply: string | null;
+        lastMessage: {
+            role: any;
+            text: string | null;
+        } | null;
+    };
 }[]>;
 export const BACKEND: "codex";

package/dist/resume/codex.js

@@ -1,6 +1,6 @@
 import { promises as fsp } from "node:fs";
 import path from "node:path";
-import { buildResumeContext, isExistingDirectory, iterateJsonlEntries, normalizeSessionId, normalizeSessionTitle, readJsonlHeadEntries, resolveHomeDir, resolveSessionRunDirectory, } from "./shared.js";
+import { buildResumeContext, buildSessionPreview, isExistingDirectory, iterateJsonlEntries, normalizeSessionId, normalizeSessionTitle, readJsonlHeadEntries, readJsonlTailEntries, resolveHomeDir, resolveSessionRunDirectory, } from "./shared.js";
 export const BACKEND = "codex";
 export function buildCliArgs(sessionId) {
     const normalizedSessionId = normalizeSessionId(sessionId);
@@ -111,12 +111,14 @@ export async function listSessions(options = {}) {
             continue;
         }
         const metaCwd = meta?.payload?.cwd;
+        const tailEntries = await readJsonlTailEntries(candidate.filePath);
         sessions.push({
             sessionId,
             sessionFilePath: candidate.filePath,
             cwd: typeof metaCwd === "string" && metaCwd.trim() ? metaCwd.trim() : null,
             title: extractCodexTitle(headEntries),
             updatedAt: candidate.updatedAt,
+            preview: buildSessionPreview(extractCodexMessages(headEntries), extractCodexMessages(tailEntries)),
         });
     }
     return sessions;
@@ -126,6 +128,40 @@ function extractSessionIdFromFileName(filePath) {
     const match = path.basename(filePath).match(SESSION_ID_IN_FILE_NAME);
     return match ? match[0] : "";
 }
+// The event stream's user/agent messages: what the user typed and the
+// assistant's replies, without injected context or tool output.
+const CODEX_MESSAGE_ROLES = { user_message: "user", agent_message: "assistant" };
+const CODEX_ITEM_TEXT_TYPES = { user: "input_text", assistant: "output_text" };
+function extractCodexMessages(entries) {
+    const messages = [];
+    for (const entry of entries) {
+        const role = entry?.type === "event_msg" ? CODEX_MESSAGE_ROLES[entry?.payload?.type] : null;
+        const text = entry?.payload?.message;
+        if (role && typeof text === "string" && text.trim()) {
+            messages.push({ role, text });
+        }
+    }
+    if (messages.length > 0) {
+        return messages;
+    }
+    // Sessions without those events only carry response items; skip injected
+    // wrappers such as <environment_context>, as the title does.
+    for (const entry of entries) {
+        const payload = entry?.type === "response_item" ? entry.payload : null;
+        const textType = payload?.type === "message" ? CODEX_ITEM_TEXT_TYPES[payload.role] : null;
+        if (!textType || !Array.isArray(payload.content)) {
+            continue;
+        }
+        const text = payload.content
+            .filter((item) => item?.type === textType && typeof item.text === "string")
+            .map((item) => item.text)
+            .join("\n");
+        if (text.trim() && !text.trim().startsWith("<")) {
+            messages.push({ role: payload.role, text });
+        }
+    }
+    return messages;
+}
 function extractCodexTitle(entries) {
     for (const entry of entries) {
         if (entry?.type === "event_msg" && entry?.payload?.type === "user_message") {

package/dist/resume/index.d.ts

@@ -11,6 +11,14 @@ export function listSessionsForBackend(backendType: any, opts?: {}): Promise<{
     cwd: string | null;
     title: string | null;
     updatedAt: number;
+    preview: {
+        firstUserMessage: string | null;
+        firstReply: string | null;
+        lastMessage: {
+            role: any;
+            text: string | null;
+        } | null;
+    };
 }[]>;
 export function resolveResumeContext(backend: any, sessionId: any, options?: {}): Promise<{
     provider: any;

package/dist/resume/shared.d.ts

@@ -11,6 +11,24 @@ export function normalizeSessionTitle(text: any, maxLength?: number): string | n
  * are skipped.
  */
 export function readJsonlHeadEntries(filePath: any, maxLines?: number, maxBytes?: number): Promise<any[]>;
+/**
+ * Parses the tail of a jsonl file (last `maxBytes`); the first, possibly
+ * partial, line is dropped unless the read started at the file's beginning.
+ */
+export function readJsonlTailEntries(filePath: any, maxBytes?: number): Promise<any[]>;
+/**
+ * Session preview for the resume picker, from `{ role, text }` messages read
+ * off the head and tail of a session file: the first user message, the
+ * assistant text that answered it, and the session's last message.
+ */
+export function buildSessionPreview(headMessages: any, tailMessages: any): {
+    firstUserMessage: string | null;
+    firstReply: string | null;
+    lastMessage: {
+        role: any;
+        text: string | null;
+    } | null;
+};
 export function isExistingDirectory(targetPath: any): Promise<boolean>;
 export function resolveSessionRunDirectory(sessionPath: any): Promise<string>;
 export function listCandidateWorkingDirectories(options?: {}): any[];

package/dist/resume/shared.js

@@ -46,7 +46,7 @@ export function normalizeSessionTitle(text, maxLength = 80) {
  * session files stay cheap to inspect). Unreadable files and unparsable lines
  * are skipped.
  */
-export async function readJsonlHeadEntries(filePath, maxLines = 50, maxBytes = 128 * 1024) {
+export async function readJsonlHeadEntries(filePath, maxLines = 200, maxBytes = 128 * 1024) {
     const entries = [];
     const input = fs.createReadStream(filePath, { end: maxBytes - 1 });
     const rl = readline.createInterface({ input, crlfDelay: Infinity });
@@ -78,6 +78,70 @@ export async function readJsonlHeadEntries(filePath, maxLines = 50, maxBytes = 1
     }
     return entries;
 }
+/**
+ * Parses the tail of a jsonl file (last `maxBytes`); the first, possibly
+ * partial, line is dropped unless the read started at the file's beginning.
+ */
+export async function readJsonlTailEntries(filePath, maxBytes = 64 * 1024) {
+    let handle;
+    try {
+        handle = await fsp.open(filePath, "r");
+        const { size } = await handle.stat();
+        const start = Math.max(0, size - maxBytes);
+        const buffer = Buffer.alloc(size - start);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, start);
+        const lines = buffer.subarray(0, bytesRead).toString("utf8").split("\n");
+        if (start > 0) {
+            lines.shift();
+        }
+        const entries = [];
+        for (const line of lines) {
+            try {
+                if (line.trim())
+                    entries.push(JSON.parse(line));
+            }
+            catch {
+                continue;
+            }
+        }
+        return entries;
+    }
+    catch {
+        return [];
+    }
+    finally {
+        await handle?.close();
+    }
+}
+function clipPreviewText(text, maxLength = 2000) {
+    const trimmed = String(text || "").trim();
+    if (!trimmed) {
+        return null;
+    }
+    return trimmed.length > maxLength ? `${trimmed.slice(0, maxLength)}…` : trimmed;
+}
+/**
+ * Session preview for the resume picker, from `{ role, text }` messages read
+ * off the head and tail of a session file: the first user message, the
+ * assistant text that answered it, and the session's last message.
+ */
+export function buildSessionPreview(headMessages, tailMessages) {
+    const firstUserIndex = headMessages.findIndex((message) => message.role === "user");
+    const replies = [];
+    if (firstUserIndex >= 0) {
+        for (const message of headMessages.slice(firstUserIndex + 1)) {
+            if (message.role === "user")
+                break;
+            replies.push(message.text);
+        }
+    }
+    const last = tailMessages[tailMessages.length - 1] || headMessages[headMessages.length - 1] || null;
+    return {
+        firstUserMessage: firstUserIndex >= 0 ? clipPreviewText(headMessages[firstUserIndex].text) : null,
+        firstReply: clipPreviewText(replies.join("\n\n")),
+        lastMessage: last ? { role: last.role, text: clipPreviewText(last.text) } : null,
+    };
+}
 export async function isExistingDirectory(targetPath) {
     const normalizedPath = typeof targetPath === "string" ? targetPath.trim() : "";
     if (!normalizedPath) {

package/dist/shared.d.ts

@@ -100,6 +100,7 @@ export const TERMINAL_GOAL_STATUSES: ReadonlyArray<GoalStatus>;
  * @typedef {Object} SessionCapabilities
  * @property {boolean} [goal]
  * @property {boolean} [compact]
+ * @property {boolean} [clear]
  */
 /**
  * Manual context compaction (`/compact`) contract for providers that
@@ -124,6 +125,22 @@ export const TERMINAL_GOAL_STATUSES: ReadonlyArray<GoalStatus>;
  * @property {unknown} [usage]
  * @property {Record<string, unknown>} [metadata]
  */
+/**
+ * Native context clear (`/clear`) contract for providers that implement the
+ * optional `runClear` method and advertise `capabilities.clear === true`.
+ * Providers must NOT emit assistant messages while clearing; the caller
+ * renders the user-facing confirmation.
+ *
+ * @typedef {Object} ClearState
+ * @property {"cleared"|"noop"} status `noop` = there was nothing to clear.
+ * @property {string} [sessionId] New session id when the backend starts a new
+ *   conversation; callers rebind the task to it.
+ *
+ * @typedef {Object} ClearResult
+ * @property {ClearState} clear
+ * @property {unknown} [usage]
+ * @property {Record<string, unknown>} [metadata]
+ */
 /**
  * Default capabilities assigned to providers that do not opt into any optional
  * feature. Treat the returned object as read-only; clone before mutating.
@@ -212,6 +229,7 @@ export type GoalResult = {
 export type SessionCapabilities = {
     goal?: boolean | undefined;
     compact?: boolean | undefined;
+    clear?: boolean | undefined;
 };
 /**
  * Manual context compaction (`/compact`) contract for providers that
@@ -254,3 +272,31 @@ export type CompactResult = {
     usage?: unknown;
     metadata?: Record<string, unknown> | undefined;
 };
+/**
+ * Native context clear (`/clear`) contract for providers that implement the
+ * optional `runClear` method and advertise `capabilities.clear === true`.
+ * Providers must NOT emit assistant messages while clearing; the caller
+ * renders the user-facing confirmation.
+ */
+export type ClearState = {
+    /**
+     * `noop` = there was nothing to clear.
+     */
+    status: "cleared" | "noop";
+    /**
+     * New session id when the backend starts a new
+     * conversation; callers rebind the task to it.
+     */
+    sessionId?: string | undefined;
+};
+/**
+ * Native context clear (`/clear`) contract for providers that implement the
+ * optional `runClear` method and advertise `capabilities.clear === true`.
+ * Providers must NOT emit assistant messages while clearing; the caller
+ * renders the user-facing confirmation.
+ */
+export type ClearResult = {
+    clear: ClearState;
+    usage?: unknown;
+    metadata?: Record<string, unknown> | undefined;
+};

package/dist/shared.js

@@ -81,6 +81,7 @@ export function isTerminalGoalStatus(value) {
  * @typedef {Object} SessionCapabilities
  * @property {boolean} [goal]
  * @property {boolean} [compact]
+ * @property {boolean} [clear]
  */
 /**
  * Manual context compaction (`/compact`) contract for providers that
@@ -105,13 +106,29 @@ export function isTerminalGoalStatus(value) {
  * @property {unknown} [usage]
  * @property {Record<string, unknown>} [metadata]
  */
+/**
+ * Native context clear (`/clear`) contract for providers that implement the
+ * optional `runClear` method and advertise `capabilities.clear === true`.
+ * Providers must NOT emit assistant messages while clearing; the caller
+ * renders the user-facing confirmation.
+ *
+ * @typedef {Object} ClearState
+ * @property {"cleared"|"noop"} status `noop` = there was nothing to clear.
+ * @property {string} [sessionId] New session id when the backend starts a new
+ *   conversation; callers rebind the task to it.
+ *
+ * @typedef {Object} ClearResult
+ * @property {ClearState} clear
+ * @property {unknown} [usage]
+ * @property {Record<string, unknown>} [metadata]
+ */
 /**
  * Default capabilities assigned to providers that do not opt into any optional
  * feature. Treat the returned object as read-only; clone before mutating.
  *
  * @type {Readonly<SessionCapabilities>}
  */
-export const DEFAULT_SESSION_CAPABILITIES = Object.freeze({ goal: false, compact: false });
+export const DEFAULT_SESSION_CAPABILITIES = Object.freeze({ goal: false, compact: false, clear: false });
 /**
  * Resolve a session's capability snapshot, falling back to
  * {@link DEFAULT_SESSION_CAPABILITIES}.

package/dist/transports/codex-app-server-transport.js

@@ -46,6 +46,27 @@ function injectEnableGoalsArgs(args, enableGoals) {
     normalized.splice(insertAt, 0, "--enable", "goals");
     return normalized;
 }
+/**
+ * Add one `-c key=value` per config override (e.g. the per-task MCP server a
+ * remote-worktree task needs), before `--listen` like `--enable goals`.
+ *
+ * @param {string[]} args
+ * @param {unknown} overrides
+ * @returns {string[]}
+ */
+function injectConfigOverrideArgs(args, overrides) {
+    const pairs = Array.isArray(overrides)
+        ? overrides.filter((entry) => typeof entry === "string" && entry.includes("="))
+        : [];
+    if (pairs.length === 0) {
+        return args;
+    }
+    const normalized = [...args];
+    const listenIndex = normalized.indexOf("--listen");
+    const insertAt = listenIndex >= 0 ? listenIndex : normalized.length;
+    normalized.splice(insertAt, 0, ...pairs.flatMap((pair) => ["-c", pair]));
+    return normalized;
+}
 function createRpcError(payload) {
     const message = String(payload?.message || payload?.error?.message || "Codex app-server request failed");
     const error = new Error(message);
@@ -78,7 +99,7 @@ export class CodexAppServerTransport extends EventEmitter {
         }
         this.command = command;
         this.enableGoals = options.enableGoals === true;
-        this.args = injectEnableGoalsArgs(args, this.enableGoals);
+        this.args = injectConfigOverrideArgs(injectEnableGoalsArgs(args, this.enableGoals), options.configOverrides);
         this.env = options.env && typeof options.env === "object" ? { ...options.env } : {};
         this.ignoreCodexApiKey = options.ignoreCodexApiKey === true;
         this.child = null;

package/dist/transports/kimi-wire-transport.d.ts

@@ -1,3 +1,15 @@
+/**
+ * Drop resume flags from the configured command line. The session id is owned
+ * by the caller (we always append our own `--session=`), so a configured
+ * `--continue`/`--session`/`--resume` would silently reattach a fresh session —
+ * e.g. a `/clear` — to the previous conversation.
+ *
+ * Only those flags are touched. Notably `-c` is kimi's alias for
+ * `--prompt`/`--command` (it takes a value), not a continue switch, so it is
+ * passed through untouched — dropping the flag alone would leave its value
+ * behind as a stray positional argument.
+ */
+export function filterKimiWireBaseArgs(args: any): string[];
 export class KimiWireTransport extends EventEmitter<[never]> {
     constructor(options?: {});
     options: {};