deepseek-ai/deepseek-harness

This system is a comprehensive AI development and interaction platform, featuring a cross-platform desktop application and a web-based GUI that connect to a local or remote host environment. It provides a unified interface for managing sessions, workspaces, and agent configurations, supporting complex workflows through a plugin-based architecture and a robust remote API for real-time event streaming. The platform includes specialized tooling for file management, terminal access, and code execution, alongside performance benchmarks and native system integrations to ensure secure and efficient operation.

The client now includes localized text for standard interface elements (such as buttons, status messages, and copy actions) in both English and Simplified Chinese. The Chinese dictionary serves as the source of truth for the key set, and the English dictionary is strictly validated against it to ensure no keys are missing or extra, guaranteeing consistent localization coverage for common UI components.

packages/client/locale/src/locales · high confidence

Introduces the \@deepseek-ai/dsh-client-ui-open-in-app\ package, which provides the browser-side split button for the 'Open In App' feature. This component registers a new entry in the session header utilities slot, allowing users to launch the current session's workspace directory in a locally installed application. It handles the display of available apps, manages the user's last choice via browser storage, and provides visual feedback for launch states (idle, busy, error).

packages/client/ui-open-in-app · high confidence

A new client plugin in ui-jobs registers a session-header action that displays a popover list of background jobs for the current session. The component shows live and settled jobs with status indicators, labels, and elapsed durations, using a shared outside-pointer dismissal hook and CSS modules for styling (including 20px menu radii and superellipse-inspired elevation strokes). It contributes localized copy for English and Simplified Chinese and injects into the conversation session header slot without issuing its own RPCs, relying on the existing jobsBySession state mirror.

packages/client/ui-jobs/src · high confidence

Users can now view a list of active schedule reminders directly in the session header via a new catalog action. This component displays scheduled and overdue reminders, showing their frequency, local target time, and relative time status (e.g., 'in 5 minutes' or '2 days overdue'). The catalog is sorted with overdue items first and updates in real-time while open, using a fixed-position menu with accessible keyboard navigation and Escape-to-dismiss behavior.

packages/client/ui-schedule/src · high confidence

The subagent UI plugin now includes a TypeScript declaration file for CSS modules and a minimal index entry point. The index exports an empty apply function, ensuring the plugin is recognized by the host loader while deferring actual browser-side implementation to a separate client export.

packages/client/ui-subagent/src · high confidence

The \packages/boot/cmdline/src\ package introduces a new mechanism where the launcher passes raw arguments to the booting application, allowing the app to own its flag parsing, help text, and error handling via the \parseCmdline\ helper. This change shifts command-line responsibility from the launcher to the app, enabling apps to define their own commander programs and publish parsed values as services. Additionally, the package provides \exitOnStdinEnd\ to manage application shutdown based on stdin EOF, ensuring proper lifecycle coordination between the launcher and the app.

packages/boot/cmdline/src · high confidence

The client-side session controller now manages session lifecycles, history, and live assistant streams locally. It introduces a \SessionManager\ to coordinate session instances, a \ProjectionValueStore\ to cache and serve host-computed projection values (like titles) with a strict higher-sequence-wins rule, and a \ClientAssistantStream\ class to fold transient live assistant frames into durable v2 settlements. Additionally, a \flattenLineage\ utility is provided to compute indentation depths for session lists, and a \Notifier\ class batches state updates for efficient UI rendering.

packages/api/session-controller/src/client/sessions · high confidence

The client now displays skill executions in a dedicated, compact row (SkillRow) that shows a summary line with state indicators (running, error, stopped) and an expandable section revealing the skill's instructions or output. This row is registered as the visual representation for 'skill' tool calls. Additionally, the plugin registers a new slash-catalog source for the '/' trigger, allowing users to invoke skills by name. This source fetches and caches the skill catalog per session, supports fuzzy ranking of candidates, and marks user-only skills with a specific label. It also handles opening file references for skills directly in the sidebar.

packages/client/ui-skill/src/client · high confidence

The Desktop application now ships with a standalone, offline-capable runtime environment. It bundles specific versions of Python, Node.js, pnpm, and key libraries (including NumPy, Pandas, and Office document tools) directly within the application. On first launch, the host automatically installs these dependencies into a local directory, ensuring that Office skills and workspace tools function without requiring the user to have these interpreters or packages pre-installed on their system. This change also introduces a mechanism to safely update these bundled components in the background while managing active tasks.

apps/desktop-host · high confidence

The desktop application now includes comprehensive documentation and configuration templates for its packaging, signing, and update workflows. New \.env.macos.example\ and \.env.windows.example\ files provide the required environment variables for code signing (Apple Developer ID, Windows certificates), notarization, and Tencent COS upload credentials. A bilingual \README\ (English and Chinese) details the release version derivation rules, the bundled Python/Node runtime installation, the native directory picker, the native recovery dialog, and the update feed structure. Additionally, \electron-builder.config.d.mts\ defines the TypeScript interface for the electron-builder configuration, ensuring type safety for the packaging setup.

apps/desktop · high confidence

Added bilingual (English and Chinese) documentation for the session package group, including a package map and detailed references for the new \session-checkpoint-policy\ (ensuring model requests and tool side effects are durable before crash) and the \session-format-catalog\ (providing a static, plugin-independent inventory of session format codecs and migrations).

packages/session · high confidence

This change introduces the official bilingual (English and Chinese) documentation for the \subagent\ package group and the \@deepseek-ai/dsh-subagent-acp\ provider. The \subagent/README.md\ files define the package family, listing the delegation service, in-process drivers (spawn/fork), and out-of-process backends (ACP, Codex, Claude Code, DSH SDK) along with their model-facing tools. The \subagent-acp/README.md\ files provide detailed configuration instructions, usage guidelines, and implementation internals for the ACP backend, including process isolation, permission policies, and failure handling.

packages/subagent · high confidence

Added bilingual (English and Chinese) README documentation for the \packages/preset\ group and the \@deepseek-ai/dsh-agent-presets\ package, detailing how sessions are composed from preset files, the configuration options for roots and defaults, and the copy-only authoring model. Included the \cordis\ agent preset definition, which enables persistent plugin management and runtime inspection, along with its associated skills for plugin development and composition editing.

packages/preset · high confidence

The \@deepseek-ai/dsh-client-connection\ package now includes comprehensive English and Chinese documentation (\README.md\ and \README.zh.md\) detailing the browser-to-Host wire layer, including Remote RPC, event-stream delivery with reconnect, exact Fetch routes, the \/api\ HTTP bridge, and the browser-trust fence. A new \README.i18n.yaml\ file enforces consistency between the two language versions. The package also introduces a dual TypeScript configuration (\tsconfig.client.json\ and \tsconfig.host.json\) to separate client-side and host-side compilation targets, along with a \tsdown.config.ts\ for bundling.

packages/client/connection · high confidence

The \packages/experimental\ area now includes the \@deepseek-ai/dsh-experimental-agent-team-profile\ and \@deepseek-ai/dsh-experimental-agent-team-web-profile\ packages, which provide the Host-side and Web-side profile layers for Agent Teams. The Host profile layer (\agent-team-profile\) patches the base configuration to disable standard subagent delegation tools and insert the Team domain along with scoped Team tools, while the Web profile layer (\agent-team-web-profile\) inserts the Client UI plugin to display the team roster, task board, and navigation in the browser. These changes are accompanied by comprehensive bilingual documentation (English and Chinese) for the experimental group and its constituent packages, detailing installation, usage, and known limitations.

packages/experimental · high confidence

A new GoalBar component is introduced as a dock entry above the message composer, displaying the current goal's phase (active, paused, blocked) and objective, with inline actions to pause, resume, edit, and clear the goal. The strip also shows process-local activation state (e.g., disarmed) and errors. Additionally, a command-input view renders the echoed /goal command in the chat transcript, styling the leading /goal token as a command chip while keeping the rest as plain text. This plugin wires the UI to the Remote API for goal mutations and subscribes to live activation events to keep the strip in sync.

packages/client/ui-goal/src/client · high confidence

The ui-goal package now includes the foundational structure for a GoalBar component that overlays the goal session projection. This change introduces the TypeScript declaration for CSS modules and a host-side plugin entry point (apply) that registers the plugin in the host configuration, while the actual browser-side UI implementation is deferred to the client export.

packages/client/ui-goal/src · high confidence

The ui-layout package now includes a TypeScript declaration file for CSS modules and a minimal entry point. The CSS module declarations allow the project to import CSS files as modules, while the entry point exports an empty apply function, indicating that this specific component provides no host-side behavior and serves as a browser-only layout plugin.

packages/client/ui-layout/src · high confidence

The ui-skill package now includes the necessary TypeScript declaration files (css-modules.d.ts) to support CSS modules and standard CSS imports, along with an index.ts file that exports an empty apply function. This establishes the plugin as a pure UI component that registers with the host application's loader without introducing any host-side behavior, enabling the skill to be discovered and loaded via the package.json client exports.

packages/client/ui-skill/src · high confidence

This change introduces the foundational build infrastructure and documentation for the \@deepseek-ai/dsh-api-session-controller\ package. It adds bilingual README files (English and Chinese) that detail the package's role in managing Session lifecycle, history, skills, and file references, as well as its client-side and host-side interfaces. Additionally, it establishes the TypeScript build configuration (\tsconfig\ files) to separate host and client compilation targets and defines the bundling setup via \tsdown.config.ts\.

packages/api/session-controller · high confidence

The \@deepseek-ai/dsh-client-ui-chat\ package is now available to render browser chat interfaces from recorded Session conversations. It supports rendering historical images, localized actions, and restoring scroll positions. The UI features compact display modes that fold completed-turn process rows while keeping final answers visible, handles file and HTTP(S) navigation through a Markdown delegate provider, and displays system prompts and turn token usage. The package is configured with TypeScript references to core session, agent, and UI components, and includes bilingual documentation (English and Chinese).

(repo-wide) · high confidence

The \@deepseek-ai/dsh-api-workspace-controller\ package is now available, providing the Host \ctx.workspaceController\ service and the generated Client \ctx.remote.workspace\ namespace. This package enables clients to create, rename, remove, and reorder workspaces and sessions, as well as archive and unarchive sessions through the API Gateway. It also includes the \ctx.directoryPickerController\ and \ctx.remote.directoryPicker\ namespace to handle directory-picking operations. The package exposes framework-neutral snapshots and subscriptions for workspace state management.

packages/api/workspace-controller, packages/client/ui-model-selection · high confidence

The ui-user-questions package now includes a TypeScript declaration file for CSS modules and an index entry point that exports an empty apply function. This establishes the basic structure for the web question plugin, defining the module interface for CSS classes and providing a host plugin body where the model-facing tool is composed per preset rather than globally.

packages/client/ui-user-questions/src · high confidence

