dsh-gatedflow

Gated, durable, human-in-the-loop workflows for DeepSeek Harness — gates
as control flow: "must verify / confirm / review" rules live in the engine,
not in prompts, so no agent can skip them under load.

Zero-mutation replan · gates as control flow · declarative subflows.
The engine core contains no LLM and no orchestrator dependencies.

Packages

Package	Description	Dependencies
@gatedflow/engine	Framework-agnostic engine core: validation, expansion, deterministic conditions, the workflow state machine.	none
@gatedflow/dsh	DeepSeek Harness adapter: gf_* tools, the gate panel UI, the anti-bypass guard, filesystem persistence.	@gatedflow/engine + DSH services

The idea in one picture

user task ──► agent composes atomics (Ref/Inline) ──► gf_start
                                                       │
              path ① single Ref ──────────────┐        │
              path ② multi/inline ── pre_start_gate (human approves the plan)
                                                       ▼
              shell (command + expect) ─ interrupt (human gate via panel)
              handoff (delegate back to the agent) ─ conditional (structured fields)
                                                       ▼
                                                   done (auto)

• Gates are control flow. interrupt steps pause the engine; the human
  approves or rejects through a panel card in the conversation. The model
  agent has no approve/reject channel — gf_advance rejects them (guard
  • schema), and decisions travel straight from the panel to the engine.
• Zero mutation. Agents cannot rewrite workflow state, params, or
  routing. Failures take exactly two paths: step-level failure with
  pause_on_failure → pause → human repairs → retry (prior outputs kept);
  otherwise abort → failed → human reviews → new workflow.
• Declarative subflows. Workflows are JSON/YAML data, validated at load
  time and snapshotted at start — what the human approves is exactly what
  executes.
• No LLM in the engine. Semantic judgment happens on the agent side and
  returns structured fields; the engine only evaluates deterministic
  operators (==, !=, >=, <=, >, <, contains, &&, ||, !).

Quick start

npm install
npm run check   # build + typecheck + unit tests

Run a workflow (as a DSH user)

The adapter registers seven tools. The agent composes a plan, then:

gf_start({ atomics: [
  { name: 'gf-verify-demo', params: { note: 'hello' } },
  { type: 'shell', params: { command: 'echo done', expect: 'true' } },
]})

• Single Ref runs the preset deterministically (no gate wrapper).
• Multiple / Inline atomics wrap a pre_start_gate: the engine pauses
  and the plan appears as a panel card above the composer. Click ✓ Approve
  to proceed or ✕ Reject to abort.
• Handoff gates pause for the agent; the agent returns structured results
  via gf_advance(handoff_complete, result).
• A failed step with pause_on_failure shows an Awaiting retry card;
  after the human repairs the environment,
  gf_advance(decision: 'retry') re-runs only that step.

Author a subflow

Drop a JSON file into a subflows directory — the session workspace's
.gatedflow/subflows (scanned automatically, takes precedence on name
conflicts) or the shared root (~/.gatedflow/subflows by default,
GATEDFLOW_SUBFLOWS_DIR to override) — then call gf_reload_subflows
(hot-loaded, no restart):

{
  "name": "release",
  "description": "build with objective verification, human review, then publish",
  "keywords": ["release", "build", "review"],
  "params": { "branch": { "required": true } },
  "steps": [
    { "id": "build", "type": "shell", "params": { "command": "npm run build", "expect": "test -f dist/index.js", "max_retries": 1, "pause_on_failure": true }, "on_success": "review", "on_failure": "abort" },
    { "id": "review", "type": "interrupt", "params": { "message": "Publish ${branch}?" }, "on_approve": "publish", "on_reject": "abort" },
    { "id": "publish", "type": "shell", "params": { "command": "npm publish" }, "on_success": "next", "on_failure": "abort" }
  ]
}

See examples/subflows/ for more.

Architecture

• docs/DESIGN.md — root constraints, step model, routing,
  data references, gate protocol, persistence and anti-stuck design, with
  the decision record.
• docs/INTEGRATION.md — mounting the adapter in a
  DSH composition, environment variables, tool reference, and the agent
  skill guidance.

Development

npm install
npm run test          # unit tests (vitest, engine + adapter)
npm run typecheck     # strict TS across both packages
npm run build         # tsc output for engine + dsh

The engine package is deliberately dependency-free and framework-agnostic;
the DSH adapter is a thin, typed wiring layer over the harness services
(fs, shell, tools, timer, subagents; the gateway row additionally
consumes webServer), configurable through a
schemastery Config schema exactly like the official DSH plugins. See the
package README for the plugin contract.
Contributions welcome — see CONTRIBUTING.md.

Status

v0.1 ships the engine core plus the DSH adapter with shell / interrupt /
handoff / conditional / agent_delegate / agent_resume steps, the
gate panel, the anti-bypass guard, gate deadlines, /stop-safe interruption
semantics, hot-reloadable subflows, bounded-tail audit logs, and
restore-on-reference persistence. Roadmap: YAML-native subflow authoring
improvements and a solidify flow that turns recurring dynamic plans into
named presets.

License

MIT — see LICENSE.

Relationship to gatedflow

This project is an independent, native implementation of the gatedflow
philosophy for DeepSeek Harness. It shares the vocabulary (atomics,
subflows, pre_start_gate, zero-mutation replan, decision records) but
re-implements everything on harness-native primitives — the engine core is
written from scratch in TypeScript with no external dependencies.