Awesome DeepSeek Harness Plugin

Manages local DeepSeek Harness skills in Settings and shows shared Agent skills as read-only.

Adds a /simplify command that asks the agent to simplify code within a selected Git change scope, including staged changes, commits, and untracked files.

Plugin governance: new/updated plugins stage in a candidate area first, then hot-mount after startup — success promotes, failure auto-disables, repeated failures freeze, one-click safe mode, sidebar diagnostics panel (npm: `dsh-my-guardian`).

HuaweiCloud DevKit gives AI agents complete command of Huawei Cloud — build, deploy, operate, always governed, always secure.

fnOS 飞牛 NAS integration for DeepSeek Harness, working through the fnOS browser SDK when the Web UI runs inside an fnOS app frame: follows the NAS theme while DSH is set to system preference, lists and revokes authorized NAS directory grants in Settings, opens files and links in the matching fnOS app, and syncs the DSH page title to the fnOS app window. Install from npm with `dsh plugin --profile web add @tnnevol/dsh-fnos`.

Read-only runtime management panel for the official DSH MCP client: connection status, registered tools, errors, and reconnect counts through the /mcp command and a Settings tab, with sanitized display and enable/disable patch suggestions.

Self-hosted DSH Web operations panel for safe restart and upgrade, health diagnostics, model-usage statistics and provider quota lookup, backup and session management, task notifications, skill controls, subagent model routing, and Linux permission maintenance.

Update management for DeepSeek Harness and its plugins: semver-aware dual-source (npm/GitHub) checks for the main program and every installed plugin, a locale-aware banner (zh/en) listing updatable items, one-click updates (the main program is backed up, integrity-checked and rolled back on failure; plugins install via a temp directory without touching other packages), and a watchdog-guarded restart after updating. The settings page adds per-plugin version lamps, live update progress, and banner/notification toggles.

Diagnoses and repairs DeepSeek Harness on native Windows around the official persistent PowerShell and Workspace Write stack, creates the desktop shortcut, and keeps earlier Git Bash and BusyBox presets behind an explicit legacy setup. No WSL.

SSH profiles, browser terminals, SFTP browsing, port forwarding, proxies, and session-scoped AI access for DeepSeek Harness.

Pi Host ABI compatibility engine: after one install, unmodified Pi extensions from npm mount as native DSH plugins with `dsh plugin add <pi-package>`. Verified end to end on stock DSH with pi-mcp-adapter (full MCP manager: OAuth, resources, prompts, MCP Apps, elicitation, sampling), @tintinweb/pi-subagents, pi-code, pi-hermes-memory and pi-background-tasks; `pi2dsh inspect` reports a package's compatibility before installing.

Zero-dependency static and sandbox smoke detector for DSH plugins: package-structure gates, cordis contract scans, keyless headless smoke, and ecosystem-listing checks.

Offline diagnostic for DSH: 19 checks across env, profile, and session state, with a settings "Doctor" panel and a read-only JSON API.

Modifies DSH plugin code at runtime, with ordered patches, inspection, and hot reload.

Exports the session event stream to OpenTelemetry OTLP and Langfuse as sanitized, buffered traces and metrics, off by default.

Runtime-switchable model output styles with Claude Code outputStyles parity, plus the output.render.* presentation protocol: a /style command, per-session persistence, systemPrompt injection, six built-in styles, a web picker, and a renderer registry with per-session/per-tool rules and /export.

Performance profiling and LLM cache diagnostics for DeepSeek Harness — context engineering, latency profiling, and cache behavior reports.

Concurrency guard and monitor for DeepSeek Harness: FIFO queue when concurrent model requests reach the limit, per-day persisted stats with error-kind classification, and interruption detection for abandoned streams.

A web Settings "Loop engine" switch that swaps the agent loop driving every dsh session among five engines — the built-in in-process loop plus hosted Claude Code, Codex, Pi, and Kimi Code — with zero changes to the harness; each hosted engine keeps its thinking and tool calls in the durable session transcript, takes over commands, skills, and the agent preset, and runs sandboxed through the dsh subprocess seam.

Continual self-evolution: versioned, auditable, rollback-safe harness state (prompts, memory, skills, subagent specs) refined from session trajectories, with review gates and hot-reloaded skills.

One-command backup & restore of DSH user data with a visual Settings panel: scheduled auto-backup, sha256 verification, hardened restore with auto-rollback, typed sub-backups (--types skills), credential redaction into a local vault, GitHub sync for cross-machine moves, and an out-of-process rescue channel that works even when the host won't boot. /backup doctor checks and repairs corrupt session logs from a known-good backup; migrate-check statically predicts which sessions a host upgrade would break (frozen event-list rules, filename/generation mismatch, hardlink support, legacy credentials layout) and the credential sentinel preserves pre-migration copies before the host rewrites them; smart backup snapshots before host upgrades and quarantines corrupt logs before rotation. macOS/Linux/Windows.

Multi-dimensional quality scoring for DeepSeek Harness plugins that scores a repo or npm package across install success, maintenance activity, documentation completeness, security scan, and protocol compliance using real CLI evidence, and produces a JSON or Markdown leaderboard report.

Instance manager for DSH Web: a Mini Utility Dock panel that lists every local dsh web instance the machine can see (port, PID, uptime, live session count, resident memory, version), starts a new instance on an automatically picked free port in 3080-3129 or on a port you name, opens a row in a new tab, and stops one or all of them through that instance’s own graceful shutdown (appExit). Rows also show what each instance is serving, and read-only instance logs and session summaries are one click away. Where a peer is configured, the same panel lists and queries instances on other machines over a bearer-authenticated link. Every route is loopback-guarded, and a browser-facing action must additionally pass the host’s own browser authentication.

Shows the installed DeepSeek Harness version in the sidebar, checks npm and GitHub Releases for updates, and provides manual or confirmed update commands.

Restart DSH: configurable restart method (Node native / legacy PowerShell), post-restart continue prompt, optional watchdog auto-relaunch.

Runs isolated install-and-smoke test drives for DSH plugins in throwaway profiles, returning structured pass/fail records and batch matrices without touching your real profile.

Version and maintenance suite for DSH itself: detects new host releases from npm dist-tags, upgrades with one click, restarts safely, and the web page auto-recovers once the host is back.

Version management for dsh: inspect the installed version against every npm channel or version line, install or downgrade in one click, stream the install log live (rollback-snapshot copy progress, npm extraction progress, elapsed time), roll back instantly from local snapshots, and automate the cycle with a policy engine (silent auto-update, execution windows, daily checks). Never stops npm mid-install — a wedged run is only stopped after an hour, and a half-committed global tree is detected and repaired from the pre-install snapshot automatically. Confirms before installing a found update, auto-restarts the host after install, and falls back to a mirror when the primary registry is unreachable.

Registers the DeepSeek Harness web server (dsh web) as an auto-start, self-healing background service — LaunchAgent / systemd / cron plus a 30s health-check watchdog — with seven dsh_daemon_* tools (install/uninstall/reinstall/status/start/stop/update).

Profile management card for the DSH Web GUI: view, create (base / web / headless templates), copy, rename and delete DSH profiles under ~/.dsh/profiles, with per-profile port configuration and a copyable launch command.

