dsh-focus-board

A cross-session task ledger for DeepSeek Harness (dsh).

Long conversations lose the original intent, several requests inside one conversation blur into each other, and conclusions reached halfway get quietly overtaken by later code. A memory plugin retrieves text; it does not hold an authoritative list of what is still open and what the next step is.

This plugin owns that list. It is a plain JSON ledger on disk, a focus tool the agent writes through, and a strip above the composer that the human reads — both of you looking at the same rows.

English | 中文

Install

dsh plugin --profile web add github:YYJ-python/dsh-focus-board

Restart dsh web (or refresh the page if only the client half changed). The entry appears in the global sidebar as 焦点台 / Focus Board.

What you get

• One item per request. focus open on every new request, focus update while working, focus close with a conclusion. Items carry a step chain (plan), notes, links, stall owner, and artifacts, so the panel can draw the flow instead of a bare sentence.
• A strip above the composer. Collapsed to titles, one expanded at a time, width following the composer. It shows only the current conversation's items, plus a quiet announcement band at the top of the window while the plugin is working.
• Injected context. Unfinished items are injected into every step, so a fresh turn still knows what is open. A docs/项目大纲.md (or AI_GUARD.md) outline is injected next to it and is preferred over guessing when a choice comes up.
• Staleness review. Code and docs move; a conclusion written a week ago may already be wrong. Each item carries a review clock and fingerprints of its artifacts (⟳ stale Nd, ⚠ basis changed, ⚠ basis missing), so the board tells you what to re-check instead of trusting it.
• Choices that learn. kind: 'choice' with options renders as clickable candidates; the ledger remembers what was picked, and focus auto decides safe repeat cases on its own. Dangerous actions (push, deploy, delete, tag, spend) are never auto-decided.
• A grant ledger (grant). Local capability questions — push? deploy? write to production? — are answered from a table instead of being re-asked. Each entry has four modes (always / timed / ask / never), an optional scope, and a pointer to where the credential lives (never the value). Items blocked on authorization render that same four-mode control inside the item card; if the entry does not exist yet it is created first, so the panel and the ledger never disagree.
• Blind-work backfill. When only a human can do the step and the result is invisible to the agent (a console toggle, a token revocation), the item asks for a 3–5 point self-check instead of accepting "done".
• Answer-driven re-judge. The scheduler does not react to "the conversation changed" — that spends tokens on unrelated items. It reads new assistant answers, matches them against each item's keywords (id, artifact filenames, Chinese 4–6 character phrases, with the trailing ledger table removed as noise), and only re-judges the items an answer actually mentions. Prompts the plugin itself sent are ignored, so it cannot wake itself.
• Big directions (大方向). Archive a one-line goal — "keep upgrading the UI" is enough — plus a schedule (daily / weekly / every N minutes). When the time comes the board sends a composed prompt into the session: investigate first (project docs & code, DSH memory, web), then dispatch the plan. Collisions are handled: one run at a time, at least 10 minutes apart (five directions set to 00:00 fire at 0:00 / 0:10 / 0:20 …), queued by their scheduled time; machine items are served least-recently-run first.
• Host-side executor. At the scheduled moment the host opens the session and submits the prompt itself (sessionController), so the browser tab does not need to be open; each direction gets its own dedicated session on first run and reuses it. Set hostExec:false in the config to fall back to panel execution. Re-judge / send / machine rounds still run through the panel.
• Machine lane (机机). Work dispatched by a direction lands in its own tab (lane:'auto'), never in your to-do list, counts or morning advice. The machine drives it round by round (each round is a separate job, so several directions interleave). Caps: 6 rounds per item, 12 per day, and a stop after two rounds with no new progress. It never asks you for authorization and never hands a decision back to you — the only endings are continue / wait for a condition / abandon; actions that need authorization are either routed around or parked with "what blocked it" written down. The human appears twice: writing the direction, and pressing "stop" if needed.
• Lessons (经验): auto-sedimented, auto-used. This tab is for the machine, not for approvals. The host harvests the conclusion of every closed item into a lesson (solid ones go straight into the injected digest, thin ones stay marked low-confidence), dedupes by title prefix, auto-promotes a lesson into a real ~/.dsh/skills/<name>/SKILL.md once it has been consulted 3 times, and retires auto-lessons nobody touched for 45 days. You only skim the page now and then.
• Tool registry (工具): auto-maintained. The host probes PATH daily and registers the commands that actually exist, absorbs installed DSH plugins, re-verifies every CLI once a day, retires one after three consecutive misses, and retires untouched auto entries after 60 days. The injected digest is ordered by how often an entry was consulted. You only skim it now and then; it records how to use a tool and never executes anything for you.
• Four ledgers that grow themselves. Once an hour (and on install, and on "rescan this machine") the board auto-maintains: the tool registry absorbs installed DSH plugins; the lesson library harvests the conclusion of a just-closed item into a draft (drafts are never injected until you adopt them); the grant ledger adds an ask entry for any capability an open item needs; the credentials page lists variable names found in env files (names only — values are never read, stored, or echoed). It only records facts that already happened.
• Sub-boards: items / machine / directions / lessons / tools / pending ideas / deploy / human-only work / Gitee / scheduler / grants / credentials / habits / outline.

