dos-skillify
dos-skillify converts agent skills by identifying self-certified claims (unverified "done" signals, ungrounded success checks, Boolean filters) and wrapping them with `dos` verb calls that defer ground-truth judgment to external witnesses rather than the skill itself. Use this when an operator needs an existing skill made DOS-aware, its self-checks grounded, or when preparing a skill variant for environments with witnessed verification. The converter reads workspace configuration from `dos doctor --json` and outputs both a modified skill copy and a re-derivable conversion report, never self-certifying its own output.
git clone --depth 1 https://github.com/anthony-chaudhary/dos-kernel /tmp/dos-skillify && cp -r /tmp/dos-skillify/src/dos/skills/dos-skillify ~/.claude/skills/dos-skillifySKILL.md
# dos-skillify — make any skill ask a witness instead of believing itself
> **A skill is a screenplay, not a program — and most screenplays trust the
> worker.** When a skill concludes "the fix shipped" because the agent said it
> committed, "the goal is met" by re-reading its own transcript, or "all 7
> workers returned" by `filter(Boolean)`, the part deciding ground truth *is*
> the part being judged. That is consistency, not grounding (docs/138). This
> skill does not rewrite the *job*; it changes **how the skill knows a step
> worked** — it finds every belief-bit and replaces the self-check with a `dos`
> verb whose byte-author is not the agent. The kernel decides; the converted
> skill narrates.
The shape is domain-free: **parse the skill into claim-sites → classify each as
ADD / REPLACE / GUARD / LEAVE → emit an additive new copy + a report.** The
*policy* (which lanes, which plan grammar, which exit codes) is data read from
`dos doctor --json`, never literals — which is exactly what lets the converted
skill run unchanged on a host with different lanes. Full design: docs/345.
## When to use this (and when not)
- **Use it** when you have a skill (a `SKILL.md`, an agent prompt, a workflow
script) that sets belief bits from self-report and you want those seams
grounded — your own skill, a vendored one, or a public skill you're preparing
a variant of.
- **Do not use it** to rewrite a skill's job, make it "smarter", or convert a
pure-prose/taste skill that sets no checkable belief bit — there is no witness
to add, and forcing one is the fake-witness anti-pattern this skill refuses.
- **This is a layer-3 helper / screenplay (a PDP, docs/99).** It shells existing
`dos` verbs and mints no new verdict. It produces a *variant + a report*; it
decides no ground truth itself. Its OWN output is admitted by witness (Step 5).
## The one rule under this skill
The converter is a judged agent. It must never *claim* "I made this skill
DOS-aware" — it must produce a report whose every row a reviewer re-derives from
the diff without trusting the converter. **A converter that self-certifies its
own output is the exact failure DOS exists to fix.** That is why Step 4 (the
report) and Step 5 (admit-by-witness) are not optional.
## Step 0 — Discover the workspace once (the WCR on-ramp)
```bash
dos doctor --workspace . --json
```
Stash it. Every lane name, plans glob, and exit-code table the converted skill
references comes from here — never a literal. (EXAMPLES.md Recipe 0.) The fields
this skill uses: `lanes` / `paths.plans_glob` / `stamp` (so a converted
`arbitrate` / `verify` step names the host's real taxonomy), and `exit_codes`
(so a converted gate branches on `$?`, not prose).
> **Want a quick score first?** `dos skillify --grade <path>` (or `--all`) runs
> the *deterministic* part of this screenplay without an agent loop: it scans a
> skill and reports its **DOS grounding signal** (STRONG/MODERATE/WEAK) plus the
> belief-bits that look ungrounded, as **review candidates**. It is a static
> estimate, NOT this skill's precise per-bit verdict — use it to triage which
> skills are worth a full conversion pass, and to gate CI (`--check`). The
> classification below is the precise instrument; the verb is the cheap one.
## Step 1 — Parse the source skill into claim-sites
Read the source `SKILL.md` (and any supporting files / prompt it references).
Walk it step by step. For each step, decide: **does it set a belief bit?** — a
place the skill concludes something is true and acts on it. Record each as
`{step, span, claim_kind, evidence_today}`. Prose that sets no belief bit is
left untouched.
A claim-site is recognized by **what it concludes**, not by a keyword (keywords
seed the search; you confirm the conclusion). Map each to its claim-kind — the
taxonomy is 1:1 with the EXAMPLES.md recipes, which is the whole spine:
| The step concludes… | claim_kind | Recipe | The `dos` verb the converted step uses |
|---|---|---|---|
| "(plan,phase) / this code shipped" | `SHIPPED` | R1 | `dos verify` — **read the rung** (`registry` > `grep-subject` > `none`), never the bare bool |
| "this commit did what its subject says" | `COMMIT_HONEST` | R1 | `dos commit-audit` — subject vs. its own diff |
| "keep working until the goal is met" | `GOAL_DONE` | R1b | `dos hook stop` wired *alongside* the harness goal (ANY-block) |
| "I created file / row / message / deploy" | `EFFECT` | R9/§2b | effect read-back — **no CLI verb today**; Python API + **log the gap** |
| "a CI / workflow run concluded GREEN/RED" | `CI_GREEN` | (issue-verify R-run) | the run's own `conclusion` field (`gh run view --json conclusion`, the `dos.drivers.ci_status` rung), never the run-log narration — **driver-witnessed, no first-party CLI verb today; log the gap** |
| "I'm editing these files (no collision)" | `WRITE` | R2 | `dos arbitrate` over the tree **before** writing; honor the redirect |
| "is there work / safe to proceed" | `GATE` | R3 | `dos gate` — branch on the exit code, not the printed line |
| "how is run R doing" | `RUN_STATE` | R4 | `dos status` — the digest with no `claimed` field |
| "this tool-loop is progressing" | `LOOP_LIVE` | R5 | `tool_stream` (Python API) — distrust repetition, not correctness |
| "this long job is alive" | `ALIVE` | R6 | `dos lease-lane heartbeat` + `dos liveness` |
| "this recalled memory is still true" | `RECALL` | R7 | `dos recall` — re-verify at read time |
| "all N fan-out workers returned a real result" | `FANOUT` | R9/R10 | `dos verify-result` + `dos coverage --declared N` |
| "this issue / ticket is resolved" | `ISSUE_DONE` | (issue-verify) | witness each effect, fold, then close |
| taste / intent / future work | `UNWITNESSABLE` | — | **no witness exists → leave as prose, never fake a check** |
The last row is load-bearing. A claim with no honest witness is **not** turned
into a `dos` call. It is recorded `UNWITNESSABLE` and surfaced in the report
(fail-to-abstain). Never manufaAdjudicate a GitHub issue's "this is resolved" claim from witnesses the claimant didn't author — then close it carrying the evidence, or refuse with the typed gap. Use when an issue looks already-solved, after landing a fix that should have closed one, or to sweep open issues for silently-resolved ones.
Pick the next most important open GitHub issue this agent can actually complete, make its done-condition true, land it with witnesses (suite + parity + commit-audit), and priority-tag every issue touched along the way. Use when asked to "work the backlog", "complete the next most important issue", or to fix a specific issue number end-to-end.
Cut a versioned release of the DOS kernel — bump the version, draft release notes, commit, tag, push to master, and create a GitHub release. The tag push triggers the gated PyPI publish pipeline (publish.yml); the skill surfaces the run and its approval gate.
Promote an already-shipped rolling release (vX.Y.Z) of the DOS kernel to a named stable channel — gated on a green kernel suite + a green third-party CI run on the candidate + a clean truth syscall + a soak window. Writes an evidence file and adds a stable/<codename> git tag on the same commit. Does NOT bump versions or build new artifacts.
One automatic plan-class lifecycle tick. Reads the DECLARED class set + transition list from the workspace `[lifecycle]` table (not a hardcoded taxonomy), evaluates each trigger, spawns a read-only JUDGE-rung adjudicator (the `dos.judges` seam — advisory, fail-to-abstain) to approve/defer each candidate transition, applies the gated transitions as plan-meta edits + one commit per cycle, and logs to the run archive. Failsafes (per-cycle cap, per-plan cooldown, a veto class) are `[lifecycle]` data; the judge content is a host `dos.judges` driver. Every path/class comes from `dos doctor --json`. Use to garden a plan portfolio's lifecycle automatically, judge-gated. The DOS lifecycle gardener (SKP Axis 5, docs/207 Phase 5c).
Run /dos-dispatch on a recurring cadence, alternating with /dos-replan when the backlog drains — the dispatch→replan→dispatch cycle. The continue/stop/next-mode decision is the kernel's typed loop decision, not inline prose: each iteration is classified (`dos gate`) into a verdict and the loop's counters (drained-twice, the unclear/dirty-zero breakers, the iteration cap) drive the next step. Several loops on disjoint lanes run concurrently, each taking its own lane lease via `dos arbitrate`. Driven entirely by `dos` verbs + the workspace's `dos.toml`. The DOS reference loop workflow (SKP Axis 5).
End-to-end plan-and-ship for one lane — snapshot the portfolio with /dos-next-up, take a lane lease via `dos arbitrate` so parallel dispatches don't collide, gate the empty case via `dos gate`, ship the packet, and archive the run under the configured run dir. Driven entirely by `dos` verbs + the workspace's `dos.toml`; names no host path, lane, or commit convention. Use when you want to plan and ship the next batch on one lane in a single command, with concurrency safety. The DOS reference dispatch workflow (SKP Axis 5).
Ground a "keep working until the goal is met" stop condition in a witness the agent did not author, instead of letting the agent self-certify "done". A harness goal/Stop-hook condition is normally checked by the model re-reading its OWN work — consistency, not grounding. This skill turns the operator's goal into checkable EFFECT claims and wires `dos hook stop` so the Stop is refused until git ancestry (a shipped phase) or an effect read-back corroborates the claimed effect. Driven by `dos` verbs and the workspace's own `dos.toml` — no host-specific paths, lanes, or commit conventions. Use when you want a self-stopping agent (or a `/loop` worker) to be unable to declare a goal complete on its own say-so. The single-agent self-stop analogue of `dos-witness-claim`.