Multi-machine sync: keeps multiple dsh replicas consistent through one private GitCode repository — skills, sessions, settings and plugin manifests each with an independent switch; changes go through branch, PR and merge, remote-only additions are pulled back before every push so nothing is deleted, and an AI smart-align step semantically merges files both sides changed (plus one-click conflict resolution); private repos enforced, pull never overwrites local edits.

Undo/redo & rollback system for DSH: every config change is auto-snapshotted; undo/redo/restore to any version from the WebUI or the offline CLI/GUI tools (works even when DSH fails to boot).

Skills & MCP section in Settings: browse, create, edit and delete skills with live directory watching, toggle loading of any on-disk skill through frontmatter policy keys, register local folders or GitHub repos as extra skill scan roots, edit the MCP server rows in the profile patch, import MCP config from Claude Code or Codex, and install from a curated market of skill repos and MCP servers.

Imports Claude Code setup into DeepSeek Harness from a native settings screen or CLI, with dry-run previews for skills, commands, agents, hooks, permission rules, and MCP config. Codex and OpenCode remain supported as secondary origins, with collision-safe apply and post-move checks.

Make your dsh ready for serious coding. (Tools x Schemas)^REPL. `skill://`, `ctx://`, `agent://`, `dvc://`, `dsh://`, IPython REPL, Context as Variables, cross compactions recallable, full context revive. `hash-edit`, `dvc://browser`, subagent as function, workflow as function.

DSH updater + official docs sync in Settings: one-click npm update of @deepseek-ai/dsh with live progress (npm output stream, elapsed timer, monotonic bar), multi-copy protection that only touches the running instance, source-tree mode via git pull, one-click PowerShell 7 install on Windows, incremental sync of the official docs/ with progress, and the dsh_docs_search / dsh_docs_read model tools.

Noname (Sanguosha-like game) extension workshop. AI writes skill and card extensions behind confirmation gates, static validation and block-based safe writes.

Windows process-tree reconciler for the DSH host: samples the host process tree and the job ledger, attributes each process to the job that created it, flags unattributed and orphaned processes with a confidence level, and offers guarded termination of a whole tree. Termination is refused unless the target belongs to the DSH host tree, is re-sampled and re-checked immediately before the kill (creation time included), and contains no protected descendant, so an allowlisted PID cannot widen the kill scope.

A permanent DSH plugin that bundles a developer workbench, an in-session conversation tree, and a plugin manager: build and run an LVAL project, browse its code, and keep per-program version snapshots with rollback; edit, retry, or branch any message in place, with message micro-versions; a feature manager plus a global-plugin library whose entries each carry an enable tier; cross-dialogue memory, one-shot temporary chats, and model collaboration; five network-permission tiers, mixed-model routing, a security audit, and browser control through a companion extension.

Shared toolkit for authoring DeepSeek Harness plugins, published as @perrylink/dsh-plugin-kit: a pluggable provider registry seam, fail-closed approval and session-event gates, shared sanitize/pricing/judge modules and a new-plugin skeleton.

DSH sidebar file-activity tab: records file reads/creates/modifies by the agent and the sidebar (including file ops hidden inside bash commands), per-session isolation, survives restarts, click a file for a floating preview (npm: `dsh-file-activity`).

Converts session, agent-loop, LLM, and tool lifecycle events into OpenTelemetry GenAI traces and metrics, exported over standard OTLP/HTTP to any compatible backend, with content capture off by default.

Docker-isolated real-host lifecycle tests for DSH plugins across install, boot, tool registration, update, uninstall, reinstall, and recovery, with structured evidence.

Continual self-refinement loop: persistent memory, periodic review-and-refine, cross-session shared knowledge, and automatic rollback through a model-callable harness_refine tool.

Context-window attribution for DSH Web: a Mini Utility Dock panel that ranks the user messages, assistant turns, reasoning blocks and tool results of a session by the tokens each one occupies, so it is clear which entries hold the window. It also shows the share by entry type, the heaviest entries across the live sessions of the host, and, where the host provides them, provider usage and the estimated system/tools/messages composition. The panel is read-only: it does not estimate cost, modify a session, or trigger compaction.

Windows system-tray launcher for dsh web: console-free background start (VBS/powershell chain), a tray menu with open UI / logs / icon presets / launch-at-login / restart Harness, one-click install and update of the bundled dsh-plugin-usage-meter, and a dsh plugin half that starts the tray together with the harness.

Browse, enable, disable, and manage Agent Skills from Claude Code, Codex, OpenCode, Gemini, and custom directories in the DSH settings panel.

Tauri 2 desktop application for Windows that detects (or installs) the global @deepseek-ai/dsh package, launches the DSH Web server and embeds it in its own window, with system tray management, login autostart, a global hotkey and desktop shortcuts.

Manages DSH skills and MCP servers from the web settings: skill cards with hot enable/disable, workspace scopes, groups, batch migration and drag-and-drop import, plus stdio/HTTP MCP CRUD with connection tests, secret redaction and the unified dsh-panel CLI.

Update copilot for DeepSeek Harness: one scan covers the DeepSeek Harness core and every profile plugin; explains what changed and how risky each update is, then updates only what you confirm.

Automatically disables a failing plugin so the rest of DSH keeps booting — by patching DSH’s own installed kernel (mount-time quarantine + self-healing), not preflight smoke-tests. Includes status tools and a one-click restore panel.

Collects and redacts DSH runtime diagnostics before filing structured issues in GitHub or Gitea.

FDE toolbox bundle: installing this one plugin pulls in a curated set of common dsh plugins (git server, WebDAV mount, knowledge base, scheduled tasks, auto-resume, UI tweaks, auto-retrospection, file manager, smart titles, task board, plugin market, context trimmer, IM bridge, sidebar enhancements), with a panel showing install status and one-click gap-filling.

Dependency graph inspector for DeepSeek Harness: snapshots the live Cordis plugin/service topology into a zoomable browser panel with graph-theory metrics, plus a graph.render tool for the model.

Claude Code rules.md-style rule prompts: activate rule markdown files by glob-matching the files an agent reads or edits, with prompt injection and ordering support.

Skill and MCP management center for DeepSeek Harness: browse and toggle user/project skills, add/edit/remove MCP servers hot without restart, with live per-session status in the sidebar.

Session-bound persistent TypeScript REPL for DSH PTC mode: bindings and imports stay live across run_code calls, edit_run_code replaces one line without resending the block, module import/export syntax is adapted via AST rewriting, and durable bindings are restored from the session journal after a cold restart.

Visual development studio for DSH WebUI plugins with isolated Git worktrees, live official-WebUI previews, source editing, patch inspection, builds, and validation.

Read-only DSH/Cordis composition doctor for plugin conflicts and upgrade rehearsal: scan profile manifests and patches, find duplicate rows, hook-order and UI ownership conflicts, compare redacted snapshots, diff plugin/row/hook changes, and preflight target DSH releases with explicit evidence boundaries — without mutating a real profile.

DSH environment diagnosis, graded repair with one-click rollback, and a runtime self-healing service.

Bidirectional Hermes ↔ DSH bridge: import Hermes sessions into DSH, consult Hermes, and receive Hermes-dispatched tasks as a single Cordis plugin.

Manage the dsh service via `dsh --profile ctl`: systemd lifecycle (install, start, stop, restart, enable, disable, uninstall), persisted config, health probe and logs, plus shell completions and self-update.

