simjecture 0.1.1__tar.gz → 0.2.2__tar.gz

{simjecture-0.1.1 → simjecture-0.2.2}/.github/workflows/release.yml

@@ -24,6 +24,27 @@ jobs:
           python-version: "3.12"
       - name: Install build frontend
         run: python -m pip install uv
+      - name: Install sandbox runtime
+        run: |
+          sudo apt-get update
+          sudo apt-get install --yes bubblewrap
+          if sysctl kernel.unprivileged_userns_clone > /dev/null 2>&1; then
+            sudo sysctl -w kernel.unprivileged_userns_clone=1
+          fi
+          if sysctl kernel.apparmor_restrict_unprivileged_userns > /dev/null 2>&1; then
+            sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0
+          fi
+          bwrap --unshare-all --die-with-parent \
+            --ro-bind /usr /usr \
+            --ro-bind /lib /lib \
+            --ro-bind /lib64 /lib64 \
+            /usr/bin/true
+      - name: Install locked test environment
+        run: uv sync --frozen --extra tui
+      - name: Lint release source
+        run: uv run ruff check .
+      - name: Test release source
+        run: uv run pytest --cov=conjecture_solver --cov-report=term-missing
       - name: Require the release tag to match the package version
         run: |
           python - <<'PY'

{simjecture-0.1.1 → simjecture-0.2.2}/CHANGELOG.md

@@ -2,6 +2,56 @@
 
 This project follows semantic versioning. Dates use ISO 8601.
 
+## Unreleased
+
+## 0.2.2 — 2026-08-24
+
+- Fixed a process-lifecycle race where the supervisor that launched a short
+  durable job could observe the child after exit but before `Popen.poll()`
+  receipted it, incorrectly recording `outcome_unknown` instead of the known
+  terminal result.
+- Made the release workflow install the sandbox runtime and locked test
+  environment, then run lint and the full deterministic test suite before any
+  distribution can be uploaded to PyPI.
+
+## 0.2.1 — 2026-08-23
+
+- Extracted a model-independent campaign kernel while preserving the existing
+  hypothesis graph, evidence contracts, commissioning, sandbox, capability,
+  provenance, and claim-closure rules.
+- Added a strict DeepSeek Harness profile backed by 21 native MCP scientific
+  tools, with generic execution and delegation surfaces disabled.
+- Split the DSH reasoning loop into a persistent, compact Lead Scientist and
+  fresh claim-scoped Falsifier/Experimenter, Repair Scientist, and tool-free
+  Judge sessions. Role-specific tool filters, mutation guards, structured
+  handoffs, and kernel rechecks prevent a child from silently exceeding its
+  scientific assignment.
+- Moved durable job waiting beneath the model-facing tool call. Simulations are
+  submitted once, read-only status checks no longer consume model turns, and
+  cancellation leaves the job recoverable rather than resubmitting it.
+- Added one-step-delayed, model-free context elision for completed large tool
+  exchanges and oversized results. Deterministic receipts shrink the active
+  model surface while the full append-only DSH log and campaign artifacts remain
+  intact; semantic compaction stays at 50% for the tested DeepSeek route.
+- Added an ordinary-Python experiment skill that separates `run_python` from
+  named capability execution, records exact JSON validation checks, and avoids
+  capability-only commissioning fields in NumPy/SciPy contracts.
+- Clarified that `observation_sufficient` records contract compliance rather
+  than self-certified scientific support. Falsifier handoffs and Judge
+  preparation now require closure-eligible evidence before adjudication, which
+  prevents a sufficient verdict from being persisted against an unclosable
+  claim.
+- Added idempotent detached simulation jobs, verified cancellation, bounded
+  status reports, single-writer enforcement, and authenticated worker receipts
+  that recover known outcomes after an MCP restart without rerunning work.
+- Added a lifetime root-campaign lease, restart-discoverable jobs and budgets,
+  cumulative active-time accounting, and durable cancellation after supervisor
+  restart. Custom skill and capability discovery roots replay in workers.
+- Validated the official DSH MCP client against the Python bridge and the
+  release-pinned CUDA WarpX/openPMD capability.
+- Shipped the pinned DSH profile inside the Python wheel and added
+  `simjecture dsh-profile` so installed deployments can pack the exact bundle.
+
 ## 0.1.1 — 2026-08-22
 
 - Added a dependency-free, localhost-only browser interface with an interactive

