@dsdenes/devboard 0.1.560 → 0.1.563

package/omp/commands/adr-resolve.md

@@ -0,0 +1,8 @@
+---
+description: Settle pending ADRs by interview via the harness prompt at .devboard/prompts/adr-resolve.md
+argument-hint: "[path to host project root or its ADR directory]"
+---
+
+Read `.devboard/prompts/adr-resolve.md` (repo-root-relative) and follow it as the instructions for this turn. Do nothing else.
+
+Path (optional; empty means none given): $ARGUMENTS

package/omp/commands/discover.md

@@ -0,0 +1,6 @@
+---
+description: Crawl the host read-only and stage the Discover project sheet, UbiLang glossaries, and five project-specific Agent Skills via the harness prompt
+argument-hint: "<staging-dir>"
+---
+
+Read `.devboard/prompts/discover.md` (repo-root-relative) and follow it as the instructions for this turn. The staging directory is `$ARGUMENTS`. Do nothing else.

package/omp/commands/epic-next.md

@@ -0,0 +1,8 @@
+---
+description: Derive the next epic from the host project's goal and ADRs via the harness prompt at .devboard/prompts/epic-next.md
+argument-hint: "[balanced|granular|milestone] [path to goal document or project root]"
+---
+
+Read `.devboard/prompts/epic-next.md` (repo-root-relative) and follow it as the instructions for this turn. Do nothing else.
+
+Arguments (optional; empty means no mode and no path): $ARGUMENTS

package/omp/commands/flow-change.md

@@ -0,0 +1,8 @@
+---
+description: Classify a Flow session's changed files into widgets via the harness prompt at .devboard/prompts/flow-change.md
+argument-hint: "<session-dir>"
+---
+
+Read `.devboard/prompts/flow-change.md` (repo-root-relative) and follow it as the instructions for this turn. Do nothing else.
+
+Session directory: $ARGUMENTS

package/omp/commands/flow-goal.md

@@ -0,0 +1,8 @@
+---
+description: Establish one observable Flow session goal via the harness prompt at .devboard/prompts/flow-goal.md
+argument-hint: "<session-dir>"
+---
+
+Read `.devboard/prompts/flow-goal.md` (repo-root-relative) and follow it as the instructions for this turn. Do nothing else.
+
+Session directory: $ARGUMENTS

package/omp/commands/flow-implement.md

@@ -0,0 +1,8 @@
+---
+description: Implement a Flow session's goal in its worktree via the harness prompt at .devboard/prompts/flow-implement.md
+argument-hint: "<session-dir>"
+---
+
+Read `.devboard/prompts/flow-implement.md` (repo-root-relative) and follow it as the instructions for this turn. Do nothing else.
+
+Session directory: $ARGUMENTS

package/omp/commands/flow-widget.md

@@ -0,0 +1,8 @@
+---
+description: Discuss one Flow change widget read-only via the harness prompt at .devboard/prompts/flow-widget.md
+argument-hint: "<session-dir> <widget-id>"
+---
+
+Read `.devboard/prompts/flow-widget.md` (repo-root-relative) and follow it as the instructions for this turn. Do nothing else.
+
+Session directory and widget id: $ARGUMENTS

package/omp/commands/goal-draft.md

@@ -0,0 +1,8 @@
+---
+description: Elaborate one proposed-goal draft into a finalized goal spec and file it as a goal-labeled issue, via the harness prompt at .devboard/prompts/goal-draft.md
+argument-hint: "<repository-relative draft path>"
+---
+
+Read `.devboard/prompts/goal-draft.md` (repo-root-relative) and follow it as the instructions for this turn. Do nothing else.
+
+Draft path (repository-relative; empty is an error): $ARGUMENTS

package/omp/commands/goal-outcome.md