Service control panel in DSH Web settings: live host info (PID, versions, uptime, memory/CPU trends, active sessions), npm update banner, and a confirm-guarded graceful stop that warns when tasks are running and can wait for them to finish.

Test-stability tools: repeatedly run vitest/jest/pytest/node:test suites, classify flaky cases, keep history, maintain a quarantine manifest and health self-check.

Back up your DSH profile configuration to a private GitHub Gist on a schedule, with merged restore.

Bridges Multica to DeepSeek Harness through a versioned JSONL process protocol.

MCP & Skill manager: enable/disable MCP servers and skills from a Settings panel to free context in real time; optional AI middle layer (mcp_search/mcp_call) calls disabled servers on demand, with state-based visibility filtering that keeps user-enabled servers visible.

Code RAG semantic index panel and settings card: live index bar with start/rebuild/cancel, plus one-click detection and configuration.

Progressive-disclosure MCP gateway that searches large remote catalogs through `mcp_search`, then invokes exact schemas through `mcp_call` with lazy connections and bounded caches.

Wakes the main agent after any DSH restart so interrupted work resumes automatically — adds a restart tool and an optional canary that validates the boot and aborts with an alert before a broken restart.

Inject deployment-configured system-prompt sections and reference exchanges into every conversation request via stream interception, with a web settings panel.

Rules, commands & skills manager for dsh: /rules slash command, settings panel with visual rule editing (add/edit/disable/delete, free-zone support), user-defined custom commands with {input} arguments, skill management, and automatic backup & one-click restore of AGENTS.md.

Backs up DSH profiles and mints a desktop "revival coin" that restores the harness after a failed boot or install: a boot guard runs a two-phase health check (HTTP 200 plus client render), marks good boots, isolates or rolls back bad ones, and keeps 3 rotating snapshots. Cross-platform.

Blocks edit/write writes that contain characters matching configurable regex rules, executed before the tool runs, with configurable messages and same-turn pwsh propagation; default rule matches full-width parentheses.

Wire-level LLM inspector: captures the raw HTTP request and response bodies of model provider calls and attributes each capture to the session that caused it through the llm/stream waterfall. The request pane renders the body as a collapsible tree with per-node sizes — one measured request was 98.6% a single 973-entry array — and the response pane reassembles the OpenAI-style SSE chunk stream into reasoning, content, tool calls and usage. Shown in a Conversation View tab and a loopback viewer page.

Component checklist for the shared Semi Design package used by tnnevol DSH plugins, opened from a `Semi UI` button in a conversation header: 35 components plus a multi-account case page, organised into seven sidebar groups from inputs, forms, selectors and trees to tables, cards, overlays and feedback, each rendered live with a one-line description and a page outline, with light, dark and follow-system preview. Install from npm with `dsh plugin --profile web add @tnnevol/dsh-semi-ui-showcase`.

Read-only insight panel for one profile: five views over the same data — config layers, plugin tree, services, tool names and models — each entry showing which layer inserted or disabled it and whether it is running.

Visualize the DSH process network path on Windows or WSL with layered DNS/TCP/TLS/HTTP probes, detect stale proxy configuration, and apply snapshot-guarded repairs.

IDE-style run configurations for DSH: save LLM prompts and shell commands as reusable run configs (global or per-workspace), run them from the session header or the new-session page, and manage them via the task_run_config tool with approval-gated writes.

LLM debug console for DeepSeek Harness: captures the full content of every model call at the llm/stream waterfall (options, stream chunks, usage, wire protocol) and shows it in a DevTools-style docked panel, with shared-prefix context diffing, wire-JSON reconstruction, JSON export and a runtime-tunable capture policy.

Host-side guard that lets the write tool only create new files: when the target already exists it denies the call before execution and tells the model to use edit instead, applied to all sessions.

Wraps Python virtual environment management commands: reduces the network and permission problems agents hit when managing environments through terminal commands, works across operating systems, and routes installs automatically through mirrors and local proxies. The tools are strictly confined by the granted read/write permissions.

Local development service console for DSH: lists every listening service on the machine and lets users inspect, safely stop, or restart services that were started during development.

Read-only repository fact scanner kernel for DSH analysis plugins: deterministic probe / file index / modules / dependencies / entry points / symbols / graphs and git facts over a stable JSON schema (CLI + library + skill runbook).

Windows desktop shortcut for dsh web: launches the server, auto-opens the browser when ready, and stops the service when the Harness window closes.

Turn codebase smells into an executable, priority-ordered refactoring plan: file-length / deep-nesting / function-length / god-object heuristics plus a staged runbook (read-only, no auto-rewrite).

Migrate Codex (OpenAI Codex CLI / Desktop) MCP servers, skills, instructions, memory and session history into DeepSeek Harness with a visual panel or CLI, with dry-run previews and secrets migrated as-is.

Use Kimi Code as the DSH agent loop over ACP, with approvals, slash commands, and local/remote (ssh+tmux) session attach.

Plugin inventory manager for DeepSeek Harness Web: table view of installed plugins with status filters, enable/disable switches applied via HMR, config viewer/copy, uninstall and npm update reminders.

Swaps the filesystem and bash providers for a mirage virtual workspace: file tools and shell commands run over mounted resources (RAM, S3, Redis, Slack, Gmail, Notion, Postgres) instead of the host disk, with per-mount read/write/exec modes, per-command sandbox routing (monty, pyodide, quickjs in process; docker, e2b, daytona remote), and installed CLIs (git, gh, slack, linear, ntn, gws, or one you register) as head words in the virtual terminal.

Verification toolkit for DSH agents: evidence-based claim checking against workspace files with line citations, config validation (JSON/YAML), and read-only URL/npm/GitHub submission-readiness probes.

One-click health check for DeepSeek Harness: 0-100 score, plain-language issue list, and safe reversible fixes via the profile's cordis.patch.yml.

Edit the global ~/.dsh/AGENTS.md rules from the web settings panel, live on save.

Boot-time watchdog for DSH web: detects broken plugins, disables them persistently so the UI opens, with quarantine audit, automatic probe recovery, and one-click restore.

Read-only MCP server over the DSH plugin-certification registry, exposing a plugin certification grade, its snapshot and the five-dimension evidence behind it.

A developer toolkit for the DeepSeek Harness (DSH) web console: a real multi-tab PTY terminal docked under the composer plus an AI-output file browser sidebar with syntax highlighting, Markdown rendering and image preview.

Dead-code detection for AI-generated codebases: graphlint builds a dependency graph, finds code unreachable from any entry point to enable codebase cleanup and functional‑effectiveness understanding, and exposes graphlint_query / graphlint_build / graphlint_config tools plus a graphlint skill to DSH agents.

Update checker (npm edition): a settings page comparing local and latest versions of @deepseek-ai/dsh and every installed plugin, with a red-dot nav reminder and ready-made update commands.

Evidence-backed inspector for DSH Web built-in capabilities: runtime/config provenance, compatibility and drift diagnostics, plus fail-closed controls for nine reviewed UI leaves.

Manual model probe for DeepSeek Harness: a session-view tab where you pick provider, API type, model and route, then send one real raw HTTP request over openai-completions, openai-responses or anthropic-messages — streaming or not — and read latency, TTFT, HTTP status, token usage and a three-layer diagnosis chain (API request / model response / strict check) on one screen, with errors in plain language.