{simjecture-0.1.1 → simjecture-0.2.2}/CITATION.cff

@@ -2,8 +2,8 @@ cff-version: 1.2.0
 message: "If you use this software, please cite the exact software version and Git commit."
 title: "Simjecture"
 type: software
-version: 0.1.1
-date-released: 2026-08-22
+version: 0.2.2
+date-released: 2026-08-24
 abstract: >-
   An evidence-governed runtime for autonomous computational experimentation and
   falsification over hypothesis trees.

{simjecture-0.1.1 → simjecture-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simjecture
-Version: 0.1.1
+Version: 0.2.2
 Summary: Evidence-governed autonomous experimentation and falsification for computational science
 Project-URL: Homepage, https://github.com/tomzhu0225/simjecture
 Project-URL: Documentation, https://github.com/tomzhu0225/simjecture/tree/main/docs
@@ -26,6 +26,8 @@ Requires-Dist: numpy<3,>=1.26
 Requires-Dist: pandas<4,>=2.2
 Requires-Dist: pydantic<3,>=2.9
 Requires-Dist: scipy<2,>=1.12
+Provides-Extra: dsh
+Requires-Dist: mcp<3,>=2; extra == 'dsh'
 Provides-Extra: tui
 Requires-Dist: textual<9,>=2.0; extra == 'tui'
 Description-Content-Type: text/markdown
@@ -263,7 +265,7 @@ uv run simjecture web artifacts/magnetic-mirror-mvp
 ```
 
 Run `simjecture web` without a path to discover recent campaigns or launch a
-new hypothesis. Version 0.1.1 binds to localhost only; `--read-only` disables
+new hypothesis. The server binds to localhost only; `--read-only` disables
 all launch and process controls. Provider credentials remain in the launching
 terminal environment and are never entered into the browser.
 
@@ -281,6 +283,43 @@ diagnostic, and control claims attached to the selected hypothesis. Press `v`
 for the complete typed audit ledger; no claim or provenance record is hidden by
 the human-first projection.
 
+## DeepSeek Harness integration
+
+The v0.2.2 integration moves the model-facing research loop to DeepSeek Harness
+without moving scientific authority out of Simjecture. DSH owns the provider,
+conversation, retry policy, compaction, and resumable session. A native MCP
+boundary implements 21 typed endpoints. A compact persistent Lead Scientist
+sees six coordination tools and delegates claim work to fresh, scoped
+Falsifier/Experimenter and Repair Scientist sessions. A separate fresh,
+tool-free Judge reviews surviving claims. The Python campaign kernel continues to own hypotheses,
+evidence contracts, commissioning, skills, simulation capabilities, sandboxing,
+provenance, and guarded claim closure. Existing WarpX CPU/CUDA capabilities use
+the same kernel path. The isolated DSH profile has no interactive approval gate
+around those tools; CampaignKernel's typed boundary and sandbox remain the
+execution authority. Provider and model selection remain DSH configuration.
+Every role handoff is verified against durable kernel state. Scientific support
+is reviewed by the Judge, and only the kernel's deterministic finish gate can
+write the terminal campaign report.
+
+The browser remains the primary interface. Once the pinned DSH profile is
+installed, the usual `uv run simjecture web` command launches new campaigns
+through DSH; existing campaign replay is unchanged. `--engine native` retains
+the built-in runner as an explicit compatibility and diagnosis path.
+
+The integration is a small DSH profile bundle, not a second simulator stack.
+Provision Simjecture and any desired runtime on the host, then follow
+[the DSH deployment guide](docs/how-to/deepseek-harness.md) to install and audit
+the isolated profile. `simjecture dsh-profile` locates the bundled profile from
+either a checkout or an installed wheel. Long simulations return durable job
+identifiers, but the DSH waiter performs lifecycle polling inside the original
+tool execution instead of spending model turns on repeated status calls. An
+authenticated worker receipt lets a restarted DSH/MCP client recover a known
+outcome without repeating the run; an unverifiable outcome remains non-evidence.
+The first snapshot after a restart reports durable job IDs and remaining action
+and active-execution budgets. The resumed DSH process reopens the same stable
+event-sourced session, reconciles that snapshot, and continues without hidden
+process state or charging stopped-process downtime.
+
 ## Core safeguards
 
 - Network-isolated writable agent workspace with no provider credentials.

{simjecture-0.1.1 → simjecture-0.2.2}/README.md

@@ -231,7 +231,7 @@ uv run simjecture web artifacts/magnetic-mirror-mvp
 ```
 
 Run `simjecture web` without a path to discover recent campaigns or launch a
-new hypothesis. Version 0.1.1 binds to localhost only; `--read-only` disables
+new hypothesis. The server binds to localhost only; `--read-only` disables
 all launch and process controls. Provider credentials remain in the launching
 terminal environment and are never entered into the browser.
 
@@ -249,6 +249,43 @@ diagnostic, and control claims attached to the selected hypothesis. Press `v`
 for the complete typed audit ledger; no claim or provenance record is hidden by
 the human-first projection.
 
+## DeepSeek Harness integration
+
+The v0.2.2 integration moves the model-facing research loop to DeepSeek Harness
+without moving scientific authority out of Simjecture. DSH owns the provider,
+conversation, retry policy, compaction, and resumable session. A native MCP
+boundary implements 21 typed endpoints. A compact persistent Lead Scientist
+sees six coordination tools and delegates claim work to fresh, scoped
+Falsifier/Experimenter and Repair Scientist sessions. A separate fresh,
+tool-free Judge reviews surviving claims. The Python campaign kernel continues to own hypotheses,
+evidence contracts, commissioning, skills, simulation capabilities, sandboxing,
+provenance, and guarded claim closure. Existing WarpX CPU/CUDA capabilities use
+the same kernel path. The isolated DSH profile has no interactive approval gate
+around those tools; CampaignKernel's typed boundary and sandbox remain the
+execution authority. Provider and model selection remain DSH configuration.
+Every role handoff is verified against durable kernel state. Scientific support
+is reviewed by the Judge, and only the kernel's deterministic finish gate can
+write the terminal campaign report.
+
+The browser remains the primary interface. Once the pinned DSH profile is
+installed, the usual `uv run simjecture web` command launches new campaigns
+through DSH; existing campaign replay is unchanged. `--engine native` retains
+the built-in runner as an explicit compatibility and diagnosis path.
+
+The integration is a small DSH profile bundle, not a second simulator stack.
+Provision Simjecture and any desired runtime on the host, then follow
+[the DSH deployment guide](docs/how-to/deepseek-harness.md) to install and audit
+the isolated profile. `simjecture dsh-profile` locates the bundled profile from
+either a checkout or an installed wheel. Long simulations return durable job
+identifiers, but the DSH waiter performs lifecycle polling inside the original
+tool execution instead of spending model turns on repeated status calls. An
+authenticated worker receipt lets a restarted DSH/MCP client recover a known
+outcome without repeating the run; an unverifiable outcome remains non-evidence.
+The first snapshot after a restart reports durable job IDs and remaining action
+and active-execution budgets. The resumed DSH process reopens the same stable
+event-sourced session, reconciles that snapshot, and continues without hidden
+process state or charging stopped-process downtime.
+
 ## Core safeguards
 
 - Network-isolated writable agent workspace with no provider credentials.

{simjecture-0.1.1 → simjecture-0.2.2}/docs/concepts/architecture.md

@@ -8,11 +8,32 @@ The operator supplies the root hypothesis, operational instruction, resource
 limits, installed capabilities, and any guided commissioning package. These
 inputs are recorded before the agent begins.
 
-## Reasoning agent
+## Reasoning harness
 
 The model decides how to operationalize the hypothesis, which diagnostics to
 write, which sub-hypotheses to register, and which admissible experiment to run
-next. Its output is a typed single action, not unrestricted host code execution.
+next. The built-in runner and the DSH profile are interchangeable reasoning
+front ends; neither is the authority for scientific state or evidence.
+
+## Native tool boundary
+
+Under DeepSeek Harness, a strict MCP profile exposes only explicit Simjecture
+tools. DSH owns the provider, conversation, retry policy, compaction, and model-facing
+session. Generic shell, filesystem, workflow, web, and subagent tools are not
+part of the scientific profile. Its approval policy is non-interactive because
+CampaignKernel is the authoritative execution gate. Each tool call crosses the
+kernel boundary at most once. The researcher receives one composite
+adjudication tool. It freezes the current evidence case, runs a fresh tool-free
+DSH child with a strict verdict schema, and commits the verdict through two raw
+MCP endpoints hidden from the researcher's scoped tool view.
+
+## Campaign kernel
+
+The model-independent Python kernel validates typed actions and owns the root
+hypothesis, hypothesis graph, claim ledger, evidence contracts, commissioning,
+skills, capability registry, provenance, and workspace policy. The legacy MVP
+runner delegates to this same kernel, so changing the reasoning harness does not
+create a second scientific implementation.
 
 The autonomous loop exposes three operational roles. The **Falsifier**
 commissions tools and searches for counterexamples. After a valid
@@ -21,6 +42,9 @@ bounded search finds no counterexample, an independent **Judge** sees only the
 auditable evidence package and decides whether it is sufficient or which gap
 must be tested next. Roles are explicit workflow contexts, not claims of
 different underlying model providers.
+An accepted verdict does not itself end the process: guarded finalization checks
+the entire scientific frontier and writes the report only when no open claim or
+unrepaired counterexample remains.
 
 ## Sandbox and capabilities
 
@@ -39,9 +63,18 @@ execution.
 
 ## Durable operational state
 
-Model calls and simulator intents are journaled before dispatch. Content hashes,
-idempotency keys, cancellation records, heartbeats, and replay logic distinguish
-scientific failure from provider, scheduler, or process failure.
+The reasoning harness retains its model session. Under DSH, a stable session ID
+and event-sourced log live inside the campaign; pause, process restart, and
+resume reopen that session instead of constructing a blank conversation.
+Simjecture journals simulator
+intents before dispatch and stores content hashes, operation identifiers,
+cancellation records, process identities, and authenticated worker receipts.
+Long jobs survive an MCP restart. A missing or unverifiable receipt remains an
+unknown operational outcome and cannot become scientific evidence. The bounded
+snapshot exposes durable jobs, operation bindings, and remaining budgets to a
+fresh session. One root runner/MCP process holds the campaign ownership lease;
+detached workers hold explicit active-job writer leases. Budget accounting is
+cumulative active execution time, not elapsed calendar time between sessions.
 
 ## Human interfaces
 

{simjecture-0.1.1 → simjecture-0.2.2}/docs/concepts/evidence-and-claims.md

@@ -7,8 +7,12 @@ action. The contract states what is observed, how outcomes map to dispositions,
 what uncertainty matters, what makes the observation inconclusive, and which
 exact program commands may generate evidence.
 
-Artifacts written while code is still being designed remain workbench records.
-They cannot be promoted retroactively.
+Agent-authored files and artifacts written while code is still being designed
+remain workbench records. They cannot be promoted retroactively. An
+execution-generated artifact is only eligible after the process succeeds and,
+for detached work, its authenticated job receipt is reconciled as succeeded.
+Failed, cancelled, or operationally unknown jobs remain non-evidence even when
+they left a plausible partial output.
 
 ## Instruments are claims too
 

{simjecture-0.1.1 → simjecture-0.2.2}/docs/conf.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 project = "Simjecture"
 author = "Bowen Zhu"
 copyright = "2026, Bowen Zhu and contributors"
-release = "0.1.1"
+release = "0.2.2"
 
 extensions = [
     "myst_parser",

{simjecture-0.1.1 → simjecture-0.2.2}/docs/getting-started/first-run.md

@@ -13,8 +13,18 @@ uv run simjecture web demos/gray_scott_counterexample/record --read-only
 See [Recorded Gray–Scott demo](../demos/gray-scott.md) for the scientific result
 and the boundaries of that record.
 
-To start a new autonomous campaign, choose a bounded hypothesis whose outcome
-can be evaluated with ordinary Python before attaching an expensive simulator.
+To start a new autonomous campaign, first install the pinned DSH profile, then
+choose a bounded hypothesis whose outcome can be evaluated with ordinary Python
+before attaching an expensive simulator. The primary path is the browser:
+
+```bash
+export DEEPSEEK_API_KEY='your-process-local-key'
+uv run simjecture web
+```
+
+Enter the hypothesis in **New hypothesis** and follow the DSH activity, typed
+scientific actions, simulation jobs, and hypothesis graph in one view. The
+headless built-in engine remains available as a compatibility path:
 
 ```bash
 export DEEPSEEK_API_KEY='your-process-local-key'
@@ -24,8 +34,9 @@ uv run simjecture mvp \
   --output artifacts/gray-scott-first-run
 ```
 
-The output directory contains the immutable manifest, complete transcript,
-claim ledger, artifact provenance, final report, and the agent's workspace.
+Both paths produce an output directory containing the immutable manifest,
+complete transcript or DSH activity projection, claim ledger, artifact
+provenance, final report, and the agent's workspace.
 
 Important distinctions:
 

{simjecture-0.1.1 → simjecture-0.2.2}/docs/getting-started/installation.md

@@ -75,14 +75,25 @@ without granting scientific-evidence status.
 
 ## Local web interface
 
-The browser dashboard is included with the core installation:
+The browser dashboard itself is included with the core installation. Recorded
+campaigns can be opened without Node.js or a model runtime:
+
+```bash
+uv run simjecture web demos/gray_scott_counterexample/record --read-only
+```
+
+New browser-launched campaigns use DeepSeek Harness by default. Install the
+pinned DSH profile once per machine with the
+[DSH deployment guide](../how-to/deepseek-harness.md), then use the same command:
 
 ```bash
 uv run simjecture web
 ```
 
 It binds only to localhost and can discover, launch, or attach to durable
-campaigns. See [Web interface](web-interface.md).
+campaigns. `uv run simjecture web --engine native` selects the built-in
+compatibility engine when DSH is intentionally unavailable. See
+[Web interface](web-interface.md).
 
 ## Optional terminal dashboard (maintenance mode)
 

{simjecture-0.1.1 → simjecture-0.2.2}/docs/getting-started/web-interface.md

@@ -17,8 +17,9 @@ uv run simjecture web demos/gray_scott_counterexample/record
 ```
 
 This starts a local server at `http://127.0.0.1:8765/` and opens the default
-browser. Use `--no-open` to print the address without opening it, or `--port 0`
-to select an available local port automatically.
+browser. Use `--no-open` to print the address without opening it, `--open` to
+state the default explicitly, or `--port 0` to select an available local port
+automatically.
 
 The interface has five connected projections:
 
@@ -132,7 +133,23 @@ uv run simjecture web --runs-root artifacts
 
 Campaigns launched in the browser use the same structured
 `operator_input/launch.json` contract as the TUI and CLI. No shell command is
-constructed from hypothesis text.
+constructed from hypothesis text. In v0.2, new browser campaigns use the
+installed DeepSeek Harness profile by default. DSH owns provider routing,
+retries, conversation compaction, and the resumable model session; Simjecture
+continues to own the hypothesis graph, evidence rules, sandbox, capabilities,
+jobs, and durable scientific record. The DSH session is stored inside the
+campaign and reopened by **Resume** rather than replaced with a blank model
+conversation.
+
+The built-in reasoning loop remains available for compatibility and diagnosis:
+
+```bash
+uv run simjecture web --engine native
+```
+
+Viewing and controlling an already recorded campaign does not require Node.js
+or DSH. Starting a new default campaign does; follow the
+[DSH deployment guide](../how-to/deepseek-harness.md) once per machine.
 
 ## Local security boundary
 

simjecture-0.2.2/docs/how-to/deepseek-harness.md

@@ -0,0 +1,180 @@
+# Run a Simjecture campaign under DSH
+
+The DSH integration is a native-tool profile plus a small resumable driver for
+a durable Simjecture campaign. Version 0.2.2 uses a persistent Lead Scientist
+and fresh, claim-scoped Falsifier, Repair Scientist, and tool-free Judge
+sessions. Fresh workers see bounded kernel state rather than inherited chat.
+The Python MCP process is the only scientific tool surface: it exposes campaign
+state, claims, evidence contracts, skills, literature metadata, workspace files,
+and bounded jobs. Generic shell, filesystem bypass, and unguarded `finish` tools are
+disabled by the profile wherever the host DSH version supports disabling them.
+The profile also sets DSH's approval policy to `never`: all remaining scientific
+side effects already cross the typed CampaignKernel policy and Bubblewrap
+boundary, so no second routine permission loop is inserted around MCP calls.
+
+## Provision the two runtimes
+
+Provision the Python environment and any WarpX installation on the host first;
+the bundle intentionally installs neither runtime. From the repository root:
+
+```bash
+uv sync --extra dsh
+source .venv/bin/activate
+```
+
+`mcp>=2,<3` is optional. It is imported only when `simjecture-mcp` starts, so
+schema and kernel-fake tests do not need the extra.
+
+Ordinary users do not set the bridge variables themselves. The Web launcher
+records the hypothesis and execution envelope first, generates a stable DSH
+session identity, and supplies contained paths to the profile. The variables
+below are shown only to make that process boundary auditable:
+
+```bash
+mkdir -p runs
+printf '%s\n' 'The initial scientific hypothesis goes here.' > hypothesis.txt
+export SIMJECTURE_WORKSPACE="$PWD/runs"
+export SIMJECTURE_CAMPAIGN="demo"
+export SIMJECTURE_HYPOTHESIS_FILE="$PWD/hypothesis.txt"
+export SIMJECTURE_CAPABILITIES="$PWD/capabilities"
+export SIMJECTURE_SKILLS="$PWD/skills"
+export SIMJECTURE_MCP_MAX_OUTPUT_CHARS=30000
+export SIMJECTURE_MCP_TIMEOUT_SECONDS=600
+export SIMJECTURE_DSH_SESSION_ID=simjecture-demo
+export SIMJECTURE_DSH_SESSION_ROOT="$PWD/runs/demo/operator_input/dsh_sessions"
+export SIMJECTURE_DSH_ACTIVITY_FILE="$PWD/runs/demo/operator_input/dsh_activity.jsonl"
+export SIMJECTURE_DSH_STATE_FILE="$PWD/runs/demo/operator_input/dsh_state.json"
+export SIMJECTURE_DSH_CONTROL_FILE="$PWD/runs/demo/operator_input/control.json"
+```
+
+The bridge uses these values for the MCP child process. It never accepts a
+generic shell command or a host-wide absolute workspace path from a tool call.
+
+## Pack and install the DSH profile
+
+The profile bundle lives in `integrations/dsh` in a checkout and is also shipped
+inside the Python wheel. Resolve, validate, and pack that copy, then install the
+resulting local bundle into the isolated harness profile:
+
+```bash
+SIMJECTURE_DSH_PROFILE="$(simjecture dsh-profile)"
+npm pack "$SIMJECTURE_DSH_PROFILE" --pack-destination /tmp
+dsh plugin --profile simjecture add @deepseek-ai/dsh-headless@0.1.1-rc.2
+dsh plugin --profile simjecture add /tmp/simjecture-dsh-bundle-0.2.2.tgz
+```
+
+For a checkout-only development install, use the directory directly when the
+CLI supports local plugin paths:
+
+```bash
+dsh plugin --profile simjecture add "$PWD/integrations/dsh"
+```
+
+The bundle pins the tested DSH prerelease and MCP-client prerelease in its
+`package.json`. Keep the lockfile produced by `npm pack`/the DSH plugin manager
+with the deployment artifact; do not silently widen either range.
+
+DSH `0.1.1-rc.2` requires Node.js `^22.19.0` or `>=24.0.0`. Install the DSH CLI
+according to its upstream instructions and verify that `dsh` is on `PATH`
+before installing this isolated profile.
+
+## Inspect the resolved configuration
+
+Before starting a long campaign, ask DSH to render the merged profile. The
+exact option name is `--dump-config` in the prerelease CLI:
+
+```bash
+dsh --profile simjecture --dump-config
+```
+
+Confirm that the native MCP client is named `simjecture`, starts
+`simjecture-mcp`, carries the `SIMJECTURE_*` environment, and has
+`failOnStartupError: true`. Also confirm `approval.policy: never`, the
+`simjecture` permission preset (`workspace-write` plus `never`), and that the
+generic tool rows are disabled. A startup or handshake failure should stop the
+scientific profile rather than silently fall back to a bypass tool.
+
+Completed large execution and workspace-write exchanges stay fully visible for
+one model request. At a later step the profile may replace the balanced exchange
+on the model-facing surface with a deterministic receipt containing stable
+identifiers, selected status fields, sizes, and hashes. Other oversized tool
+results receive deterministic head/tail pruning. Both are model-free, and all
+original events remain in the append-only DSH log and Simjecture's durable
+artifacts.
+
+The tested `deepseek-official/deepseek-v4-flash` route advertises a one-million-
+token context window. The Simjecture profile performs semantic compaction for
+that exact route at 50% pressure and retains a 3% verbatim tail; DSH defaults
+remain in force for other routes. This is a context threshold, not a campaign
+token quota: scientific work continues until a durable stop condition or the
+operator's wall/action budget is reached.
+
+The bundle intentionally does not select a scientific reasoning model. Inspect
+the resolved `agent-default-model` row and configure the desired provider/model
+through DSH's profile settings or a later local patch.
+
+## Launch through the Web interface
+
+After the profile has been installed and inspected, use the ordinary Simjecture
+entry point:
+
+```bash
+uv run simjecture web
+```
+
+New browser campaigns use DSH by default. Recorded-run viewing needs neither
+Node.js nor DSH, and `uv run simjecture web --engine native` retains the built-in
+runner for compatibility and diagnosis. Pause and resume use the same Web and
+CLI controls; resume opens the stable DSH session stored under
+`operator_input/dsh_sessions` rather than starting an empty conversation.
+
+The MCP server also supports a direct smoke launch when diagnosing the host:
+
+```bash
+simjecture-mcp --workspace "$SIMJECTURE_WORKSPACE" \
+  --campaign "$SIMJECTURE_CAMPAIGN" \
+  --hypothesis-file "$SIMJECTURE_HYPOTHESIS_FILE"
+```
+
+That command speaks MCP over stdio and expects an MCP client; it is not a
+human-facing REPL. Use DSH's initialize/list-tools/call-tool trace to verify the
+21 explicit MCP endpoints before submitting work. The persistent lead sees six
+tools: two durable reads, fresh falsification and repair delegation, independent
+adjudication, and guarded finalization. Each worker receives a narrower tool
+surface plus a claim-scoped argument guard. Raw judge prepare/commit operations
+are private to the adjudication composite.
+
+`observation_sufficient=true` means that a linked artifact satisfies its
+selected prospective contract; it is not a researcher-issued support verdict.
+Falsifiers may record that contract compliance but cannot close a scientific
+claim as supported. The adjudication composite refuses to start a Judge without
+at least one qualifying link under the selected contract, and only a sufficient
+Judge verdict can pass the deterministic support gate.
+
+Long-running actions have caller-supplied operation identifiers and return
+durable jobs. Under DSH the waiter checks `job_status` below the model surface,
+so one submitted run produces one terminal tool result instead of repeated
+polling turns. An interrupted wait leaves the job durable and recoverable; it
+never resubmits. A direct MCP client must perform these status reads itself.
+Authenticated receipts let a restarted client recover known results, while
+absent or invalid receipts remain `outcome_unknown`. A fresh `snapshot` includes
+a bounded durable job list and remaining action/active-execution budget.
+The campaign wall-time envelope charges time while its DSH researcher process
+is active, including model and tool waits. The kernel additionally records
+actual tool and simulation execution for durable recovery and per-command
+limits. Calendar time while DSH and the MCP process are stopped is not charged.
+
+One root MCP process owns the campaign for its lifetime. A second DSH profile or
+the legacy runner fails closed instead of alternating writes through stale
+in-memory ledgers. Detached simulation workers are the only exemption and use
+the kernel's durable active-job lease.
+
+## Scientific operating rule
+
+Register a prospective evidence contract before linking an observation. Skill
+materialization, literature results, workbench jobs, and partial jobs are
+guidance or process metadata, not evidence. After a meaningful falsification
+search, use the isolated adjudicator instead of self-certifying support. A
+rejected package returns evidence gaps; an accepted package may close the claim,
+but `finalize_campaign` writes a conclusion only after the global finish gate
+passes. Preserve the durable campaign directory as the hand-off artifact.

{simjecture-0.1.1 → simjecture-0.2.2}/docs/index.md

@@ -29,6 +29,8 @@ hypothesis solving or empirical closure.
   [Guided commissioning](how-to/guided-commissioning.md).
 - **Operator:** use [Deploy runtime profiles](how-to/deploy-runtimes.md) to
   provision and verify the core, WarpX CPU, or WarpX CUDA environment.
+- **DSH operator:** use [Run a Simjecture campaign under DSH](how-to/deepseek-harness.md)
+  to install the native MCP profile and verify its tool boundary.
 - **Reviewer:** inspect [Evaluation status](research/status.md),
   the [recorded Gray–Scott demo](demos/gray-scott.md),
   the [recorded collisionless GEM demo](demos/collisionless-gem.md),
@@ -69,6 +71,7 @@ research/limitations
 how-to/guided-commissioning
 how-to/add-a-capability
 how-to/deploy-runtimes
+how-to/deepseek-harness
 ```
 
 ```{toctree}

{simjecture-0.1.1 → simjecture-0.2.2}/docs/reference/cli.md

@@ -20,7 +20,8 @@ Principal command families:
 - `watch`: follow durable MVP events until a terminal report or pause;
 - `pause`: request an action-boundary pause of a verified live runner;
 - `resume`: repeat a stored launch contract for a paused or incomplete run;
-- `web`: local browser dashboard and reviewed campaign controls;
+- `web`: local browser dashboard and reviewed campaign controls; new launches
+  use DSH by default, with `--engine native` as the compatibility fallback;
 - `tui`: optional interactive dashboard (`uv sync --extra tui`);
 - `benchmark`: deterministic planted scientific benchmarks;
 - `campaign`: durable bounded campaign execution;