Tools

Tool	Purpose
focus	open / update / close / drop / list / review / decide / auto / brief
grant	list / check / upsert / remove — answers "may I do this class of action?"

grant stores where a credential lives (env:NAME, file:/path#KEY, conv:SESSION, mem:ID, keychain:NAME), never the value itself: the ledger is injected into every prompt.

Data

Everything lives under ~/.dsh (or $DSH_HOME):

~/.dsh/focus-board/board.json      # the ledger
~/.dsh/focus-board/grants.json     # the authorization table
~/.dsh/focus-board/config.json     # optional local config (paths, owner name)
~/.dsh/secrets/focus-board.env     # optional credentials (Git, SSH) — never committed

Optional integrations

Two sub-boards talk to a specific machine layout. Both are disabled until configured; the ledger, strip, scheduler and grants work without them.

// ~/.dsh/focus-board/config.json
{
  "owner": "your name",
  "arrayRoot": "/path/to/your/repos",          // repo discovery for the Gitee sub-board
  "giteeEngine": "/path/to/engine",            // python engine (ops.py) for repo status
  "python": "python3",
  "deployRegistry": "/path/to/projects.yaml"   // deploy targets: hosts, systemd units, health checks
}

The same values can come from environment variables: DSH_FOCUS_OWNER, DSH_FOCUS_ARRAY_ROOT, DSH_FOCUS_GITEE_ENGINE, OPSCTL_PYTHON, DSH_FOCUS_DEPLOY_REGISTRY.

The deploy sub-board runs SSH commands defined by your registry (checkout a tag, sync an env file, install, restart, health-check). It is a convenience for one machine, not a general CI system; the authorization table gates it like everything else.

Status & known rough edges

Early software (0.x). It has been used daily for real work, but expect rough edges: the UI is dense, some copy is Chinese-only, and the optional integrations assume a Unix-ish remote host. Issues and PRs are welcome.

One action per card, and cards that are busy get out of your way

Every card in the focus sub-board carries several buttons that either write the ledger or send a prompt (decide / backfill / close / park / review / re-judge / send / loop). Pressing one of them locks the whole card for the round trip: the other buttons are disabled, the card cannot be expanded, the header says which action is running and why the rest are locked. The lock is kept in a synchronous Map, so a double click cannot slip through; it clears when the write returns (20 s timeout unlocks and asks you to refresh to see whether the ledger landed), and checkboxes, evidence inputs, prompt drafts and inline grant controls lock with it.

A card that is currently being advanced — a write in flight, the loop pinned to it, a re-judge in flight, or the host reporting its session moved within 5 minutes (item.live) — is rendered dimmed, desaturated, auto-collapsed and not expandable, with a spinning micro-icon and a line saying it will reopen by itself. Cards waiting on you are exempt: they stay readable and expandable even if their session just moved.

Test: node test/ui-lock.mjs (26 assertions, stubbed renderer, no host, no real ledger).

Security

Installing a DSH plugin runs third-party code with your own permissions. This one can, if you configure it, run git and SSH commands and read a credentials file you create. It never sends data anywhere and never stores a secret value in the ledger. Read the source before you install; the whole plugin is two files (index.js, client.js).

License

MIT