Clean slate

.agents/skills/conformance/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: conformance
+description: "Behavioral conformance check across GraphReFly language runtimes (ts/rust/py) for the clean-slate redesign. Replaces the old structural 'parity' diff. Parity = does each runtime satisfy the wave-protocol behavior (conformance scenarios) + dispatcher contract — NOT 'do the symbol sets match'. Use after implementing/changing substrate behavior in any runtime, or when adding a new protocol rule. Authors/runs language-agnostic scenarios and updates conformance.jsonl runtime status. Triggers: 'conformance', 'cross-lang check', 'does rust match', 'parity', 'run the conformance suite', 'is the substrate behavior consistent'."
+argument-hint: "[rule-id | scenario-id | 'full'] [optional: runtime ts|rust|py]"
+---
+
+You are executing **conformance** for the clean-slate GraphReFly redesign.
+
+**Parity is behavioral, not structural (D24).** There is NO `Impl` symbol-set to diff and NO
+cross-track-ledger. Operators / sugar / inspection are **per-language and never in parity**
+(D6/D27 — graph-layer wraps everything to `(ctx)=>void` before register). The ONLY parity
+surface is: **wave-protocol behavior + dispatcher contract + handle format**. Conformance =
+each runtime passes the same language-agnostic scenarios.
+
+## Authority
+
+| Source | Role |
+|---|---|
+| `~/src/graphrefly/spec/conformance.jsonl` | The scenario registry: `{id, name, covers:[rule-id], runtimes:{ts,rust,py}, status, note}`. |
+| `~/src/graphrefly/spec/rules.jsonl` | The rules scenarios pin (`covers` must resolve here). |
+| `~/src/graphrefly/spec/protocol.proto` | Protocol-contract IDL (DR-2) — the light structural anchor codegen'd into each runtime's interface stub. |
+| `~/src/graphrefly/formal/*.tla` | TLA+ model (γ); property tests mirror its invariants. |
+
+## Scope from $ARGUMENTS
+
+- **rule-id** (e.g. `R-diamond`) → all scenarios whose `covers` includes it.
+- **scenario-id** (e.g. `C-1`) → that scenario.
+- **full** → every `status:"required"` scenario.
+- optional **runtime** → restrict to one arm.
+
+## Phase 1 — scenario integrity
+
+1. Load `conformance.jsonl` + `rules.jsonl`. Verify every `covers` rule-id resolves (else HALT — fix the scenario or add the rule via `/spec-amend`).
+2. List the **DR-5 required hard scenarios** and their status: `C-1` cross-graph diamond, `C-2` async-result-at-paused-node, `C-3` INVALIDATE×ctx.state×onInvalidate, `C-4` mixed sync/async diamond, `C-5` PAUSE-lockset multi-source. These are the load-bearing ones — behavioral parity is a blank cheque until they're green on each shipped runtime.
+
+## Phase 2 — run / verify per runtime
+
+For each in-scope `(scenario, runtime)`:
+1. Locate/author the scenario harness in that runtime's conformance test dir (language-agnostic spec → per-runtime adapter; the scenario describes observable wave behavior, not a symbol call).
+2. Run it. Record outcome.
+3. Update `conformance.jsonl` `runtimes.<rt>`: `"todo" | "poc-pass" | "pass" | "fail"`.
+4. Mirror the invariant as a property test (fast-check ts ↔ proptest rust ↔ hypothesis py) where the rule is property-shaped (L5-Q2 / D14).
+
+## Phase 3 — report
+
+| scenario | covers | ts | rust | py | verdict |
+|---|---|---|---|---|---|
+
+- **Behavior drift** = same scenario, different observable outcome across runtimes → this is the ONLY kind of parity gap. File it as a substrate bug in the lagging runtime (route fix via `/dev-dispatch` on that package).
+- **Missing scenario** for a rule (rule's `covers_by` empty) → author it (this is the real risk under behavioral parity: untested behavior can drift silently — D24 residual). Flag via `/dashboard` Gaps (uncoveredRules).
+- **NOT a gap:** a runtime having a different operator set / different sugar / different inspection ergonomics. Those are per-language by design — do not report them.
+
+## Phase 4 — gate
+
+Run `node ~/src/graphrefly/dashboard/build.mjs --check` (scenario↔rule links intact). For a runtime
+to be declared "conformant", all `status:"required"` scenarios must be `"pass"` on its arm.
+
+## Boundaries
+
+Does NOT diff symbol sets (that's the retired structural model). Does NOT touch operators/sugar/inspection
+(per-language). New protocol behavior must go through `/spec-amend` FIRST (scenario authored before code).

.agents/skills/dashboard/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: dashboard
+description: "Build / check the GraphReFly internal docs dashboard (jsonl single-source -> generated HTML with progress, structure map, gaps, search). Use when the user wants to see global project state, regenerate the dashboard, run the docs consistency gate (broken links / orphans / coverage gaps), or after editing any jsonl in ~/src/graphrefly (decisions/plan/spec/sessions/guide). Triggers: 'build the dashboard', 'check docs consistency', 'what are the gaps', 'show progress', 'regenerate dashboard', 'doc gate'."
+argument-hint: "[--check (gate only) | (default: build + report)]"
+---
+
+You are executing **dashboard** for the clean-slate GraphReFly redesign.
+
+**Repo:** `~/src/graphrefly` (clean-slate branch). All structured docs are jsonl (single source of truth, decision 2); the dashboard renders them into one searchable HTML view for the maintainer (decision 3). Schema contract: `~/src/graphrefly/dashboard/README.md`.
+
+## What this skill does
+
+1. **Run the generator:**
+   - `node ~/src/graphrefly/dashboard/build.mjs` → writes `dashboard/dashboard.html` + prints counts / gaps / broken-links / orphans report.
+   - `node ~/src/graphrefly/dashboard/build.mjs --check` → consistency gate only; **non-zero exit on broken links** (use as a pre-commit / CI gate).
+2. **Interpret the report** for the user:
+   - **counts** — per-jsonl row counts (decisions/phases/rules/conformance/...).
+   - **gaps** — designPhases (status=design|gap) · openDecisions · deferredBacklog · uncoveredRules (no conformance) · todoConformance (runtimes=todo). This answers "哪里还有缺口".
+   - **broken links** — must be zero (session.locks → decision; phase.sessions → session; conformance.covers → rule; flowchart.explains → rule|D#). Legacy 3-digit D### / R# refs are external (old main), reported separately as OK.
+   - **orphans** — decisions referenced by no session (informational).
+3. **If broken links exist:** locate the offending jsonl row, fix the id reference (or add the missing record), re-run `--check`.
+
+## When the jsonl changed
+
+After any edit to `decisions/`, `plan/`, `spec/`, `sessions/`, `guide/` jsonl — run `--check` to catch dangling references immediately (fixes P4 stale-premise + P6 link-rot). The generator is the enforcement mechanism for "single canonical, no broken cross-refs."
+
+## UI styling
+
+`build.mjs` emits a **placeholder shell** with the data model embedded. Visual design / interactive search is a separate `/frontend-design` pass — do NOT hand-style the HTML here; keep `build.mjs` focused on the data model + consistency checks. The dogfood endgame (phase CSP-8) rebuilds this dashboard *with GraphReFly itself* (jsonl producer → reactive views → HTML effect).
+
+## Output
+
+The counts + gaps + link-health report, a plain-language "where are the gaps / what's the progress" summary, and (unless `--check`) confirmation that `dashboard.html` was written. Flag any broken link as a blocker to fix before commit.

.agents/skills/decision-guard/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: decision-guard
+description: "GraphReFly clean-slate decision-consistency check. Loads the user's locked values/principles + the unified D-numbered decision log (decisions.jsonl) + recurring decision-process patterns. Use BEFORE answering any question of the form 'is this consistent with our decisions?', 'should I pick option A/B/C?', 'what about this proposed fix?', 'is X part of our scope?', 'is this a regression on a prior decision?'. Triggers: 'decision check', 'drift check', 'align check', 'is this consistent', 'should I pick', 'what about this', 'is this in scope', 'consistency review'."
+argument-hint: "[short context of what you're being asked about — paste the proposal if relevant]"
+---
+
+# decision-guard — recall and apply locked decisions, values, invariants (clean-slate)
+
+**Purpose.** Conversations lose context-window state quickly. This is the canonical recall
+surface for the **clean-slate** redesign: invoke BEFORE answering decision questions to anchor
+against the user's locked positions and prevent silent drift — especially when a chat proposes
+a scope expansion mid-implementation, presents A/B/C as a fork, uses "completeness" to justify
+expanding a locked slice, or builds on a premise that may be stale.
+
+> **Clean-slate retired the old port model.** Do NOT reach for `rust-port-decisions.md`,
+> `cross-track-ledger.md`, the `Impl` parity contract, `BindingBoundary`, the actor model, or
+> 3-digit D### port decisions — those are old-`main` history. The clean-slate decision
+> authority is below.
+
+## Sources (load in order)
+
+| Source | Role |
+|---|---|
+| `~/src/graphrefly/decisions/decisions.jsonl` | **Unified D# log** (D1–D33 + DR-*). Canonical record: `{id, layer, question, decision, rationale, supersedes, status}`. |
+| `~/src/graphrefly/sessions/active/SESSION-clean-slate-redesign.md` (DS-1) | Full design narrative + 8 forced constraints + spec-amendment list + conformance hard scenarios. |
+| `~/src/graphrefly/plan/antipatterns.jsonl` | Lessons / anti-patterns to flag against. |
+| `~/src/graphrefly/spec/rules.jsonl` | Protocol rules — for "does the spec already pin this?". |
+| Memory `feedback_*` files | The user's durable values/principles (below). |
+
+## Locked values (durable — cite by name)
+
+1. **No backward compat** (pre-1.0): structurally cleaner option, no legacy shims. `feedback_no_backward_compat`.
+2. **No imperative triggers** in public API: reactive `ctx.up`/signals, not emitters/callbacks/timers+set; remove imperative paths when no caller depends. `feedback_no_imperative`.
+3. **Single source of truth**: one canonical per concern; index points, never duplicates. `feedback_single_source_of_truth`.
+4. **No autonomous decisions** (hard rule): surface spec↔code conflicts; don't silently pick; file-by-file review for multi-file rewrites. `feedback_no_autonomous_decisions`.
+5. **No implement without approval**: decisions locked ≠ implementation approved. `feedback_no_implement_without_approval`.
+6. **Verify premise before greenfield**: design tables lag code — grep symbols + check landed markers before a 9Q; stale premise = HALT. `feedback_verify_premise_before_greenfield`.
+7. **Latest versions + context7** for current API docs. `feedback_latest_versions_context7`.
+8. **Long-command observation discipline** (run-logged + DONE sentinel; no tail; no sleep-poll) and **subagent bg hygiene** (sync-verify or teardown before return). `feedback_long_command_observation`, `feedback_subagent_bg_hygiene`.
+
+## Clean-slate floor (never violate)
+
+**Sacred (L0.7):** topology declarative/serializable/inspectable · wave protocol is a public spec ·
+wave protocol impl is **sync** · all fn go through dispatcher.
+
+**Forced (F-*):** F-PERF (budget every abstraction) · F-PROTO-SPEC (spec+TLA++property) ·
+F-SYNC-CORE (dispatcher.invoke sync void) · F-DISPATCH-ALL (no inline-fn bypass) ·
+F-GRAPH-FIRST-API · F-NO-WEDGE-CUT (every primitive ≥2 segments) ·
+F-NO-IMPL-DEFINED (spec-locked or explicitly undefined-by-design) · F-NO-LLM-ONLY.
+
+**Red flags (HALT if proposed):** async in the sync wave core (async lives only in pools/wire-bridge) ·
+inline-fn bypassing dispatcher · a primitive serving only LLM workflows · a protocol behavior left
+"implementation-defined" · user-replaceable onMessage/onSubscribe · adding a 10th tier casually ·
+graph-level shared mutable state accessed implicitly (must be explicit node + dep).
+
+## Decision-process patterns (apply in order)
+
+1. **Identify the governing D#.** Grep `decisions.jsonl` by `layer`/keyword. Is the proposal within a locked D's scope? Mid-implementation scope expansion = anti-pattern unless promoted to a NEW D#.
+2. **Check the spec.** Does `rules.jsonl` pin the behavior? If yes, follow it — divergence is a bug, not a design call. If silent/ambiguous → real design HALT.
+3. **Verify premise (value 6).** Has the symbol/surface already landed? grep before designing new surface.
+4. **Apply values + floor.** Especially: no autonomous decisions, no imperative, single source of truth, sync-core/async-at-boundary, F-* constraints.
+5. **Verdict:** `consistent (cite D#)` / `regression on D#` / `out-of-scope` / `needs new decision (don't auto-pick)`.
+6. **Routing:**
+   - New fork, no governing D# → present options + recommend, **do NOT lock** → that's `/design-review` → user approval → append `decisions.jsonl`.
+   - Changes protocol behavior → `/spec-amend` (spec-first).
+   - Cross-runtime parity concern → `/conformance` (behavioral scenario, not structural diff).
+
+## Common decision shapes
+
+- **A/B/C (fix shape):** default = the option that **structurally extends an existing pattern** beats per-site workarounds.
+- **Completeness vs discipline:** if a proposal closes a real semantic gap → formalize as a NEW D# (don't continue under the original D's banner). If speculative scope expansion → revert.
+- **Orthogonal sub-decisions:** before locking two "orthogonal" sub-decisions, sketch ONE input exercising BOTH — confirm orthogonality survives the example (antipatterns.jsonl; the 30-second check that catches coupling at design-time).
+
+## Scope boundaries
+
+Read-mostly. Loads decisions + values + patterns; produces **decision + reasoning + relay-ready text**.
+Does NOT run gates, apply fixes, or author scenarios — those are `/dev-dispatch` / `/qa` / `/conformance`
+after a decision locks. Invoke when the question is "what should I decide?", not "what should I do?".
+
+## Update protocol
+
+When a new D# locks (after user approval): append to `~/src/graphrefly/decisions/decisions.jsonl`
+(`{id, layer, date, question, decision, rationale, supersedes, status:"locked", session}`), update the
+session's `locks` in `sessions.jsonl`, and run `node ~/src/graphrefly/dashboard/build.mjs --check`.
+When a new anti-pattern recurs: append to `~/src/graphrefly/plan/antipatterns.jsonl` (+ a `feedback_*`
+memory if generalizable). When a new durable value surfaces: add a `feedback_<name>.md` memory + a
+pointer line here.