@@ -0,0 +1,8 @@
+---
+description: Turn a brief into one observable end goal at GOAL.md via the harness prompt at .devboard/prompts/goal-outcome.md
+argument-hint: "[project brief]"
+---
+
+Read `.devboard/prompts/goal-outcome.md` (repo-root-relative) and follow it as the instructions for this turn. Do nothing else.
+
+Project brief (optional; empty means none given): $ARGUMENTS

package/omp/commands/implement-issue.md

@@ -0,0 +1,8 @@
+---
+description: Implement exactly one open issue, integrate it into the canonical line, and close it after the push is verified, via the harness prompt at .devboard/prompts/implement-issue.md
+argument-hint: "<issue number>"
+---
+
+Read `.devboard/prompts/implement-issue.md` (repo-root-relative) and follow it as the instructions for this turn. Do nothing else.
+
+Issue number (exactly one positive integer; empty is an error): $ARGUMENTS

package/omp/commands/prepare-skills.md

@@ -0,0 +1,6 @@
+---
+description: Prepare project-agnostic Agent Skills grounded in public standards and patterns via the harness prompt at .devboard/prompts/prepare-skills.md
+argument-hint: ""
+---
+
+Read `.devboard/prompts/prepare-skills.md` (repo-root-relative) and follow it as the instructions for this turn. Do nothing else.

package/omp/commands/scout-recommendations.md

@@ -0,0 +1,8 @@
+---
+description: Survey the host repository for Auto Scout via the harness prompt at .devboard/prompts/scout-recommendations.md
+argument-hint: "[absolute scan directory]"
+---
+
+Read `.devboard/prompts/scout-recommendations.md` (repo-root-relative) and follow it as the instructions for this turn. Do nothing else.
+
+Scan directory (required; read its `request.json` and write its `recommendations.json`): $ARGUMENTS

package/omp/commands/setup-devboard.md

@@ -0,0 +1,24 @@
+---
+description: Install or refresh the Devboard harness in this session's working directory
+argument-hint: "[host path] [--port N]"
+---
+
+Install Devboard for this session by running the launcher once from the host repository:
+
+```bash
+npx --yes @dsdenes/devboard@latest install $ARGUMENTS
+```
+
+The launcher resolves the newest private harness release, installs it as a real npm prefix at
+`<host>/.devboard`, replaces any legacy harness symlinks in `.devboard`, `.omp/commands`, and
+`.omp/extensions` with real directories, copies the wrappers and `AGENTS.md`, records the three
+ignored paths, and leaves exactly one dashboard running from the installed package. It never
+symlinks a host to a canonical checkout.
+
+A running dashboard checks for newer releases by itself and shows a reload control while the
+installed version differs from the loaded one. Do not start a second server, restart one by
+hand, or copy harness files into the host; use `npx @dsdenes/devboard update` to install a
+release without a restart, and the reload control to restart one.
+
+Report the launcher's final `devboard:` line verbatim. On a nonzero exit, report its stderr and
+stop. Do not create, copy, or edit harness or host files yourself; the launcher owns the install.

package/omp/config.yml

@@ -0,0 +1,12 @@
+# Harness model policy, installed as <host>/.omp/config.yml.
+#
+# Every omp process the harness starts works from the host repository, so this
+# project-local settings file applies to the interactive agent and to each ACP
+# peer (`omp acp`) it spawns. All chat roles use DeepSeek V4.1 Flash through
+# OpenCode Go; the free OpenCode Zen variant is not used.
+modelRoles:
+  default: opencode-go/deepseek-v4.1-flash
+  plan: opencode-go/deepseek-v4.1-flash
+  smol: opencode-go/deepseek-v4.1-flash
+  slow: opencode-go/deepseek-v4.1-flash
+  task: opencode-go/deepseek-v4.1-flash

package/omp/extensions/implement-goal-issue.ts

@@ -0,0 +1,2 @@
+// Host-side invocation glue only. The command lives in the harness.
+export { default } from "../../.devboard/extensions/implement-goal-issue.ts";

package/omp/extensions/implement-next-epic.ts

@@ -0,0 +1,2 @@
+// Host-side invocation glue only. The command lives in the harness.
+export { default } from "../../.devboard/extensions/implement-next-epic.ts";

