project-spec 0.0.0-stage → 0.7.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +323 -2
- package/bin/project-spec.mjs +279 -0
- package/package.json +40 -4
- package/skills/project-knowledge/LICENSE +21 -0
- package/skills/project-knowledge/SKILL.md +139 -0
- package/skills/project-knowledge/agents/openai.yaml +4 -0
- package/skills/project-knowledge/assets/viewer.html +3615 -0
- package/skills/project-knowledge/references/audit.md +52 -0
- package/skills/project-knowledge/references/format.md +215 -0
- package/skills/project-knowledge/references/gaps.md +159 -0
- package/skills/project-knowledge/references/investigate.md +33 -0
- package/skills/project-knowledge/references/merge.md +70 -0
- package/skills/project-knowledge/references/migrate.md +56 -0
- package/skills/project-knowledge/references/sync.md +102 -0
- package/skills/project-knowledge/scripts/knowledge.py +929 -0
- package/skills/project-knowledge/scripts/maintain.py +545 -0
- package/skills/project-knowledge/scripts/merge.py +182 -0
- package/skills/project-knowledge/scripts/test_knowledge.py +1121 -0
- package/skills/project-knowledge/scripts/test_maintain.py +864 -0
- package/skills/project-knowledge/scripts/test_merge.py +165 -0
- package/skills/spec-change/LICENSE +21 -0
- package/skills/spec-change/SKILL.md +63 -0
- package/skills/spec-change/agents/openai.yaml +4 -0
- package/skills/spec-change/references/gaps.md +159 -0
- package/skills/spec-change/references/plan.md +40 -0
|
@@ -0,0 +1,56 @@
|
|
|
1
|
+
# Migrating a vault written before the spec/gap split
|
|
2
|
+
|
|
3
|
+
Use this when `check` fails on a vault made by an earlier version of this skill. Older vaults mixed everything in one layer: gap-like pages carried a `status`, spec notes linked to gaps and listed requirements as sources, and audit or implementation-plan results lived in index pages. The current format ([format.md](format.md), [gaps.md](gaps.md)) keeps the as-built spec and the gap layer apart, so each gap can be rechecked and decided on its own.
|
|
4
|
+
|
|
5
|
+
The aim of a migration is to change the shape of the vault without inventing facts. It does not research the code again, and it does not decide anything for anyone.
|
|
6
|
+
|
|
7
|
+
## What `check` reports on an old vault
|
|
8
|
+
|
|
9
|
+
Expect many errors at once, mostly of a few kinds:
|
|
10
|
+
|
|
11
|
+
- gap pages with a `status` (an error on gaps) and without `kind`, `recheck` or `decision`;
|
|
12
|
+
- gap pages missing one of the six sections;
|
|
13
|
+
- spec pages (`area`, `note`) linking to gaps or plans, or listing a requirements document in `sources`;
|
|
14
|
+
- hand-written audit or plan index pages that fit no current page type.
|
|
15
|
+
|
|
16
|
+
A page with a frontmatter error still counts as a target for links, embeds, area membership, a plan's `gap` and `duplicate_of`, so you will not also see a flood of "missing wikilink" errors for every link to it. A failing `check` ends with a count of errors and of the pages they are on. Page-level errors come first; fix those, then rerun to see what remains. If you find yourself fixing links, you are probably fixing the wrong thing.
|
|
17
|
+
|
|
18
|
+
## Order that worked
|
|
19
|
+
|
|
20
|
+
Do these in order, rerunning `check` between steps. Each step removes a class of errors, and later steps are hard to judge while earlier ones are still failing.
|
|
21
|
+
|
|
22
|
+
1. **Gap frontmatter.** On each gap page drop `status`, add `kind`, `recheck` and `decision`. Map the old state to the nearest honest value: an unchecked gap is `recheck: "not-checked"` and `decision: "open"`. Do not carry over a recheck or a decision unless the page itself records who did it and when; then use that name and date. An agent never writes its product name, and never writes a person's decision that the page does not show.
|
|
23
|
+
2. **Gap sections.** Give every gap the six sections (`Current behavior`, `Gap`, `Evidence`, `Recheck`, `Discussion`, `Decision`), moving the old text into the section where it belongs. Write "Not checked yet." and "Open." where nothing was recorded.
|
|
24
|
+
3. **Split multi-question pages.** A page that asks two things gets two pages, but only when the two aspects have different next steps or owners. A page that merely carries two kind tags for one question stays one page. In the real migration a vault of 21 gaps became 30 pages this way. Keep the original id on the page that continues the original question and cross-reference the new one in `Discussion`.
|
|
25
|
+
4. **Clean the spec pages.** Remove links, embeds and summaries that point from `areas/` and `notes/` to gaps or plans, and remove requirements documents from their `sources`. If a spec sentence is only intent, move it to the matching gap's `Evidence`, labelled as documented intent, and leave the spec to what the code does.
|
|
26
|
+
5. **Replace audit and plan index pages.** An audit or implementation-plan index becomes a `run` page that records the pass, plus a dated entry in each gap's `Discussion` carrying the options the old page listed. Do not keep a combined page of findings; the gaps are the findings.
|
|
27
|
+
6. **Plans.** `plans/` holds a plan only for a gap a person accepted. In the real migration it stayed empty, because no person had decided anything. Do not infer an acceptance from an old priority, a task, or an existing implementation plan.
|
|
28
|
+
7. **Fingerprints and views.** Run `snapshot --notes ID...` only for pages you actually re-read against their sources, and delete the files earlier versions generated (see below). `snapshot --notes` is blocked only by errors on the pages you select (or by an unknown or duplicated id, or an error that belongs to no page, such as a damaged `sources.json`), so it works on fixed pages while other pages still fail and tells you how many other errors it ignored; `snapshot --all` needs the whole vault valid. Accepting a fingerprint says "I read this page against these bytes", so never use it to clear a warning on a page you did not re-read.
|
|
29
|
+
|
|
30
|
+
## Run pages that link to everything
|
|
31
|
+
|
|
32
|
+
Older run pages linked every page they touched, and `check` now reports `run pages are history, not part of the map` with the number of links. Those links made each run a hub in Obsidian's graph and pulled all areas into one ball. The fix is mechanical and changes no claim: in each `runs/*.md` replace `[[notes/example|the example rule]]` with the label and the path in code formatting, `the example rule (`notes/example`)`, and do the same for embeds and Markdown links to vault pages. Links to source files and URLs stay. Nothing is generated into the vault any more: read it with the `serve` command, which always shows the current files. Delete what earlier versions generated: `AS-BUILT.md`, `GAPS.md`, `.knowledge/graph.json`, `graph.html` and `Map.canvas`. Until they are gone, `check` reads an old `AS-BUILT.md` or `GAPS.md` as a page and reports its missing frontmatter. A `01-coverage.md` page is no longer asked for; move what it says about each area into that area's page, or leave it as an ordinary index page.
|
|
33
|
+
|
|
34
|
+
## Notes that describe a mechanism, or tables that replaced the notes
|
|
35
|
+
|
|
36
|
+
Two kinds of vault read badly and pass `check`, so only a person or this pass notices.
|
|
37
|
+
|
|
38
|
+
- A vault written before version 0.5.0 describes mechanisms ("a worker runs durable jobs") rather than the rules a person looks up.
|
|
39
|
+
- A vault filled in with 0.5.x has the rules, but in one table page per kind of thing per area (`<area>-forms`, `<area>-screen-actions`, `<area>-permissions`), while the note of the feature itself says little more than "see the fields table". Its notes also carry a line naming their area, a "Verification" section, line numbers in code links and long `sources` lists, which mark most pages as outdated after any change.
|
|
40
|
+
|
|
41
|
+
Sync and update repair the pages they pass ("Leave each page better" in the skill). To bring the whole vault up at once, work through it one area at a time, as **explore <area>**:
|
|
42
|
+
|
|
43
|
+
1. For each feature note, write the opening that says what the feature is for, who uses it and where they find it, and fix the `summary` to say the same in a sentence.
|
|
44
|
+
2. Bring the feature's rules home, under the standard headings (`How it works`, `Fields`, `Business rules`). Move each row of a per-kind table into the note of the feature it belongs to: a form's fields into its `Fields` table, an action or a permission into a numbered row of `Business rules` (`BR-PROFILE-01`), and turn rules that sit in prose into rows too. Drop rows that carry no rule (a control that only opens, closes, goes somewhere or tries again). Re-read the code for each rule you move; where the vault has no rule yet, read it off the code.
|
|
45
|
+
3. Delete a per-kind table page once it is empty, and remove or reword every link to it. Keep, or write, a reference note only for what the code registers in one place and no single feature owns: jobs, emails, routes, roles, plan limits, flags.
|
|
46
|
+
4. On each note you touched, remove the line naming the area and the "Verification" section (a result worth keeping goes on the run page), take the line numbers out of code links, and cut `sources` to the files that decide the behavior.
|
|
47
|
+
5. On the area page, list the feature notes, then the reference notes, and name the lists not written yet.
|
|
48
|
+
6. Run `snapshot --notes` for the notes you re-read and `check`, and record the pass on a run page: what moved where and what was deleted.
|
|
49
|
+
|
|
50
|
+
This changes content, not structure, so it is not part of a format migration: do it as its own pass, area by area, and keep the claims you did not re-read as they are.
|
|
51
|
+
|
|
52
|
+
## Rules that kept the migration honest
|
|
53
|
+
|
|
54
|
+
- No decision is inferred from priorities, tasks or plans. If a page does not show who decided and when, the gap is `open`.
|
|
55
|
+
- A migration changes structure. If the spec text is wrong, fix it from the code in a separate pass and say so in the run page.
|
|
56
|
+
- Write one `run` page for the migration listing what was split, moved and left unfinished, and the checks you ran.
|
|
@@ -0,0 +1,102 @@
|
|
|
1
|
+
# Incremental sync
|
|
2
|
+
|
|
3
|
+
Use this for `sync` or a broad Git-based `update`. Deterministic discovery (the scan) finds which commits and sources are pending; your research decides what they mean. The helper cannot read code or certify that prose is true. `$SKILL_DIR`, `$REPO` and `$VAULT` are defined in [SKILL.md](../SKILL.md).
|
|
4
|
+
|
|
5
|
+
A sync does two jobs in order. First it brings the **spec notes** in line with the code. Then it revisits the **gaps** whose cited sources changed, because a code change may have closed or altered a question someone is still carrying.
|
|
6
|
+
|
|
7
|
+
## Shared and local state
|
|
8
|
+
|
|
9
|
+
- Canonical Markdown, `.knowledge/sources.json` and `.knowledge/review.json` travel with normal repository commits. `review.json` names the integrated branch and the last commit accounted for. It is a checkpoint, not a completeness score.
|
|
10
|
+
- `.knowledge/sync-plan.json`, `.knowledge/sync-status.md`, the review receipt and `sync.html` are local reports; keep them out of Git. They show what was observed at scan time.
|
|
11
|
+
- Use the repository's pinned copy of this skill if it supports the workflow; otherwise say there is a version mismatch and use a complete installed copy. Keep one version through a merge and the sync that follows it.
|
|
12
|
+
|
|
13
|
+
## 1. Discover the range
|
|
14
|
+
|
|
15
|
+
Read the repository instructions and check current edits and task ownership. If several contributors changed the vault, follow [the merge workflow](merge.md) first; sync reviews application history and does not reconcile competing note text, fingerprints or checkpoints. Then scan, read-only:
|
|
16
|
+
|
|
17
|
+
```sh
|
|
18
|
+
python3 "$SKILL_DIR/scripts/maintain.py" scan --repo "$REPO" --vault "$VAULT" --json
|
|
19
|
+
```
|
|
20
|
+
|
|
21
|
+
The default target is checkout HEAD. Review every reachable commit since `reviewed_through`, including merged branches and changes later reverted; do not filter by author or age. The vault, the portable skill directory and its two wrapper files (`knowledge/README.md`, `knowledge/.gitignore` when the vault is under `knowledge/`) are not part of the application queue. A range with only those paths needs no receipt or run page.
|
|
22
|
+
|
|
23
|
+
For a team-wide sync, refresh the remote tracking branch with `git fetch` only (no pull, merge or prune) and compare it with the integrated branch; scan `--target origin/main` if that is the real branch. A remote target that differs from checkout HEAD is triage only: do not advance the checkpoint or treat its content as local bytes. Label a local-only scan, or a failed fetch, as unknown upstream freshness. Unmerged branches are proposals, not current behavior.
|
|
24
|
+
|
|
25
|
+
Missing or shallow history, divergent ancestry, unresolved Git conflicts and an absent checkpoint each need an explanation; never reset the checkpoint to HEAD to make them go away. For a new vault, research the initial snapshot, write a run page describing its partial coverage, then initialize `review.json` with the observed revision:
|
|
26
|
+
|
|
27
|
+
```json
|
|
28
|
+
{"schema":1,"ref":"refs/heads/main","reviewed_through":"FULL_REVIEWED_SHA","run_path":"runs/initial.md","coverage":"partial"}
|
|
29
|
+
```
|
|
30
|
+
|
|
31
|
+
Existing clones reuse the shared checkpoint.
|
|
32
|
+
|
|
33
|
+
## 2. Update the spec, then revisit gaps
|
|
34
|
+
|
|
35
|
+
Follow the repository's task coordination for substantive writes, and respect other people's claims on specific notes and source areas.
|
|
36
|
+
|
|
37
|
+
**Spec notes.** Read each relevant diff in its execution context. Inspect the mapped notes, connected rules and uncovered files; a new route or service may need a new area or note. Classify every pending path as reviewed, excluded with a concrete reason, or deferred. A generated asset may be excluded; an unknown behavior may not be excluded just to empty the queue. Credential files are not evidence and their contents never enter the vault. Update claims from the code, keep manual text and stable IDs, and resolve deleted or renamed sources by investigation. A changed registration point (a new job, route, email, role or flag) updates the reference note that lists that kind of thing; a changed form or screen updates its feature note. A note you re-read gets what it is missing, what the feature is for and its rules with their values, and loses what a reader does not need; see "Leave each page better" in the skill. For a renamed or split file, point `sources` at where the rule lives now and re-read the page. If evidence is truly gone, keep the note as `stale` or `superseded` with a line saying what could not be found; open a gap only if a question about the product remains. a missing note is not evidence of missing functionality.
|
|
38
|
+
|
|
39
|
+
**Gaps.** List the gaps whose `sources` include a changed path, and any gap whose described behavior the diff touches. For each, re-read the current code:
|
|
40
|
+
|
|
41
|
+
- The code now does what the question asked for (or the question no longer applies): set `decision: "done"` and say in `Decision` where the code does it. Reading the code to reach that conclusion is a recheck, so also record `recheck: "not-reproduced"`, `rechecked_by: "agent"`, today's `rechecked_on` and a dated `Recheck` entry saying what you read ([closing a gap as done](gaps.md#closing-a-gap-as-done)). Update the spec note from the code in the same pass. If you are unsure the question is closed, leave it open.
|
|
42
|
+
- Otherwise, if the gap has a recorded recheck (`confirmed` or `not-reproduced`) and a cited source changed, set `recheck: "outdated"`, keep `rechecked_by` and `rechecked_on` (they record the last recheck actually done), and add a dated line to `Recheck` naming the source and range. An open gap then returns to `needs-recheck`. Leave `decision` alone. A person, or an agent re-checking the gap (the investigate mode of this skill), records the fresh recheck, which replaces all three fields and adds a new dated entry. Run one yourself only if you really can.
|
|
43
|
+
- You do not have to catch every case by hand: the viewer shows a "recheck outdated" badge on the gap, and lists it under Recent changes, whenever a cited source's current bytes differ from its accepted fingerprint (line-ending-only differences are ignored). The marker exists so the queue shows staleness before anyone edits the gap; setting `outdated` makes it explicit in the page.
|
|
44
|
+
- New doubts found along the way become new gaps (one question each), not notes.
|
|
45
|
+
|
|
46
|
+
Keep unrelated dirty sources deferred; `finish` handles that case without losing the rest of the work (see [partial finish](#partial-finish-when-something-is-deferred)). A normal implementation task can still reread its own edited files, update its own notes, then run `knowledge.py snapshot --notes ID...` without advancing the shared checkpoint; never snapshot someone else's work in progress.
|
|
47
|
+
|
|
48
|
+
At finish time, each selected source must be a regular tracked file whose working bytes equal the raw blob at the target commit, whatever Git ignore, assume-unchanged or skip-worktree flags say. This rejects CRLF conversion and smudge-filter output rather than normalizing it. Explain the mismatch, defer the notes that cite such a file, and leave the checkpoint pending until the checkout is aligned. Missing evidence may remain on explicitly `stale` or `superseded` notes.
|
|
49
|
+
|
|
50
|
+
Write a run page under `runs/`: exact range, observed dirty state, pages changed, exclusions, gaps closed, outdated or created, and the checks you actually ran. Name pages by path in code formatting (`notes/example`), not as links ([why](format.md)). It needs `type: "run"` and the JSON-string properties `review_base` and `review_target`, equal to the full scanned SHAs. An old run page is not a receipt for a new interval, and an empty no-change scan gets no new run page.
|
|
51
|
+
|
|
52
|
+
## 3. Plan, receipt, finish
|
|
53
|
+
|
|
54
|
+
After research and edits, refresh the plan and status:
|
|
55
|
+
|
|
56
|
+
```sh
|
|
57
|
+
python3 "$SKILL_DIR/scripts/maintain.py" scan --repo "$REPO" --vault "$VAULT" --write-status
|
|
58
|
+
```
|
|
59
|
+
|
|
60
|
+
Compare it with the discovery scan; if sources changed during research, reread them. New notes and the run page must exist now. Then have the helper generate the receipt. It fills in every hash from the plan, the notes and the run page, so none is typed by hand:
|
|
61
|
+
|
|
62
|
+
```sh
|
|
63
|
+
python3 "$SKILL_DIR/scripts/maintain.py" receipt --repo "$REPO" --vault "$VAULT" \
|
|
64
|
+
--plan "$VAULT/.knowledge/sync-plan.json" \
|
|
65
|
+
--out "$VAULT/.knowledge/sync-review.json" --run runs/2026-11-15-sync.md
|
|
66
|
+
```
|
|
67
|
+
|
|
68
|
+
`--run` is optional and takes the run page's path inside the vault. Without it the helper picks the single `runs/*.md` page whose `review_base` and `review_target` equal the plan's range, and asks for `--run` if there are none or several. The file gets `plan_sha256`, `run_path` and `run_sha256`, each pending path with an empty `status` and `reason`, and each affected note with an empty `status` and its current `expected_sha256`. Running it again with the same `--out` refreshes the hashes and drops entries that left the plan. It keeps a path's status and reason only when the plan is byte-identical to the one the old receipt was written for, and a note's status only when that note file is unchanged since; otherwise the entry comes back empty and must be reviewed again, because a disposition belongs to the bytes that were reviewed. When an earlier receipt had dispositions, `receipt` tells you how many path and note dispositions it kept, how many it reset and why (the plan changed since the receipt was written, or a note file changed, naming the notes), and how many were dropped because they are no longer in the plan, so you know exactly what to review again. A `reason` you entered on a note is carried over with its status. You fill the dispositions after doing the research:
|
|
69
|
+
|
|
70
|
+
- paths: `reviewed`, `excluded` or `deferred`;
|
|
71
|
+
- notes: `updated`, `unchanged` or `deferred`;
|
|
72
|
+
- a short reason for each, naming what you read. A `deferred` path or note needs a reason that says why it is waiting and for whom.
|
|
73
|
+
|
|
74
|
+
Do not edit the hashes, and do not fill a disposition for work you did not do. Affected notes include those whose previous fingerprints cite a changed path, so replacing a deleted source cannot hide a note. Selected source paths must be canonical and clean; alias or symlink evidence needs canonicalizing and rereading. Then:
|
|
75
|
+
|
|
76
|
+
```sh
|
|
77
|
+
python3 "$SKILL_DIR/scripts/maintain.py" finish --repo "$REPO" --vault "$VAULT" \
|
|
78
|
+
--plan "$VAULT/.knowledge/sync-plan.json" --review "$VAULT/.knowledge/sync-review.json"
|
|
79
|
+
```
|
|
80
|
+
|
|
81
|
+
`finish` rejects empty or unknown dispositions, checks plan identity, checkout and target, source and note drift, and holds a lock while it accepts only the reviewed notes' fingerprints and writes the checkpoint last. On drift or a held lock, inspect the new state and its owner instead of forcing it. The lock covers one local finish; it does not protect concurrent note editing, so use separate branches or worktrees, or one writer per note, and merge explicitly afterwards.
|
|
82
|
+
|
|
83
|
+
### Partial finish when something is deferred
|
|
84
|
+
|
|
85
|
+
Sometimes part of the range cannot be accepted yet: another contributor has uncommitted edits to a file you would have read, or a note depends on work still in progress. `deferred` exists for this, and `finish` does not abort the whole run because of it. Mark the waiting paths and the notes that cite them `deferred`, each with a reason, and finish as usual. A dirty source no longer makes `finish` fail by itself; it requires that a dirty changed path be `deferred` (or cleaned and rescanned), and that every note citing a dirty source or a deferred path be `deferred` too. A source a note was fingerprinted on before but no longer cites is checked against the deferred paths only (a match requires the note to be `deferred`); it is not checked for dirtiness. A note that cites one and is marked `updated` or `unchanged` makes `finish` reject the whole receipt and write nothing, because its claims could not be checked against committed bytes. A deferred note needs a `reason` just as a deferred path does; the generated receipt has a `reason` field on paths only, so add one to the note when you defer it. The run page is required for a partial finish as for a full one.
|
|
86
|
+
|
|
87
|
+
What a partial finish does:
|
|
88
|
+
|
|
89
|
+
- It accepts fingerprints only for notes marked `updated` or `unchanged` whose currently cited sources are clean, tracked, pass the raw-bytes check and are not among the deferred or dirty paths, and none of whose cited or previously fingerprinted sources is a deferred path. Deferred notes keep their previous fingerprints, so they keep showing as needing review.
|
|
90
|
+
- It writes `sources.json`.
|
|
91
|
+
- It writes `.knowledge/review.json` only when nothing is deferred, so in a partial finish it leaves it alone. The checkpoint moves only when nothing applicable is deferred. This is the guarantee that matters: if the checkpoint advanced past deferred work, nobody would ever be told that work was never reviewed.
|
|
92
|
+
- It ends with exit status 3 (2 is reserved for command-line usage errors, 1 for any other failure) and lists each deferred path and note with its reason, and what was accepted. Exit status 0 still means a full finish with the checkpoint advanced, so a script or an agent can tell the two apart. Report a partial finish as partial; do not describe the sync as complete.
|
|
93
|
+
|
|
94
|
+
A scan over the same range still lists the deferred paths as pending, because the checkpoint did not move. It also still lists the notes accepted in the partial finish as affected, since affected means only that a note cites a changed path; they show no freshness warnings. When the other contributor's work is committed, scan again, re-read those files, mark the paths reviewed and the deferred notes `updated` or `unchanged`, give the already-accepted notes a disposition again (normally `unchanged`, if nothing about them changed since) and finish again. That second finish advances the checkpoint if nothing else is deferred. A range with no application paths at all still finishes with exit 0 and leaves the checkpoint as it was.
|
|
95
|
+
|
|
96
|
+
While you wait, `knowledge.py check --strict --ignore-dirty` lets you validate the vault without the other contributor's uncommitted files failing it ([what it hides](format.md)). It forgives a changed source only when the accepted fingerprint still equals the file at `HEAD`, so a change that was committed without review keeps failing, however many uncommitted edits sit on top; untracked and unbaselined sources are never forgiven. It is for a shared working tree, not for CI.
|
|
97
|
+
|
|
98
|
+
### Committing the vault before the sync is finished
|
|
99
|
+
|
|
100
|
+
Prefer to finish the sync before committing vault changes. A vault commit made while an application range is still pending moves HEAD, and the plan and the run page then name an older target. Both `finish` and `receipt` recognize this when every commit between the plan's target and HEAD touches only excluded paths (the vault, the portable skill copy and their wrapper files) and say so. If it happens, first set the run page's `review_target` to the new HEAD (`review_base` stays), because the plan records the run page's bytes; then re-run `scan --write-status`, regenerate the receipt, fill in the dispositions and finish again. Editing the run page after the scan makes the receipt fail its run-hash check. Do not commit the vault between those steps, since that moves HEAD again. If an application commit is in between, the ordinary plan-changed error applies and you need a normal re-scan and review. A range made only of excluded commits needs none of this and no receipt.
|
|
101
|
+
|
|
102
|
+
Finally scan again for the local status and report: the reviewed range, pages added or changed, gaps closed or marked outdated, pending or upstream scope, verification evidence, the path to `sync.html` and the `serve` command that shows the vault. A clear queue does not mean the whole repository has been researched.
|