dsh-think-ultra v0.1.0 - Think Ultra Complete Official Release

Think Ultra v0.1.0 — Complete Official Release

Think Ultra is the heavy, local reasoning layer for the official DeepSeek Harness (DSH). This is its first stable, complete release.

It does not change a single byte of the model. It changes how much compute surrounds every request. The floor is welded to DeepSeek's native maximum effort; everything above it is built out of real, additional, independent maximum-effort calls — more samples, more judges, more verification, more reconciliation — running entirely on your machine, with zero network calls of its own. This release turns the earlier experimental preview into a finished product: four isolated surfaces, a 0–20 global capability control, an over-clocking mode engine, a 46-axis reasoning kernel, an L1–L5 metacognition core, seven deterministic Rust engines, and a hardened, self-defending build.

---

1. What "Ultra" actually is

DeepSeek's API exposes four reasoning efforts: off, low, high, max. There is no fifth. Send reasoning_effort="ultra" and the provider rejects the request outright. Think Ultra never makes that mistake.

It wraps the already-registered provider adapter with a proxy. The proxy adds an Ultra row to the native dropdown, and on the way out — in both the streaming and the prepare-call paths — it maps ultra back to max, the strongest effort the API actually accepts. That mapping is cached per (provider, model), so the models never overwrite each other.

So the floor is welded to native max, always. Ultra is not a magic word sent to the model — it is the machinery that runs around and above a max call. Raising a slider widens that machinery; it never changes the word in the request.

It is not a prompt wrapper. The gain is meant to come from test-time compute, not adjectives in a system prompt. Every heavier tier issues real, additional, independent max calls through Harness's own llm surface, then reconciles them.

---

2. Four fully isolated surfaces (new in v0.1)

State no longer mixes across model × mode. Think Ultra keeps four surfaces, each persisted independently — slider positions, toggles, mode, authorization state and directives are stored per surface and never bleed into one another:

	Velocity (迅流) — the base	Apex (极境) — the strict superset
Flash	Flash · Velocity: single-chain direct reasoning, N=1, no voting, no rollback, lowest latency	Flash · Apex: swarm coverage, wide fan-out, maximum iteration density
Pro	Pro · Velocity: the strong model on a fast, direct path	Pro · Apex: elite deep push, deeper tournament and the full metacognitive stack

• Velocity is the base. It is a clean, fast, single-chain mode: one chain, one pass, minimal latency. Switching back to Velocity resets all advanced parameters so nothing from Apex lingers.
• Apex is built on top of Velocity. Apex is the over-clocking layer — the base is still there, but the OC (over-clocking) engine, tournament and verification stack are armed on top of it.
• Switching model or mode is a clean state transition, animated smoothly, with a per-surface default state for first-time users.

A locked, greyed third mode exists purely as a placeholder for the future; it is not clickable and schedules nothing.

---

3. Global capability control — the 0–20 slider (new)

A single global capability slider sits next to the conversation input and in General Settings, rendered immediately after the permission row. It is the one number that drives the whole reasoning ceiling.

• It exists only on Ultra. It is gated on the model being on an Ultra inference tier. On any non-Ultra tier (Max / default) it is greyed out, frozen, and unclickable — and it appears in the same language as the rest of the UI.
• Range 0–20, 20 is the deliberate ceiling. Each notch maps a real model × mode × tier matrix to the actual intensity of every axis. It is a view over the essence engine, not an independent flag.
• Notches escalate the depth of reflection, branching and verification. The 19→20 step is intentionally a sharp discontinuity: 20 arms the full chain (over-clocking, tournament voting, recursive reflection, maximum token headroom, the complete quality ceiling).
• It remembers. Slide from 16 to 18, and the next launch is still 18. First-run users start at 5; a fresh schema reset cleans legacy state.
• A popup describes every notch, the jobs it suits, and the future headroom.

---

4. A 46-axis reasoning kernel, presented as 7 / 10 / 8 main rods

The raw power surface is 46 independent engine axes, each consumed by its own engine and written into a single authoritative essence structure — there are zero fake controls. For daily use they are folded into a small set of master rods (Flash 7, Pro 10, Vision 8) that drive the underlying rods in batches; an advanced panel lets you micro-tune all 46.

Seven magnetic notches per axis — off, low, medium, high, ultra-high, extreme, zenith — with an additional locked "ultimate" visual tier. Per-axis and per-model ceilings differ on purpose, leaving headroom for later builds.

