Preface

Exploring ideas in DeepSeek Harness (DSH) often involves continuous follow-ups within a single session. As directions multiply, context becomes cluttered, and branches risk cross-contamination. Starting a new session solves isolation but requires manual copy-pasting to transfer conclusions from parent branches or progress from sibling branches.

Below introduces DSH Solo Thinking (npm package name: dsh-plugin-solo-thinking). It organizes brainstorming into a thinking tree, where each direction corresponds to an independent DSH Session. Cross-branch information is exchanged only through Handoffs actively written by the Agent. This capability originates from the Thinking module of the Solo project and was ported to the DSH plugin system by maintainer fredalxin. It is categorized as a “Workflow” in the SkillHub plugin directory.

What This Is

DSH Solo Thinking is a workflow plugin for DSH 0.1.0-rc.6. In one sentence: Solo-style isolated brainstorming branches, automated Handoffs, and a visual thinking tree.

Compared to “multi-turn divergence in a single session,” its key differences lie in Session-level isolation and an explicit Handoff protocol: branches have independent conversations and lifecycles, sibling branches are not automatically awakened in the background, and each only reads the latest Handoff during its next explicit model turn.

Core Features

Thinking Tree & Independent Sessions

  • Default Suggestion Mode: When information is sufficient, the Agent can automatically create 2–4 truly independent directions (preferring 4, without splitting just to fill numbers).
  • Independent Sessions: Each node has its own conversation, state, and lifecycle; suggested nodes remain dormant until activated by the first message.
  • Workspace Inheritance: Branch persistence is attached to the parent Session’s Workspace, avoiding the “Ungrouped” category.
  • Input Isolation: The main input box only sends to the current Session; messages can be sent directly from the thinking tree to other selected branches; only “Enter Conversation” triggers navigation.

Automated Handoffs

Branch inheritance, Current State, sibling awareness, and Return summaries are all automatically written by the Agent—no manual writing required. Handoffs use concise Markdown, covering objectives, confirmed conclusions, evidence, risks, open questions, and next steps.

Cross-branch information comes only from explicit Handoffs; the plugin does not read other branches’ raw conversations or call external network services.

Interface & Compatibility

When only Solo Thinking is installed, a full “Brainstorming” tab appears at the top of the conversation, with all Host-side Thinking capabilities available.

If DSH Better Sidebar >=0.12.1 is also installed, you can view the thinking tree, select nodes, control branches, and send messages directly from the right sidebar. Better Sidebar is an optional peer dependency for the right sidebar feature; if not installed, the full top tab remains usable.

Installation Combo Full Top Tab Right Sidebar
Official DSH 0.1.0-rc.6 + Solo Thinking ✓ —
Plus Better Sidebar >=0.12.1 ✓ ✓

Replayable Persistence

Tree state is written to DSH’s append-only Session events and restored via Projections. Uninstalling the plugin does not proactively delete historical Session data.

Installation & Activation

Requires Node.js ^22.19.0 || >=24.0.0 and DSH 0.1.0-rc.6.

DSH currently does not auto-mount transitive dependencies, so both plugins must be listed as direct dependencies in the profile:

dsh plugin --profile web add dsh-better-sidebar dsh-plugin-solo-thinking

Both packages are published on the official npm Registry; when no version is specified, the latest tag is installed. After installation, they are auto-mounted via their respective dsh.bundle.patch files.

One-Line Installation (Latest Release)

macOS / Linux:

curl -fsSL https://raw.githubusercontent.com/fredalxin/dsh-solo-thinking/main/scripts/install.sh | bash

Windows PowerShell 5.1+ / pwsh:

irm https://raw.githubusercontent.com/fredalxin/dsh-solo-thinking/main/scripts/install.ps1 | iex

The installer first processes the build allowlist for Better Sidebar, then downloads and verifies the prebuilt Solo Thinking .tgz, and finally mounts it via the official dsh plugin add. Example with pinned version:

curl -fsSL https://raw.githubusercontent.com/fredalxin/dsh-solo-thinking/main/scripts/install.sh | bash -s -- 0.1.19

Avoiding Remote Scripts: Pinned GitHub Tag

dsh plugin --profile web add github:fredalxin/dsh-solo-thinking#v0.1.19

Post-Installation Startup

dsh --profile web --dump-config
dsh --profile web

If running DSH from source, replace dsh with pnpm dsh in the commands. After installation, restart DSH and hard-refresh the browser.

Uninstallation:

dsh plugin --profile web remove dsh-plugin-solo-thinking

Typical Usage

30-Second Start

In a normal DSH conversation, say:

Start brainstorming. The topic is "Build a local AI workbench for indie developers."
Please diverge first; if there are multiple directions worth deep exploration independently, create suggested branches directly.

The Agent will invoke thinking_start, then call thinking_suggest when appropriate. Suggested branches are created but not auto-run; click a node to view its Handoff, or send a message in the tree to activate that branch.

Thinking Tree Operations

  • ＋ Split: Only fill in the direction name; the parent Agent automatically prepares a targeted Handoff for the new node.
  • ● Progress: Have the current branch organize its Current State from the full conversation for the next model turn of sibling branches.
  • ✓ Return: The branch Agent writes a final Handoff, returns it to the parent node, and seals the current branch.
  • ■ End: Ends and clears the interface state of the current thinking space; historical Sessions and Handoffs are preserved and can be used to start a new tree.
  • Enter Conversation: Explicitly navigate to that Session; clicking the node itself only selects it without navigation.
  • Branch Input Box: Send a message to a non-current branch; the main Session remains in the middle.

Thinking Tools

Tool Purpose
thinking_start Establish a brainstorming space in the current Session
thinking_suggest Create 2–4 dormant suggested directions at once
thinking_split Agent autonomously splits and writes a targeted Handoff
thinking_fork_handoff Supplement a manually created node with the parent branch’s Handoff for inheritance
thinking_checkpoint Publish the Current State of this branch
thinking_return Submit the final Handoff to the parent branch and seal the current branch
thinking_end End the entire tree and allow the original Session to restart
thinking_status Read the current node and entire tree state

Use Cases & Considerations

Who It’s For: Developers who need to explore multiple solution directions in DSH in parallel while keeping branch contexts controllable. Especially suitable for scenarios like architecture selection, product direction divergence, and technical solution comparison that require “divide and conquer” followed by synthesis.

Boundary with Full Solo: This plugin only ports the core invariants of Thinking and does not include Solo’s Channel, Team Agent relationships, PostgreSQL, daemon, or CLI management. DSH Sessions replace Thinking Node message scoping, and DSH persistence replaces process pools and database bindings.

Security & Permissions: The plugin runs with the current DSH process permissions. Before installation, check the source code and MIT License. curl | bash / irm | iex executes remote installers from a public repository; if this trust model is unacceptable, use the transparent official CLI one-liner or first download and review scripts/install.sh / scripts/install.ps1. For production, consider pinned npm versions, GitHub tags, or Release-verified installers.

Ecosystem Note: DSH’s philosophy is “everything is a plugin”; SkillHub is a community-maintained plugin directory and is not officially affiliated with DeepSeek / High-Flyer.

Conclusion

DSH Solo Thinking transforms brainstorming from a single-session long conversation into a Session-isolated, Handoff-driven thinking tree. After installing the plugin, a single natural language utterance can initiate divergence; branch dormancy, progress synchronization, and return summaries are handled by the Agent and toolchain.