Metadata-first runtime profiler for DSH agents: turn/step traces, model and tool wall-time timelines, provider usage, retries, errors, and live or historical sessions.

Reloads an upgraded plugin inside the running dsh process instead of restarting it, and rolls back to the old version when a reload fails.

Auto-log failed tool calls across native tools, PTC run_code, and inline invocations: dedup and count root causes into a skill so repeated mistakes fade.

Evidence-backed Skill self-evolution for DeepSeek Harness: redacted trajectory learning, quarantined proposals, arena validation, canary monitoring, automatic rollback.

Ren'Py galgame production workbench: a host-side project service (write gateway plus git snapshots, a dialogue/scene dialect parser, derived progress, human-only review stamps, pinned-SDK validation and playtest, local publish) behind one seam, driven by an embedded web panel and agent tools.

Track the origin of local development ports on Windows and safely manage verified DSH services.

Skills & MCP manager in the DSH web settings: browse/enable/import/delete skills across project and user roots, and manage stdio/streamable-http MCP servers with a real connection (tools registered as mcp__<server>__<tool>, config in ~/.dsh/mcp.json).

Read-only Sentry tools: project listing, issue search at organization or project scope, single issue detail, and the latest or a specific event with a trimmed stacktrace. Local variables, request headers and bodies, query strings, packages and secret-looking tags are removed before the event reaches the model, and oversized events degrade through source context, breadcrumbs and frames rather than failing.

Replaces the headless startup to add --model provider/model, --resume <id|latest>, --continue and --session-info flags to dsh headless runs.

Adds a Check for Updates row in Settings and a right-sidebar card that update the DSH CLI and every profile plugin, with npm channel selection (auto/stable/next/alpha), minimum release age, backups, one-click rollback and a test reminder for the badge and browser notification.

Escaped, theme-aware HTML code-block rendering service for DSH Web plugins, built on structured syntax-highlight tokens with source line-ending preservation.

Network optimization for the DSH web UI: reduces transfer size with caching and compression to greatly speed up page loading, plus a connection-drop indicator and automatic reconnection. Ideal for users pursuing peak performance or using unstable networks.

Compiles a Windows .bat/.cmd launcher into a real .exe from inside DSH: renders an icon from a built-in bitmap font, emits a C# wrapper that runs the batch file next to it, compiles with csc.exe (or dotnet build), and can write Start Menu / Desktop shortcuts.

Evidence-first conclusion gate that cross-checks first-hand claims against a durable per-session tool-activity index, blocks unverified guesses and tracks blocked-versus-converted metrics.

Loader-independent startup recovery for DSH Web that detects likely broken plugins, temporarily skips them, and restores only Boot Guard-managed changes.

Hands standalone jobs to the Cursor CLI signed in on the same machine, with CLI readiness and proxy diagnostics, child-model settings, and a read-only connectivity test.

Developer quick-reference toolbox for DSH: 12 themed categories (195 entries) plus zero-dependency tools — regex tester, JSON formatter, timestamp converter, Base64/URL codec, cron generator and line diff, in a searchable settings panel.

Runtime observability and plugin operations panel for DeepSeek Harness: shows the profile plugin tree, real Loader fiber state, capabilities/dependencies/compatibility, current-session plugin activity and upstream source/version checks, with one-click enable/disable/update/uninstall plus a standalone startup-failure diagnostics page that works while DSH is not running.

Boot-time guard that repairs corrupt session logs, preflights plugin composition, vm-checks client artifacts, smoke-tests host apply() and quarantines crash-causing bundles, so a broken plugin can never brick startup.

Exposes bounded Prometheus metrics for DSH sessions, agents, LLM calls, tools, approvals, subagents, and jobs, with a Grafana dashboard and a loopback-only endpoint by default.

Collapsible right-docked web terminal (xterm.js) bridged to a host PTY over WebSocket: bash/zsh switching, resizable panel, and fold/unfold that keeps the session alive.

Edit the host-wide global instructions (~/.dsh/AGENTS.md) from a dedicated Customize page in Settings - every session on this machine applies them.

Parses DSH session logs to attribute AI-written files, overlays c8 coverage, and reports AI vs human code coverage with a trust score, plus a check/fix/verify tool loop for closing test gaps.

Plugin quality scorecard for DeepSeek Harness: 0-100 with grade, 6 components, fix suggestions per deduction, batch leaderboard - CLI plus an agent-callable quality_score tool.

Plug/unplug any DeepSeek Harness plugin cleanly — list every mounted layer (bundles + patch rows), remove with full cleanup, disable/enable without deleting, and audit for orphaned/dangling state. CLI + agent-callable unplug tool. Read-only by default; destructive operations require explicit confirmation.

Version-token-validated in-process result cache for the DSH read tool: repeated reads of unchanged files skip file I/O and line rendering, with a readcache tool for stats and clearing.

Ship a project to Cloudflare and publish your plugin to npm — the first deploy needs no cloud account, and credentials never reach the model.

Agent2Agent protocol v1.0 for DSH: run a standard A2A server to let other agents call this instance, connect to remote A2A agents as clients, and manage both from a visual settings page.

Diagnose duplicate DSH loader entry IDs before startup, report version-locked repair status in a read-only settings card, and apply or revert audited loader repairs through an external CLI.

Exposes the DSH workspace as an HTTP API: browse, search and read files, and run natural-language agent tasks that answer with cited sources.

Replaces the web profile's pwsh shell executor with a subclass that rewrites every command through `rtk rewrite` before execution for token savings, running the original command unchanged on any rewrite failure (no equivalent, missing rtk, timeout) and keeping sandbox semantics intact.

Adds a restart row to Settings → General that relaunches dsh web with the same invocation through a detached helper, refuses under a detected systemd supervisor unless allowRestart is true, and tests whether the listening port is free by connecting to it rather than binding it.

Loads Claude-style plugins into DeepSeek Harness (dsh): discovers skills, commands and optional SessionStart hooks from Claude plugin directories, with hot command reload and uninstall cleanup.

One-click start/stop launcher for DSH Web on macOS — start (foreground/daemon), stop, status, duplicate-launch guard, auto browser open, plus a Dock-able DSH.app built by script.

Auto-adjust model reasoning effort per task (off/low/high/max): task classification, \[effort=...] markers, in-turn error escalation, DeepSeek peak-pricing-period capping with countdown notices, and manual-selection priority.

Test-insight plugin that turns repository facts and change risk into evidence-backed test plans and isolated, reviewable test drafts.

Bridges the harmonyos-dev-mcp Python MCP server into DSH: HarmonyOS device discovery, build/install/run/uninstall, UI automation (click/input/keys/swipe/screenshot), E2E UI-tree inspection, and log/crash analysis as 18 mcp__harmonyos__* tools.

Langfuse observability for DeepSeek Harness (DSH): per-turn trace trees aggregated by session id, with prompt versioning and evaluation.

Exits the dsh CLI process automatically when the Web UI closes, with a configurable grace period and dry-run mode.

TapTap Maker integration for DeepSeek Harness: bundled MCP tools, Maker workflow and feature skills, plus a packaged CLI path for project initialization and diagnostics.