• Reasoning depth / breadth / falsification / memory / execution convergence / compression / planning form the common backbone.
• Pro adds formal assault (proof / coherence / calibration / code), meta-reflection (meta / abstraction / reflection / replay), and topological reasoning (fractal / recursion / fusion / cross-model / axiom / synthesis).
• Vision adds tile close-reading, cross-checking, zoom, tracking, spatial reconstruction, dense OCR and visual counterfactuals.
• Stability rods (agent, consist, heal, longcode, reclaim) keep multi-agent coordination alive, preserve consistency across long runs, fuse and retry silently, and reclaim idle resources.

---

5. The metacognition core chamber, L1–L5

A dedicated director resolves the whole configuration into a single scheduling vector with non-linear budget amplification:

• L0 Off · L1 Linear · L2 Devil's Advocate · L3 Multi-Jury · L4 Frame Deconstruction · L5 Recursive Self-Reference — ×1 / 1.05 / 1.35 / 1.9 / 2.8 / 4.2 structural budgets.
• Red enhancements (3): counterfactual branch forest, provenance audit, meta-contradiction resolution.
• Black extremes (6, Pro/Vision only, L4+): recursive doubt stack, thought-experiment sandbox, blind-spot scan, fractal nesting, conclusion-self-kill, multi-conclusion coexistence.
• Lab (4, unlocked by typing the risk phrase): probability field, infinite recursion, cognitive deconstruction, counter-intuitive forcing.
• Abyss (6, L5+, with intensity): ontic suspension, strange self-reference, modal collapse, axiom drift, infinite observer regress, semantic vacuum rebuild.
• Every higher notch is monotonic — structure, budget and engine set only ever grow, never weaken. Flash can never reach the black tiers.

---

6. Seven deterministic Rust engines (std-only, zero dependencies)

An optional native core, written in Rust with the standard library only — no network APIs, no third-party crates, a hand-written JSON parser over line-delimited stdio JSON-RPC. Everything stays on the machine.

1. meta_rules — axiom / paradigm / truth-standard override with compliance checks.
2. output_modality — how much of the reasoning process is visible.
3. cross_model — thinker / critic / deconstructor / experimenter / synthesizer role waves with trust-weighted fusion.
4. runtime_guard — dev-only policy; the shipped build performs no real anti-debug self-destruct, fingerprinting, or network call-back.
5. ultra_orchestrator — an 8-wave execution plan (anchor → main reasoning → meta topology → red boost → black extreme → proof circuit-break → fusion collapse → output projection).
6. probability_field — hypothesis distributions, Shannon entropy, Bayesian collapse, dual-peak interference, jury pooling, a self-feedback convergence loop.
7. policy_compiler — deterministically reduces the astronomical slider×tier×chamber combination space into a handful of finite strategies with a monotonic seal.

If the native binary is missing or blocked, the plugin transparently falls back to a built-in JS engine; nothing crashes.

---

7. The OC over-clocking engine (Velocity → Apex)

In Apex, the over-clocking pipeline runs: multiple candidates → 2-gram clustering → self-consistency voting → cross-verification → falsification elimination → confidence ranking → optimal synthesis. A live strip shows candidates, eliminations and confidence. Flash Apex leans on a swarm for wide coverage; Pro Apex uses a smaller, elite set pushed deeper.

---

8. Reasoning stack and toolboxes

The test-time layers, from cheap to expensive:

• L1 tournament — several independent max samples, a separate adjudicator pass, a repair pass aimed at the concrete defects the judge named, and only the strongest candidate is delivered.
• L1.5 executable verification — anything computable (arithmetic, pure functions, dates, complexity claims) is extracted as an assertion and actually executed in an isolated local VM. A failed assertion is hard evidence, not an opinion.
• L2 cross-review — the main answer is audited by an independent pass; only the specific faults found are patched back in.
• L3 multi-paradigm forward forge — the problem is solved again under several different paradigms; at least two independent routes must agree.
• Recursive reasoning tree — the root fans out into viewpoints, each layer is judged, and a falsification pass tries to kill the leading answer.
• Model-callable toolboxes — 30 professional tools across five boxes (code, documentation, learning/creative, data, productivity) plus 21 layered reasoning tools, with a three-layer fuse (per-tool wall-clock, per-turn, token budget). The model function-calls them itself, only on Ultra sessions.

Around these sit a metacognition loop, a multi-agent schedule...