@grilling-sleek/dsh-tool-grill-user

English | 中文

A DeepSeek Harness (dsh) plugin that gives the agent the grill_user tool: one decision-tree branch of structured questions per call, each question with a recommended answer, and the user's decisions returned as structured JSON. It is the dsh distribution channel of grill-me-sleek — the same Hub and answer page the CLI and the packaged skill use, mounted natively as a Cordis plugin.

How it answers

grill_user asks on two links at once and the first answer wins:

• Downstream — the native userQuestions waterfall: desktop cards, IM bridges, remote apps. Every answerer already in the composition works with zero code.
• Hub — a grill-me-sleek round on the configured Hub. The user opens the answer page (https://<hub>/#session_id) on any network and answers there.

The Hub round opens before the card goes out (bounded by a 2 s reveal budget), so the answer-page URL rides the question card — on the first question's detail line, the one page every answerer sees — and is logged once per round; answer on whichever surface you see first. A Hub round that cannot be opened in time degrades that round to the card only (warned; the result then carries no hub).

The loser is converged: a Hub win withdraws the downstream question everywhere (the gateway's cancel frame); a downstream win proxy-submits the answers to the Hub and revises on conflict so both agree. The Harness session log records the round through the tool call itself — arguments carry the questions, the result carries the answers and the opened Hub linkage — so replay and history see what was asked and answered.

How revisions reach the agent

The Hub is the source of truth for answers, and the user can revise any answered round on the answer page at any time while the session is active. Everything the agent was delivered is a cached view with a per-round revision watermark, and three layers converge it — the watcher accelerates delivery, the other two make it lossless:

1. The revision watcher. From the first successfully opened round, the plugin reads the session's SSE stream (the same one the answer page uses). Every response.revised fetches that round's latest answers and delivers them to the agent out-of-band — an idle agent is woken (followup), a busy one is handed an inject for its next step boundary — under a small consecutive-wake budget that an answered round refills. Every (re)connection replays the round summaries, so a missed event or a dropped stream heals by the watermark comparison. Node has no dependable global EventSource, so the reader is a small fetch-body parser with reconnect and backoff.
2. The result delta. Before each new round opens, the plugin aligns the watermarks with the Hub and carries any newly revised rounds in the result's revisions[] field — each entry holds the round number, its branch name, the revision, and the full latest answers.
3. The wait notices. The long-poll loop collects the revision notices the Hub attaches to pending responses, and the result delivers those rounds' latest answers too.

Layered this way, a revision is lost only when every layer fails at once; the watermark comparison collapses duplicates across layers. A failed or aborted round cancels the Hub session and resets the linkage (the next call opens a fresh session), and agent disposal cancels the session best-effort — the answer page then says so instead of collecting revisions nobody will read. Beyond that the plugin never closes a session: sessions live to their TTL (one hour on the public Hub), and that lifetime is the user's revision window. The skill body teaches the model the matching discipline: the latest revision of every round supersedes earlier deliveries, and no close action exists or is needed.

Install

Prerequisite: DeepSeek Harness (dsh) itself. Then one command:

dsh plugin --profile web add @grilling-sleek/dsh-tool-grill-user

Restart the profile — that is the whole install. The package ships its cordis.patch.yml bundle patch, so the CLI's plugin coordinator mounts it into the profile's bundle stack; no profile file edits.

Out of the box every round races on the public Hub at https://grillingsleek.online — the same answer page the CLI and the packaged skill use — so the browser answer surface works with zero configuration. Point the plugin at a self-hosted Hub instead (or go hubless) by re-inserting the plugin row with a config block in any later layer — the profile's own cordis.patch.yml or a --patch overlay; later layers win per row:

- insert:
    - id: tool-grill-user
      name: "@grilling-sleek/dsh-tool-grill-user"
      config:
        baseUrl: "https://your-hub.example.com"

With baseUrl: "" the plugin runs hubless: user questions are then the only answer surface, and a profile without any answerer fails the call immediately instead of hanging.

| Field | Default | Meaning | | ---------------------- | ------------------------------ | ------------------------------------------------------------- | | baseUrl | https://grillingsleek.online | Hub origin serving the answer page; '' switches to hubless | | maxQuestionsPerRound | 16 | Largest accepted question batch per round (1..64) | | roundTimeoutMs | 14400000 | How long one round may stay pending before closing as expired |

The plugin also registers the grilling-sleek interview skill at runtime (when a skill registry is present), so /grilling-sleek and model-matched triggering work with no separate skill installation.

Secondary channels: every dsh-v* GitHub Release carries the packed tarball — dsh plugin --profile web add ./grilling-sleek-dsh-tool-grill-user-<version>.tgz — and a git pin also works (dsh plugin --profile web add github:jukanntenn/grill-me-sleek#<sha>). A git install fetches sources and runs the prepare build, so allowlist the package in the profile's pnpm-workspace.yaml allowBuilds first.

Version line

0.0.x cuts are dogfooding, published as npm latest — an untagged install rides the current one. From 0.1.0-rc.1 on, pre-releases publish under next and 0.1.0 hands latest to the stable line. A release is cut by pushing a dsh/package.json version bump to main; the workflow publishes, tags dsh-v<version>, and opens the GitHub Release with the tarball (GS-RFC 2026-09-01).

The interview discipline

One branch per call; stable grill_-prefixed snake_case question ids; two or more options with the recommendation marked (recommended + explanation); optionless questions are free text. Main agent only — an owned subagent has no human answerer and its call is rejected before any round exists. Answers return as { roundId, hub?: { sessionId, url }, revisions?: [...], answers: [{ id, selected, custom? }] } — hub present whenever the round raced on one, revisions present whenever earlier rounds changed — including the synthesized grill_additional_notes catch-all.

The runtime skill body carries these as an explicit Construction rules checklist. The tool schema's enforced subset cannot express value constraints (no pattern, minItems, or minimum), so mapping.ts checks them at execute time; the checklist is the model's only pre-call view of them, kept in step with the checks by JSDoc cross-references until a mechanical gate replaces the prose anchor (GS-RFC 2026-09-02).

Known limitations

• No custom session events. The Harness persistence read path refuses event types outside its generated catalog, which only in-repo packages can enter — so this plugin records rounds through the standard tool call and result instead of a dedicated grilling/* event family. A future upstream contribution could restore the dedicated family without changing the tool.
• The losing surface sees a bare withdrawal. The cancel frame carries no payload: other ends learn the question was cancelled, not the winning answers.
• Hub convergence is best effort. A failed proxy submit or revise is logged and swallowed; the round is already answered in the session log.
• A Hub round that cannot open degrades the round. The call answers on the card alone (warned, and the result carries no hub); a misconfigured baseUrl therefore converges nothing — the warning and the missing field are the diagnosis surface.
• Late answers are dropped by design. An answer submitted in the milliseconds between the race settling and the withdrawal arriving is accepted by its surface and silently discarded.
• Revision delivery degrades, never gates. The watcher is an accelerator: a deployment that blocks SSE still converges every revision at the next grill_user call's result delta, and the wake budget means a long run of idle revisions past three without an answered round in between is injected (parked for the next step boundary) rather than waking the agent.
• The package tracks the published dsh alpha channel (0.1.2-alpha.x); pre-release Harness may rename seams, and this package follows.

Design rationale and the alternatives that lost live in GS-RFC 2026-08-31 and, for the revision model, GS-RFC 2026-09-02.