Preface¶

DSH’s positioning is “everything is a plugin”: models, tools, memory, and interfaces can all be provided by plugins, and the session itself is not responsible for maintaining cross-turn personas. When building “long-term companions” or “assistants with their own memory,” the common practice is to stuff history into the context every time, or write a pile of scattered markdown memory files and stuff them back into the prompt. The problems with this path are easy to list: context gets eaten up by history, memory lacks forgetting and archiving mechanisms, persona settings and runtime data are mixed together, and migrating to a new machine is also troublesome.

The plugin introduced below, muvuula/deepseek-harness-core (named mcore.fit inside the repo, package name @muvuula/mcore, formerly DHC / DeepSeek Harness Core), takes a different path: it treats itself as a resident kernel, loaded into the DSH process, managing persona, memory, and timeline, and exposing HTTP APIs and model-callable tools externally. Data stays on the local machine, and persona data is migrated only via explicit export/import.

It was developed by maintainer muvuula, categorized as “Memory” on the community directory page, and starred as 2. The README badges show version v0.72.1, platforms Windows / macOS / Linux, tests 4 suites · 74 asserts, license MIT. Inside the repo’s package.json, the version field is 0.74.0; there is an inconsistency between the two, so the version actually installed takes precedence.

What is this¶

One sentence: A DSH plugin that turns “persona + memory + sense of time” into a resident layer, calling itself the “Self-Fitting Local AI Kernel Framework” (mcore.fit — Core your model, Fit the reality).

It aims to solve the problem that an agent’s personality shouldn’t be hardcoded in prompts, but should self-update during long-term interaction with the owner; memory shouldn’t blindly pile into context, but needs layers, forgetting, archiving, and automatic compression; and this data should not leave the local machine.

Core Capabilities¶

Persona Composition: Four-Piece Set plus Five Organs¶

README breaks down the persona into modules, each with an independent version. Evolving a module increments that module’s version by +0.01:

The “Five Organs” are not inlined into mcore code, but are five independent plugins, which mcore calls via the harness’s global tool system: Eyes ModLens (visual bridge read_image), Left Hand dsh-at-file (@ file reference), Right Hand dsh-genui (render_ui), Feet dsh-automation (scheduled tasks), Mouth/Workspace dsh-better-sidebar. README explicitly warns not to inline them, otherwise you get duplicate factory registration and a white screen.

This is the biggest difference between it and “custom-prompting personality”: personality is runtime state with its own versioning and upgrade mechanism, not static text.

Three-Layer Memory and Context Compression¶

Memory is divided into instant/short-term/long-term layers, plus forgetting/archiving. AI automatically collects during interaction, retrieval uses persona_recall semantic search rather than full backfill.

Context side does compression: persona_compact folds old memory into long-term summaries. README says it auto-compresses at zero tokens when memory exceeds 90%. This is the main means to alleviate context bloat.

Also, it distinguishes “Knowledge” from “Skills”: Skills record “how to” (steps/traps), personal knowledge inventory records “what/why” (facts/parameters/specs/stance), corresponding tools are persona_kb_save / persona_kb_search / persona_kb_list / persona_kb_use, and /api/dhc/kb* endpoints, automatically recalled by topic.

Timeline and Growth¶

Chrono (Time Evolution) is the section heavily emphasized: Trace back past (recover forgotten knowledge via history backup), foresee future (growth curve prediction + risk), fold time (4D decision making), auto upgrade (GitHub detection, auto-execution in L4 low-risk scenarios), levels transition linearly from L0 to L4. The Free Will section mentions autonomous decision/action/evolution under L4, the core iron law is the boundary of freedom: do not harm owner, do not destroy system, do not violate personality profile, do not leak privacy.

This section is largely narrative design; validity depends on long-term running results; README doesn’t provide quantitative conclusions.

The Pet is a Separate Layer¶