Ships a skill plus six Node scripts for a DSH install that will not come up - walking the boot stages before readiness, the plugin dependency bridges and junctions under a profile, dead or duplicated plugin rows, and the upgrade path. The scripts are diagnostics first; the rebuild helper only writes when it is given --fix.

Android Studio-style ADB logcat viewer with live filtering and level colors.

Lists the Docker Compose projects of your DSH workspaces in the right sidebar, one group per project directory, with container status, project- and service-level up/stop/restart, and streamed per-service logs.

Diagnoses current and saved DeepSeek Harness trajectories with AgentDebugX and opens structured reports in its dashboard.

On Windows, the available bash tool is limited to Git Bash and PowerShell is disabled.

Compares existing DSH sessions or runs controlled A/B trials between agent presets, showing aligned timelines, paired metric deltas, explicit success checks, and exportable reports.

Configurable per-turn budgets for supported file mutations, limiting distinct files, mutation calls, and UTF-8 payload bytes before tool execution.

Freshness gate for the agent's test, typecheck, lint and build claims: each verification run becomes a receipt on tools/post-execute, file edits are tracked, and on agent/turn-stopping a claim whose latest receipt is stale, failed or has no readable result steers one more step naming the receipt and the files edited since.

Branch-aware code knowledge graph for DSH - callers, impact, trace and architecture over 158+ languages, freshness-gated, one dispatcher tool, zero MCP sessions.

An MC-Fabric-style hook processor.

Track DeepSeek Harness's own releases and update in one click: reads the npm dist-tags and the GitHub changelog, shows every change between the running build and the target, grades the risk, then hands the install to a detached helper that backs the current install up with an atomic rename, runs npm, verifies what landed, relaunches, and rolls back when the new build does not come up.

Loopback-only ACP door for DeepSeek Harness: attach an external client (such as the DSH Panel VS Code extension) to the kernel you already have running, exposing session listing and permission presets.

Session-header button that previews and downloads the exact request frame DeepSeek Harness sends to the model: the full system prompt, the declared tools array, and the wire message array (system/user/assistant/tool-result) rebuilt from the session log via the same folds the agent loop reads.

Runtime governor for DeepSeek Harness: zero-progress steering, generation-bound verification evidence, evidence-aware completion guarding, and task-profile tool restriction.

Builds, tests, archives and runs an Xcode project or workspace on iOS or macOS through xcodebuild — a live filterable build log, scheme and destination pickers read from the project, and log streaming for simulators and USB devices, including iOS 16 and earlier over libimobiledevice, whose app logs stay readable while the device is locked. macOS only.

One repository, three parts: a runtime injector for DSH plugin packages (inject, hot-reload, unload, promote a dev staging tool to the front, route self-heal, plus a settings-page plugin manager that lists, unloads and drags folders in to internalize), a task-aware reasoning-mode router agent preset (router-standard / router-spec / router-react), and a graded two-level task protocol whose six tools (commit_star, lock_stage, revise_do, edit_plan, mark_task, redteam_verdict) pin task state to disk. The injector implementation ships in-tree, so the install carries its own behaviour rather than a dependency list.

Community distribution: TUI, desktop, and Web UI as one bundle with layered installation.

Compare multiple skills on the same task and pick the winner.

Run the dsh runtime on Multica.

Context injection audit: token costs of instruction chains / skill catalogs / tool schemas, duplicate and conflict detection.

Plugin health checks: manifest protocol / patch format / build traps, zero-dependency and read-only.

Restart recovery for DeepSeek Harness web: after a crash or restart, an interrupted agent turn continues automatically (host-side agent/created listener, no browser timing races).

Evaluation harness for DSH plugins: YAML cases drive real headless agent runs, assert on tool calls, args, results and token usage, with a baseline gate for CI regression.

Bridge Claude Code's .claude/ directories into DSH with zero migration: project and user-level skills, commands, rules (one system-reminder envelope), agent files, hooks (PreToolUse/PostToolUse/UserPromptSubmit/ SessionStart/SessionEnd) and .mcp.json servers, plus Claude Code plugin marketplaces. Ships /cc-plugin for full plugin/marketplace management (claude CLI first, self-implemented fallback), /cc-resume to list and import Claude Code sessions into DSH as native event-sourced logs, and /cc-export to write DSH skills back as Claude Code skills. Two-way Claude Code <-> DSH bridge, versioned and released as dsh-claude-compat.

Plugin template repo (based on the official turtle-ui repo).

Skill pool manager in the Settings sidebar: enable/disable, folder batch import with rename-conflict prompts, state-driven one-click DSH-spec check & auto-fix, system/project scope labels.

The organ kernel of Agent-Body: plugins organized as one body. Each command is turned into a nerve impulse that deterministically innervates the organ which should handle it and names the capability to use; a heartbeat with a variable interval (faster on alerts, slower when idle) pumps operator directives, proprioception and homeostasis warnings system-wide; reflex arcs fire with zero model calls; failures go through deterministic attribution (missing tool / arguments / permission / timeout / network), a prescription, and a re-check loop, with argument errors never auto-retried. A missing organ is compensated by the one with the highest capability overlap, and tool schemas are gated by the current intent (84.7% measured reduction, reproducible in-repo). This entry is the kernel plugin package inside the agent-body repository.

Self-evolution: the agent hot-mounts/removes persistent plugins on itself mid-session.

Discovers installed DSH plugins with tags, overlap and compatibility detection, one-click enable/disable, failure diagnosis, and update checking.

Network proxy manager for DeepSeek Harness: switch between system, manual, and direct modes from a live settings UI, applied instantly.

A starter template for dsh plugins covering config, tools, events, services, hooks, browser UI slots, and slash commands.

Generate Functions, MCP tools, workflow Skills, and offline test packages from user-authorized source code.

Frame-level scan diagnostics for session files (torn/corrupt/empty detection).

A small self-contained power control for DSH: sidebar power button with an upward restart/shutdown menu and a Windows-shutdown-style overlay. Own restart & shutdown engine (no dependency on other plugins), dynamic-port aware.

Health checks for DSH plugins: manifest/patch/entry/build/pack/install verification, model-callable plugin_check, profile host-shadowing + BOM detection, environment diagnostics, and poison preflight.

One-click restart button for the DSH Web UI: a sidebar footer button that restarts the dsh web process with a single click and persists across the restart it triggers.

Load Claude Code assets into DSH at runtime — skills, slash commands, rules, permission rules (deny/ask/allow), subagents and hooks from .claude/ plus Claude Code plugins (plugin.json / marketplace / skills / agents / MCP), via a memory-IR parse layer that keeps .claude as the source of truth with no writes back. Six installable packages: loader, skills, permissions, agents, hooks, mcp.

Environment housekeeper for the agent: toolchain inventory (node/pnpm/git/gh/ffmpeg/browsers), scratch/cache scan with whitelist-guarded one-click cleanup, and the machine rules file (AGENTS.md) editor - all in the Web GUI settings.

Read-only trajectory review in a resizable conversation sidebar, with rule analysis, optional model explanations, evidence navigation, and same-range run comparison.

Browse, search, delete, undo-delete, and update user skills from the Web settings panel; checks GitHub/Gitee Releases for newer skill versions.

DSH self-updater in the settings page: one-click check/pull (`git pull --ff-only`), auto background checks, version diff and changelog preview with a red-dot reminder.

