@chatcode/chatcode-cli 3.0.4 → 3.0.5-rc.1

package/runtime/node_modules/@deepseek-ai/dsh-llm-deepseek/lib/types/adapter.d.ts

@@ -1,24 +1,8 @@
-/** Direct Messages transport with one cancellable lifecycle per model request. */
-import { LlmAdapter } from '@deepseek-ai/dsh-llm';
-import type { GenerateOptions, PreparedAdapterCall, StreamChunk } from '@deepseek-ai/dsh-llm';
-import type { DeepSeekAdapterOptions, DeepSeekConnectionOptions as Connection } from './types.ts';
+import type { DeepSeekAdapterOptions, DeepSeekConnectionOptions } from './types.ts';
+import { DeepSeekProtocolAdapter } from './protocol-adapter.ts';
 /** DeepSeek provider using Messages content and native thinking replay. */
-export declare class DeepSeekAdapter<C extends Connection = Connection> extends LlmAdapter {
-    private readonly dependencies;
-    private readonly files;
-    private readonly imageAccess;
+export declare class DeepSeekAdapter<C extends DeepSeekConnectionOptions = DeepSeekConnectionOptions> extends DeepSeekProtocolAdapter<C> {
+    /** @param dependencies - request-local configuration, credentials, and Host services. */
     constructor(dependencies: DeepSeekAdapterOptions<C>);
-    providerInfo(provider: string): {
-        id: string;
-        name: string;
-    };
-    providerRetryPolicy(_provider: string): import("@deepseek-ai/dsh-llm").ResolvedRetryPolicy;
-    listModels(provider: string): Promise<never[] | import("@deepseek-ai/dsh-llm").LlmModelInfo[]>;
-    resolveModel(provider: string, model: string, _signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-llm").LlmResolvedModelInfo>;
-    imageRequestPricing(_provider: string, model: string): import("@deepseek-ai/dsh-llm").LlmImageRequestPricing;
-    prepareCall(provider: string, model: string, _signal?: AbortSignal): Promise<PreparedAdapterCall>;
-    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
-    private generate;
-    private request;
 }
 //# sourceMappingURL=adapter.d.ts.map

package/runtime/node_modules/@deepseek-ai/dsh-llm-deepseek/lib/types/chat-completions/adapter.d.ts

@@ -0,0 +1,8 @@
+import { DeepSeekProtocolAdapter } from '../protocol-adapter.ts';
+import type { DeepSeekAdapterOptions, DeepSeekConnectionOptions } from '../types.ts';
+/** DeepSeek OpenAI-compatible transport with raw reasoning replay and Files recovery. */
+export declare class DeepSeekChatCompletionsAdapter<C extends DeepSeekConnectionOptions = DeepSeekConnectionOptions> extends DeepSeekProtocolAdapter<C> {
+    /** @param dependencies - explicit API root, request authentication, defaults, and Host services. */
+    constructor(dependencies: DeepSeekAdapterOptions<C>);
+}
+//# sourceMappingURL=adapter.d.ts.map

package/runtime/node_modules/@deepseek-ai/dsh-llm-deepseek/lib/types/chat-completions/serialize.d.ts

@@ -0,0 +1,10 @@
+import type { serialize as serializeMessages } from '../serialize.ts';
+import type { WireRequest } from './types.ts';
+/**
+ * Serialize prepared history without rewriting durable reasoning or tool arguments.
+ * Tool-result images follow their complete consecutive tool-result group in a user message.
+ * @param args - request, validated connection, prepared history/images, access resolver, replay reporter, and Files ids.
+ * @returns a streaming Chat Completions request with usage enabled.
+ */
+export declare function serialize(...args: Parameters<typeof serializeMessages>): WireRequest;
+//# sourceMappingURL=serialize.d.ts.map

package/runtime/node_modules/@deepseek-ai/dsh-llm-deepseek/lib/types/chat-completions/sse.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Decode an SSE byte stream into event `data` payloads. Framing — chunk
+ * reassembly, UTF-8/CRLF/BOM handling, comment and non-data field skipping,
+ * multi-`data:` joining — is `eventsource-parser`'s. Comments are reported
+ * only through an optional transport-activity callback. This module keeps the
+ * DeepSeek protocol: the literal `[DONE]` is yielded so the caller owns final
+ * flushing, and EOF before it raises {@link LlmError}. Framing is spec-strict:
+ * an event dispatches only on its blank-line terminator, so an unterminated
+ * tail at EOF is truncation, not a flushable payload.
+ *
+ * @module dsh-llm-deepseek/sse
+ */
+/** The terminal payload DeepSeek (and OpenAI) send after the last chunk. */
+export declare const DONE = "[DONE]";
+/**
+ * Parse an SSE byte stream into data payloads. Yields `[DONE]` as the final
+ * value and returns; throws `LlmError('STREAM_CLOSED')` when the stream ends
+ * without it (truncated response — the model call cannot be trusted).
+ * @param stream - raw SSE bytes; reads may split anywhere, including mid-UTF-8 sequence.
+ * @param onComment - optional transport-activity callback; comments never enter the yielded payload stream.
+ * @returns each event's data payload in arrival order, the `[DONE]` sentinel last.
+ */
+export declare function parseSse(stream: ReadableStream<BufferSource>, onComment?: (comment: string) => void): AsyncGenerator<string>;
+//# sourceMappingURL=sse.d.ts.map

package/runtime/node_modules/@deepseek-ai/dsh-llm-deepseek/lib/types/chat-completions/translate.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Translate DeepSeek SSE payloads with one stateful harness block per content, reasoning, or tool
+ * call index. An empty initial reasoning delta does not open a block. Finish reason and the latest
+ * usage are deferred until `[DONE]`, covering both finish-attached and trailing usage-only shapes
+ * while ensuring no chunk follows `finish`.
+ *
+ * Translate DeepSeek wire chunks into the harness `StreamChunk` protocol.
+ * @module dsh-llm-deepseek/translate
+ */
+import type { FinishReason, StreamChunk, TokenUsage } from '@deepseek-ai/dsh-llm';
+import type { WireUsage } from './types.ts';
+/**
+ * Map the wire finish_reason vocabulary to the harness FinishReason.
+ * @param reason - the wire `finish_reason` string.
+ * @returns the mapped reason; unrecognized values (content_filter, …) become `{kind: 'error'}` with the uppercased value as `code`.
+ */
+export declare function mapFinishReason(reason: string): FinishReason;
+/**
+ * Map wire usage fields. DeepSeek's `prompt_tokens` INCLUDES cache hits
+ * (`prompt_tokens = prompt_cache_hit_tokens + prompt_cache_miss_tokens`,
+ * api/create-chat-completion); the harness TokenUsage convention is
+ * DISJOINT counts, so cache reads are subtracted out of `inputTokens`.
+ * @param usage - wire usage from the finish chunk or the trailing usage-only chunk.
+ * @returns disjoint harness counts; an exact total is present only when the
+ *   aggregate prompt/completion counters are valid and agree with any wire total.
+ */
+export declare function mapUsage(usage: WireUsage): TokenUsage;
+/**
+ * Consume SSE data payloads (ending with `[DONE]`) and yield StreamChunks.
+ * Malformed JSON payloads abort the stream with `MALFORMED_RESPONSE`.
+ * @param payloads - SSE data payloads from {@link parseSse}, `[DONE]`-terminated.
+ * @returns deltas as they arrive; `block-end`s, `usage`, and `finish` are all deferred to the `[DONE]` sentinel.
+ *   A `stop` (or absent) finish with no opened blocks is a degenerate provider completion and maps to an
+ *   `EMPTY_RESPONSE` error finish instead of a successful empty message.
+ */
+export declare function translate(payloads: AsyncIterable<string>): AsyncGenerator<StreamChunk>;
+//# sourceMappingURL=translate.d.ts.map

package/runtime/node_modules/@deepseek-ai/dsh-llm-deepseek/lib/types/chat-completions/types.d.ts

@@ -0,0 +1,159 @@
+/** DeepSeek Chat Completions request and streaming response types. */
+/** Request body for `POST {baseURL}/chat/completions`. */
+export type WireRequest = {
+    model: string;
+    messages: WireMessage[];
+    stream: true;
+    stream_options: {
+        include_usage: true;
+    };
+    /** Thinking-mode toggle (top level, NOT inside extra_body on the wire). */
+    thinking?: {
+        type: 'enabled' | 'disabled';
+    };
+    /** Thinking effort (official levels). */
+    reasoning_effort?: 'low' | 'high' | 'max';
+    tools?: WireTool[];
+    temperature?: number;
+    max_tokens?: number;
+    /**
+     * Stop sequences (OpenAI `stop`): generation halts as soon as the model
+     * produces any one of these strings. Mapped from `GenerateOptions.stop`.
+     */
+    stop?: string[];
+};
+/** System-role message: a single string of instructions. */
+export type WireSystemMessage = {
+    role: 'system';
+    content: string;
+};
+/** Text part inside a multimodal user message. */
+export type WireTextContentPart = {
+    type: 'text';
+    text: string;
+};
+/** Files API reference inside a multimodal user message. */
+export type WireFileContentPart = {
+    type: 'file';
+    file_id: string;
+};
+/** Inline base64 data URL inside a multimodal user message. */
+export type WireImageUrlContentPart = {
+    type: 'image_url';
+    image_url: {
+        url: string;
+    };
+};
+/** One image representation accepted by a multimodal user message. */
+export type WireImageContentPart = WireFileContentPart | WireImageUrlContentPart;
+/** Ordered input part accepted by a multimodal user message. */
+export type WireUserContentPart = WireTextContentPart | WireImageContentPart;
+/** User-role message: text-only string or ordered multimodal input. */
+export type WireUserMessage = {
+    role: 'user';
+    content: string | WireUserContentPart[];
+};
+/** Tool-role message: the result of one tool call, keyed by its call id. */
+export type WireToolMessage = {
+    role: 'tool';
+    tool_call_id: string;
+    content: string;
+};
+/** One entry of the request `messages` array, discriminated on `role`. */
+export type WireMessage = WireSystemMessage | WireUserMessage | WireAssistantMessage | WireToolMessage;
+/** Assistant history retains empty-string content on tool-only and reasoning-only turns. */
+export type WireAssistantMessage = {
+    role: 'assistant';
+    content: string;
+    /** Exact reasoning text replayed on every reasoning-carrying assistant turn. */
+    reasoning_content?: string;
+    tool_calls?: WireToolCall[];
+};
+/** A completed tool call replayed on an assistant history message; `arguments` is the raw JSON string. */
+export type WireToolCall = {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+};
+/** One entry of the request `tools` array; `parameters` is a JSON Schema object. */
+export type WireTool = {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: Record<string, unknown>;
+    };
+};
+/** One parsed SSE `data:` payload (a chat.completion.chunk). */
+export type WireChunk = {
+    choices?: WireChoice[];
+    /** Arrives attached to the finish chunk and/or as a trailing usage-only chunk. */
+    usage?: WireUsage | null;
+};
+/** One streamed choice (requests always ask for a single one); `finish_reason` is non-null only on its terminal chunk. */
+export type WireChoice = {
+    delta?: WireDelta;
+    finish_reason?: string | null;
+};
+/** The incremental content of one streamed choice; any subset of fields may be present per chunk. */
+export type WireDelta = {
+    role?: string;
+    /** Visible text. Null/empty on reasoning/tool-call chunks. */
+    content?: string | null;
+    /**
+     * Thinking-mode CoT. The FIRST chunk carries an empty string (must not
+     * open a reasoning block); absent entirely in non-thinking mode.
+     */
+    reasoning_content?: string | null;
+    tool_calls?: WireToolCallDelta[];
+};
+/** A streamed fragment of one tool call; fragments sharing an `index` concatenate into one call. */
+export type WireToolCallDelta = {
+    /** Disambiguates parallel tool calls; stable across a call's deltas. */
+    index: number;
+    /**
+     * Carried by the first delta of each call. Gateways observed in the wild
+     * repeat it on continuation deltas as `''` or `null`; both mean "unchanged".
+     */
+    id?: string | null;
+    type?: 'function';
+    function?: {
+        /** Carried by the first delta of each call, with the same `''`/`null` repetition as {@link WireToolCallDelta.id}. */
+        name?: string | null;
+        /** Argument JSON fragment (concatenate across deltas). */
+        arguments?: string | null;
+    };
+};
+/**
+ * Wire token accounting. `prompt_tokens` INCLUDES cache hits (it equals
+ * `prompt_cache_hit_tokens + prompt_cache_miss_tokens`); `mapUsage` subtracts
+ * them to keep the harness convention of disjoint counts.
+ * `prompt_tokens_details.cached_tokens` is the OpenAI-compat spelling of the
+ * hit count.
+ */
+export type WireUsage = {
+    prompt_tokens: number;
+    completion_tokens: number;
+    /** Provider-reported aggregate across prompt and completion tokens. */
+    total_tokens?: number;
+    prompt_cache_hit_tokens?: number;
+    prompt_cache_miss_tokens?: number;
+    prompt_tokens_details?: {
+        cached_tokens?: number;
+    };
+    completion_tokens_details?: {
+        reasoning_tokens?: number;
+    };
+};
+/** Non-2xx error body. */
+export type WireError = {
+    error?: {
+        message?: string;
+        type?: string;
+        code?: string;
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/runtime/node_modules/@deepseek-ai/dsh-llm-deepseek/lib/types/file-store.d.ts

@@ -23,12 +23,15 @@ export interface DeepSeekFileReference {
     uploaded: boolean;
 }
 interface FileStoreOptions {
+    /** Files dialect; omission retains the existing Messages namespace. */
+    protocol?: 'messages' | 'chat-completions';
     index?: DeepSeekUploadIndex;
     now?: () => number;
     fetch?: typeof fetch;
 }
 /** User-scoped durable file-id reuse for the DeepSeek route. */
 export declare class DeepSeekFileStore {
+    private readonly protocol;
     private readonly index;
     private readonly now;
     private readonly fetchImpl;

package/runtime/node_modules/@deepseek-ai/dsh-llm-deepseek/lib/types/files-api.d.ts

@@ -46,6 +46,8 @@ export declare class DeepSeekFilesError extends LlmError {
  */
 export declare function isFilesQuotaError(error: unknown): error is DeepSeekFilesError;
 interface FilesApiOptions {
+    /** API dialect; omission retains Messages. */
+    protocol?: 'messages' | 'chat-completions';
     baseURL: string;
     /** Provider-resolved authentication headers for this endpoint. */
     headers: Readonly<Record<string, string>>;
@@ -53,6 +55,7 @@ interface FilesApiOptions {
 }
 /** Direct Files client retaining the configured URL root and refusing redirects before credentials can leave its origin. */
 export declare class DeepSeekFilesClient {
+    private readonly protocol;
     private readonly baseURL;
     private readonly authHeaders;
     private readonly fetchImpl;
@@ -60,6 +63,7 @@ export declare class DeepSeekFilesClient {
      * @param options - endpoint, authentication headers, and optional test transport.
      */
     constructor(options: FilesApiOptions);
+    private parseFile;
     private request;
     /**
      * Upload one image with an explicit expiry.

package/runtime/node_modules/@deepseek-ai/dsh-llm-deepseek/lib/types/index.d.ts

@@ -3,6 +3,7 @@ export { deepSeekConfigFields, Config, plainOptions, resolveAdapterOptions, PUBL
 export type { Options, ResolvedDeepSeekOptions } from './config.ts';
 export { DEFAULT_CONTEXT_WINDOW, DEFAULT_FILE_EXPIRY_SECONDS, DEFAULT_FILE_QUOTA_CLEANUP_BATCH, DEFAULT_FILE_REFRESH_MARGIN_SECONDS, DEFAULT_FILES_API_TIMEOUT_MS, DEFAULT_IMAGE_OFFLOAD_BYTE_QUANTUM, DEFAULT_IMAGE_OFFLOAD_COUNT_QUANTUM, DEFAULT_INLINE_IMAGE_OFFLOAD_BYTE_QUANTUM, DEFAULT_MAX_INLINE_REQUEST_IMAGE_BYTES, DEFAULT_MAX_TOKENS, DEFAULT_STREAM_IDLE_TIMEOUT_MS, } from './defaults.ts';
 export { DeepSeekAdapter } from './adapter.ts';
+export { DeepSeekChatCompletionsAdapter } from './chat-completions/adapter.ts';
 export type { DeepSeekRequestAuth, DeepSeekAdapterOptions, DeepSeekCatalogModel, DeepSeekConnectionOptions } from './types.ts';
 export { DEFAULT_LOW_DETAIL_IMAGE_PIXEL_BUDGET, DEFAULT_MAX_IMAGES_PER_REQUEST, DEFAULT_MAX_REQUEST_FILES_BYTES, DEFAULT_REQUEST_IMAGE_MAX_BYTES, REQUEST_IMAGE_MAX_DIMENSION, deepSeekImageRequestPricing, resolveRequestImageMaxBytes, resolveRequestImageTarget, } from './request-pricing.ts';
 export { deepSeekImageTokens, deepSeekRequestImageDimensions } from './image-tokens.ts';

package/runtime/node_modules/@deepseek-ai/dsh-llm-deepseek/lib/types/protocol-adapter.d.ts

@@ -0,0 +1,41 @@
+/** Shared cancellation, image recovery, authentication, and delivery lifecycle for DeepSeek protocols. */
+import { LlmAdapter } from '@deepseek-ai/dsh-llm';
+import type { GenerateOptions, PreparedAdapterCall, StreamChunk } from '@deepseek-ai/dsh-llm';
+import type { DeepSeekAdapterOptions, DeepSeekConnectionOptions as Connection } from './types.ts';
+import type { DeepSeekProtocol } from './protocol.ts';
+/** Provider adapter with protocol-independent request ownership and image recovery. */
+export declare class DeepSeekProtocolAdapter<C extends Connection = Connection> extends LlmAdapter {
+    private readonly dependencies;
+    private readonly protocol;
+    private readonly files;
+    private readonly imageAccess;
+    /**
+     * @param dependencies - request-local configuration, authentication, and Host services.
+     * @param protocol - serializer, resource URLs, and stream decoder.
+     */
+    constructor(dependencies: DeepSeekAdapterOptions<C>, protocol: DeepSeekProtocol);
+    providerInfo(provider: string): {
+        id: string;
+        name: string;
+    };
+    providerRetryPolicy(_provider: string): import("@deepseek-ai/dsh-llm").ResolvedRetryPolicy;
+    listModels(provider: string): Promise<never[] | import("@deepseek-ai/dsh-llm").LlmModelInfo[]>;
+    resolveModel(provider: string, model: string, _signal?: AbortSignal): Promise<{
+        context?: import("@deepseek-ai/dsh-llm").LlmModelContext;
+        defaultMaxTokens?: number;
+        reasoning?: import("@deepseek-ai/dsh-llm").LlmModelReasoningInfo;
+        systemPromptUpdate?: import("@deepseek-ai/dsh-llm").SystemPromptUpdate;
+        provider: string;
+        id: string;
+        name: string;
+        description?: string;
+        inputModalities?: readonly import("@deepseek-ai/dsh-llm").ModelModality[];
+    }>;
+    imageRequestPricing(_provider: string, model: string): import("@deepseek-ai/dsh-llm").LlmImageRequestPricing;
+    prepareCall(provider: string, model: string, _signal?: AbortSignal): Promise<PreparedAdapterCall>;
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+    private describe;
+    private generate;
+    private request;
+}
+//# sourceMappingURL=protocol-adapter.d.ts.map

package/runtime/node_modules/@deepseek-ai/dsh-llm-deepseek/lib/types/protocol.d.ts

@@ -0,0 +1,35 @@
+/** Wire-specific operations used by the shared DeepSeek request lifecycle. */
+import type { StreamChunk } from '@deepseek-ai/dsh-llm';
+import type { DeepSeekLlmApiExtensionRequest } from '@deepseek-ai/dsh-deepseek-llm-api-extensions';
+import type { serialize } from './serialize.ts';
+/** Serialization and transport rules for one DeepSeek API dialect. */
+export interface DeepSeekProtocol {
+    /** API family included in transport diagnostics. */
+    readonly name: string;
+    /** Files API dialect and upload-cache namespace. */
+    readonly files: 'messages' | 'chat-completions';
+    /**
+     * Resolve the model endpoint.
+     * @param baseURL - configured API root.
+     * @returns the model request URL.
+     */
+    endpoint(baseURL: string): string;
+    /**
+     * Serialize one request and its protocol-specific headers.
+     * @param args - prepared request inputs shared with the Messages serializer.
+     * @returns the request body and protocol headers.
+     */
+    prepare(...args: Parameters<typeof serialize>): {
+        body: DeepSeekLlmApiExtensionRequest['body'];
+        headers: Readonly<Record<string, string>>;
+    };
+    /**
+     * Convert provider bytes to Harness chunks, preserving terminal ordering.
+     * @param stream - provider response bytes.
+     * @param activity - notification for each received SSE frame.
+     * @param model - requested model id for response replay.
+     * @returns the decoded chunks.
+     */
+    translate(stream: ReadableStream<BufferSource>, activity: () => void, model: string): AsyncIterable<StreamChunk>;
+}
+//# sourceMappingURL=protocol.d.ts.map

package/runtime/node_modules/@deepseek-ai/dsh-llm-deepseek/lib/types/transport.d.ts

@@ -9,7 +9,8 @@ export declare function providerErrorDetail(raw: unknown): string;
  * @param raw - decoded response or in-band error event.
  * @param status - HTTP status when the error preceded streaming.
  * @param headers - response headers for retry delay and request identity.
+ * @param protocol - API family used in fallback diagnostics; defaults to Messages.
  * @returns a stable error consumed by LlmRuntime and llm-retry.
  */
-export declare function providerError(raw: unknown, status: number | undefined, headers?: Headers): LlmError;
+export declare function providerError(raw: unknown, status: number | undefined, headers?: Headers, protocol?: string): LlmError;
 //# sourceMappingURL=transport.d.ts.map

package/runtime/node_modules/@deepseek-ai/dsh-llm-deepseek/lib/types/types.d.ts

@@ -1,4 +1,4 @@
-/** Model catalog and request-local dependencies for DeepSeek Messages. */
+/** Model catalog and request-local dependencies for DeepSeek transports. */
 import type { LlmModelInfo, ModelModality, SystemPromptUpdate, ToolUpdate, ResolvedRetryPolicy, ImageAttachmentAccess } from '@deepseek-ai/dsh-llm';
 import type { AttachmentStore, ImageAttachmentRef } from '@deepseek-ai/dsh-attachment';
 import type { AnonymousUserId } from '@deepseek-ai/dsh-anonymous-user-id';
@@ -47,7 +47,7 @@ export interface DeepSeekCatalogModel {
  * makes a configuration change reach the next request without re-registration.
  */
 export interface DeepSeekConnectionOptions {
-    /** Messages API root; custom paths remain unchanged. */
+    /** API root for the selected adapter; custom paths remain unchanged. */
     baseURL: string;
     /** Request defaults applied to every call (thinking mode, effort). */
     defaults: RequestDefaults;

package/runtime/node_modules/@deepseek-ai/dsh-mcp-client/lib/index.js

@@ -19,13 +19,14 @@ import { assertSupportedJsonSchema } from "@deepseek-ai/dsh-tools";
 */
 /**
 * The subprocess seam's scrubbed parent env (credential-shaped and stale
-* `DSH_*` names dropped), plus the spec's explicit env. The MCP SDK owns the
-* actual spawn, so this transport shares the scrub definition rather than the
-* spawn path.
+* `DSH_*` names dropped), without pnpm's inherited package-manager version
+* control, plus the spec's explicit env. The MCP SDK owns the actual spawn.
 */
 function buildChildEnv(extra) {
+	const env = scrubbedParentEnv();
+	for (const key of Object.keys(env)) if (/^npm_config_manage[-_]package[-_]manager[-_]versions$/iu.test(key)) Reflect.deleteProperty(env, key);
 	return {
-		...scrubbedParentEnv(),
+		...env,
 		...extra
 	};
 }

package/runtime/node_modules/@deepseek-ai/dsh-session-log-export/lib/client.js

@@ -20,7 +20,7 @@ window.__ModuleLoader__.load({
 		* @returns one safe browser download filename.
 		*/
 		function sessionLogZipFilename(sessionId) {
-			return `dsh-session-${String(sessionId).replace(/[^A-Za-z0-9_-]/g, "_")}.zip`;
+			return `cco-session-${String(sessionId).replace(/[^A-Za-z0-9_-]/g, "_")}.zip`;
 		}
 		/**
 		* Hand a Host download route to the browser download manager, which resolves it
@@ -169,8 +169,8 @@ window.__ModuleLoader__.load({
 			});
 		}
 		//#endregion
-		//#region \0dsh-css:/Users/shiguifeng/IdeaProjects/chonggou/deepseek-harness/packages/session-query/session-log-export/src/client/HeaderAction.module.css.mjs
-		const css = ".HfnF4a_moreButton{width:28px;color:var(--dsw-alias-label-secondary);flex:none;padding:0}.HfnF4a_moreButton svg{width:15px;height:15px}";
+		//#region \0dsh-css:/Users/shiguifeng/IdeaProjects/chonggou/chatcode-cli-harness/packages/session-query/session-log-export/src/client/HeaderAction.module.css.mjs
+		const css = ".yAiIdG_moreButton{width:28px;color:var(--dsw-alias-label-secondary);flex:none;padding:0}.yAiIdG_moreButton svg{width:15px;height:15px}";
 		const tagId = "@deepseek-ai/dsh-session-log-export/HeaderAction.module.css";
 		if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId) + "]") === null) {
 			const tag = document.createElement("style");
@@ -179,7 +179,7 @@ window.__ModuleLoader__.load({
 			tag.textContent = css;
 			document.head.appendChild(tag);
 		}
-		var HeaderAction_module_css_default = { "moreButton": "HfnF4a_moreButton" };
+		var HeaderAction_module_css_default = { "moreButton": "yAiIdG_moreButton" };
 		//#endregion
 		//#region lib/types/client/HeaderAction.js
 		/**

package/runtime/node_modules/@deepseek-ai/dsh-session-log-export/lib/index.js

@@ -245,7 +245,7 @@ function safeSessionIdSegment(id) {
 * @returns the attachment filename for the session's export archive.
 */
 function sessionLogZipFilename(sessionId) {
-	return `dsh-session-${safeSessionIdSegment(sessionId)}.zip`;
+	return `cco-session-${safeSessionIdSegment(sessionId)}.zip`;
 }
 /**
 * Yield the export entries in zip order: the preloaded root log first, then

package/runtime/node_modules/@deepseek-ai/dsh-session-persistence-jsonl/lib/index.js

@@ -2653,12 +2653,12 @@ var JsonlSessionPersistence = class extends SessionPersistence {
 						} finally {
 							await marker.close();
 						}
-						await this.syncDirPosix(dir);
+						if (process.platform !== "win32") await this.syncDirPosix(dir);
 						for (const entry of await readdir(dir)) if (entry !== "session.lock" && entry !== DELETED_FILENAME) await rm(join(dir, entry), {
 							recursive: true,
 							force: true
 						});
-						await this.syncDirPosix(dir);
+						if (process.platform !== "win32") await this.syncDirPosix(dir);
 					}
 					for (const id of claimed) {
 						this.coldLogMemo.delete(id);

package/runtime/node_modules/@deepseek-ai/dsh-tool-cordis/lib/types/api-catalog.js

@@ -1687,6 +1687,11 @@ export const SERVICE_API = [
                 description: 'Bundle packages used to start this process, before any persisted edits.',
                 parameters: [],
             },
+            {
+                signature: 'readonly defaults?: readonly PatchOptions[]',
+                description: 'Launcher-owned defaults, applied after bundles and before editable profile and home patches.',
+                parameters: [],
+            },
             {
                 signature: 'readonly overlays: readonly PatchOptions[]',
                 description: 'Parsed command-line overlays, applied above profile and home patches.',
@@ -3474,21 +3479,22 @@ export const SERVICE_API = [
     },
     {
         key: 'workspaceChanges',
-        summary: 'Serves the summaries and file comparisons the recorder keeps for live Sessions.',
-        description: 'Serves the summaries and file comparisons the recorder keeps for live Sessions.',
+        summary: 'Serves live and archived turn summaries and file comparisons.',
+        description: 'Serves live and archived turn summaries and file comparisons.',
         methods: [
             {
-                signature: 'summary(sessionId: SessionId, seq: number): WorkspaceChangesSummary | undefined',
+                signature: 'summary(sessionId: SessionId, seq: number): Promise<WorkspaceChangesSummary | undefined>',
                 description: 'The summary announced by one `workspace/changes` event.',
                 parameters: [{ name: 'sessionId', description: 'the Session that appended the event.' }, { name: 'seq', description: 'the event\'s sequence number.' }],
-                returns: 'the summary, or undefined once its Session was disposed or when this Host never recorded it.',
+                returns: 'the live or archived summary, or undefined when no record exists.',
+                throws: ['when an archived summary cannot be read or validated.'],
             },
             {
                 signature: 'diff(sessionId: SessionId, seq: number, index: number, signal: AbortSignal): Promise<WorkspaceFileDiff | undefined>',
                 description: 'Compare one listed file\'s contents at turn start and turn end.',
                 parameters: [{ name: 'sessionId', description: 'the Session that appended the event.' }, { name: 'seq', description: 'the event\'s sequence number.' }, { name: 'index', description: 'the file\'s index in the summary\'s `files`.' }, { name: 'signal', description: 'cancels the reads.' }],
-                returns: 'the comparison, or undefined once its Session was disposed, when this Host never recorded it, or when no file has that index.',
-                throws: ['when a snapshot read fails for a live Session.'],
+                returns: 'the live or archived comparison, or undefined when no record or file exists.',
+                throws: ['when a snapshot or archive read fails.'],
             },
         ],
     },
@@ -6483,10 +6489,6 @@ export const TYPE_API = [
         name: 'SessionCreateValue',
         declaration: 'export interface SessionCreateValue {\n    readonly sessionId: SessionId;\n    readonly agentPreset?: string;\n}',
     },
-    {
-        name: 'SessionDeletion',
-        declaration: 'export interface SessionDeletion extends AsyncDisposable {\n    commit(): Promise<void>;\n}',
-    },
     {
         name: 'SessionEvent',
         declaration: 'export type SessionEvent<T extends SessionEventType = SessionEventType> = {\n    [K in SessionEventType]: {\n        type: K;\n        seq: SessionSeq;\n        time: number;\n        data: SessionEventMap[K];\n        ignorable?: true;\n    } & (K extends SurfaceEventType ? SurfaceIntent<K> : {\n        surfaceOp?: never;\n        sourceEventSeqs?: never;\n    });\n}[T];',