Users can now open interactive terminals in the Web sidebar that run with the execution environment's system-user permissions, independent of the Agent's sandbox mode. The system discovers available shells (defaulting to the environment's choice, with candidates like zsh, bash, fish, pwsh, and cmd), remembers the user's last selection in the browser, and allows launching new tabs with a specific shell. Terminals persist across browser reloads via saved bindings and close requests, allowing users to reconnect to existing processes and recover their screen history. The sidebar also manages terminal lifecycles by retaining open terminals for active windows and automatically reclaiming unattended ones after a configurable idle timeout.

packages/api/terminal-controller · high confidence

Users can now open and interact with terminal sessions directly within the right sidebar. This feature includes a guide entry to launch new terminals, allowing users to choose and remember their preferred shell from a provider-discovered list. Terminals automatically follow the application theme for colors and cursor contrast, and the sidebar preserves terminal state across sessions, restoring unattended terminals when a conversation is reopened. The UI also handles background process cleanup, showing actionable alerts if a terminal fails to close, and allows users to rename terminal tabs inline.

packages/client/ui-sidebar-terminal, packages/client/ui-sidebar-terminal/src · high confidence

The \packages/context\ group now includes the \@deepseek-ai/dsh-agent-instructions\ plugin, which loads workspace guidance from \AGENTS.md\ and \CLAUDE.md\ files into the agent's context. The plugin discovers instruction files starting from the user-global home directory down to the project root, respecting a configurable byte budget (\maxBytes\) to bound the injected prompt size. Instructions are injected as durable, model-visible user messages that persist in session history, and the plugin automatically reconciles the context when files are added, removed, or modified during a session. This package is included by default in \dsh-base\ but can be disabled or reconfigured via profile patches.

packages/context · high confidence

The \packages/boot/app-boot\ package is introduced as the shared Loader boot library for \dsh\ profiles and the temporary Python SDK runtime. It handles loading environment layers, composing profile bundles and patches, booting plugins, and providing startup diagnostics and configuration preview capabilities. The package includes bilingual documentation (English and Chinese) detailing its usage, profile management, and failure handling, along with build configuration for TypeScript and bundling via tsdown.

packages/boot/app-boot · high confidence

The \packages/client/hmr\ package is introduced to provide live graph synchronization and development bundle reloads for Web client plugins. This feature allows plugin enable/disable changes to take effect without reloading the page or restarting the Host, and enables code rebuilds to replace affected plugins with fresh component state. The package includes bilingual documentation (English and Chinese) detailing the reload chain, configuration options like \pollIntervalMs\, and implementation specifics such as the SSE transport and failure policies. It is configured via \tsdown.config.ts\ to bundle the client-side HMR driver and is structured with references to core dependencies like \cordis\, \loader\, and \client-modules\.

packages/client/hmr · high confidence

The new \@deepseek-ai/dsh-client-locale\ package enables users to switch the web GUI between English and Chinese (with extensible support for additional languages via plugins). Language preferences are applied immediately to UI copy and the \\<html lang\>\ attribute. On loopback pages, the selection is persisted to \$DSH\_HOME/settings.yaml\; on non-loopback pages, it remains process-local. For new browsers without a stored preference, the system defaults to the first supported language requested by the browser, falling back to English. Plugin authors can register typed namespace dictionaries and language packs to extend the available locales.

packages/client/locale · high confidence

The new \@deepseek-ai/dsh-client-modules\ package enables the web GUI to load client plugins lazily on demand. It turns a plugin's \dsh.client\ declaration into a loadable browser bundle, where the host composes a boot graph and serves bundles over \/plugins\, while the browser loads them only when first used. This ensures that plugin code and side effects (including CSS) do not run until a plugin is actually activated, improving startup performance and reducing initial payload.

packages/client/modules · high confidence

The \packages/client/store\ package now provides a framework-agnostic snapshot store engine built on Zustand and Immer, offering synchronous and animation-frame (raf) publication modes, optional \localStorage\ persistence, and a declarative \defineStore\ API. This library enables Client controllers and renderer adapters to manage browser-side state with stable snapshots and subscriptions without depending on React, while the corresponding React hooks remain in the \@deepseek-ai/dsh-client-ui-renderer\ package.

packages/client/store · high confidence

This change introduces the \@deepseek-ai/dsh-client-ui-agent-preset\ package, which provides the user interface for managing agent presets in the Web GUI. Users can now select an agent preset for new sessions via a new-session chip, view the active preset in the session header, and manage available presets through a Settings section. The package includes a visibility switch to show or hide the preset picker, allowing users to toggle between using a saved user default or the deployment default. It also supports creating custom presets by copying existing ones, viewing shipped presets in a read-only mode, and handling broken presets with appropriate UI feedback. The package is localized for English and Chinese, with bilingual documentation provided.

packages/client/ui-agent-preset · high confidence

The new ui-attachment package provides a unified attachment experience for the Web client, rendering a mixed draft-attachment rail under the composer, a full-viewport drop overlay with intake limits, and a shared image gallery with a lightbox for Chat, Trajectory, and Tool results. It operates as a client plugin that registers components into declared slots (e.g., conversation input, message images, trajectory images, tool call images) rather than exporting standalone components, ensuring attachment data, upload state, and callbacks are driven by the slot owners.

packages/client/ui-attachment · high confidence

The \ui-conversation\ package is now documented with a new English README and a synchronized Chinese translation (README.zh.md), establishing the package's role in target-neutral conversation assembly, browser shell management, and input state handling. The documentation details the event and view registries, per-session bindings, and the standard props (\useConversation\, \useInput\, \inputActions\) exposed to consumers. It also covers the temporary composer takeover mechanism, the optimistic submission flow, and the specific behaviors of the composer (e.g., busy-Enter settings, file attachment handling, and queue operations). A new \README.i18n.yaml\ file tracks the git blob hashes for both language versions to ensure consistency. The package's build configuration (\tsconfig.json\, \tsdown.config.ts\) is also established, referencing its dependencies like \ui-slots\, \ui-primitives\, \session-controller\, and \workspace-controller\.

packages/client/ui-conversation, packages/client/ui-primitives · high confidence

The Web GUI now includes a new \@deepseek-ai/dsh-client-ui-deliverables\ package that renders a "changed-files" card at the end of each turn, showing the files modified by the agent along with line counts and a "review" tab for comparing changes. It also provides cards for explicitly delivered files and converts inline code references in the closing prose into clickable links that open files in the right sidebar. This package registers the necessary system prompt sections, sidebar tabs, and file-reference services to support these features.

packages/client/ui-deliverables · high confidence

The Web GUI now features a new \@deepseek-ai/dsh-client-ui-input-trigger\ package that handles the detection of \/\ and \@\ triggers in the input field. When a user types these characters, a grouped menu appears offering slash commands, file references, and session references. The package supports keyboard and pointer selection, including drill-down capabilities, and routes selections to the appropriate sources for execution or insertion. This change introduces the core logic and UI components for this input trigger pipeline, including bilingual documentation and build configurations.

packages/client/ui-commands, packages/client/ui-input-trigger · high confidence

The new \@deepseek-ai/dsh-client-ui-layout\ package provides the Web GUI's three-column AppFrame shell, managing the sidebar, main content, and right column. It handles layout state, including sidebar collapse, right panel width preferences, and fullscreen presentation, while also owning theme presentation (color schemes, font sizes, and document metadata). The package exposes a \ctx.layout\ API for panel selection and layout control, and includes bilingual documentation (English and Chinese) to guide users and maintainers.

packages/client/file-upload, packages/client/ui-layout, packages/client/ui-sidebar · high confidence

A new \@deepseek-ai/dsh-client-ui-plan\ package has been added to manage the plan mode user interface. This package provides a status chip in the composer that allows users to toggle plan mode on and off, and it handles the display of submitted plan cards in the conversation's artifact area and the right sidebar. The package is configured with its own TypeScript and build settings and documents the integration with \ui-conversation\ and \dsh-plan-mode\.

packages/client/ui-plan · high confidence

The new \@deepseek-ai/dsh-client-ui-schedule\ package renders a read-only catalog of active Schedule reminders in the Web session header. It displays overdue items first, followed by future reminders sorted by target time, with localized status labels and relative times derived from the browser's locale and clock. The catalog is disabled by default and must be enabled via the Schedule overlay (\dsh web --patch ...\); once active, it provides a popover with keyboard accessibility (Escape to dismiss) and responsive positioning, while remaining strictly read-only without any mutation or delivery-receipt capabilities.

packages/client/ui-schedule · high confidence

The new \@deepseek-ai/dsh-client-ui-settings\ package provides a centralized foundation for managing user preferences in the web client. It allows feature plugins to read and write namespace-scoped settings backed by the Host document without implementing their own transport or schema handling. Key capabilities include atomic multi-field updates, schema validation, and protection against silently overwriting concurrent changes via revision fencing. The package also defines standard extension points (slots) for settings chrome, pages, plugin tabs, and onboarding flows, while maintaining a single shared mirror of the settings document in the browser to ensure consistency across surfaces.

packages/client/ui-goal, packages/client/ui-settings, packages/client/ui-workspace · high confidence

The new \@deepseek-ai/dsh-client-ui-skill\ package enables users to invoke skills via the \/\ suggestion menu or by typing \/name\ directly in the composer. This feature provides a dedicated skill tool row in the conversation UI that displays skill status (running, failed, or settled) and expands into an \Instructions\ card with stable, durable output. It includes bilingual documentation (English and Chinese) and integrates with the existing \ui-tool\ and \ui-input-trigger\ components to handle candidate ranking, session caching, and sidebar file previews.

packages/client/ui-skill · high confidence

The new \@deepseek-ai/dsh-client-ui-slots\ package provides a pure, zero-dependency registry core that allows web client plugins to define and compose typed UI regions. It supports four slot kinds—\single\, \list\, \keyed\, and \chain\—and introduces reusable Component Factories that let unrelated parents render independent assemblies with caller-selected local components. The package manages scoped state, injection, locale, and child-render props through declaration-merged types, and includes a store seat mechanism for declaring reactive state handles. It enforces strict declaration discipline at load time to prevent conflicts and provides a renderer installation contract for the \ui-renderer\ to handle the actual React rendering.

packages/client/ui-slots · high confidence

The new \@deepseek-ai/dsh-client-ui-tool\ package serves as the client-side plugin responsible for rendering tool calls within the dsh web client conversation. It manages the composition of the entire tool call tree, including nested subcalls, and dispatches individual atomic tool calls to their specific UI views via a keyed slot system (\tool.call.toolview\). This package provides built-in presentations for various tool types—such as shell, read, write, image, and question—and handles state visualization (running, successful, failed, interrupted) by relying on frozen call/result slices from the runtime. It also defines the contract for business packages to register their own custom tool views and includes documentation for its rendering logic and integration points.

packages/client/ui-tool · high confidence

The \packages/boot/hmr\ package adds a new Hot Module Replacement (HMR) service that serializes module replacements, Include refreshes, and profile configuration changes into a single queue, ensuring that package installation operations run outside this queue to avoid conflicts. It replaces the previous \@deepseek-ai/cordis-plugin-hmr\ module while maintaining the existing \ctx.hmr\ service key and events (\hmr/change\, \hmr/reload\). The service uses Chokidar to watch module roots and exact configuration paths, applying write-stabilization to prevent lost events during rapid edits, and integrates with the Node loader to replace cached modules and reload plugins without requiring a full application restart.

packages/boot/hmr · high confidence

The \packages/subprocess\ area now includes the \@deepseek-ai/dsh-subprocess-local\ package, which serves as the local host provider for the shared subprocess service. This provider manages child processes and terminal sessions using platform-specific native containment: Linux launches use transient user-systemd scopes, while Windows uses private Job objects, falling back to detached process groups or observed sessions on unsupported hosts. It features scrubbed starting environments, bounded output collection with spill recovery, and synchronous finalization on Node host exit. The release also adds bilingual (English and Chinese) README documentation for the \subprocess\ group and the \subprocess-local\ package, along with a script to ensure the \node-pty\ spawn helper has the correct executable bit.

packages/subprocess · high confidence

The \packages/todo\ area now includes the \@deepseek-ai/dsh-tool-todo\ package, which provides the \todo\_write\ tool for agents to maintain a structured, session-owned task list. The tool supports whole-list replacement (no partial updates) and persists the plan across turns and reopened sessions via the \todo/write\ event and a \todos\ session projection. A required \allowParallelInProgress\ configuration flag controls whether multiple tasks can be marked \in\_progress\ simultaneously, affecting both the model-facing instructions and input validation. The package also registers a durable invariant companion to validate snapshot integrity and ensure writes only occur during open turns.

packages/todo · high confidence

The native/system area now provides the \@deepseek-ai/node-addon-system\ package family, which exposes two independent capabilities: a Linux Landlock confinement executable (\landlock-run\) and an asynchronous POSIX file-lock binding (\flock\). The \./landlock-run\ entry point resolves the prebuilt launcher binary, builds grant arguments, and runs a functional probe to determine enforcement status (full, partial, or unusable) without relying on environment variables. The \./flock\ entry point lazily loads the \system.node\ Node-API v8 addon to perform nonblocking exclusive locks (\LOCK\_EX \| LOCK\_NB\) on caller-owned file descriptors, rejecting with \EAGAIN\/\EWOULDBLOCK\ on contention. Platform packages deliver precompiled binaries for Linux (glibc/musl) and macOS, ensuring consumers never need to compile native code during installation.

native/system · high confidence

The \dsh-client-ui-reference\ package is added to provide a unified \@\ completion menu for Web users, allowing them to mention files, folders, and sessions from a single source. The menu prioritizes files over sessions, supports drilling into folder paths without closing the menu, and inserts atomic inline references (e.g., \@dir/\ for folders, \@\label\\ for sessions) with stable clipboard forms. Session mentions are validated before model context is captured, and file references can be clicked to preview contents in the right sidebar.

packages/client/ui-reference · high confidence

Users can now select an agent preset for new sessions via a chip on the new-session screen, view the active preset in the session header, and manage the full roster in a new settings section. The settings section displays built-in and custom presets as cards, allows duplicating existing presets to create custom ones, setting a default, deleting presets, and viewing the composition of shipped presets. It also includes a toggle to enable or disable the preset picker on new-session surfaces.

packages/client/ui-agent-preset/src/client · high confidence

The Chat view now features a full-session turn rail that allows users to load and jump to specific turns, alongside a compact meta line for turn tails. Token usage and timing are displayed as clickable icon pills that open detailed stat dialogs. File references and skills are opened directly in the right sidebar, and the system prompt is now visible within the chat. Users can also control the presentation of completed turn process content via a new 'Transcript View' setting (Normal or Compact).

packages/client/ui-chat/src/client · high confidence

The vendor/loader module now implements a structured plugin loading system using the Cordis framework. Users can define plugins as entries within a hierarchical tree, supporting nested groups and dynamic configuration updates. The loader introduces service isolation, allowing plugins to intercept or isolate specific services via local or global realms, ensuring that changes to one entry do not inadvertently affect others. Configuration entries can be disabled conditionally using JavaScript expressions, and the loader handles module resolution for both relative and builtin specifiers. Additionally, the vendor includes a console logger exporter for both Node.js and browser environments, providing formatted, color-coded logging with configurable time and diff display options.

vendor/loader · high confidence

The Python area now provides the \deepseek-harness-sdk\ and \deepseek-harness-runtime-bin\ packages, enabling Python applications to drive the DeepSeek Harness agent via a JSON-RPC subprocess. The SDK exposes the \DeepSeekHarness\ class for managing agent turns, session state, and notifications, while the runtime wheel bundles the \dsh\ CLI and its Node.js dependencies into a single executable that requires no system Node.js installation. This change includes the full bilingual documentation (English and Chinese) for the SDK, runtime, and contributor workflows, along with a runnable minimal example and the build infrastructure (Hatch hook, platform manifest) required to package and validate the platform-specific wheels.

python · high confidence

The \packages/llm/deepseek-llm-api-extensions\ package adds a registry that allows plugins to contribute independent, top-level fields to official DeepSeek LLM API requests. This registry (\ctx.deepseekLlmApiExtensions\) enables lifecycle-owned metadata—such as the incremental session log and plugin package inventory—to be added to requests without modifying the base adapter, ensuring these fields are prepared atomically and accepted only after a successful HTTP response.

packages/llm · high confidence

The \@deepseek-ai/dsh-client-ui-settings-general\ package provides the shared presentation layer for the client's Settings panel, including a sidebar trigger, a connection-recovery indicator, and a sequential first-run onboarding flow. Users can now see a 'Disconnected' action with a retry button in the sidebar, which shows a spinner and recovers to a 'Connected' state. The package also supports opening local configuration files via the native text editor on loopback browsers and projects onboarding steps from a ledger, ensuring only one step is active at a time. Feature plugins contribute their own settings rows and onboarding content, while this shell manages the chrome, navigation, and state transitions.

packages/client/ui-settings-general · high confidence

The \packages/mcp/mcp-client\ plugin now connects to external Model Context Protocol (MCP) servers and exposes their tools to the model under stable, server-qualified names (e.g., \mcp\_\github\\_create\_issue\). It supports both \stdio\ (local process) and \streamable-http\ transports, automatically reconnecting with bounded exponential backoff after connection drops, and atomically swapping tool definitions to prevent partial or conflicting tool sets. Server instructions are injected into the system prompt, and image results are projected into the conversation when supported.

packages/mcp · high confidence

The new \@deepseek-ai/dsh-client-ui-settings-models\ package provides the Models settings page in the web client, allowing users to manage API keys (stored write-only via credential references), edit provider model lists, and hand-declare custom pi-ai routes. The page features a first-run onboarding flow for official DeepSeek credentials and exposes two extension slots (\settings.models.provider-card\ and \settings.models.footer\) for plugins to inject custom UI into provider rows and the page footer.

packages/client/ui-settings-models · high confidence

The \ptc-runtime\ package now includes the \@deepseek-ai/dsh-ptc-runtime-node\ provider, enabling model-written TypeScript to run in fresh, managed Node processes under the configured sandbox policy. This runtime enforces strict execution limits (timeouts, output bytes, V8 heap size) and captures program output and return values via a length-framed JSON control channel. It also introduces bilingual (English and Chinese) README documentation for the PTC execution capability family and its Node backend.

packages/ptc-runtime · high confidence

This change adds the \ui-session\ package, which provides the React adapter for the Session Controller. It introduces selector hooks (\useSessions\, \useSession\, \useSessionStatus\, \useSessionRetainInfo\) to expose session state and lifecycle data to the UI, and implements a \PendingInteractionDomain\ class to manage scoped pending interactions and ensure they are properly settled during plugin teardown. The adapter also registers session-specific standard props and scope bindings within the UI slots system, enabling domain-owned interactions like approvals and questions to be handled within the correct session context.

packages/client/ui-session/src · high confidence

A new right-Sidebar Browser tab type is available, allowing users to browse HTTP(S) pages—including loopback services—within an iframe in both Web and Desktop environments. The implementation enforces a strict security sandbox by default, rejecting local file URLs, embedded credentials, and the application's own origin. Users can navigate using application-managed history (Back, Forward, Reload) and temporarily disable the sandbox for compatibility with sites that require downloads or top-level navigation, though this reduces isolation. The feature includes localized UI strings and a dedicated store for tab state.

packages/client/ui-sidebar-browser · high confidence

The new @deepseek-ai/dsh-client-ui-trajectory package provides a turn-aware event ledger and interactive timing overview for inspecting agent activity. It groups User, Assistant, Tool, and compaction records, supports virtualized long histories, and includes a code inspector for PTC calls. This entry documents the package's bilingual README files (English and Chinese) and its build configuration (tsconfig and tsdown), which establish the package's structure and documentation standards.

packages/client/ui-trajectory · high confidence

The API gateway now includes a new Typert Gateway service that handles Remote method invocations and live event streams. This change introduces a WebSocket-based multiplexing server for streaming data, a dedicated protocol for forwarding Host-side Cordis events to Clients, and a unified error vocabulary for gateway infrastructure failures. Users benefit from a more robust and standardized way to interact with Remote services, with improved handling of real-time events and clearer error reporting for gateway-level issues.

packages/api/gateway/src · high confidence

The Typert package now includes a build-time generator that analyzes public TypeScript types to produce compiler-independent models, Zod schema factories, and Remote call descriptors, enabling typed Host-to-Client calls without hand-written wire code. This release adds the generator implementation (analyzer, model, emitter, and tsdown plugin) alongside comprehensive English and Chinese README documentation for the Typert group, including the generator, loader, protocol, and registry packages.

packages/typert · high confidence

The client UI agent preset package now includes a minimal plugin structure to integrate with the host application. A new TypeScript declaration file enables CSS modules support, while the main entry point exports an empty \apply\ function to satisfy the host's plugin loader requirements. This setup prepares the package to expose the General settings row for agent preset selection via the client-side export mechanism.

packages/client/ui-agent-preset/src · high confidence

This change adds the \@deepseek-ai/dsh-client-ui-permission-presets\ package, which provides the Web GUI interfaces for managing permission presets. It introduces a General Settings row that sets the default permission for future sessions and a \/permission\ slash-command picker that switches permissions for the current session. The UI supports built-in presets (Read Only, Workspace Write, Full access) and an experimental Auto review mode (marked with an EXP badge). The package includes comprehensive bilingual documentation (English and Chinese) explaining the feature, its implementation details, and known limitations, along with the necessary TypeScript and bundling configuration to integrate with the client UI system.

packages/client/ui-permission-presets · high confidence

A new \@deepseek-ai/dsh-acp-app\ profile bundle is available to launch persistent harness agents via the Agent Client Protocol (ACP) over stdio. This bundle builds on \dsh-base\ and configures a coding-agent persona with the \deepseek-official\ provider and \deepseek-v4-flash\ model by default. It disables module Hot Module Replacement (HMR) and model-generated session titles, ensuring deterministic behavior for automation workflows. The profile binds stdin EOF to a bounded shutdown and reserves stdout for ACP JSON-RPC frames, allowing \dsh --profile acp --help\ to display help without claiming stdio.

packages/bundle/acp-app · high confidence

The \dsh\ command is now the sole supported Node application launcher, replacing previous entry points. It boots named profiles (such as \web\, \headless\, \sdk\, \sdk-minimal\, and \acp\) which are ordered stacks of plugin-bundle patch layers. The launcher parses only its own flags and forwards remaining arguments to the booted profile, allowing injected plugins to handle application-specific options. Profiles can be created from shipped templates or initialized via the \dsh plugin\ command, and their configuration trees can be inspected using \--dump-config\ or \--dump-default-config\ without booting.

apps/cli · high confidence

A new 'Files' tab type is now available in the right sidebar, allowing users to browse the session's workspace directory tree. The implementation includes a dedicated body component that renders a scrollable, lazy-loaded file tree with file-type icons, path clipping for long names, and distinct states for loading, empty, and error conditions. The tab is registered via the sidebar's tab system, complete with a folder icon in the guide menu and localized labels for English and Simplified Chinese.

packages/client/ui-sidebar-files/src · high confidence

The host package now includes an adaptive chooser (\directory-picker-auto\) that automatically selects the appropriate directory-picking backend at boot time. It resolves the host environment—checking for loopback binding, SSH launch status, and display availability—to mount either the native OS chooser (for local, attended sessions) or the in-app browse backend (for remote, headless, or SSH-forwarded sessions). This ensures users get the best available interaction without manual configuration, while maintaining a stable capability contract throughout the service lifetime.

packages/host · high confidence

The \packages/api/remotes/src\ package now exposes a centralized allowlist of Host events (defined in \remote-events.ts\) that are forwarded to remote consumers. This change establishes a single source of truth for event names and modes (emit vs. waterfall), ensuring that the Host-side forwarding loop and the client-side \ctx.remote.$on\ interface remain synchronized. Users can now rely on a consistent, type-safe set of forwarded events—such as session status changes, plugin manager updates, and credential reference updates—without needing to manage duplicate declarations across different parts of the application.

packages/api/remotes/src · high confidence

The \@deepseek-ai/dsh-acp\ package is introduced to expose persistent harness sessions to trusted programmatic clients via the Agent Client Protocol (ACP) over JSON-RPC stdio. This bridge enables clients to initialize sessions, send prompts (including validated inline images and resource links), manage model configuration (provider, model, and reasoning effort), and handle tool calls and permissions. It strictly enforces an automation-only contract, rejecting unsupported content types like audio and embedded resources, and ensures that image prompts are only admitted when the underlying model explicitly declares image input support.

packages/acp/acp/src · high confidence

The client file-upload module now exposes a dedicated background upload service accessible via the Cordis context. This service supports uploading file data as Blobs, byte arrays, or ReadableStreams, utilizing a background worker for Blob uploads to provide real-time byte-progress callbacks, while ReadableStream bodies are sent via standard fetch. The implementation includes a defined contract for upload requests and responses, allowing applications to cancel uploads and monitor progress during the staging process.

packages/client/file-upload/src/client · high confidence

The \packages/jobs\ area now provides the background-job capability family, allowing tools to register long-running work that the owning agent can read, wait on, list, and cancel without blocking its own turn. This change introduces the abstract \@deepseek-ai/dsh-jobs\ contract (\ctx.jobs\), the process-local \@deepseek-ai/dsh-jobs-local\ implementation (which runs jobs in-memory with a default concurrency limit of 10 per owner), and comprehensive bilingual (English and Chinese) README documentation for the group and its packages. Jobs are scoped to the agent session that started them, ensuring one agent never sees another's work, and completion is delivered via in-session notices rather than polling.

packages/jobs · high confidence

The client connection module now provides a browser-compatible transport layer, including a new \ConnectionController\ that manages connection generations, exponential-backoff reconnection, and network-state awareness (online/offline). A new \api.ts\ exports shared protocol types and a \resultOf\ helper, while \rpc.ts\ implements a browser caller (\createWebConnectionRpc\) that uses \fetch\ for unary RPCs and validates response envelopes. UUID generation (\random-uuid.ts\) is now browser-safe using \crypto.getRandomValues\. These changes enable the client to establish, maintain, and recover connections in browser environments, with loopback and transport hooks (\ClientTransportHooks\) allowing shells to inject custom transports or declare host ownership.

packages/client/connection/src/client · high confidence

The \ui-settings\ package now provides the foundational client-side infrastructure for managing application preferences, including a \SettingsDescribeMirror\ that serves as the single source of truth for settings data and handles synchronization with the host, a \SettingsSchemaService\ for validating and mutating settings drafts, and a \SettingsScopeBinder\ that exposes reactive, namespace-scoped state to individual features. This change establishes the contract for settings slots (such as triggers, headers, and sections) and enables features to register their own settings surfaces without depending on the presentation shell, effectively decoupling settings data ownership from the UI chrome.

packages/client/ui-settings/src · high confidence

The \ui-primitives\ package now includes a dedicated icon system (\packages/client/ui-primitives/src/icons\) that exports a shared \IconProps\ interface and a batch of SVG-based icon components (such as \IconNewChatOutline16\, \IconSearchOutline16\, and \IconSettingsOutline14\). These components provide a consistent, scalable interface for rendering the application's visual assets, standardizing how icons are sized and styled across the UI.

packages/client/ui-primitives/src/icons · high confidence

The \@deepseek-ai/dsh-client-resources\ package is now available, providing a protocol-based resource model that allows components to read live data by URL address (e.g., \dsh-resource://\<type\>/…\) without needing to know the data's origin. Slot components can use the global \useResource\ hook to subscribe to these resources, which are managed by a central registry that handles lifecycle, pinning, and failure states. Protocol providers register their data streams via \ctx.resources\, enabling decoupled data access across the client.

packages/client/resources · high confidence

A new client-side Hot Module Replacement (HMR) plugin has been added to the development tooling, enabling the browser to receive and apply code changes via Server-Sent Events (SSE) without a full page reload. This plugin connects to the specified events endpoint, parses incoming frames, and uses the module system to either sync graph snapshots or reload specific module IDs, allowing developers to see changes instantly in the running application.

packages/client/hmr/src/client · high confidence

The ui-approval package now provides a dedicated client-side interface for handling pending approval requests. This includes a new ApprovalPanel component that renders a styled card with details, a reject button, and an 'allow once' action, along with the underlying PendingApproval class to manage the request's lifecycle (answering, aborting, or delegating). The feature integrates with the existing session and remote event systems to present these requests within the composer slot, supporting localized copy in English and Simplified Chinese.

packages/client/ui-approval/src · high confidence

The client now manages session state locally via a new \ClientSessions\ service and a reconnecting control stream, replacing previous ad-hoc handling. Users benefit from live assistant stream frames being emitted directly to the client, enabling real-time feedback during interactions. The system now supports scoped agent contexts, allowing independent local event routing per session generation without interfering with global state. Additionally, session history and projections are handled through a robust baseline merging mechanism that preserves client-visible order while applying authoritative updates, and strict validation ensures only well-formed wire events are processed.

packages/api/session-controller/src/client · high confidence

Adds a new set of React components and styles in the \ui-trajectory\ package to power the trajectory inspection view. This includes a \TrajectoryTable\ for the main event ledger, a \TrajectoryTimeline\ for Chrome-Network-style overview navigation, a \TrajectoryToolbar\ for search and fold controls, and supporting cells (\TrajectoryCell\, \TrajectoryTurn\, \TrajectoryGroupHeader\) to render individual steps, turns, and group headers with specific styling for system, user, tool, and message kinds.

packages/client/ui-trajectory/src · high confidence

The client now registers a new deliverables plugin that adds a 'Changed Files' card to the turn tail, displaying added/deleted line counts and a collapsible list of modified files. Clicking a file or the card header opens a new 'changes-review' tab in the right sidebar, which renders a unified or side-by-side diff of the file's changes with controls for wrapping and opening the file. The plugin also introduces a 'PresentRow' component to display the status of file delivery tool calls and provides a 'chatFileMentions' service that allows inline code mentions of produced files to open them in the sidebar.

packages/client/ui-deliverables/src/client · high confidence

The client locale module now registers a dedicated 'locale' settings namespace within the host's settings provider. This change introduces a durable user preference for explicit locale selection (supporting BCP 47 language tags like 'zh' and 'en'), which overrides the default browser detection. The implementation includes the necessary TypeScript type definitions for CSS modules and a schema validation layer to ensure only valid language identifiers are persisted.

packages/client/locale/src · high confidence

The client UI theme package now persists user preferences for theme mode (light, dark, or system) and content font size (12–17px) in the host settings under the 'ui-theme' namespace. To prevent flash-of-wrong-theme, the theme bootstrap generates head CSS and a body script that apply the selected palette and font size before the main shell mounts, reading the current settings via the host context and injecting them into the index table.

packages/client/ui-theme/src · high confidence

The \@deepseek-ai/dsh-client-ui-workflow-run\ package adds a new Conversation Node that reconstructs top-level workflow runs as independent chat entries with nested phase and member disclosure. Users can expand a run to view its phases and members; running, failed, cancelled, and interrupted levels open by default, while completed levels remain closed. The node displays identity and status information only, excluding scripts, outputs, errors, logs, usage, topology, and controls. Navigation to child sessions is restricted to running members that belong to the current session and are available locally. The package registers its definition, locale dictionary, and renderer as Cordis effects and is included in the shipped Web bundle after \ui-conversation\ and \ui-tool\.

packages/client/ui-workflow-run · high confidence

Users can now view persistent, structured summaries of workflow runs directly within the chat interface. This new feature renders a dedicated panel that displays the run's name, overall status (running, completed, failed, cancelled, or interrupted), and a breakdown of individual phases and their members. The panel dynamically updates as agents start and finish, providing real-time visibility into multi-step workflows without requiring users to navigate away from the conversation.

packages/client/ui-workflow-run/src · high confidence

The \packages/browser-use\ area now includes a new \@deepseek-ai/dsh-browser-use\ service that enforces exclusive registration of a single browser backend per session. This service provides a \BrowserUseRegistry\ that accepts one provider name at a time, rejecting any subsequent registration attempts until the current provider is disposed. It exposes a \providerName\ getter to track the active provider and integrates with the Cordis lifecycle to automatically release the registration when the provider plugin unloads. The package also includes bilingual documentation (English and Chinese) and tests verifying the exclusive registration and disposal behavior.

packages/core · high confidence

The right sidebar now supports an extensible tab system where different content types (such as file previews, terminals, or guides) register themselves via a typed registry. Navigation is strictly typed through \SidebarRightResourceParamsMap\ and \SidebarRightTabParamsMap\, allowing callers to open resources or pages with validated parameters. The sidebar's UI is driven by slot registrations (\sidebar.right.pane.tab\, \sidebar.right.pane.tab.title\, \sidebar.right.tab.guide\), enabling external packages to inject custom tab bodies, titles, and guide entries without modifying core sidebar code. Layout state, including pane splits and floating panels, is persisted per session in \localStorage\ and restored on startup, ensuring users return to their previous workspace configuration.

packages/client/ui-sidebar-right/src · high confidence

The \settings-file\ package now provides a user-editable configuration store that keeps all namespace settings in a single local YAML or JSON document (defaulting to \settings.yaml\ under the harness home). Users can edit this document directly in any editor, and changes take effect live via file watching without requiring a restart. The provider ensures data integrity through cross-process writer locks, atomic file replacements, and read-modify-write cycles that preserve YAML comments and formatting. It supports both YAML and JSON formats, handles concurrent edits safely, and fails loudly on invalid documents at boot while keeping the last good state during runtime reloads.

packages/settings · high confidence

The web client now uses a dedicated boot kernel (\AppWebEntry\) that manages a two-phase startup: first, it applies structured index injections (scripts, styles, globals) to the page, then it activates a plugin loader (Cordis) to compose the application. During this process, a lightweight, framework-free boot page displays real-time loading progress and detailed failure reports for individual plugins, ensuring users see clear status even if React or other UI plugins fail to load. The kernel also handles prefetching immediate-tier bundles and mounts the UI renderer only after all client entries have successfully activated.

packages/client/web/src · high confidence

The \packages/lsp\ area now includes the \@deepseek-ai/dsh-lsp-stdio\ package, which allows agents to navigate code using locally configured language servers. This provider maps file extensions to server commands, spawns processes on demand, and executes read-only operations (go to definition, find references, hover) through a transient open/close lifecycle. It enforces strict bounds on message and document sizes, serializes queries per workspace, and ensures that source text is read fresh for each query so the server always sees current content. The package ships no language servers by default; deployments must supply the commands and extension mappings.

packages/lsp · high confidence

The \@deepseek-ai/dsh-headless\ package provides a new command-line entry point for running a single agent task and exiting. It supports reading the task from a positional argument or stdin, and allows adopting an existing persisted session via the \--session-id\ flag. When the \--json\ flag is used, the runner outputs a newline-delimited stream of machine-readable events to stdout instead of the final assistant text, with all string and key values bounded to 8 KiB and total event lines capped at 32 KiB to prevent runaway output. Reasoning progress is streamed to stderr, and the runner ensures that the final output is derived from the durable session log rather than live, potentially discarded, attempts.

packages/bundle/headless/src · high confidence

Users can now manage durable, session-spanning objectives directly from the UI using the \/goal\ slash command (create, edit, pause, resume, clear, and inspect) without consuming a model turn. The command supports image and file attachments that are submitted as standard user messages for subsequent rounds to read. Additionally, the \goal-round-driver\ enables automatic, unattended continuation of active goals within the same session, allowing the agent to take multiple turns toward an objective until a configured round limit is reached or the goal is paused, blocked, or completed.

packages/goal · high confidence

The \credentials/\ package now includes a new \authorization\ sub-package that allows plugins to register flows for obtaining credentials that cannot be supplied via configuration alone. This enables a conversation with the human user—such as an OAuth sign-in, code entry, or account selection—where the flow owns the write to the credential store, ensuring the new credential is committed before the attempt is reported as authorized. The seam supports one attempt per credential key at a time, routes prompts and notices to the specific surface that initiated the request, and provides a neutral vocabulary for interactions, making it safe to use in both UI and headless contexts.

packages/credentials · high confidence

The \@deepseek-ai/dsh-client-ui-directory-picker-browse\ package is now available, providing an in-app Miller-column dialog for browsing, navigating, and creating folders within the Web GUI. This component replaces the need for an operating-system file chooser when the browser is remote or in-process, allowing users to select workspace directories through a breadcrumb interface with path editing and prefix filtering. It integrates with the \ui-workspace\ slots and the \dsh-host-directory-picker-browse\ backend to handle directory listing and creation, while explicitly excluding search, multi-select, and file deletion capabilities.

packages/client/ui-directory-picker-browse · high confidence

The shell package now includes the \@deepseek-ai/dsh-bash-local\ executor for running unconfined Bash commands on POSIX, and the \@deepseek-ai/dsh-bash-sandbox\ executor for running confined Bash commands with file-access restrictions. The local executor supports configurable budgets for timeouts, output caps, and working directories, while the sandbox executor integrates with the sandbox capability to enforce modes like \read-only\ or \workspace-write\, reporting denials and escalation opportunities directly in command results. Comprehensive English and Chinese documentation has been added for both executors, detailing their configuration, implementation internals, and model-facing behavior.

packages/shell · high confidence

The \attachment-local\ package now provides a persistent, content-addressed backend for storing files and images rooted in \DSH\_HOME/attachments/v1\. Images undergo deterministic normalization (converting to 8-bit sRGB, stripping metadata, and applying quality ladders) before storage, with configurable limits for pixel counts, dimensions, and byte sizes. Files are stored verbatim using SHA-256 content addressing. The store also caches request-specific image variants (resized/encoded for model inputs) in a separate cache directory to optimize repeated access.

packages/attachment/attachment-local/src · high confidence

The \packages/fs\ group now includes a new \fs-local\ backend that provides durable, policy-governed access to the host filesystem. This backend supports reading, listing, and atomically writing or editing files, with relative paths resolving from a configurable base directory. It implements realpath-based identity so that symlinks and their targets share the same version guard, and it serializes mutations per file to prevent concurrent write interleaving. A key addition is Windows-specific support that preserves file permissions and DACLs during atomic file replacements. The package also introduces a configurable \diffBasisMaxBytes\ limit to bound the size of diff bases returned on overwrites, and it exposes structured \FsError\ codes for stable error handling.

packages/fs · high confidence

The \spill-local\ package now provides a local filesystem backend for the spill capability, saving oversized text to private, session-scoped files with unpredictable names and owner-only permissions to prevent leakage or symlink redirection. It includes a one-shot startup cleanup sweep that reclaims files older than a configurable retention period (default 30 days) and safely discovers prior default roots. The package registers as the \ctx.spillStore\ service, returning file path locators and retrieval hints to consumers like the spill policy.

packages/spill · high confidence

The \sandbox-local\ package now provides the local confinement backend for Linux, macOS, and Windows, automatically selecting the appropriate runner (bwrap or Landlock on Linux, Seatbelt on macOS, and a Windows ACL restricted-token runner) and failing closed with \SANDBOX\_UNAVAILABLE\ if no runner is usable. On Windows, confined children are restricted to writing only in the session workspace and a private, per-session temporary directory, with enforcement reported as \partial\ due to system requirements. The package includes comprehensive bilingual (English and Chinese) documentation and tests to verify the runner selection, profile application, and enforcement behavior.

packages/sandbox · high confidence

The desktop application now includes a native mandatory update flow, featuring a dedicated renderer page (mandatory-update.html/js) that displays update status, progress, and error details, along with a generic update dialog (update-dialog.html/js) for standard update notifications. A local loading placeholder (policy-login-loading.html) is shown while the policy login page loads, and a directory picker (directory-picker.ts) is implemented to attach workspace folder dialogs to the application window. These changes are supported by a new backend controller (backend-controller.ts) for managing the host process lifecycle, a core package set validator (core-package-set.ts) for verifying bundled npm packages, and a fatal recovery system (fatal-recovery.ts) for handling startup failures with native dialogs.

apps/desktop/src · high confidence

The \packages/compaction\ area now includes the \@deepseek-ai/dsh-command-compact\ package, which registers a \/compact\ command in chat UIs. This command allows users to manually condense older conversation history into a summary on demand, independent of automatic token-pressure triggers. The command is backend-independent, does not consume a model turn, and provides stable user-facing feedback for various states (e.g., busy, cancelled, or successful compaction with token savings). It is designed to work with any \CompactionEngine\ implementation and integrates with the existing compaction seam.

packages/compaction · high confidence

Adds a new client plugin that injects Like/Dislike buttons into the assistant message action strip and a feedback dialog into the conversation overlay. Users can now rate individual messages, select from a set of categories, and provide optional text details; submissions are persisted with optimistic concurrency control to handle conflicts. The dialog also supports a session-level feedback entry point via the /feedback command, and the UI includes localized copy for both English and Simplified Chinese.

packages/client/ui-message-feedback/src · high confidence

The \packages/terminal\ area now includes the \@deepseek-ai/dsh-terminal-bash\ package, which provides a persistent shell backend allowing agents to maintain interactive bash or PowerShell sessions across tool calls. This backend manages session lifecycle, readiness detection, and bounded output retention, enabling stateful interactions like debugging or REPL exploration that outlive single commands. It supports both POSIX (bash) and Windows (pwsh) dialects, enforces sandbox policies to prevent privilege escalation during active sessions, and includes comprehensive configuration options for timeouts, scrollback limits, and terminal dimensions.

packages/terminal · high confidence

The \packages/workspace\ package now provides a durable registry (\ctx.workspaceRegistry\) that maintains an ordered list of named project directories and groups sessions by the directory they ran in. Users can create, rename, and manually reorder projects; sessions are automatically attached to projects based on their working directory, and can be hidden or restored without deletion. Removing a project leaves its folder and session history intact, converting those sessions to ungrouped history. The registry persists across restarts, handles path canonicalization and validation, and includes an archive set for global session hiding.

packages/workspace · high confidence

Adds the initial structure for the plan control plugin within the client UI layer. This includes a TypeScript declaration for CSS modules and an index file that registers the plugin as a pure UI component with an empty host-side apply function, allowing it to be discovered by the host loader while deferring actual plan behavior to the separate \@deepseek-ai/dsh-plan-mode\ package.

packages/client/ui-plan/src · high confidence

Users can now toggle Plan mode on and off directly from the composer input area using a new status chip that shows the current state and allows exiting the mode. When a plan is submitted, it appears as a persistent card in the chat turn, providing a quick way to open the full plan document in the right sidebar. The sidebar also supports previewing temporary plan reviews and displays a plan icon in the tab title for easy identification.

packages/client/ui-plan/src/client · high confidence

The \packages/plan\ area now provides a plan mode feature that guides the agent to explore and design before executing. Users can enter this mode via the \/plan\ command (optionally with instructions and attachments) and leave it with \/plan off\. When the agent has a finished plan, it calls the \exit\_plan\_mode\ tool, which presents the plan for user review; the user can approve to proceed or request further planning. The mode is configured via a deployment-owned guidance section, persists across session resumes and forks, and is tracked via a durable session projection.

packages/plan · high confidence

The client now displays a dedicated plan review card that shows a concise summary of the plan (title and description) and provides options to approve, refuse, or request changes, with submitted plans opening in the sidebar. Additionally, the question composer supports multi-line answers, allows the question card to be collapsed to save viewport space, and preserves user drafts across session switches so progress is retained when navigating between sessions.

packages/client/ui-user-questions/src/client · high confidence

This change introduces a new \popupSelect\ shell component (\PopupSelectView\) that provides a dedicated overlay for command options, featuring local search filtering, keyboard navigation (Enter, Tab, Escape), and risk confirmation dialogs. It replaces the previous single-command popup mechanism with a session-keyed \CommandDirectory\ for managing command catalogs and a \CommandUiRuntime\ service that handles slash-menu candidate synthesis, localized command faces, and per-session popup controllers. The update also adds localized dictionaries for built-in commands (goal, plan, feedback, compact, permission, export) and reorganizes the command UI into a modular structure with separate files for contracts, presentation, resolution, and state management.

packages/client/ui-commands/src · high confidence

The \ui-dockkit\ package adds a reversible docking engine and React components that allow users to split, dock, float, and rearrange panes in a tabbed layout. The engine is pure TypeScript (no React/DOM) and maintains an undo/redo history of layout operations, while the React components render the layout and report user gestures as intents to the embedding application.

packages/client · high confidence

This change introduces the \@deepseek-ai/dsh-client-ui-sidebar-right\ package, establishing the right sidebar as a distinct product component. It adds comprehensive bilingual documentation (English and Chinese) detailing the sidebar's architecture, including its docking surface, tab domain, extension seats, and navigation controller (\ctx.sidebarRight\). The package also includes standard build configurations (\tsconfig.json\, \tsdown.config.ts\) to support its integration into the client build system.

packages/client/ui-sidebar-right · high confidence

Added a new profile resolution subsystem that allows the application to intercept and redirect Node.js module resolution based on active profile configurations. This includes a legacy link inspector to handle pnpm-managed fallback symlinks, a core resolver that supports both ESM and CommonJS loaders with configurable enforcement or verification modes, and a service layer that exposes resolved package metadata to the plugin system. Worker threads are also bootstrapped to inherit this resolution context, ensuring consistent package routing across the application's execution environment.

packages/boot/app-boot/src/profile-resolution · high confidence

The client UI renderer now provides a structured slot registry and React integration layer. It introduces a \SlotRegistry\ service that manages slot declarations, enforces ownership boundaries, and handles store instance lifecycles scoped to the root or active session. React components can now bind to these scoped data sources using identity-stable hooks (\observableHook\, \keyedObservableHook\), ensuring that UI updates are synchronized with the underlying state without unnecessary re-subscriptions. The renderer also supports a boot handoff mechanism that preserves the initial loading state during React hydration, and exposes a \mount\ API for the application kernel to initialize the UI tree.

packages/client/ui-renderer/src · high confidence

The \packages/schedule\ package now provides a complete system for creating, listing, and canceling reminders that persist across session restarts and deliver as ordinary follow-up messages within the same conversation. Users can schedule one-time reminders (after a delay or at an absolute time) and fixed-interval repeating reminders (minimum 5 minutes). The system ensures durability by waiting for session flush barriers before decisions and confirmations, and it strictly confines delivery to the active session—no external notifications are sent. The package includes a plugin that registers tools for root agents, a strict event-based state machine for replay, and an optional read-only projection for UI catalogs.

packages/schedule · high confidence

The \packages/hooks\ area now includes the \@deepseek-ai/dsh-hook-protocol\ library, which provides the shared engine for running existing Claude Code and Codex shell hooks during agent runs. This library handles command execution, outcome decoding, and merging of hook results, allowing both the \dsh-hooks-claude-code\ and \dsh-hooks-codex\ bridges to apply consistent rules to \hooks.json\ configurations. It defines the \hook/invoked\ and \hook/result\ log-only session events, manages detached run quiescence, and enforces invariants to ensure hook records are paired and turn-enclosed.

packages/hooks · high confidence

The \packages/util\ group now includes new zero-dependency libraries: \dsh-atomic-write\ provides safe, cross-process file replacement with writer locking; \dsh-brand\ adds nominal string and number types to prevent domain value confusion at compile time; and \dsh-chunked-list\ offers immutable, append-only lists with bounded memory usage. These packages are accompanied by comprehensive bilingual documentation (English and Chinese) and unit tests to ensure reliability across the platform.

packages/util · high confidence

The new \@deepseek-ai/dsh-client-ui-sidebar-documentpreview\ package enables previewing readable files directly in the right sidebar without opening a new tab. It supports Markdown, code, plain text, PDF, HTML, and common images (PNG, JPEG, GIF, WebP, BMP, ICO, SVG), with a plain-text fallback for unknown extensions. Office documents (.doc, .docx, .xls, .xlsx, .ppt, .pptx) are converted locally to PDF for preview. The sidebar tab manages loading, file status, renderer selection, text wrapping, and reloading, while document bodies register through a shared metadata registry and child slot. PDF rendering is lazy-loaded to avoid startup overhead, and HTML previews run in a sandboxed iframe with strict security limits. Office conversion uses a local cache with configurable limits for entries and bytes, and displays font availability notices.

packages/client/ui-sidebar-documentpreview · high confidence

The right Sidebar now includes a new 'files' tab type that displays the session's workspace root as a lazy-loaded tree, fetching directory levels on demand via the remote API. Users benefit from preserved scroll positions when switching between sidebar tabs, as the tree's state (including scroll offset and expanded levels) persists in the store across tab switches. The tab registers as a built-in navigator entry accessible from the guide page, opening files into the sidebar pane using resource addresses.

packages/client/ui-sidebar-files · high confidence

The client now displays a unified candidate menu when typing slash commands (/) or @ references in the input field. This new feature includes a keyboard-driven interface with arrow key navigation, Tab support for drilling into directories, and localized copy for commands, skills, and subagents. The menu supports dynamic loading states, breadcrumb navigation for nested paths, and respects the composer's focus to prevent accidental dismissal.

packages/client/ui-input-trigger/src/client · high confidence

A new entry point at packages/bundle/sdk-app/src/index.ts registers the 'sdk-app-startup' Cordis plugin, which configures the command-line interface to serve DeepSeek Harness SDK clients over stdio JSON-RPC. This change enables the 'sdk' profile to launch a zero-option command that waits for client connections and handles graceful shutdown upon stdin end, effectively providing the standalone SDK application bundle.

packages/bundle/sdk-app/src · high confidence

A new entry point for the \@deepseek-ai/dsh-sdk-minimal\ package has been added. This module serves as the public interface for the standalone minimal SDK profile, which is configured via \cordis.patch.yml\ and resolved by the profile composer. The entry point itself is an empty export, indicating that the actual runtime logic and configuration are handled by the underlying bundle composition rather than this specific file.

packages/bundle/sdk-minimal/src · high confidence

The file-upload service now exposes a new HTTP route at /api/session/uploadFileBinary that accepts raw byte streams (application/octet-stream) for authenticated file uploads. This change adds a dedicated HTTP handler to process streaming uploads directly, supporting session-scoped file staging and receipt generation, while maintaining the existing protocol-based upload path for other clients.

packages/client/file-upload/src · high confidence

The attachment package now provides a dedicated service for managing image and file uploads, replacing ad-hoc handling with a structured admission pipeline. Users uploading images or files via base64-encoded payloads will now have their inputs validated against strict policies—such as media type, pixel budgets, and byte limits—before being stored. Successful uploads return durable, content-addressed references rather than raw data, ensuring that prompt content is safely normalized and that storage failures are clearly distinguished from caller-correctable input errors.

packages/attachment/attachment/src · high confidence

The \app-boot\ package now centralizes the startup logic for \dsh\ profiles, managing the composition of configuration layers (bundled patches, user patches, and CLI overlays) and the lifecycle of profile plugins. Users benefit from more robust profile initialization, including automatic backup of corrupted patch files during recovery, explicit control over the telemetry opt-out switch, and safer environment variable handling that prevents \.env\ files from overriding critical bootstrap settings. The package also introduces a reconciliation system that automatically activates or deactivates plugin bundles based on installed dependencies and user preferences.

packages/boot/app-boot/src · high confidence

The \@deepseek-ai/dsh-client-ui-subagent\ package is now available, providing a UI for browsing subagent conversations nested under a parent session, opening any descendant, and viewing its running status, token usage, and active-turn duration. Completed one-shot conversations open as read-only execution records, while continuable conversations accept follow-up prompts in submission order and provide an independent Stop button. The package registers a specific resource and sidebar tab type for navigation, and includes a separate \@\ reference source that inserts a running child's label into a user message without resolving it into a continuation address.

packages/client/ui-subagent · high confidence

The session header now includes a lineage switcher that lets users navigate the hierarchy of subagent conversations, displaying details such as active duration, token usage, and running status. For subagents that are one-shot or whose parent session is offline, the composer is replaced with a read-only view that explains why further input is unavailable. Additionally, subagent chats can be opened in the right sidebar for focused interaction.

packages/client/ui-subagent/src/client · high confidence

The \ui-dockkit\ package now provides a complete docking kit for managing split-pane layouts and floating panels. This includes a \DockSurface\ for rendering the split tree with draggable dividers and tab strips, a \FloatLayer\ for managing floating panels with move/resize gestures, and supporting components like \PaneTree\, \TabPanel\, and \TabMenu\. The kit handles pointer capture, drop-zone previews, and layout measurements, exposing a contract via \adapter.ts\ for embedders to provide labels, tab rendering, and intent handling.

packages/client/ui-dockkit/src/components · high confidence

The \packages/client/ui-slots\ package now provides the core infrastructure for a slot-based UI composition model. It introduces a \SlotMap\ registry where owners declare slot contracts (defining kind, scope, and props), a \SlotRendererHost\ that manages registration, priority-based shadowing, and error reporting, and a \LocaleFace\ for namespace-bound translation. This system enables components to declare child slots and receive injected standard hooks (like \useStore\ or \useProjection\) as props, facilitating a structured, type-safe approach to building complex UI hierarchies with shared state and localization.

packages/client/ui-slots/src · high confidence

The \packages/workflow\ group now includes the \@deepseek-ai/dsh-tool-ralph\ package, which provides a new \ralph\ tool for users. This tool executes a fixed, foreground loop of fresh child agents against a single immutable objective, using the shared workspace as long-term memory and passing only bounded structured reports between rounds. It is designed for explicit fresh-agent iterative execution, distinct from standard goal tools or multi-agent fan-out workflows, and includes configuration for round limits, handoff sizes, and provider selection.

packages/workflow · high confidence

This change adds the core client-side assembly for the conversation interface, including the main entry point, service layer, and state management. It provides the conversation controller for sending messages, managing file uploads, and handling queue operations, along with localized copy for the composer, attachments, and tool outputs. The assembly also includes logic for context occupancy calculation, image label resolution, and view selection persistence.

packages/client/ui-conversation/src/client · high confidence

The client now uses a new three-column frame (sidebar, center, rightbar) with a dedicated layout service (ctx.layout) for global panel selection and geometry. Users can resize columns via drag handles, and the sidebar auto-collapses on narrow viewports. The layout adapts to platform chrome: Windows uses a caption row with rounded content corners, while macOS applies a translucent sidebar for vibrancy. A new ThemePresenter applies dark/light palettes, content font-size, and native color-scheme to the document. Global panels (e.g., settings) can be selected in the center, and a frame-wide overlay layer is available for toasts or badges.

packages/client/ui-layout/src/client · high confidence

Users can now control how completed conversation turns are displayed in the chat interface, with options for 'normal' or 'compact' presentation. This change introduces a new settings schema for the chat module that persists the user's preference for transcript view mode, defaulting to 'compact' to preserve the existing process disclosure style. The settings are registered with the host application's settings provider, ensuring the choice is saved and applied across sessions.

packages/client/ui-chat/src · high confidence

The \@deepseek-ai/dsh-client-web\ package now provides the core boot kernel for the web GUI, implementing a two-stage startup process that loads the client module system and activates all plugins before mounting the application. This ensures the full UI only appears when every plugin is ready, while a framework-free boot page displays per-entry status and specific failure reasons (such as missing services or import errors) instead of a blank screen. The package also defines the shared module table (\PLATFORM\_MODULES\) for resolving dynamic bundle externals and includes automatic CJK/Latin auto-spacing for content in supporting browsers.

packages/client/web · high confidence

The web application now includes a dedicated entry point (index.html) and a Web App Manifest (manifest.webmanifest) that enables PWA capabilities such as fullscreen display and offline-ready icon registration. A new SVG favicon is provided, which dynamically adapts to the system's color scheme (dark/light mode). The build system (Vite) has been reconfigured to split the output into distinct index and vendor chunks, with specific npm packages (e.g., katex, shiki, micromark extensions) grouped into the vendor chunk for better caching, while grammar and font assets are organized into dedicated subdirectories (assets/langs/, assets/fonts/). Additionally, a preview page (preview.html) is generated to support worker bootstrapping, and build isolation plugins are introduced to enforce dependency boundaries and prevent standalone serving.

apps/web · high confidence

The \packages/web/tool-web\ package exposes \web\_search\ and \web\_fetch\ tools to the model, allowing it to discover current information and retrieve page content. The tools are configurable via \search\, \fetch\, \searchMaxResults\, \searchMaxQueries\, \fetchTimeoutMs\, \searchTimeoutMs\, and \fetchMaxOutputChars\. \web\_search\ supports multi-query execution with concurrent fan-out and round-robin merging, while \web\_fetch\ converts HTML to Markdown using \turndown\ with GFM support, stripping hidden content and bounding conversion depth to 512 to prevent DoS. Security policies include blocking non-public fetch destinations, rejecting credentialed redirects, and enforcing a 30-second default tool-call timeout via the \dsh-tool-call-timeout-policy\. Tools remain visible even if providers are unavailable, returning structured \WebError\ codes instead.

packages/web · high confidence

This change adds the \@deepseek-ai/dsh-webhook\ runtime and the \@deepseek-ai/dsh-webhook-github\ adapter to the \packages/webhook\ area. The webhook runtime provides a fire-and-forget registry for trusted programmatic rules that can create new agent Sessions inside a Web Workspace upon receiving external events. The GitHub adapter registers a signed HTTP endpoint that verifies incoming GitHub webhook payloads and dispatches them to the runtime, enabling automated session creation from GitHub events without requiring a delivery database or retry queue.

packages/webhook · high confidence

A new \workspaceFiles\ service is added to the API layer, exposing read-only file previews (text and raw bytes with configurable page/window caps), workspace-scoped directory listings, and a real-time change feed based on instrumented filesystem observations. The service enforces strict size limits (defaulting to 2 MB per page, 32 MB per file, 5,000 lines, and 2,000 directory entries) and distinguishes between absolute paths for content reads and workspace-relative paths for directory operations, while rejecting binary content and symlinks during text reads.

packages/api/workspace-files/src · high confidence

The new \@deepseek-ai/dsh-api-workspace-files\ package provides a dual-face API for the web GUI to preview and observe files within a Session's workspace. On the Host side, it exposes bounded reads (text pages, byte windows, and complete files), file metadata (\stat\), directory listing, and a change feed (\changes\) scoped to the workspace root. On the Client side, it registers a \file\ resource provider that resolves \session/\<sessionId\>/\<path\>\ addresses, fetches metadata via \stat\, and streams updates through a shared, per-session change feed, enabling UI components to react to file modifications without managing the underlying Remote subscriptions.

packages/api/workspace-files · high confidence

The \ui-dockkit\ engine now provides a complete, reversible docking system that manages layout state, undo/redo history, and pointer interactions. Users can dock, float, split, and resize panes via drag-and-drop, with the engine enforcing constraints such as a maximum of four docked panes, minimum pane sizes, and split room rules to prevent unusable layouts. The controller exposes an observable snapshot of the layout, allowing the UI to react to changes, while the underlying operation sequence supports undo and redo actions that group related changes into single steps for a smoother user experience.

packages/client/ui-dockkit/src/engine · high confidence

This change adds the \@deepseek-ai/dsh-api-remotes\ package, which acts as a facade to select and mount Host Remote capabilities (such as Office conversion, credentials, settings, and file operations) for Client consumers. It introduces a split TypeScript build configuration (Host and Client faces) to manage the boundary between Host-side event forwarding and Client-side type projections, ensuring that Client packages depend on a single, type-safe interface rather than the underlying Gateway implementation. The package also includes bilingual documentation (English and Chinese) explaining its role as a two-sided BFF for Remote capabilities.

packages/api/remotes · high confidence

The \packages/client/ui-settings-general\ package is introduced, providing a host loader entry that registers a durable settings namespace (\ui-onboarding\) for tracking the last acknowledged product welcome version. This change establishes the foundational schema and registration mechanism for GUI onboarding facts within the settings provider, alongside necessary CSS module type definitions.

packages/client/ui-settings-general/src · high confidence

A new \dsh-base\ profile bundle has been added to the package structure, serving as the shared core for the design system. This bundle is defined by a \cordis.patch.yml\ manifest and is resolved by the profile composer, providing a foundational layer for other bundles like \dsh-web-app\ and \dsh-headless\ without exposing a direct runtime API.

packages/bundle/base/src · high confidence

The desktop installer now uses a custom native Windows UI instead of the default NSIS interface, featuring a dark/light theme that respects system settings, DPI-aware layout, and antialiased GDI+ graphics. Installation progress is now tracked smoothly across extraction, copying, registration, and cleanup stages, with a dedicated progress overlay that updates in real-time based on 7-Zip extraction output. The installer validates installation paths, checks for existing processes, and ensures sufficient disk space before proceeding.

apps/desktop/installer · high confidence

The native directory picker is now integrated into the client application, allowing users to select directories via the operating system's native file chooser when adding or managing workspaces. This change introduces a new client plugin that registers the native picking flow into both the conversation hero workspace and the sidebar workspaces, replacing previous implementations with a renderless React component that handles the asynchronous selection lifecycle and error reporting.

packages/client/ui-directory-picker-native/src · high confidence

The deliverables plugin now supports opening declared and changed workspace files directly in the host operating system's file manager. It introduces authenticated API routes to serve change summaries and file diffs, allowing users to review the specific files modified during a session turn. Additionally, it registers system-prompt instructions to guide the agent in providing clickable, precise file references for outputs.

packages/client/ui-deliverables/src · high confidence

A new client package, @deepseek-ai/dsh-client-ui-directory-picker-native, has been added to provide the native directory-picking surface for the Web GUI. This package enables the browser to open the operating system's folder dialog on the local machine when a workspace flow requests a directory, reporting the picked path, cancellation, or failure. It is designed to be mounted alongside ui-workspace and the host backend dsh-host-directory-picker-native, filling the directory-flow slots declared by ui-workspace via a single cordis.yml row. This surface is intended for scenarios where the browser runs on the same machine as the Host; for remote or in-process deployments, the separate -browse surface should be used instead. The package includes bilingual documentation (English and Chinese) and is configured with specific TypeScript and bundling settings.

packages/client/ui-directory-picker-native · high confidence

The \packages/client/ui-theme\ area now contains the \@deepseek-ai/dsh-client-ui-theme\ package, which provides the Web GUI's theme and content font-size settings. Users can select a color scheme (light, dark, or system) and adjust conversation text size from 12 to 17 px in the General settings section; these preferences persist across restarts via the Host settings API. The package ships the \--dsw-\*\ token stylesheets, handles pre-plugin palette injection for the first paint, and allows third-party themes to register alias-token overrides. This entry covers the package's documentation, build configuration (tsconfig, tsdown), and the core settings logic defined in this location.

packages/client/ui-theme · high confidence

The \packages/document\ area now includes the \office-to-pdf\ package, which provides a shared service to convert authorized Office files (DOC, DOCX, XLS, XLSX, PPT, PPTX) into reusable PDFs on the Host. The service uses the \@deepseek-ai/libreoffice-kit\ (version 0.0.1) and selects a declared native engine when available, falling back to Node WASM otherwise. It enforces bounded concurrency, configurable timeouts, and strict byte limits for both input and output, while caching results by content digest to share conversions across different source paths. The package exposes a \ctx.officeToPdf.convert()\ API for direct programmatic use and a \render\ Remote method for browser-based previews, and it includes comprehensive tests for its queue, output validation, and provider logic.

packages/document · high confidence

A new browser-side UI plugin, \@deepseek-ai/dsh-client-ui-settings-unarchive-sessions\, adds an 'Archived sessions' section to the client Settings. This page lists sessions hidden from Workspace navigation, sorted by newest archive first, and allows users to restore them via a per-row 'Unarchive' action. The view includes a search box to filter by session title or Workspace name, handles loading states and missing session summaries gracefully, and integrates with the existing Workspace service to perform the restore operation.

packages/client/ui-settings-unarchive-sessions · high confidence

This change introduces the \ssh/\ package group, providing a shared OpenSSH connection and remote helper to run files, processes, terminals, and sandbox enforcement on a remote POSIX host. It includes \@deepseek-ai/dsh-ssh\ for connection and transport lifecycle, \@deepseek-ai/dsh-fs-ssh\ for remote filesystem operations, \@deepseek-ai/dsh-sandbox-ssh\ for remote confinement, and \@deepseek-ai/dsh-subprocess-ssh\ for subprocess management. The implementation uses TLS-protected Unix socket forwarding for streams, verifies helper digests on startup, and supports headless or custom profiles where the Harness stays local while the remote machine supplies the execution environment.

packages/ssh · high confidence

A new read-only Plugin Inventory tab has been added to the Web Settings interface, allowing users to browse, search, and inspect the current state of all installed plugins. The tab displays plugins in a two-column card layout, showing module names, identities, and runtime phases (such as loading, active, or failed) with localized status labels. Users can expand individual cards to view detailed facts like configuration status and runtime state, and can switch between different Agent presets to see how plugin compositions vary per session. The feature includes a search filter, handles loading and error states with retry options, and integrates with the existing settings slot system for consistent navigation.

packages/client/ui-settings-plugin-inventory/src · high confidence

A new Plugins entry has been added to the Web sidebar, opening a dedicated management page that lets users install, enable, disable, and uninstall profile plugin bundles. The page displays two groups: Official bundles (shipped with the installation, switched off by default) and Installed bundles (held by the profile). Users can install bundles via package name, Git URL, tarball, or local path, with a pre-install check that validates the spec and shows pnpm output. Bundles can be toggled on or off, and individual rows within a bundle can be enabled or disabled, with changes written to the profile's \cordis.patch.yml\. Plugins that register their own configuration pages render those forms directly on the Plugins page via declared slots (\plugins.item\, \plugins.bundle.config\, \plugins.row.config\), rather than in the global Settings. Built-in profile bundles are hidden from the card list, and the page is unavailable if the Host does not manage a profile.

packages/client/ui-plugin-manager/src · high confidence

A new Plugins settings section has been added to the client, providing a dedicated page where users can manage plugin configurations. This includes a tabbed interface (PluginsSettingsSection) that hosts specific configuration cards for built-in plugins: Agent Loop (parallel tool call limits), Bash (command timeout and output size), Web Search (API key, endpoint, and usage limits), and Subagent (delegation depth, active subagent capacity, and model authorization). Each card uses a shared form model that stages edits locally, allowing users to preview changes and save them as a single document mutation, with support for read-only states, invalid input blocking, and credential fields that write separately from the settings document.

packages/client/ui-settings-plugins/src · high confidence

A new \@deepseek-ai/dsh-api-session-controller\ package has been introduced to centralize session business logic, replacing scattered implementations with a unified Remote service. This package provides a comprehensive API for managing session lifecycles, including creating, resuming, and forking sessions, as well as handling model selection and renaming. It introduces a new \SessionCommandController\ for explicit command execution, a \SessionHistoryController\ for cold-safe history pagination and live event following, and a \SessionControlController\ for broadcasting live state changes like jobs and projections. Additionally, it includes a \SessionAssistantStreamAccumulator\ to manage and replay live assistant stream frames for reconnecting clients, and exposes a browsable model catalog via \buildModelCatalog\. The package also handles file references, media serving through \/api/file\, and session search, providing a single, cohesive entry point for all session-related operations.

packages/api/session-controller/src · high confidence

The General Settings area now features a complete modal shell (SettingsRoot) with a sidebar trigger, section navigation rail, and a centered panel. This shell displays desktop update status via a sidebar badge and a footer indicator (DesktopUpdateIndicator), showing phases like checking, downloading, and errors with localized copy. It also includes an optional 'Open configuration file' action (SettingsDocumentAction) for loopback hosts, and renders a General section (GeneralSection) that aggregates feature-owned settings items via slots.

packages/client/ui-settings-general/src/client · high confidence

The \packages/sdk\ area now includes the \@deepseek-ai/dsh-sdk-client\ TypeScript library, which allows external programs to spawn and drive a DeepSeek Harness runtime subprocess over stdio JSON-RPC. The client exposes a high-level \DeepSeekHarness\ API for owned runs (launching sessions, sending prompts, and collecting events until idle) and a lower-level \HarnessClient\ for direct protocol requests and notification subscriptions. It manages the child process lifecycle with a private teardown ladder (stdin EOF → SIGTERM → SIGKILL) and provides typed errors for transport, timeout, and protocol failures. This entry covers the new client implementation, its associated launch and disposal logic, and the bilingual (English/Chinese) documentation that describes these capabilities.

packages/sdk · high confidence

The ui-primitives package now includes a suite of new UI components and assets: a BrandWordmark for displaying the official brand logo with an optional whale mark, a Button atom with primary/ghost/outline/toolbar variants and md/sm sizes, a Checkbox with native form semantics, a ConnectionIndicator for showing connection states (disconnected, connecting, recovered) with animations, a DiffBlock for rendering file diffs with copy and expand/collapse functionality, a DisclosureRow for collapsible sections, and FileTypeIcon/CodeFileIcon for displaying file-type-specific icons. These components provide the foundational UI building blocks for the client interface.

packages/client/ui-primitives/src · high confidence

The \@deepseek-ai/dsh-client-ui-message-feedback\ package introduces the Web GUI's feedback interface, adding Like/Dislike controls to the action row of finalized assistant messages and a unified feedback dialog accessible via those controls or the \/feedback\ command. The dialog collects optional category and description inputs, submitting ratings as log-only Session events that do not enter the model context, and provides acknowledgement or warning toasts for submission outcomes.

packages/client/ui-message-feedback · high confidence

The workspace-controller package now exposes a comprehensive Remote API for managing workspaces and their contents. Users can create, rename, delete, and reorder workspaces and sessions via explicit commands, while a reconnect-safe streaming feed (\follow\) provides real-time baseline and incremental state updates. Additionally, a new directory-picking capability allows users to select directories via the host OS chooser or an in-app browser, and sessions can now be archived or unarchived to manage their visibility within workspace groupings.

packages/api/workspace-controller/src · high confidence

The \packages/client/ui-attachment/src\ directory now contains the core React components and styles for the attachment interface. This includes a scrollable \AttachmentRail\ for managing draft attachments with edge-arrow paging, a full-page \DropOverlay\ for drag-and-drop interactions, and \FileCard\ components that display file metadata, upload progress, and retry options for failed uploads. Image handling is provided by \MessageImage\ and \ImageGallery\, which support single-image fitting, tiled gallery layouts, and a click-to-open \ImageLightbox\ for full-size previews.

packages/client/ui-attachment/src · high confidence

Added a new benchmark suite in benchmarks/agent-continuation that measures long-history request processing, cold tool-heavy continuation, and repeated discovery of inactive fork children without network services or recorded user data. The suite includes workers for request-history, tool-continuation, child-catalog, and an SDK profile-continuation scenario (using the shipped sdk-minimal profile with an explicit editor patch and real file reads). It enforces reviewed median budgets (e.g., 297 ms for request history, 1,125 ms for catalog and tool continuation with 1.25× headroom) and reports runtime details (CPU, platform, Node/V8 versions) and memory metrics. Bilingual README documentation (English and Chinese) is included to explain the workload, run instructions, and measurement constraints.

benchmarks/agent-continuation · high confidence

The chat UI now uses a new set of conversation node definitions in \packages/client/ui-chat/src/client/conversation-nodes\ to render chat content. This includes dedicated node definitions for assistant messages (handling streaming and settled states), user and steering messages, system prompts, commands, compaction, and retries. A new \chat-snapshot-builder.ts\ provides the underlying store and index for these nodes, enabling more structured and performant chat rendering.

packages/client/ui-chat/src/client/conversation-nodes · high confidence

Introduces the \@deepseek-ai/dsh-client-hmr\ package, which implements Hot Module Replacement for the web client by polling executable bundle file stats to detect changes and broadcasting graph updates and rebuild notifications to the browser via a \/plugins/events\ Server-Sent Events (SSE) channel. The package includes a Cordis plugin that mounts these watches and the SSE endpoint, along with an invariant companion to ensure file watchers are properly cleaned up when the plugin fiber is disposed.

packages/client/hmr/src · high confidence

The \packages/client/ui-conversation/src/client/contract\ directory now contains a comprehensive set of TypeScript interfaces and functions that define the data structures and logic for the conversation UI. This includes types for composer blocks and submission modes, input handling (drafts, attachments, triggers), and conversation state (turns, steps, locations). It also introduces detailed record types for assistant messages, tool results, and system prompts, alongside inspection logic for request prompts and system prompt state. Additionally, slot definitions for the UI layout and snapshot management are provided, establishing the foundational contract for how conversation data is structured, inspected, and presented to the user.

packages/client/ui-conversation/src/client/contract · high confidence

The conversation UI has been restructured into a new component skeleton (ContextMeter, ConversationContent, ConversationMainPanel, etc.) that introduces a context-occupancy meter below the composer to display token usage and breakdown, adds a resizable conversation column with draggable width handles that persist user preferences, and implements a new hero state for blank sessions featuring a workspace chip and animated fish logo.

packages/client/ui-conversation/src/client/skeleton · high confidence

A new \PluginManager\ service has been introduced to manage plugins and bundles within the current profile. It provides remote capabilities to list, enable, disable, install, and remove bundles, along with parsing and validating installation specifications. The service handles pnpm operations with output buffering, cancellation support, and file locking, while classifying installation failures into specific categories (e.g., network, permission, build-blocked). It also includes a mechanism to approve pending build scripts in the profile's \pnpm-workspace.yaml\ and exposes these management functions to agents via a dedicated tool requiring full access approval.

packages/boot/plugin-manager/src · high confidence

The \packages/deliverables\ group now provides two core plugins: \tool-present\ allows the model to explicitly declare existing files as final deliverables (recording paths and descriptions without copying content), and \workspace-changes\ automatically summarizes files modified during a turn using git snapshots and whole-file captures. These plugins append durable session events (\deliverables/presented\ and \workspace/changes\) that the Web client renders as turn-tail cards, giving users a clear view of what files were delivered and how the workspace changed during the session.

packages/deliverables · high confidence

The desktop build scripts now include a comprehensive, platform-specific packaging and auto-update system. This introduces a new build target structure (mac-arm64, mac-x64, win-x64) with isolated build paths, and integrates Tencent COS for artifact uploads with strict timeout and retry controls. The system supports both test and production auto-update environments, resolves deployment-specific origins and buckets, and enforces mandatory update policies. It also handles platform-specific signing and notarization (macOS Apple ID/API Key/Keychain, Windows CER/SignTool) via isolated dotenv files, and includes a dedicated worker for building installed updates with strict security checks (PID validation, signing clearance).

apps/desktop/scripts · high confidence

The website area now hosts a VitePress-based documentation site that projects bilingual (English and Chinese) content from the docs tier into a structured navigation. Users can copy the current page's raw Markdown to the clipboard or view it as plain text via a split-button menu, and Mermaid diagrams can be opened in a fullscreen, zoomable, and pannable viewer. The site also isolates code-group tabs into separate forms to prevent search excerpts from clearing platform selections, and serves raw Markdown twins and an llms.txt index for each route.

website · high confidence

The client now includes a dedicated Language preference row in the General settings section, allowing users to switch between English and Chinese. This change introduces a new UI component (LanguageRow) with a selector pill, a backing store to mirror locale state, and logic to persist the user's explicit language choice while falling back to the browser's detected language when no preference is set. It also ensures the HTML lang attribute stays in sync with the active locale.

packages/client/locale/src/client · high confidence

Added a new benchmark in benchmarks/long-session-browser that measures browser performance with a synthetic 240-turn session, including opening the history, paging through older pages, navigating to the Trajectory view, and typing a draft during a streamed reply. The benchmark uses Playwright with a custom Web scaffold to load built artifacts, enforces specific time budgets (1125 ms for open, 875 ms for paging, 650 ms for trajectory), and validates input overlap behavior while streaming. Bilingual documentation (English and Chinese) is included to explain the measurement methodology and calibration.

benchmarks/long-session-browser · high confidence

The \guard/\ package introduces two plugins to keep the agent loop productive. The \repeat-tool-reminder\ plugin detects when the model repeats the exact same tool call with identical arguments and injects advisory messages to encourage changing approach or finishing, with configurable thresholds (default 3, 5, 8) and tool scoping. The \timeout-policy\ plugin enforces cooperative time limits on tool calls that declare a \timeoutMs\, replacing the result with a clear \TOOL\_TIMEOUT\ error if the deadline fires and the tool honors cancellation. Both are enabled by default in the \dsh\ base bundle.

packages/guard · high confidence

The Models settings section now includes a suite of new React components to manage provider and model configurations. This adds a \CustomProviderCard\ for creating new provider routes, a \DeepSeekModelsEditor\ for managing the DeepSeek adapter's model catalog, and a \ModelListEditor\ for handling model lists with discovery capabilities. It also introduces a \DeepSeekOnboardingDialog\ to guide first-run users through credential setup, along with supporting UI elements like \ModelRow\, \ModelInputTypes\, and \EditorFooter\ to handle model identity, input types, and action buttons.

packages/client/ui-settings-models/src · high confidence

The composer now features a dedicated model selection seat that allows users to choose a model and its reasoning effort level. This new interface replaces the previous single-level selection with a two-level menu: users can first select a model from a provider-grouped catalog, and then drill down to adjust the reasoning effort (e.g., 'Default', 'High') if the model supports it. The selection is shared between the composer seat and the \/model\ popup command, ensuring consistency. The UI includes localized copy for both English and Chinese, handles loading and error states with retry options, and respects session availability (e.g., blocking selection for subagent sessions).

packages/client/ui-model-selection/src · high confidence

The \packages/client/ui-tool/src\ directory now contains a complete, modular rendering system for Tool calls, replacing the previous inline implementations. This change introduces a slot-based architecture where the \ToolCallTree\ component recursively renders tool calls and their subcalls, dispatching to specific atomic views (such as \AskQuestionCard\, \ToolRow\, and image/diff/read cards) via keyed slots. The new codebase includes dedicated model files for deriving card data from raw tool blocks (e.g., \diff-card-model\, \image-card-model\, \read-card-model\) and localized presentation logic for various tool types (bash, file mutation, search, web, todo). This refactoring separates the tool presentation logic into a reusable \ui-tool\ package, improving maintainability and allowing for more granular control over how different tool interactions are displayed in the chat interface.

packages/client/ui-tool/src · high confidence

Added new example configuration files in the CLI config examples directory to demonstrate opt-in integrations. These include a GitHub webhook overlay for automated pull request reviews, references for memory backends (Engram, MCP Reference Memory, and Memorix), and a scheduling context patch. Users can now reference these examples to enable specific features like GitHub PR monitoring, persistent memory storage, and time-aware scheduling within the CLI tool.

apps/cli/config · high confidence

The packages directory now includes a comprehensive README (with a Chinese translation) that maps out the entire npm package workspace, organizing packages into capability groups such as core, shell, web, and session, along with release expectations and dependency contracts. A new AGENTS.md file establishes package-specific development conventions, covering plugin exports, service access patterns, testing requirements, and invariant publishing rules. Additionally, a new tsdown.worker.ts utility provides a banner function to ensure the profile resolution bootstrap is loaded correctly in Node Worker bundles before execution.

packages · high confidence

The repository now includes a dedicated benchmarking system to measure and enforce performance budgets for client-side conversation folding. This change introduces a new \benchmarks/\ directory containing a \tsdown.config.ts\ build configuration that compiles TypeScript benchmark workers into plain JavaScript for execution in isolated Node processes, ensuring measurements reflect production runtime behavior without TypeScript loaders. It adds a \conversation-fold\ benchmark that synthesizes large conversation histories (up to 200 turns with 2,000 deltas each) and measures the time required to fold and render them against calibrated CI budgets. Supporting infrastructure includes a \built-worker.ts\ utility for spawning and monitoring these isolated benchmark processes, a \calibration.ts\ module for converting reference-machine expectations into CI time budgets, and an \AGENTS.md\ guide defining the rules for writing and maintaining these performance tests.

benchmarks · high confidence

This change introduces the client-side UI for managing permission presets, adding a new row in General Settings to set the default permission mode for future sessions and a new selector in the Composer input to change permissions for the current session. The implementation includes a shared process-wide catalog that fetches available presets from the host and updates when the connection generation changes. Users can now choose between Read Only, Workspace Write, and Full Access presets, with Full Access requiring an explicit risk acknowledgment. An experimental 'Auto review' preset is also included, marked with an 'EXP' badge, which runs without a sandbox but requires a same-model review for every tool call.

packages/client/ui-permission-presets/src · high confidence

The client now provides dedicated configuration pages for host-plane plugins, accessible via the sidebar's Plugins panel. Users can inspect built-in plugins in a read-only inventory and configure settings for plugins like the shell executor, agent-loop parallelism, Subagent delegation limits, and DeepSeek search. Each configuration page allows users to edit values, which are staged locally until explicitly saved; changes are discarded if the page is left without saving. The system prevents overwriting concurrent changes by rejecting saves if the underlying settings document has been updated since the page loaded. Secret fields are handled securely through the credentials domain.

packages/client/ui-settings-plugins · high confidence

A new 'Plugin list' tab has been added to the Web client's Plugins settings section, allowing users to inspect the host's plugin inventory without modifying configurations. The tab displays agent preset compositions and global plugin entries, grouped by scope and initially collapsed, with search functionality across both groups. It shows enablement status, source details, runtime state, and discovery failures, and includes a preset switcher to view inventory for different agent presets. The view is read-only and takes a snapshot on first load or retry, without subscribing to live changes.

packages/client/ui-settings-plugin-inventory · high confidence

The Gateway client now exposes a typed \ClientRemote\ service (mounted on \ctx.remote\) that provides \$stream\ for creating independently cancellable, reconnecting logical streams, and \$host\ for reading identity-stable Host facts (home directory and loopback status). It introduces \RemoteJournalStream\ for cursor-based, snapshot-first journal pagination with live-tail and gap repair, \RemoteSnapshotStream\ for baseline-and-delta state updates, and \ClientRemoteEvents\ for subscribing to and receiving forwarded Host events. These changes improve reliability and observability for browser-based consumers of Remote services by handling reconnection, generation tracking, and structured event delivery without requiring manual proxy-based invocation.

packages/api/gateway/src/client · high confidence

The storage package group now includes a new \storage-domain\ component that provides a typed, schema-validated key-value interface for host-side data. This layer allows applications to declare domains with Zod schemas, ensuring that all stored records are validated against the schema before being persisted. It offers synchronous reads from an in-memory cache and durable, serialized writes that emit change events, abstracting away the underlying storage backend (JSON files or SQLite) from the consumer. This enables safer, type-safe persistence for non-session data like workspace records without direct backend interaction.

packages/storage · high confidence

A new Python script (\encode\_gif.py\) has been added to the \record-browser-gif\ skill to convert Playwright video recordings or ordered screenshot directories into GIF files. The tool accepts command-line arguments to control encoding parameters such as frame rate, maximum width, color palette size, and file size limits, and it supports trimming, speed adjustment, and custom frame durations. Comprehensive unit tests have been included to verify encoding logic, input validation, and output integrity.

.agents/skills/record-browser-gif/scripts · high confidence

The settings-controller package now exposes two new remote namespaces—\settings\ and \credentials\—to manage configuration surfaces. The \settings\ namespace provides redacted read access (hiding secrets) and supports merge, replace, and path-addressed mutation operations, along with native document opening capabilities. The \credentials\ namespace allows batched description of credential references and secure write/unset operations, ensuring secret values are never returned in responses. Both controllers enforce strict input validation via Zod schemas and map provider refusals to specific error codes like \settings/conflict\ for revision mismatches or \credential/rejected\ for write failures.

packages/api/settings-controller/src · high confidence

The sidebar now features a comprehensive document preview pane that supports multiple file types through a pluggable renderer architecture. This includes a new text preview component with paged loading, syntax highlighting for code files (TypeScript, JavaScript, Python, etc.), HTML rendering in isolated iframes, and a shared loading indicator. The system registers a fallback text viewer for all file types while allowing specific extensions to be handled by specialized renderers, with support for binary file detection and unviewable format handling.

packages/client/ui-sidebar-documentpreview/src · high confidence

The sidebar UI has been replaced with a new \SidebarRoot\ component that uses a slot system to compose the column layout, allowing other features to register content into defined regions (brand, global panels, workspace browser, settings, and footer). The sidebar now features a slide-and-crossfade collapse animation that preserves layout stability, and scrollbars are hidden when the pointer is not hovering over the column. On macOS desktop, when the sidebar is fully collapsed, the toggle and New Session controls move to the conversation header's leading seat to remain accessible. On Windows, the sidebar integrates with the custom titlebar, pinning controls to fixed positions. The component also supports localized labels for all controls and panels.

packages/client/ui-sidebar/src · high confidence

This change introduces the official documentation for the \skill/\ package group, including bilingual (English and Chinese) READMEs that explain the skill registry, local filesystem discovery, and the new \@deepseek-ai/dsh-skill-badge\ provider. The \dsh-skill-badge\ package provides an optional, disabled-by-default skill that allows agents to add an official "powered by dsh" attribution badge to generated content, supporting both remote Shields.io Markdown and a bundled PNG asset for environments with unreliable remote image fetching. The entry also includes the implementation and tests for this badge provider, which registers a fixed, immutable skill candidate on the session skill catalog.

packages/skill · high confidence

Introduces a new \ui-input-trigger\ package that defines the core types and plugin interface for handling slash (/) and mention (@) triggers in the composer. This change establishes the contract for trigger sources, candidate menus, and pick actions (such as drilling into directories), enabling the UI to display and manage command suggestions and file references. It serves as the foundational provider layer for the slash command menu presentation and reference handling features.

packages/client/ui-input-trigger/src · high confidence

The \packages/interaction\ area now includes a new \commands\ sub-package that provides a plugin-owned slash-command registry (\@deepseek-ai/dsh-commands\). This registry allows interactive UIs to execute commands directly against an agent without creating a model message, supporting agent-scoped shadowing, attachment handling, and cancellation. The change also introduces comprehensive bilingual (English and Chinese) documentation for the \interaction\ group and its \commands\ package, along with the necessary TypeScript types, branding utilities, and invariant tests to ensure lifecycle consistency.

packages/interaction · high confidence

The chat interface now uses a new Markdown rendering pipeline that supports incremental streaming, syntax highlighting via Shiki, and TeX math rendering via KaTeX. Code blocks feature a sticky header with a copy button, optional line numbers, and incremental highlighting as content streams. Markdown links can be delegated to open in a sidebar browser or local file previews. The renderer also supports collapsible JSON blocks and handles local file paths and images within Markdown content.

packages/client/ui-primitives/src/markdown · high confidence

The \packages/test-support\ area introduces two new test-harness packages: \agent-loop-testkit\ and \client-runtime\. \agent-loop-testkit\ provides \mountAgentLoopTestDependencies\ and \mountAgentLoopTestHarness\ to set up prerequisite services and a production AgentLoop driver for tests, along with \createInboxStub\ and \unsupportedInbox\ for structural Inbox testing. \client-runtime\ provides \SlotTestRuntime\ for jsdom-based slot and store testing, and \createClientTest\ for whole-client assembly testing with Remote mocks. Both packages include comprehensive bilingual documentation (English and Chinese) and TypeScript configuration.

packages/test-support · high confidence

Users can now customize the application's appearance and readability directly within the General section of the settings panel. The new interface includes an Appearance row with selectable Light, Dark, and System (follow OS) theme options, and a Font-size row that allows adjusting the conversation content size via a stepper pill. These preferences are persisted in the host settings and dynamically applied to the UI.

packages/client/ui-theme/src/client · high confidence

The web application now uses a new entry point (main.ts) that initializes the AppWebEntry and integrates with the desktop host's boot sequence. When running in a desktop environment, the web client waits for the host to become ready, receives necessary injections and stream configuration, and dynamically loads required scripts before resolving the boot gate. A new node-module-stub.ts provides browser-compatible shims for Node.js module APIs to prevent runtime errors. Additionally, a preview.ts file enables worker-based preview functionality by connecting to a host worker with specific image and overlay configurations.

apps/web/src · high confidence

The web-app package now includes a new plugin (index.ts) that manages the browser-surface runtime glue, including mounting the frontend static fallback, registering prompt sections, and handling the default browser handoff. Additionally, a new startup module (startup.ts) introduces command-line flag parsing for the web profile, allowing users to specify --host, --port, --trusted-host, and --no-open options. The --host 0.0.0.0 option is explicitly rejected for safety reasons, requiring users to use 127.0.0.1 instead.

packages/bundle/web-app/src · high confidence

The sidebar now features a dedicated workspace browsing region that displays workspaces and their sessions in a grouped tree or flat list, complete with inline search, manual reordering, and hover cards showing creation time and path. A new workspace picker component handles adding workspaces via a directory-flow slot, supporting both native OS pickers and in-app browsing, with a retryable error dialog for adoption failures. The UI includes localized copy for workspace and session actions (rename, delete, fork, archive) and integrates with the session controller for navigation and state management.

packages/client/ui-workspace/src · high confidence

The new \@deepseek-ai/dsh-client-ui-brand-official\ package allows an \official\ client build to display the DeepSeek Harness mark and name in the sidebar. When the \DSH\_CLIENT\_BUILD\_PROFILE\ environment variable is set to \official\, the plugin registers the official brand occupants in the sidebar slots; other build profiles retain the shell's default fish mark and local-build label. The conversation hero always uses the animated fish fallback regardless of the profile, and the package does not affect model requests or retain runtime state.

packages/client/ui-brand-official · high confidence

The Python SDK runtime now includes the DeepSeek Harness (dsh) CLI as a bundled, platform-specific executable (with sidecars for ripgrep and Office conversion) alongside a dev-only Node.js carrier. Users can now invoke dsh commands directly through the Python SDK without requiring a separate Node.js installation in production, as the runtime automatically resolves and executes the correct native binary for Linux, macOS, or Windows. The system requires an explicit DSH\_HOME environment variable and supports switching to the source-based Node carrier for local development via the DSH\_RUNTIME\_MODE environment variable.

python/sdk-runtime · high confidence

Users can now manage messages waiting to be sent via a new Queue Dock, which displays queued items with file attachments and text previews, supports collapsing/expanding the list, and allows editing or removing items before they are sent. Additionally, a new setting row lets users configure how the Enter key behaves when the composer is busy, offering a choice between queuing the message or steering it into the active turn.

packages/client/ui-conversation/src/client/queue · high confidence

Users can now record feedback about the system's output through two independent channels: a new \/feedback\ slash command for session-level remarks and a Web dialog for per-message ratings. The slash command appends a \feedback/record\ event to the session log, acknowledging the session and anonymous user IDs, while the Web dialog allows selecting from a fixed taxonomy of categories (such as task-result, instruction-following, and security-privacy-permission) and adding optional text. Per-message feedback is handled by a separate service that stores ratings, categories, and notes in the session log, ensuring that none of this feedback enters the model's context or history. Both features are log-only, meaning they do not interrupt model work or change the conversation flow, and they are available in the standard Web client out of the box.

packages/feedback · high confidence

The client now provides a single, unified \@\ trigger menu that lets you reference files, folders, and chat sessions. File and session discovery run in parallel through generated Remote APIs, with deterministic ordering and labels. File rows show the parent directory only when needed, while session rows are dated by last activity and distinguish subagent chats. Directory rows support a 'drill' action to descend into subfolders, and picking a file or session inserts the appropriate mention into the input. The menu includes localized copy for sections like 'Files & folders', 'Subagents', and 'Sessions', as well as relative time labels.

packages/client/ui-reference/src · high confidence

The Cordis plugin framework and its foundation libraries are now vendored as source code within the monorepo instead of being installed via npm. This gives the harness full ownership of the framework layer, making it auditable, patchable, and pinned to specific upstream commits. The vendored packages are rescoped under the \@deepseek-ai\ namespace (e.g., \@deepseek-ai/cordis\), and local modifications—such as lifecycle hardening, resilient config reloading, and Node-compatible TypeScript support—are documented in the vendor manifest.

vendor · high confidence

The \session-log-export\ package now enables Web users to download a complete session history as a ZIP archive. Users can trigger the export via a new "Download session log" menu item in the Session Header's more-actions button or by typing the \/export\ slash command. The backend streams the archive (including the session log, sub-sessions, and attachments) directly to the browser without buffering the full file in memory, and the browser handles the local save.

packages/session-query · high confidence

The Workspace Controller now exposes a dedicated client API and state model in \packages/api/workspace-controller/src/client\. This adds a \ctx.workspaces\ service that provides a reactive snapshot of workspace lists, order, and archived sessions, along with commands to create, rename, delete, reorder, and archive/unarchive sessions. The implementation uses a reconnecting state stream to keep the client in sync with the host and includes logic to resolve race conditions between local optimistic updates and remote replies, ensuring the latest server state always wins.

packages/api/workspace-controller/src/client · high confidence

The connection package now enforces a strict security boundary on all /api requests to prevent DNS rebinding and cross-site attacks. Every request is validated against a Host/Origin fence that requires the request to originate from a loopback address or a configured trusted host, and modern browsers must present same-origin markers. Additionally, a new browser-authentication system using signed cookies and process launch tokens ensures that only authenticated browser sessions can access the API, with malformed trusted-host configurations failing loudly at startup.

packages/client/connection/src · high confidence

The session controller now exposes a formalized client contract defining how sessions are managed and how events are presented. This includes a new \SessionEventWindow\ system that distinguishes between durable session events and transient 'live chunks' for streaming assistant responses, allowing the UI to display real-time updates before they are committed to history. The \ISession\ interface introduces explicit methods for managing local submission echoes (\beginSubmission\), handling deep history paging (\loadThrough\), and controlling session lifecycle (fork, rename, cancel). Additionally, the \ISessions\ service interface now exposes session retention, reference counting, and subagent catalog management, providing a structured way for feature packages to interact with sessions without accessing internal implementation details.

packages/api/session-controller/src/client/contract · high confidence

The \dsh\ command-line interface has been reorganized to center on booting named profiles, managing their plugins, and inspecting configuration. Users can now boot a profile via \dsh --profile \<name\>\ (or the shorthand \dsh \<name\>\), passing remaining arguments directly to the booted application. A new \dsh plugin --profile \<name\> \<pnpm-args\>\ command manages profile dependencies by forwarding arguments to pnpm. Configuration inspection is handled by \--dump-config\ (printing the composed profile tree) and \--dump-default-config\ (printing the tree without user layers or overlays). Profiles can be initialized from shipped templates using \--from-default-profile\, and additional patch overlays can be applied via \--patch\. The \desktop\ profile is reserved for the Electron application and cannot be booted from the CLI.

apps/cli/src · high confidence

The client now uses a single assembly module to mount and expose Host capabilities (such as agent presets, commands, settings, file uploads, and plugin management) via the \ctx.remote\ interface. This change consolidates previously scattered Remote contributions into one entry point, ensuring that business logic packages interact with a unified, typed client surface while keeping runtime values isolated behind their respective module edges.

packages/api/remotes/src/client · high confidence

The repository now enforces a canonical LF line-ending format for all text files via .gitattributes, with a specific exception for Windows command scripts (\*.cmd) which retain CRLF. Additionally, .editorconfig mandates that all text files end with a final newline. This ensures byte-level consistency across platforms, simplifying static analysis, coverage reporting, and diff verification.

(repo-wide) · high confidence

The HMR service now provides detailed, code-frame-formatted error logs for build failures, improving developer debugging experience. Additionally, the service implements a recursive dependency traversal to accurately classify changed files as accepted or declined for reloading, ensuring that only relevant modules are updated while avoiding unnecessary full reloads for external dependencies.

vendor/hmr · high confidence

The conversation input area now uses a Lexical-based rich text editor instead of a plain textarea. This change introduces inline reference chips (displaying icons and labels for files or skills), supports clicking to preview references, and provides improved keyboard navigation (arrows, Tab, Enter, Escape) and paste handling. The editor also highlights the active command token and supports IME composition, resulting in a more structured and interactive input experience.

packages/client/ui-conversation/src/client/input/editor · high confidence

The client module system has been rebuilt as a dual-face package (\@deepseek-ai/dsh-client-modules\) that coordinates a Node.js host half and a browser client half. The Node half scans packages for \dsh.client\ declarations, composes a revisioned entry graph (\window.\_\_DSH\BOOT\\_\), and serves combo scripts and source maps. The browser half implements a lazy CommonJS-style module table that materializes plugin factories on first import, manages entry lifecycles, and supports Hot Module Replacement (HMR) by replacing code in place without reloading the page. This change enables incremental plugin updates and preserves bootstrap invariants during live graph reconciliation.

packages/client/modules/src · high confidence

The workspace directory picker now uses an in-app modal dialog instead of the previous runtime-based approach. The dialog features a Miller-column layout (single column until selection, then two side-by-side panes) with a breadcrumb path bar that supports inline editing, a 'Show hidden files' toggle, and a 'New folder' creation flow. It integrates with the host's directory listing and creation APIs via the \ui-workspace\ service slots, ensuring consistent behavior across conversation and sidebar workspace contexts.

packages/client/ui-directory-picker-browse/src · high confidence

The client now defines a dedicated \PlanReview\ interface and \PendingQuestion\ class to handle plan approval workflows. This change introduces a specific slot (\conversation.plan-review.actions\) for rendering plan review cards and a \planReviewOf\ helper to narrow generic question batches into structured plan-review requests, enabling the UI to present approval/decline options for plans while preserving the underlying question infrastructure.

packages/client/ui-user-questions/src/client/contract · high confidence

This change establishes a new set of TypeScript interfaces and utility functions in the chat client contract layer to structure how chat data is modeled and presented. It defines the shape of chat nodes (including assistant, tool, and retry data), turn-process specifications (tracking control anchors, answer boundaries, and subagent counts), and turn metrics (calculating TTFT and throughput). It also introduces helper functions to detect assistant reply content, determine tool call states, and compare turn-process specifications, providing a stricter, more structured foundation for chat rendering and state management.

packages/client/ui-chat/src/client/contract · high confidence

The client UI theme now includes a comprehensive set of new CSS files that establish a unified design system. This introduces a new color palette (including DeepSeek-specific blues and neutrals), refined typography with adaptive font sizing and markdown hierarchy, and new elevation/shadow tokens for depth. Visually, rounded surfaces now use superellipse corners where supported, scrollbars are custom-styled to match the theme, and code blocks feature dedicated Shiki syntax highlighting. These changes collectively update the look and feel of the interface with more consistent spacing, colors, and visual hierarchy.

packages/client/ui-theme/src/styles · high confidence

The conversation UI now uses a new incremental assembly engine (ConversationNodeAssembler) that processes event windows to build context and view snapshots. This engine supports streaming updates published every three frames to improve performance, and includes a session-scoped historical image cache for resolving and caching image URLs. The system also introduces registries for event definitions and view builders, allowing for modular and extensible conversation rendering.

packages/client/ui-conversation/src/client/conversation · high confidence

The input area now uses a Lexical-based editor instead of the previous textarea stack, enabling richer text interactions and precise reference token detection (slash and @ mentions) via a new plain-text reference scanner. A dedicated SubmitMachine handles the submission lifecycle, supporting optimistic sends for plain messages and a new 'steer' mode that allows Cmd/Ctrl+Enter to route queued messages into the currently running turn when the agent is busy, controlled by a new 'busy-Enter' preference. The input system is managed by a new InputHub that resolves per-session input shells, and a ComposerBlockRegistry allows plugins to temporarily block input with localized reasons.

packages/client/ui-conversation/src/client/input · high confidence

The conversation UI now persists user preferences, specifically the 'busy enter' behavior (queue or steer), in the host's durable settings. This is achieved by registering a new settings namespace 'ui-conversation' with a defined schema, allowing the host to store and retrieve these configuration values across sessions.

packages/client/ui-conversation/src · high confidence

The chat interface has been rebuilt to support a more structured and transparent conversation flow. Assistant responses now render as Markdown with support for wide tables, local media paths, and image galleries. A key behavioral change is the introduction of collapsible 'Turn Process' blocks: reasoning steps and tool calls are now hidden by default in a compact summary, which users can expand to inspect the model's internal logic or command details. Additionally, system context injections (such as instructions, recalls, and tool catalogs) are now presented as expandable disclosure rows, keeping the main transcript clean while preserving full visibility into the session's background operations.

packages/client/ui-chat/src/client/chat · high confidence

The \.claude/skills\ location is now a symbolic link pointing to \../.agents/skills\. This change moves the actual skills content to the \.agents\ directory while maintaining the previous path for compatibility, effectively restructuring where skills are stored and accessed within the project.

.claude · high confidence

The client now uses a dedicated plugin to render file and image attachments consistently across the composer, message history, and trajectory views. In the composer, attachments appear in a unified rail that supports drag-and-drop, shows upload progress for files, and provides image thumbnails with a lightbox preview. Historical messages and trajectory items display images in a gallery format, while tool call results also reuse this image gallery renderer, ensuring a consistent visual experience for all attachment types.

packages/client/ui-attachment/src/client · high confidence

The Cordis dependency injection and plugin framework, along with its cosmokit utility library, are now vendored directly as TypeScript source files under vendor/cordis and vendor/cosmokit. This enables native TypeScript source loading and explicit type specifiers, replacing previous compiled or bundled forms. The update includes the full plugin-author surface, a transactional config reload mechanism, and hardened lifecycle ownership for plugin fibers.

vendor/cordis · high confidence

This update patches two internal dependencies to resolve issues with macOS code signing and the packaged runtime's virtual file system. The \@electron/osx-sign\ patch changes \fs.stat\ to \fs.lstat\ during directory walks, ensuring symbolic links are handled correctly and preventing signing failures on projects with symlinks. The \@yao-pkg/pkg\ patch restores support for \readdirSync\ with the \withFileTypes\ option in the SEA virtual file system, allowing applications to correctly read directory entries as \Dirent\ objects (including file type and symlink information) instead of just names, which fixes compatibility with libraries expecting standard Node.js \fs\ behavior.

patches · high confidence

The scripts now run reliably on Windows and with Node.js 22.18+. The notices generator normalizes manifest glob paths to handle Windows directory separators, and replaces asynchronous file system globbing with a synchronous version to resolve compatibility issues with the latest Node runtime.

scripts · high confidence

ACP snapshot test infrastructure and fixtures added; Add benchmark for active stream reconnect performance; Add terminal I/O performance benchmarks with memory and throughput bounds; Added Web profile e2e tests for plugin persistence, startup failure handling, and isolation; Added browser and unit tests for the model selection plugin; Added client-side tests for UI tool row components; Added client-side tests for attachment UI components; Added client-side tests for directory picker browsing and directory browser UI; Added client-side tests for the General Settings UI and Desktop Update flows; Added client-side unit tests for UiSession; Added comprehensive client-side tests for the agent preset management UI; Added comprehensive test coverage for the ACP bridge and approval service; Added comprehensive test coverage for the Trajectory UI component; Added comprehensive test coverage for the UI Dockkit layout engine and React components; Added comprehensive test coverage for the UI Workspace browser and session management; Added comprehensive test coverage for the client UI layout system; Added comprehensive test coverage for the local attachment store; Added comprehensive test coverage for the message feedback plugin; Added comprehensive test coverage for the plugin manager; Added comprehensive test coverage for the sidebar document preview plugin; Added end-to-end and unit tests for the Remote API integration; Added end-to-end smoke tests for the Python SDK keyless profile; Added end-to-end tests for the ACP CLI profile; Added headless agent end-to-end test suite; Added headless test fixtures for CLI snapshot validation; Added host-level tests for Settings and Credentials controllers; Added integration and unit tests for the web-app bundle; Added integration tests for command-line parsing and row injection; Added provider-cwd test fixture for headless bundle; Added snapshot tests for the sidebar shell component; Added stress test for reasoning chunk rendering performance; Added subagent inheritance test fixtures; Added test coverage for Workspace Controller directory picker and client model; Added test coverage for client connection and authentication logic; Added test coverage for client locale management and UI integration; Added test coverage for client module loading, entry lifecycle, and server-side integration; Added test coverage for desktop update verification, backend controller, and packaging configuration; Added test coverage for headless runner startup, session adoption, and JSON projection; Added test coverage for permission preset UI components and settings logic; Added test coverage for sidebar terminal lifecycle, recovery, and UI components; Added test coverage for the Models settings page and its components; Added test coverage for the client UI commands system; Added test coverage for the client UI sidebar; Added test coverage for the client-side UI plan feature; Added test coverage for the ui-deliverables client and host components; Added test coverage for the user questions client plugin and UI components; Added test coverage for web client boot, styling, and mounting logic; Added test expectations for subagent diagnostic scenarios; Added test fixtures and snapshot runner for the DSH badge skill; Added test fixtures for CLI profile initialization, provider validation, and shutdown behavior; Added test fixtures for GitHub webhook real-end-to-end validation; Added test fixtures for remote model domain and service definitions; Added test fixtures for the type-model generator; Added tests for HMR client plugin event parsing, node-side watching, and transport logic; Added tests for PendingApproval lifecycle and settlement; Added tests for SDK app bundle configuration and startup behavior; Added tests for UI job plugin registration and job list action component; Added tests for WorkflowRunPanel styling and conversation definition logic; Added tests for attachment admission, storage, and image projection; Added tests for client resource wiring and registry lifecycle; Added tests for file upload HTTP route and client worker; Added tests for goal activation, UI plugin, and command input components; Added tests for subagent UI components and sidebar chat integration; Added tests for the UI reference input trigger source; Added tests for the UI schedule catalog plugin and action component; Added tests for the base bundle configuration and platform gating; Added tests for the browser plugin integration and settings tab UI; Added tests for the client UI slots core infrastructure; Added tests for the native directory picker client integration; Added tests for the plugin manager UI and store logic; Added tests for the sidebar files plugin; Added tests for the standalone SDK-minimal bundle configuration; Added tests for the ui-skill browser plugin and SkillRow component; Added tests for workspace-files client and service logic; Added unit tests for client-side settings infrastructure; Added unit tests for the ui-chat client package; Document web e2e test architecture and add access-confirmation scenario; Expanded CLI test coverage for profiles, agents, and lifecycle; Expanded test coverage for API gateway streams, protocols, and client behavior; Expanded test coverage for app-boot startup, configuration, and profile resolution; Expanded test coverage for client UI primitives; Expanded test coverage for session controller components; Expanded test coverage for the conversation UI assembly and state management; Introduce cold Session opening performance benchmarks; Updated headless CLI test snapshots for goal tools and credential handling; Updated headless profile test snapshots; Updated headless test expectations for session resume and semantic checkpoints.

This release updates dependencies across 330 manifests, including vendor packages (cordis, cosmokit, group, hmr, include, loader, logger-console, schemastery, timer) and runtime libraries (node-pty, pi-ai, node-addon).

(dependencies) · medium confidence

Documentation for the Cordis dynamic package client runner; Initial package documentation and build configuration for the user questions UI.

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 51.

• Code Health 70
• Architecture 79
• Maturity 91
• Readiness 49
• Security 43
• Accessibility 57

• 300 commits — 211 feature/other, 89 fixes

• (repo) — 102 commits
• packages/client — 78 commits
• .agents/notes — 23 commits
• apps/desktop — 23 commits
• apps/web — 13 commits
• packages/boot — 8 commits
• apps/cli — 7 commits
• packages/api — 7 commits
• snapshots/web — 7 commits
• packages/document — 6 commits
• docs/module-graph.i18n.yaml — 4 commits
• packages/extensions — 3 commits
• .github/review-ownership — 2 commits
• packages/llm — 2 commits
• packages/skill — 2 commits
• scripts/snapshots — 2 commits
• (root) — 1 commit
• apps/desktop-host — 1 commit
• benchmarks/long-session-browser — 1 commit
• docs/subsystems — 1 commit

• fix: Fix Desktop async window-state lint
• fix: Merge pull request #4323 from deepseek-harness/fix/desktop-mac
• fix: Merge pull request #4339 from deepseek-harness/fix/session-used-toast
• fix: Merge pull request #4361 from deepseek-harness/07akioni/fix-windows-shell-console
• fix: Merge pull request #4390 from deepseek-harness/worktree/fix-4187-thinking-markdown
• fix: Merge pull request #4408 from deepseek-harness/fix/trajectory-attachments
• fix: Merge pull request #4442 from deepseek-harness/revert-3906-perf/code-block-preview-renders
• fix: Merge remote-tracking branch 'origin/master' into fix/session-used-toast
• fix: Revert "feat(client): optimize code block previews and source highlighting"
• fix: fix(boot): keep startup metadata out of ordinary error output
• fix: fix(boot): timestamp profile patch backups
• fix: fix(cli): complete startup diagnostics before exiting
• fix: fix(cli): group startup failures and pending services
• fix: fix(cli): save full startup diagnostics under DSH_HOME logs
• fix: fix(client): align Sidebar Browser security docs
• fix: fix(client): align subagent sidebar references
• fix: fix(client): clarify Subagent capacity help text
• fix: fix(client): handle Sidebar Browser navigation fallbacks
• fix: fix(client): keep sidebar integration optional
• fix: fix(client): preserve round sidebar action
• …and 280 more

• 0 containers · 1 bounded contexts · 0 dependency edges (baseline)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

deepseek-ai/deepseek-harness was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.