Bridges the Codebase Memory MCP code knowledge graph into DSH and keeps indexed repositories fresh with a debounced filesystem watcher. Windows-only MCP bridge (the watcher half is cross-platform); auto-installs its npm CLI via npx on first start.

Unified LLM request/response inspector: reasoning-effort tuning, external-think export, traffic & bundle analysis.

Settings -> Plugins switchboard: every loaded plugin card shows its package description and runtime phase, with fuzzy search and start/stop toggles that never rewrite config files.

Unified Godot asset and project-goal management for DSH: godot_* model tools, a /gap REST surface, and a better-sidebar UI with asset manager, scene-tree viewer, and Git panel.

C/C++ LSP configuration plugin for DeepSeek Harness using clangd.

C# LSP configuration plugin for DeepSeek Harness using OmniSharp.

Go LSP configuration plugin for DeepSeek Harness using gopls.

Java LSP configuration plugin for DeepSeek Harness using the Eclipse JDT language server.

Kotlin LSP configuration plugin for DeepSeek Harness using kotlin-language-server.

Lua LSP configuration plugin for DeepSeek Harness using lua-language-server.

PHP LSP configuration plugin for DeepSeek Harness using Intelephense.

Python LSP configuration plugin for DeepSeek Harness using Pyright.

Ruby LSP configuration plugin for DeepSeek Harness using ruby-lsp.

Rust LSP configuration plugin for DeepSeek Harness using rust-analyzer.

Swift LSP configuration plugin for DeepSeek Harness using sourcekit-lsp.

TypeScript and JavaScript LSP configuration plugin for DeepSeek Harness using typescript-language-server.

Registers `list_profiles` and `export_profile`, so the agent can show what setups exist and hand back a whole profile — bundle order, plugin versions and patch — as one portable file to share. Read-only.

Zero-touch runtime telemetry for DSH: every session auto-writes task, model tier, tools, failures, duration, status into a human-readable journal with a stats section (pure observer — no tools, no LLM calls, no injection).

Runs the agent's filesystem, bash and PTY terminals inside a Docker container by providing the `ctx.fs` and `ctx.subprocess` seams, so cwd, environment and background processes survive a harness restart.

Model-driven /init command: the agent analyzes the current repo and generates/updates a high-signal AGENTS.md, with a persistent system-prompt reminder to keep it maintained.

A TPS metrics plugin.

Pre-flight plugin-library index for DSH agents: injects per-step trigger-table hints into the runtime context so suitable installed plugins get used predictably instead of opportunistically.

Self-update for the harness launcher; checks npm for a newer @deepseek-ai/dsh, stages the tarball, and applies it on harness exit or via update-and-restart from the web panel.

Skill Manager page in the DSH settings panel: browse system / user / workspace / preset skills, expand a skill to its file tree, view and edit files, import skills from a zip, and export or delete them (system skills read-only).

Automated unit-test generation: a /testgen command and generate_tests tool that scaffold, run, and fix tests until they pass (LLM + offline template generators; vitest/jest/mocha/node:test).

Capability transform & assembly engine (Qian Xuesen cybernetics/systems framework): static resident layer manages the skill/MCP/plugin registries, auto-absorbs skills and tool metrics, and drives a negative-feedback evolution loop (scan Sick/Weak → mutate → select promote/reject → 30s rollback); includes a Web UI panel and a GitHub dsh-plugin store bridge.

A dockable IDE workbench for the DSH web UI: a GPU-accelerated terminal (restty renderer over a Rust PTY), a CodeMirror editor, a file explorer, notes, a sandboxed browser, and ripgrep content search.

Plugin development toolkit for DeepSeek Harness with scaffolding, contract checks, plugin vetting, impact analysis, and upstream compatibility tracking.

Unifies every DSH extensibility seam behind one declarative DSL: a runtime `fabric` service, `fabric_extend`/`fabric_inspect` tools, and a capability-graph settings page.

Plugin compiler with a blueprint registry (scaffold → validate → deploy) exposed as a runtime service, three model tools, and a blueprint-gallery settings page.

One-click start/stop button pinned to the window bottom-right corner: restarts DeepSeek Harness in place via a detached helper that relaunches the exact boot invocation (loopback same-origin guarded), with an optional stop-only action.

Evidence-first guard: warns the agent when it claims success without a matching tool-execution record in recent context.

Reuses hooks declared in Claude Code, Codex and opencode configs on dsh, executing shell, webhook, oracle and proxy handlers with zero runtime dependencies.

Session export and compliance archiving for DeepSeek Harness: deterministic redaction, Markdown/JSONL/PDF outputs, on-disk archive management, and a trend/audit view.

Compares coding agents in isolated Git worktrees with deterministic validation, scoring, and explicit winner application.

Source-aware prompt injection guard for DSH: tracks untrusted turn context, detects injection signals, scores sensitive sinks, and blocks high-risk tool calls with explainable audit logs.

Weekly digest generator: aggregates git commits, DSH session activity and daily memory entries into a Markdown weekly report, read-only.

Floating power dock for the DSH web GUI: one-click restart or graceful shutdown of the dsh host, loopback-guarded and dependency-free.

One-click health check for the DSH Web GUI: a sidebar button runs the ops kit's check-health.ps1 through a plain HTTP route (independent of the tool registry) and renders a structured report card; colors follow the active theme, Windows/PowerShell.

Plugin-combination analysis for the DeepSeek Harness: dependency trees, conflict detection, risk scoring with prediction, visualization, and combination simulation.

Windows system-tray launcher for DeepSeek Harness Web: start, stop, restart, open the Web UI, tail logs, live status icon, and a launch-at-login toggle.

Prunes the tool schema to a whitelist and injects a structural preamble on a session's first turn only, then passes every later turn through untouched.

PWA plugin for DSH — adds offline support, service worker caching, and install-as-app capability.

Manage the DSH web service from a settings panel: status, version, restart, stop, and one-click updates.

Kubernetes ops for the agent: get resources with structured JSON output, describe, logs, exec, apply/delete (user-confirmed) and port-forward.

Runs reproducible DSH profile and patch experiments with guided case authoring, assertions, Web comparison reports, recovery, and policy gates.

Automatic type-check diagnostics: after the model edits or creates TS files, runs `tsc --noEmit` in the background (debounced per project) and reports errors via the `code_check` tool — grouped by file with line/column, severity and TS error codes, closing the "edit → check → fix" loop.

Preflight checks for a DeepSeek Harness plugin before submitting it to the community list: verifies the dsh.bundle manifest, cordis.patch.yml wiring, client bundle shape, and peer ranges that silently exclude prerelease harness builds. CLI plus one read-only agent tool.

Registers a `config_doctor` tool that checks the harness's own configuration for problems that boot silently: fields a patch dropped by whole-config replacement, patches targeting missing entry ids, and tool-name collisions. Read-only.

Read-only health clinic for the installed DSH plugin set: loader health, dependency integrity, version compatibility, install-script risk, duplicates and patch integrity, delivered as a model tool, a Settings dashboard and JSON reports.

Scans the DSH loader tree at startup for plugin conflicts (duplicate mounts, failed or pending plugins, duplicate config row ids), auto-stops or restores the affected plugins, and shows a conflict report popup in the web UI.