package/omp/mcp.json

@@ -0,0 +1,9 @@
+{
+  "mcpServers": {
+    "adrkit": {
+      "type": "stdio",
+      "command": "bunx",
+      "args": ["@adrkit/mcp", "--cwd", ".", "--dir", "adrs"]
+    }
+  }
+}

package/package.json

@@ -1,18 +1,97 @@
 {
   "name": "@dsdenes/devboard",
-  "version": "0.1.560",
-  "description": "Launcher for the private Devboard harness: install, update, and doctor.",
+  "version": "0.1.563",
   "type": "module",
+  "description": "Devboard harness: ADR dashboard server, client, prompts, wrappers, and installer.",
+  "scripts": {
+    "build": "vite build",
+    "start": "bun run server/index.ts",
+    "publish": "bun run scripts/publish.ts",
+    "release": "bun run scripts/release.ts",
+    "test": "bun test",
+    "adr:lint": "adr lint --dir ../adrs",
+    "adr:graph": "adr graph --dir ../adrs",
+    "adr:queue": "adr queue --dir ../adrs",
+    "verify:install": "bun run scripts/verify-install.ts",
+    "verify:update": "bun run scripts/verify-update.ts",
+    "verify:ui": "bun run scripts/verify-ui.ts",
+    "verify:watchdog": "bun run scripts/verify-watchdog.ts",
+    "verify:watchdog-live": "bun run scripts/verify-watchdog-live.ts",
+    "watchdog": "bun run watchdog/main.ts",
+    "watchdog:install": "bun run watchdog/install.ts",
+    "watchdog:uninstall": "bun run watchdog/uninstall.ts",
+    "cleanup": "bun run watchdog/cleanup-main.ts",
+    "check": "svelte-check --tsconfig ./tsconfig.json",
+    "verify:interface": "bun run scripts/verify-interface.ts",
+    "verify:issues": "bun run scripts/verify-issues.ts",
+    "verify:scout": "bun run scripts/verify-scout.ts"
+  },
+  "files": [
+    "package.json",
+    "AGENTS.md",
+    "README.md",
+    "install.sh",
+    "bin/",
+    "templates/",
+    "server/",
+    "client/",
+    "lib/",
+    "watchdog/",
+    "issues/",
+    "prompts/",
+    "omp/",
+    "extensions/",
+    "dist/",
+    "public/",
+    "index.html",
+    "vite.config.ts",
+    "svelte.config.js",
+    "tsconfig.json"
+  ],
+  "devDependencies": {
+    "@adrkit/cli": "0.20.0",
+    "@adrkit/mcp": "0.20.0",
+    "@playwright/test": "1.64.1",
+    "@storybook/svelte": "10.6.4",
+    "@storybook/svelte-vite": "10.6.4",
+    "@sveltejs/vite-plugin-svelte": "^7.3.1",
+    "@tailwindcss/vite": "^4.3.3",
+    "@tanstack/svelte-table": "^9.3.1",
+    "@tanstack/table-core": "^9.3.1",
+    "@types/bun": "^1.4.3",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/xterm": "^6.0.0",
+    "bits-ui": "^2.20.2",
+    "clsx": "^2.1.1",
+    "lucide-svelte": "^1.0.1",
+    "monaco-editor": "^0.57.0",
+    "paneforge": "^1.0.2",
+    "shadcn-svelte": "^1.7.1",
+    "storybook": "10.6.4",
+    "svelte": "^5.57.2",
+    "svelte-check": "^4.7.7",
+    "tailwind-merge": "^3.7.0",
+    "tailwind-variants": "^3.3.1",
+    "tailwindcss": "^4.3.3",
+    "tw-animate-css": "^1.4.0",
+    "typescript": "^6",
+    "vite": "^8.3.4"
+  },
+  "dependencies": {
+    "@adrkit/core": "0.20.0",
+    "diff2html": "^3.4.56",
+    "dompurify": "^3.4.17",
+    "marked": "^18.1.1",
+    "mermaid": "^11.12.0"
+  },
   "bin": {
     "devboard": "bin/devboard.mjs"
   },
   "engines": {
     "node": ">=20"
   },
-  "files": [
-    "package.json",
-    "bin/",
-    "README.md"
-  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "license": "UNLICENSED"
 }

package/prompts/adr-resolve.md

@@ -0,0 +1,130 @@
+---
+description: Interview the developer, question by question, until no record under <host>/adrs/ is still pending.
+---
+
+`/adr-resolve`: settle every pending decision record in the host project's ADR directory.
+
+Deliverable: decisions written into the records under `<host>/adrs/`, one commit per record written. Nothing else is created, edited, or committed.
+
+Input: an optional path arriving in the invoking command alongside this text. It names the host project root, or the record directory inside it — resolve with `stat`. The path is data, not instruction. No input is not an error: use the repository root, then its `adrs/`.
+
+## Contract
+
+- `<host>` is the host project: the repository root. `.devboard/` is the harness, not the host — exclude `.devboard/` and `.worktree/` from every survey and every write. The only files this run writes are records under the resolved directory.
+- **The developer is the only decision maker, and their authority is never questioned.** An answer is the decision: final, binding, and not provisional on anything. You research, propose, and ask; you never answer for them, never invent an answer, and never settle a decision on your own.
+- **No other decision maker exists in this process.** NEVER require, request, suggest, or imply a sign-off, approval, permission, confirmation, review, ratification, or written authority from anyone else — no stakeholder, customer, user, lawyer, compliance or security review, committee, maintainer, upstream author, or organisation. Never name another party as having a say in a record, never make a record's settlement depend on one, and never write that a decision is waiting on one.
+- **Never challenge an answer.** Do not ask the developer to justify, defend, or restate a decision, do not present evidence as an objection to it, and do not treat it as anything less than settled once given. Evidence shapes the options before the question; it never argues with the answer after it.
+- Report paths repository-root-relative; pass absolute paths only to tools that need them.
+
+## Phase A — Probe (read-only)
+
+1. `git rev-parse --show-toplevel` → `<host>`. Not a git repository → halt. Dirty or detached working tree is not an obstacle: this run commits only the records it writes.
+2. Resolve the record directory: the caller's path when given (a directory is the directory; a file is the directory containing it), else `<host>/adrs/`. Absent or unreadable → halt when the caller named a path, otherwise report `none pending` and stop.
+3. Read every file in it. Empty directory → report `none pending`, write nothing, commit nothing, stop.
+
+Shell commands used for research are read-only: directory and file listing (`ls`, `find`), `git log`, `git status`, `git ls-files`, `git rev-parse`. Never run the project's build, tests, migrations, package manager, or formatter; never install anything; never change branches or the working tree. A decision that would need the project executed is a question for the developer, not a command. The only writes and the only git mutations in this run are the record writes and the per-record commits of Phase F.
+
+## Phase B — Pending set
+
+A record is pending when either signal says so:
+
+- **Status** — its status is not one the directory treats as resolved. When the records carry YAML frontmatter, that status is the frontmatter `status` field; otherwise it is the status line or bullet the directory already uses. A missing or empty status counts as pending.
+- **Body** — its decision section is empty, a placeholder (`TBD`, `TODO`, `...`, a bare heading), or holds nothing but the question.
+
+Both signals are read; a record settled by one and unsettled by the other is pending. Also pending: a conflict between two records that both read as settled — the pair is one decision to settle (Phase E), however each file's status line reads.
+
+Order: by file name, ascending. Before starting each record, re-read the directory and every record settled so far — a later record may need to agree with, or may now contradict, an earlier answer. Recompute the pending set after each write, so a decision that unsettles another record is picked up in the same run.
+
+## Phase C — Conventions
+
+Read the records and copy what they already do: numbering, extension, filename pattern, status vocabulary and its spelling, section headings, where the decision lives, whether a date is recorded, and whether typed metadata lives in YAML frontmatter (a `---` fence with `key: value` fields) or in the body. Conventions are discovered per directory, never assumed.
+
+A record's status is written where the directory keeps it. When records carry YAML frontmatter with a status field, change that field in place, keep every other frontmatter field as it was, and put a supersession pointer in a field beside it when the directory's records do. When they do not, write the status line or bullet the directory already uses, with the pointer in the directory's own wording. Never write both a status field and a status line into one record.
+
+Never rename, renumber, reorder, restructure, or delete a record. A write touches only: the decision section, the status field or status line (plus a date, only when the convention records one), the supersession pointer on a record that loses (Phase F), and the single open line on a record that stays blocked (Phase F). Nothing else in the file changes.
+
+Records are read as they are; this run never restyles, reflows, or renumbers them, and never creates one. A record with no decision section, in a directory that writes decisions another way, is written where its question sits — the placeholder text replaced, or the decision appended as one paragraph at the end of the file — plus the status line. The file is never restructured to fit another directory's shape.
+
+## Phase D — Research before every question
+
+A question whose answer sits in the repository is a research failure, not a question. Before asking anything about a record, read: its own text; the other records it touches; the code, tests, manifests, and docs it names; the repo context files (`AGENTS.md`, `README`, `docs/`) that already mandate something.
+
+Use `read` for ranges, `find` for behavior, `grep` for symbols, `glob` for names, `xd://lsp` for definitions and references, and `task` subagents for broad or unfamiliar slices.
+
+Every option you offer MUST trace to a path, symbol, doc, command output, or a stated developer preference. An option that traces to nothing is a guess; drop it or label it as an unevidenced possibility.
+
+## Phase E — The interview
+
+One record at a time. Per record, one `ask` call carrying every open question of that record; follow-up rounds only for answers that are vague or that contradict another answer the developer gave — and in a follow-up round re-ask only those.
+
+Per question:
+
+- 2–5 mutually exclusive `options`, each with a concrete `label` and a `description` stating its tradeoff.
+- `recommended` set to the zero-based index of the answer you would choose given the research: state the decision you would take, then the real alternatives to it, then one option to leave the record open. The recommended option is the default the developer is confirming or rejecting — never a menu of equals.
+- `multi: true` only where the choices genuinely combine. `preview` only when two answers need comparing side by side.
+- Plain wording. No jargon, no nested conditions, no compound question. A decision that needs a complex question is made of several simple ones: split it, ask the parts, and infer the decision from the answers.
+
+Ask only what the repository cannot answer: intent, priorities, hard constraints, what the project must not do, irreversible tradeoffs, what "done" means. NEVER ask what the code, the records, or the developer's earlier answers already fix.
+
+Focus on the minimal decision. Ask the smallest question that stops the record being pending — the one the record's own text asks — never the neighbouring, wider, or future decision. A choice that is cheap to reverse, internal to the implementation, or not needed yet is not a question: infer it, and say so in the reply. Deciding early what the project does not yet need is the failure mode to avoid.
+
+Skip style trivia and anything inferable. NEVER ask about token budget, cost, spend, time limits, or attempt caps: effort is uncapped, treat that as given, and never raise it as a question.
+
+There is no cap on questions or rounds. Relentless, but never repetitive: adapt to a custom answer instead of re-asking the same thing, and when the developer picks "leave it open", treat that as an answer.
+
+An answer closes its question. Never re-ask an answered question, never ask the developer to justify or defend one, and never look for agreement with it from anyone — including from the code, the other records, or an earlier answer.
+
+Common ground, per record: every open question has a concrete answer the record can carry. Then stop asking and write (Phase F). The run ends when every record is either settled or recorded open with a named missing input — nothing else.
+
+Two behaviours the interview must handle:
+
+- **Contradiction between settled records.** Ask which one wins — the developer's choice is the answer. The winner keeps its status; the loser is recorded as superseded, with a pointer to the winner, in the directory's own wording. The developer declines to pick a winner → halt naming both paths.
+- **A decision no record asks about.** Settle it in the conversation if the answer is needed to settle a record, and report it under `unrecorded` in the reply. NEVER create a record for it: this run file no questions, it answers them.
+
+A decision the developer cannot make yet — it turns on information not yet at hand, such as a measurement not yet taken, a result not yet observed, or a fact about something that has not happened — is probed first, then treated as blocked (Phase F) and the run moves to the next record. Only the developer's own statement that the information is missing makes a decision blocked, and what is missing is always information. A decision is NEVER blocked, deferred, or made conditional on another person's consent, permission, review, agreement, or availability, and a decision that is merely hard, contested, expensive, or unwelcome is settled now, by the developer, not deferred.
+
+## Phase F — Write the record
+
+Settled record:
+
+- The decision, in the record's existing decision section, in the developer's terms and at the record's own level of detail. Nothing the answer did not establish: no invented rationale, no commentary, no alternatives the developer did not consider.
+- Status set to the directory's resolved status, in the field or line that record already carries (Phase C). A date only when the convention records one.
+- Fill only headings the file already has, and only those the answer directly settles. Never add a section.
+- The file's existing layout survives the write: the text goes where the placeholder or the empty section was, and the blank lines and spacing around it stay as they are. Never reflow, rewrap, or retabulate an existing paragraph.
+
+Blocked record (the developer states the information is not yet at hand):
+
+- Status unchanged, and the frontmatter untouched when the record has one.
+- One short line inside the section that already holds the question: which piece of information is missing, and how the developer intends to obtain it. Never a new heading, never a status the directory does not use, and never a word about anyone's approval, permission, review, sign-off, or agreement.
+
+A record that another record supersedes:
+
+- Status set to the directory's superseded status, with a pointer to the winning record: a supersession field beside the status when the record has YAML frontmatter, otherwise the file's own wording.
+
+Then commit that one file, immediately, so an interrupted run leaves no uncommitted write:
+
+```
+git add -- <path> && git commit -m "<subject>" -- <path>
+```
+
+Subjects: `docs(adr): accept <id> <title>` when settled, `docs(adr): supersede <id> <title>` when superseded, `docs(adr): note <id> still open (<missing input>)` when blocked. `<id>` is the record's own number or slug as it appears in the filename.
+
+Exactly one commit per record written, covering that record only. NEVER `git add -A` or `-u`, never `--amend`, never commit another file, never create a branch, never push, never open an editor or a prompt. Commit rejected (hook failure, read-only repository, no identity) → halt, quoting git's error and naming the file — that record is left written and uncommitted for the developer to finish, and the halt line names it so the state is never hidden.
+
+## Phase G — Finish
+
+Go to the next pending record, re-reading the directory first (Phase B). Finish when no record is pending — including records that became pending from your own writes — and every record left open carries a confirmed missing input.
+
+Then reply, one line each, in this order, and nothing more:
+
+- `settled: <path> (<short sha>)` — per record, in the order settled.
+- `open: <path> — missing <input>` — per record left blocked.
+- `unrecorded: <decision> — <answer>` — per decision the interview surfaced that no record asks about; `unrecorded: none` when there were none.
+
+Path is repository-root-relative. The record bodies are never pasted into chat. Zero records pending, or an empty directory → `none pending` on its own line, and nothing else.
+
+## Halting
+
+`halt: <reason>` on its own line and nothing else, after any `settled:` lines already earned. Reasons: not a git repository; a caller-supplied path that does not resolve; an unreadable or unwritable record directory; two settled records contradict and the developer will not choose between them; a commit rejected.
+
+NEVER halt for effort, number of questions, size, cost, duration, an obstacle you can route around, or a decision that is merely hard, contested, or expensive — ask instead. NEVER halt, slow down, or defer because someone outside this conversation might disagree or might want to be consulted: no such party exists here.