Preface¶

Under the “everything is a plugin” philosophy of DSH (DeepSeek Harness), two common issues arise when agents execute complex tasks: first, every task starts planning from scratch, lacking reusable historical approaches; second, if rules are hard-coded directly, they tend to mismatch when tasks evolve.

dsh-task-planner addresses this by treating historical approaches as an experience base, allowing the model to recall similar past plans before starting a task, then evaluate whether the current task is suitable for reuse, and finally generate a step-by-step plan. Below, we introduce its positioning, core capabilities, installation methods, and typical usage.

What This Is¶

dsh-task-planner is a task planning plugin for DeepSeek Harness, positioned as “task planning with experiential muscle memory.”

Verified package information:

• Package name: dsh-task-planner
• Version: 1.0.0
• Type: module
• Main entry: index.mjs
• License: MIT
• Plugin patch file: ./cordis.patch.yml
• GitHub repository: https://github.com/ztl34245881-commits/dsh-task-planner

It primarily solves four types of problems:

1. Generate a plan before starting complex tasks, rather than executing directly.
2. Consolidate experience from completed tasks into editable Markdown files.
3. Match steps against an optional capability catalog during planning.
4. Add a “humanize-then-review” requirement for text delivery steps.

Core Features¶

Experience Base¶

The plugin provides task_memory save/recall/list capabilities for saving, recalling, and listing experiences.

Experiences are saved in plain Markdown format with signature keywords. The default experience base path is:

~/.dsh/planner-lessons

These experience files are suitable for manual editing, retrieval, and migration.

Reflexive Planning¶

The main flow of plan_task is:

1. Recall similar past plans based on the current task.
2. Have the LLM evaluate whether those plans are suitable for the current task.
3. If suitable, reuse and improve them; if not, explain the reasons and re-plan.
4. Output decomposed steps, combined with capability matching, risks, and next actions.

The judgment here is performed by the model; the plugin primarily provides historical experience context and an optional capability catalog context.

LLM-Driven, Not Rule-Driven¶

dsh-task-planner does not hard-code fixed combinations into tasks. The model decides based on the current task which historical experiences to use, how to break down steps, and how to match capabilities.

The context provided by the plugin mainly includes:

• Content from the historical experience base
• An optional Markdown capability catalog

Text Delivery Standards¶

The plugin requires text output steps to go through a “humanize-then-review” process before delivery.

The focus here is adding a layer of humanization processing and review before delivery, rather than outputting raw text results directly.

Automatic Experience Consolidation¶

plan_task automatically writes an experience draft with the status:

draft

When the task concludes and the workflow closes, the agent updates the experience outcome and marks the status as:

verified

This allows the process of a single task to gradually consolidate into reusable experience.

Zero Keys, Zero Absolute Path Constraints¶

The plugin emphasizes configurability. The default experience base path is:

~/.dsh/planner-lessons

If you wish to use a different experience directory or capability file, you can modify it through configuration options.

Installation and Enablement¶

Before installation, confirm that the current dsh environment is available. The GitHub installation command in the README uses the placeholder <your-user>, not necessarily a command specific to a particular owner:

dsh plugin --profile web add github:<your-user>/dsh-task-planner

If you already have the repository locally, you can also add it as a local bundle:

dsh plugin --profile web add /path/to/dsh-task-planner

The plugin’s package.json declares the DSH bundle patch file:

{
  "dsh": {
    "bundle": {
      "patch": "./cordis.patch.yml"
    }
  }
}

Therefore, when enabled, the plugin reads cordis.patch.yml from the repository as the patch entry point.

The plugin requires the following services to be available:

llm
shell
tools

The README states that these services already exist in the standard harness.

Model invocation uses the harness default model:

agentDefaultModel

If using a reasoning model, sufficient space must be reserved for maxTokens. The README mentions internally using 8k.

Typical Usage¶

Planning Before Starting a Task¶

For complex tasks, call plan_task first:

plan_task { task, goal?, constraints? }

This step generates a plan before execution, rather than entering execution directly.

Saving Experience¶

To manually save an experience, use:

task_memory save { task, plan, outcome }

plan_task also automatically calls this capability to write draft experiences.

Recalling Experience¶

Perform reflexive recall based on the task description:

task_memory recall { task }

Viewing the Experience List¶

To view all experiences:

task_memory list

Experience Lifecycle¶

Experience status progresses according to the task loop:

1. plan_task automatically writes a draft experience:

status: draft

2. After the task concludes and the workflow closes, the agent updates the result and marks it as:

status: verified

3. If an experience is successfully reused 3 times, it can be promoted to a formal skill.
4. If an experience is rejected 2 times, it should be marked as obsolete.

Optional Configuration¶

In the profile’s cordis.patch.yml, you can configure the experience directory and capability file:

- id: dsh-task-planner
  name: dsh-task-planner
  config:
    lessonsDir: /path/to/your/lessons
    capabilityFile: /path/to/capability-map.md

Where:

• lessonsDir: Points to the experience directory, defaulting to ~/.dsh/planner-lessons.
• capabilityFile: Points to a Markdown capability catalog, provided as context to the LLM.

By pointing capabilityFile to a skills, plugins, or tools inventory, planning steps can align more specifically with existing capabilities.

Applicable Scenarios and Considerations¶

Suitable for the following situations:

• Building agent workflows with DSH that involve many task steps.
• Wanting repeated tasks to gradually consolidate into Markdown experiences.
• Wanting planning to incorporate a capability catalog rather than relying purely on prompt-generated content on the fly.
• Having quality requirements for text delivery and wanting to add a “humanize-then-review” step.

Points to note before use:

1. The plugin runs with the permissions of the current dsh process. Before installation, inspect the source code, dependencies, patch files, and license.
2. The license is MIT.
3. Runtime dependencies include the llm, shell, and tools services.
4. The default experience base path is ~/.dsh/planner-lessons.
5. Model invocation uses agentDefaultModel; reasoning models require sufficient maxTokens.
6. Experience files are plain Markdown and can be edited directly, but status transitions should still follow lifecycle conventions such as draft, verified, and obsolete.

Conclusion¶

The value of dsh-task-planner lies in transforming task planning from one-time generation into an experiential process that can be consolidated, edited, and reused: first recall similar experiences, then let the model judge applicability, and finally generate a step-by-step plan while updating the experience status.

GitHub repository:

https://github.com/ztl34245881-commits/dsh-task-planner

The community directory can be searched by package name dsh-task-planner for the corresponding page. The DSH community directory is an independent site with no official affiliation to DeepSeek / High-Flyer, nor is it an official app store.