According to the 2026-11-03 split, pets are divided into two layers and communicate only via HTTP: Rendering (illustrations/animations/bubbles/physics/desktop window + /dsh-pet-7340/* host routes) is provided by a separate dsh-pet plugin; the bridge between persona/emotion/relations/long-term memory and the pet (/api/pet/*) is provided by this package mcore. The two layers do not import each other.

Do not enable both sides: When MCORE_PET_HOST=1 (default 0 in README table) and dsh-pet are present simultaneously, the /dsh-pet-7340/* prefix gets duplicated. Symptoms are the pet appearing intermittently, or rendering two pets on the webpage.

Installation and Enablement¶

Prerequisites¶

1. Node ≥ 22 (maintainer’s dev machine is 26; plugin itself is not affected by this requirement).
2. DeepSeek Harness CLI (dsh) installed and dsh web successfully run once.
3. This package’s dsh.client.inject depends on @deepseek-ai/dsh-client-*, benchmark verified with DSH 0.2.1-rc.2, earlier rc unverified.
4. Port 3080 is free, listening only on 127.0.0.1.

Note the package name: mcore on npm is another project (v1.0.2), this plugin is @muvuula/mcore, README explicitly says do not use dsh plugin add mcore.

Three Installation Paths¶

Path A: Local tarball (suitable for distribution to others)

# Package in source machine's source directory
npm pack                        # Output mcore-0.72.1.tgz, approx 61 MB, pet assets are the bulk
# Give tgz to the other party, they execute
dsh plugin --profile web add file:/absolute/path/mcore-0.72.1.tgz

The compressed package is approx 61 MB, of which 106 webm animations take 51.8 MB, fonts 3.9 MB, memes 4.6 MB, nested dependencies 5.4 MB, main program code is less than 2 MB. README reminds that these assets are used for real rendering by this package’s host when MCORE_PET_HOST=1 (default), so they are not stripped by default.

A known pitfall: npm’s built-in tar parser is unstable at the 60 MB level, might throw npm warn tar zlib: incorrect data check or npm error Z_DATA_ERROR. This is not a corrupted package; the same tgz works fine with full zlib decompression and per-entry checksums. README’s testing shows about 1 failure in 3 consecutive installations; after failure, clearing cache and reinstalling basically passes:

npm cache clean --force
# Or bypass public cache: add --cache <a blank directory>
# Then re-run the dsh plugin ... add command above

To root out the issue, assets need to be split into independent packages (@muvuula/mcore-assets), listed as known TODO in README, not yet implemented. Also, the repo does not store these binaries (.gitignore excluded), need to run node scripts/import-pet-assets.mjs to copy assets from a clean clone before packaging, otherwise the package has no animations (bubbles might still appear, but screen doesn’t move).

Path B: Repository or npm direct install

gh auth login                     # Need to authorize first for private repo
dsh plugin --profile web add github:muvuula/DeepSeek-Harness-Core#v0.72.1
dsh plugin --profile web add @muvuula/mcore@0.72.1   # npm registry, no GitHub auth needed

Path C: Point to local directory (maintainer dev use, changes take effect immediately)

dsh plugin --profile web add file:C:/path/to/DeepSeek-Harness-Core

Pet Rendering Layer¶

If you need the pet’s appearance, install the rendering layer:

dsh plugin --profile web add @muvuula/mcore   # Persona core + pet bridge
dsh plugin --profile web add dsh-pet          # Rendering layer

If you don’t want to use the pet, you can turn off the bridge: MCORE_PET=0 (no bridge or scheduled sync, persona core works normally).

Post-Installation Self-Check¶

After installation, restart dsh web. MCore takes effect globally, any preset session will have it. Then do two curl checks:

curl -s http://127.0.0.1:3080/api/dhc/state       # version / workspaceRoot / heartbeat
curl -s http://127.0.0.1:3080/api/dhc/selfcheck   # consistency self-check

Typical Usage¶

The actionable examples given in README focus on interfaces and migration channels. Going through the following order verifies the whole system is running:

1. Start service and confirm bound address. MCore only listens on port 3080 on 127.0.0.1, suitable for local private use; do not expose it to the local network.

2. View runtime status.

curl -s http://127.0.0.1:3080/api/dhc/state

The return content includes version, workspaceRoot, and heartbeat, used to confirm the plugin has loaded with dsh web.

3. Run consistency self-check, confirm persona data, memory, and event bus states are not misaligned.

curl -s http://127.0.0.1:3080/api/dhc/selfcheck

4. Read/write knowledge base. Use persona_kb_save to record facts, persona_kb_search to retrieve, avoiding mixing “what” and “how”.

5. Observe if memory can handle the load. After long sessions, persona_compact folds old memory into long-term summaries; README says it auto-compresses at zero tokens when memory exceeds 90%.

6. Migrate persona to another machine. Only use the export/import channel:

# Export (soul/export), get persona data that can be moved
# New machine imports (soul/import) to restore

README emphasizes persona data doesn’t go into repo or npm packages, release-check does pre-release validation (called “open source isolation” gate in README). Screenshots in the repo have blurred out machine codes, local absolute paths, original dialogue text, and network config.

7. If dsh-pet is installed, interactively view pet and emotional trajectory on the webpage. If not installed and just want to verify functionality, the self-check above is enough.

More detailed interface list (all HTTP API endpoints, model tools list) is listed in the repo README’s table of contents; this article doesn’t expand on each one individually, check directly when needed.

Mounting the Five Organs Plugins¶

If you need this set of persona components to have real capabilities, install in the following order (official channel):

dsh plugin --profile web add @liustack/modlens@latest            # Eyes: read_image visual bridge
dsh plugin --profile web add "git+https://github.com/omdsh-dev/dsh-at-file.git#v0.4.1"   # Left Hand: @file reference
dsh plugin --profile web add git+https://github.com/omdsh-dev/dsh-genui.git             # Right Hand: render_ui
dsh plugin --profile web add github:titanwings/dsh-automation#v0.1.5                   # Feet: scheduled autonomous tasks
dsh plugin --profile web add dsh-better-sidebar@0.11.0                                  # Mouth/Workspace

These are independent plugins; maintainers install them once in ~/.dsh/profiles/web/; mcore calls them via the harness’s global tool system, no need to inline their code into mcore.

Applicable Scenarios and Notes¶

Who is it for: Assistants you want to run in DSH with continuous persona, long-term memory, and data staying local, and can accept a package significantly larger than ordinary tool plugins; if you write your own memory management framework, this is equivalent to directly reusing these four things: versioning, forgetting/archiving, auto-compression, and migration channels.

Points to note:

1. Install running under current dsh process permissions. Read the source code (docs/DEVELOPMENT.md, docs/PRIVACY.md in the repo) before installing to confirm directories and ports it reads/writes locally match expectations.

2. License status “as stated in material” has a conflict. The README badges and acknowledgments on GitHub currently say MIT, freely usable/modifiable/distributable; but the top of the README in the v0.72.1 tag of the same repo says “This repo is private source code, not open source released: for personal use, please do not redistribute source code or package artifacts”, license section title is “Proprietary · Source visible, not Open Source”. Please verify the latest LICENSE and repo description yourself before installing or redistributing.

3. Package size and npm tar parser instability are known issues, see reinstall instructions above.

4. Node version must be ≥ 22, DSH version should not be lower than 0.2.1-rc.2.

5. There are two switches for pet-related features: MCORE_PET_HOST (default 0, enables mcore’s built-in host) and MCORE_PET (0 turns off pet bridge). Do not enable both with dsh-pet.

6. Ecosystem context: DSH is a plugin framework, the community directory site (skillhub.cn) is an independent site with no official affiliation to DeepSeek / Fudan, do not treat plugins as official products.

Conclusion¶

The value of mcore.fit lies in moving cross-session runtime states (persona, memory, timeline) from prompts and manual markdown into a kernel with versioning, forgetting mechanisms, and only export/import channels. It’s not small, pet assets take up the bulk, and the installation path also has known instability points, but the functional boundaries and data flow are relatively clear, suitable for evaluating this solution before starting to self-develop a “long-memory assistant” from scratch.

Directory page: https://www.skillhub.cn/plugins/muvuula/DeepSeek-Harness-Core
GitHub: https://github.com/muvuula/DeepSeek-Harness-Core