Contract regression harness for plugin authors: a scripted LLM adapter drives the real pipeline in isolated child processes with session-event assertions (load/contract/behavior/fault layers); zero API key, CI-ready.

Reusable Markdown prompt profiles for DeepSeek Harness with per-turn model selection, argument substitution, and state restoration.

Bidirectional RPC between DSH Host and Client through the native Connection and Typert Gateway, with targeted peer calls, cancellation, and connection lifecycle handling.

Stability audit for installed dsh plugins: static risk grading (hook surface, startup work, inject, entry, dep ranges) plus optional isolated install verification.

System proxy detection (scutil/env/PAC) with a status tool and a proxy_export bash snippet tool.

/repro exports a minimal, secret-scrubbed, replayable problem bundle: the session log, failed commands, and Git diff.

Exposes the DSH dynamic-Cordis toolset to Claude Code over MCP (streamable HTTP on the existing web port, no new listener): ten tools to list, inspect, define, run, stop and permanently remove dynamic plugins in a live DSH session, with the same approval flow the GUI uses for packages that ship a client half. Bearer auth is mandatory — the token is configured on a DSH settings page, the endpoint answers 503 rather than serve without one, accepts loopback only and never emits CORS headers.

DSH-native uv environment manager: create, sync and run Python virtualenvs from the settings tab, with pip fallback, read-only conda visibility and a dry-run project sync preview.

Enforced pain-point gate: after two non-converged experiments it injects the three questions, denies non-investigative tool calls until answered, and blocks same-direction retries.

GitLab and Kubernetes monitoring for DSH: merge request and pipeline management, deployment and pod status with logs and events, webhook-triggered alerts, and a dashboard UI.

MCP management panel for DeepSeek Harness — live connection status per server (green dot), one-click pip/npx upgrades for local stdio servers with Windows file-lock handling, pause/resume/delete, an add-server form writing cordis.patch.yml, real initialize-handshake probes, and beginner-friendly usage help.

Structured machine-readable CI output for DeepSeek Harness: JSON/NDJSON session reports, JUnit XML, semantic exit codes, artifact collection and privacy redaction - a dsh profile bundle plus a standalone CLI.

Turns code review into a hard gate: deterministic severity rules, LLM-assisted findings, a team approval quorum and a durable compliance audit trail that must pass before a merge proceeds.

Self-healing runtime layer: a resource control loop with strategy switching and repair escalation, error-storm and fiber-failure insight, cross-session knowledge carry-over, a self-healing dashboard and 7 tools.

Exposes dsh's internal capabilities (language, workspace registry, agent-status and approval events) over HTTP under /dsh-api on the local loopback socket dsh already listens on, with SSE fan-out at /dsh-api/events.

Crash protection plugin that auto-isolates plugins causing startup crash or hang, with independent watchdog process for total hang recovery.

Manage and organize your agent skills by category, tags and collections in DeepSeek Harness, with a settings panel and a slash-command folder picker.

Self-editing desktop workbench for DeepSeek Harness: a full dsh web replica with an edit mode in which the agent modifies the workbench (patch layers, plugins, UI) with hot reload.

Document-code consistency guard: audits version headers / changelog tables / directory trees / module & test counts / cross-doc references for drift, with severity-sorted, read-only fix suggestions.

Windows boot autostart and one-click restart for the DSH service, from inside DSH: a resident supervisor that outlives the host, so a failed restart cannot leave DSH down; DSH spawned attached to a hidden console the supervisor owns, so no console window appears; plus a restart button, the current tokenised access URL and an optional post-start hook.

Cadence SKILL (Virtuoso Lisp) assistant for EDA engineers: official-doc-anchored API lookup (3557 entries across 5 IC6.1.8 manuals, signature confidence levels, never invents APIs) plus zero-execution static analysis driven by a lexical depth coordinate system — iterator-safe deletion with position-sensitive copy() protection, printf placeholder/argument reconciliation, in-loop nth O(N^2) detection, deprecated APIs with page refs, dangerous-intent interception and CIW error-log triage. Host half has zero third-party dependencies.

Registers /wrapped, which reads the session's own stats and renders a shareable dark SVG summary card — tool vs. thinking time, decode speed, and a tool/thinking-ratio verdict.

Keeps what the agent builds at runtime: turns a `cordis_define` dynamic package into a real installed plugin that survives restart, writing the bundle and registering the profile layer with no pnpm, no network, and no build authorization.

Read-only DSH environment health check: disk, memory, latency, ~/.dsh bloat and outdated-plugin detection with graded reports and baseline trend comparison. Deletes nothing.

Runtime plugin loading for the Web UI: a watched hot directory installs/updates client-plugin bundles live on every open page, no restart. Includes a right-column subagent dashboard example.

Telemetry backend exporting turns, model steps, and tool calls to yiTrace.

Fullscreen business-app framework for DeepSeek Harness Web with a dark-sidebar workbench bundling a database connectivity tester and SQL query panel, a two-level knowledge base (bill and accounting) with local search and Word document ingestion, metadata environment comparison with alter-SQL generation, a data dictionary, agent log-search report demos, a system test-case runner, Evernote-style notes, developer utilities, and mini-games.

Azure resource management: query and show resources, deploy Bicep/ARM templates, and check the activity log.

OpenAI Codex CLI wrapper: one-shot exec, repo review and session resume with a default read-only sandbox.

Load testing with Grafana k6: smoke-test first, then run scripts and read percentiles from the JSON summary.

Infrastructure as code: gated plan/apply, state and output inspection, and configuration validation via the terraform CLI.

Windows Package Manager: search, install, upgrade, uninstall, import/export and pin software through native tools.

Conversation header badge showing the DeepSeek Harness version, checking npm for the latest release and prompting upgrades.

Enables or disables DSH plugins from Settings → Plugins: each toggle stops or starts the plugin immediately without a restart and the change persists across restarts.

China-network bootstrap for dsh: probes npm/npmmirror/GitHub/HuggingFace/Gitee and local proxies, reads registry config, recommends mirrors/proxy, and generates a PowerShell + bash bootstrap script. Read-only by default; apply is explicit. CLI plus an agent-callable cn_boot tool.

Dependency supply-chain hygiene audit for dsh projects and profiles: peer-range resolvability, broken dist-tag detection (#2763 class), stale / missing-license / non-registry dependencies, and installed-vs-declared drift — CLI plus an agent-callable dep_audit tool.

Official GitHub Discussions radar for DeepSeek Harness: list, filter and search the official boards (Ideas / Q&A / Show Your Plugins! / General / Announcements / Polls) — CLI plus an agent-callable discussions_radar tool, dsh-discussions-radar/v1 reports, zero runtime deps, read-only public API.

Disk-usage audit for dsh data directories: total size, per-directory breakdown, largest files, oversized-file warnings (session logs can hit hundreds of MB) and cleanup suggestions — CLI plus an agent-callable disk_audit tool, dsh-disk-audit/v1 reports, zero runtime deps, read-only.

Generate llms.txt for dsh plugin repositories from package.json + README — AI-readable discovery files, zero runtime deps, read-only by default. CLI plus an agent-callable llms_forge tool.

Generate README.md for dsh plugin repositories from package.json + cordis.patch.yml + source layout — install/CLI/tools/dev/license sections, deterministic, zero runtime deps, read-only by default. CLI plus an agent-callable readme_forge tool.

Turn-based time tracking from dsh session logs: totals, per-day/project/provider/source rollups, tool-call counts, failure rates, and time-to-first-token — CLI plus an agent-callable timesheet tool, dsh-timesheet/v1 reports, zero runtime deps.

Audits installed plugin compatibility after a DeepSeek Harness upgrade, repairs or disables incompatible plugins, and keeps an out-of-host supervisor that rescues boot failures or rolls back to the previous host snapshot.

Runtime-switchable outbound HTTP/SOCKS5 proxy for DSH with a web settings card.

Real-time stage, ETA & cost dashboard for headless dsh tasks: turns the black-box session event stream into a live multi-task grid (cordis plugin + standalone local dashboard, no API calls).

Ecosystem trend dashboard (行情面板): snapshot the dsh-plugin topic and the awesome list into local history, then report weekly trends — new plugins, star gainers, category heat, awesome coverage — plus a keyword radar for new plugins and star surges.

Quality suite: background tsc --noEmit diagnostics fed back after the agent edits TypeScript, plus a /code-review command running five parallel review lenses with confidence scoring; absorbs dsh-code-check and dsh-command-code-review.

Spec-driven service forge and integrated operations workspace for DeepSeek Harness.

Manage development projects from the DSH web UI in a draggable floating window: add/remove, one-click start/stop/restart, hot-reload restart on file changes, and real-time persistent logs.

Scaffold DSH local bundles in the dph format from any workspace and keep a pitfall experience library to steer later development.

Verifies that Cordis-managed runtime resources return to baseline after isolated plugin teardown, with deterministic cleanup receipts.

Self-diagnosing, self-repairing watchdog for DSH plugins: 15s health patrol, version-switch repair with observe window and auto rollback, unknown symptoms escalated to human.

DSH plugin for bounded agent evaluation: compare an original with candidate prompt or supported configuration changes against user-supplied checks, record evidence and costs, and leave adoption to the user.

Dependency-topology guard: pre-install conflict prediction and post-install detection of duplicate @deepseek-ai/dsh-* copies, version drift, and vendored core services that cause Symbol-key crashes like "Cannot read properties of undefined (reading 'prepare')".

Per-process tool-call statistics: a `tool_stats` tool reporting per-tool call counts, error counts, and average durations.

Auto-update plugin for DeepSeek Harness — checks and updates a git-checkout or npm-global dsh plus integration repos, with ff-only pulls, automatic rollback, cancel, and an optional idle-aware auto-apply mode.

Evidence-first frontend release checks: real-browser content, accessibility, runtime, network, and baseline regression reports with screenshots.

Local-first control plane for managing multiple DSH runtimes, profiles, presets, sessions, plans, and knowledge references.

Diagnose DSH home, leftover processes, ports, and oversized sessions, then write a paste-ready /doctor report.

Take control of your tmux panes: list/send-keys/capture, run long jobs in a pane with watch mode, and approval-gated destructive commands.

Close and restart controls for DeepSeek Harness Desktop and Web on Windows, in Settings → General.

Service farm for DSH: register, start, stop and restart long-running project services, with agent tools (farm_status/start/stop/restart/logs/register), farm.yaml declarations and an overview drawer UI with live log follow, search and export.

Auto-approval agent for DSH permission requests: rule layer (denyAlways/allowlist) plus Hermes Pro semantic adjudication with quick-fail retries, fail-closed to human when Hermes is unavailable, rejection feedback returned to the requesting session, and approve tasks enqueued into the task queue with a shared busy mutex.

Mandatory cross-review for design proposals and lessons-learned: auto-detects design doc writes and enqueues them (tier=review) into the task queue, delivers the external reviewer verdict back to the initiating session, and appends approved preventive measures to OPS-GUARDRAILS.md (append-only, conflict-checked).

Hands DSH reset requests to an external ops agent via a versioned JSON protocol: preflight snapshot, pre-restart maturity gate (no pending approvals, free disk, cooldown), restart, health check, and interrupted-work recovery, with the result delivered back to the requesting session.

Tiered task queue as the single source of truth for DSH↔Hermes work (reset > approve > review): enqueue tools for all submission paths, lease/claim model with concurrency 1, priority aging against starvation, atomic busy mutex, and a Hermes-side consumer (cron */1 + monitor gating) that drains tasks, writes review-handoff requests with single-slot checks, and invokes the reset agent.

Audits a DSH profile for capabilities nothing consumes: inventories the declared composition rows, counts how often each registered tool and skill is actually called in the session logs, separates calls that were made from calls that returned a result, and reports the ones with no observed consumer. Ships a skill that fixes the evidence-chain format for completion claims.

Real AST-based scan of installed plugins for malicious-intent patterns (dynamic eval, cross-plugin writes, exfiltration-shaped network calls), with an optional periodic schedule and auto-quarantine on critical findings.

Minimal-anchored agent preset: request #1 keeps the real bash + str_replace_editor pair with auto-injected context stripped, then promotion unlocks the full Standard catalog and posts a one-shot background-jobs notice against sleep-polling habits.

Complement to official Creator mode: stage, validate, live-mount via ctx.plugin, score, and solidify or roll back in-memory tool-plugin trials.

Provider-scoped HTTP/HTTPS forward proxy for DeepSeek Harness: configure independent proxy URLs and enable/disable switches per LLM provider, with environment-variable references for proxy credentials and model discovery routing.

S3-compatible backend for the spill seam: oversized tool output goes to object storage (S3, MinIO, R2) with hashed session prefixes and unguessable keys, instead of the agent's local disk.

Aborts startup when another live dsh instance holds the same DSH_HOME data directory, preventing the concurrent session-log writes that corrupt transcripts.

Manage Proxmox VE through conversation: 116 read + 116 write tools covering VMs, containers, storage, nodes, clusters, backups and firewalls, with API-token or username/password (ticket) auth.

Microsoft Agent Framework (MAF) plugin for DeepSeek Harness: validate, run, and scaffold declarative agents and workflows (YAML).

WSL (Windows Subsystem for Linux) bridge for DeepSeek Harness: run Linux commands, manage distros, convert paths, and copy across the Windows/Linux boundary.

Native DSH right-sidebar tab that lists the ports this machine is listening on together with the process behind each one, and offers per-port actions to open it, copy its address, reveal its working directory or end the process.

A development safety kit: rolling config snapshots, automatic rollback on plugin failures, boot-failure rescue, and an in-settings management panel.

A hands-off safety net: directories the agent deletes go to a trash folder first and symlinks are never followed, with zero approvals.

Preview native WeChat Mini Programs in the DSH sidebar with a local runtime and WXML source locations.

Crash protection for installed plugins: crash cards with one-click disable, static pre-flight inspection, black-box crash telemetry, and a safe-mode rescue profile for a broken UI.

First-run health check for DeepSeek Harness: verifies Node/pnpm/dsh toolchain, home, profile, API key (names only, never values), workspace writability and npm registry, then prints actionable next steps — CLI plus an agent-callable quickstart tool, dsh-firstrun/v1 reports, zero runtime deps.

Verification-driven self-evolution loop: failure logs become verified AGENTS.md rules; in-session plugin (evolve_learn / evolve_apply / evolve_touch / evolve_recall), tool-verify gate, rule lifecycle, local recall.