@dzhechkov/skills-idea2prd 0.1.0 → 0.1.3

package/templates/.claude/skills/goap-research-ed25519/scripts/goap_planner.py

@@ -3,7 +3,7 @@
 GOAP Research Planner with Ed25519 Verification
 
 Enhanced Goal-Oriented Action Planning for research tasks with
-cryptographic verification support for anti-hallucination protection.
+cryptographic provenance and tamper-evidence support.
 
 Features:
 - A* search for optimal research paths
@@ -383,8 +383,8 @@ def find_research_plan(
         if goal_state.issubset(current_state):
             # Check if verification requirements are met
             if require_verification and current.unsigned_claims > 0:
-                # In strict/paranoid mode, penalize but don't reject
-                pass
+                # In strict/paranoid mode, unsigned or invalid claims are rejected.
+                continue
             
             # Reconstruct state progression
             states = [initial_state]
@@ -396,7 +396,7 @@ def find_research_plan(
             
             # Calculate confidence based on verification
             base_confidence = 1.0 - (current.unsigned_claims * 0.1)
-            estimated_confidence = max(0.5, min(1.0, base_confidence))
+            estimated_confidence = min(1.0, base_confidence)
             
             return ResearchPlan(
                 actions=current.actions,

package/templates/.claude/skills/goap-research-ed25519/scripts/test_ed25519_verifier.py

@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+"""Load-bearing security tests for ed25519_verifier.py."""
+
+import copy
+import unittest
+
+import ed25519_verifier as ev
+
+
+@unittest.skipIf(ev.CRYPTO_BACKEND is None, "No Ed25519 backend installed")
+class Ed25519VerifierSecurityTests(unittest.TestCase):
+    def make_pinned_pair(self):
+        signer = ev.Ed25519Verifier(auto_generate_keypair=True)
+        verifier = ev.Ed25519Verifier(
+            trusted_issuers={
+                "nature.com": {
+                    "pubkey_b64": signer.get_public_key_b64(),
+                    "status": "active",
+                }
+            }
+        )
+        return signer, verifier
+
+    def test_attacker_self_signed_trusted_string_rejected(self):
+        _, verifier = self.make_pinned_pair()
+        attacker = ev.Ed25519Verifier(auto_generate_keypair=True)
+
+        fact = attacker.create_issuer_signed_fact(
+            claim="Fabricated result was published",
+            source_url="https://nature.com/articles/example",
+            source_content="attacker-controlled content",
+            issuer="nature.com",
+        )
+
+        result = verifier.verify_fact(fact)
+
+        self.assertFalse(result.verified)
+        self.assertEqual(result.confidence, 0.0)
+        self.assertNotEqual(result.confidence, 0.95)
+
+    def test_fact_signed_by_pinned_trusted_key_verifies(self):
+        signer, verifier = self.make_pinned_pair()
+
+        fact = signer.create_issuer_signed_fact(
+            claim="Pinned-key fact",
+            source_url="https://nature.com/articles/example",
+            source_content="source content",
+            issuer="nature.com",
+        )
+
+        result = verifier.verify_fact(fact)
+
+        self.assertTrue(result.verified)
+        self.assertEqual(result.trust_class, ev.TRUST_CLASS_ISSUER_SIGNED)
+        self.assertEqual(result.confidence, 0.95)
+
+    def test_relabelled_or_moved_fact_fails(self):
+        signer, verifier = self.make_pinned_pair()
+        fact = signer.create_issuer_signed_fact(
+            claim="Pinned-key fact",
+            source_url="https://nature.com/articles/example",
+            source_content="source content",
+            issuer="nature.com",
+        )
+
+        relabelled = copy.deepcopy(fact)
+        relabelled.issuer = "science.org"
+        relabelled_result = verifier.verify_fact(relabelled)
+
+        moved = copy.deepcopy(fact)
+        moved.source_url = "https://nature.com/articles/other"
+        moved_result = verifier.verify_fact(moved)
+
+        self.assertFalse(relabelled_result.verified)
+        self.assertEqual(relabelled_result.confidence, 0.0)
+        self.assertFalse(moved_result.verified)
+        self.assertEqual(moved_result.confidence, 0.0)
+
+    def test_reordered_citation_chain_fails(self):
+        signer, verifier = self.make_pinned_pair()
+        chain = ev.CitationChain(chain_id="test-chain")
+
+        for index in range(3):
+            chain.add_fact(
+                signer.create_issuer_signed_fact(
+                    claim=f"Claim {index}",
+                    source_url=f"https://nature.com/articles/{index}",
+                    source_content=f"source content {index}",
+                    issuer="nature.com",
+                )
+            )
+
+        signer.sign_chain(chain)
+        ok, _, error = verifier.verify_citation_chain(chain, signer.get_public_key_b64())
+        self.assertTrue(ok, error)
+
+        reordered = ev.CitationChain(
+            chain_id=chain.chain_id,
+            facts=[chain.facts[1], chain.facts[0], chain.facts[2]],
+            chain_signature=chain.chain_signature,
+        )
+        reordered_ok, _, reordered_error = verifier.verify_citation_chain(
+            reordered,
+            signer.get_public_key_b64(),
+        )
+
+        self.assertFalse(reordered_ok)
+        self.assertIn("Invalid", reordered_error)
+
+
+if __name__ == "__main__":
+    unittest.main()

package/templates/.claude/skills/idea2prd-manual/SKILL.md

@@ -18,11 +18,83 @@ trust_tier: 1
 
 | Feature | Benefit |
 |---------|---------|
-| **Phase 4.5: Pseudocode** | +99% code quality (research-backed) |
+| **Phase 4.5: Pseudocode** | Algorithm logic fixed before code, so codegen implements a decided design rather than inventing one (see `references/pseudocode-style.md`) |
 | **Phase 5: Test Scenarios** | TDD-ready Gherkin specs |
 | **Phase 6: Completion** | CI/CD, deployment, monitoring |
 | **9 Checkpoints** | Full control over each phase |
 
+## What's New in v3 (honesty + memory layer)
+
+| Feature | Benefit |
+|---------|---------|
+| **Claim Discipline** | Every accuracy/count/percentage claim in an emitted doc carries an honest tag (MEASURED / CLAIMED / ESTIMATED) — no unsourced numbers |
+| **ADR Confirmation stanza** | Every generated ADR names its load-bearing property + the fitness function / Gherkin test that would falsify it (Phase 3 → Phase 5 wired) |
+| **Brain memory (Step 0 recall → closing teach)** | Recalls prior PRD/ADR lessons into the brief and teaches new ones at the end — idea2prd stops being write-once |
+
+---
+
+## Authoring Discipline (applies to EVERY emitted doc)
+
+### Claim Discipline (MEASURED / CLAIMED / ESTIMATED) — mandatory
+
+The docs this skill emits (PRD, ADRs, fitness targets, executive summary) **must not carry untagged
+accuracy, count, percentage, or performance claims.** Whenever you write a metric term next to a number
+(`%`, `x faster`, coverage, latency, "N of M", "reduces … by …"), the same paragraph MUST carry one of
+these honest tags, else do not write the number:
+
+| Tag | Use when |
+|-----|----------|
+| `(MEASURED — <reproducer / source>)` | You actually ran/observed it — cite the command, file, or source |
+| `(CLAIMED — <who/where>)` | Repeating an external/vendor claim you did not verify — attribute it |
+| `(ESTIMATED — <basis>)` | A projection or target, not an observation — name the basis |
+
+**Rule:** an untagged number that looks like a result is a defect. Prefer deleting a fabricated number
+over dressing it up. This applies to **fitness-function targets and count tables too** — a target cell or
+a count cell is a claim: template it as a `[placeholder]` and tag the real value MEASURED (an observed
+baseline, naming its reproducer) or ESTIMATED (a chosen target, naming its basis) when it is filled in.
+
+**Perfect-score prohibition:** a bare `100%` / `0 defects` / `never fails` / `always` cell is always a
+HIGH finding — `dz claim-check` flags such a literal even when tagged, because perfection is almost never
+observed. State the real value against a baseline (tag it MEASURED, name the reproducer), or express a
+target as ESTIMATED with its basis (for example `target >= 95 (ESTIMATED from NFR-P01)`).
+
+(This mirrors the harness Integrity Rule; a `dz claim-check` scan over the emitted `docs/` should pass —
+run it if `dz` is available: `dz claim-check docs/ --fail-on medium`. Use `medium`, not `high`: `high`
+lets ordinary untagged medium claims through — the false-green this discipline exists to stop.)
+
+### Brain memory — recall at Step 0, teach at the end (pin ONE canonical store)
+
+If the `dz` CLI is available, idea2prd **learns across runs**. The learned-pattern store is pinned to
+**ONE canonical brain store** — the project root as an ABSOLUTE path (the directory that will hold
+`docs/`) — via `--project`, so lessons land in one store instead of fragmenting across sub-directories
+(a recall from one store and a teach to another cannot reinforce each other):
+
+- **Step 0 (before Gate 0):** recall prior PRD/ADR lessons and fold the top ones into the brief.
+- **Closing (after Phase 6):** teach the genuinely new lessons from this run.
+
+Both are guarded by "if `dz` present" — absent `dz`, skip silently and run the pipeline unchanged.
+
+---
+
+## Step 0: Brain Recall (run BEFORE Gate 0)
+
+**Action (only if `dz` is on PATH — else skip silently):** resolve `<BRAIN>` to the **ABSOLUTE** path of
+the project root (the directory that will hold `docs/`, e.g. via `pwd`) and use that SAME absolute path in
+Step 0 recall and the closing teach. Via Bash run VERBATIM (`<BRAIN>` shell-quoted so a path with spaces
+does not break the command):
+
+```bash
+cd "<BRAIN>" && dz recall "<key domain terms of this idea/problem> PRD ADR bounded-context" --project "<BRAIN>"
+```
+
+> `<BRAIN>` MUST be absolute. A relative `<BRAIN>` makes `cd "<BRAIN>"` then `--project "<BRAIN>"` resolve
+> against the new working directory (a nested `<BRAIN>/<BRAIN>`), pinning the store to the wrong place.
+
+- Log the number of patterns loaded.
+- Fold the top 3 applicable patterns into the Task Brief / Requirements as a `{LEARNED_PATTERNS}` note,
+  and **preserve their text** so the closing teach step can compare candidate lessons against them.
+- No patterns (first run) → proceed normally.
+
 ## Bundled Components
 
 ```
@@ -328,8 +400,14 @@ idea2prd-manual/
 
 ### Phase 3: ADR + C4
 
+**Reference:** `references/adr-catalog.md` (ADR template — the `## Confirmation` stanza is REQUIRED).
+
 **Генерирует:**
-- 10+ ADRs
+- 10+ ADRs — **every ADR MUST carry a `## Confirmation` stanza** (Method / Monitoring / Success metric /
+  Owner / **Load-bearing property** / **Required automated check: `<fitness function or Gherkin test>`**).
+  The named check MUST be a real Phase-5 artifact (a `FF-NNN` fitness function or a `.feature` Gherkin
+  scenario) — this is what wires Phase 3 → Phase 5 and turns each ADR from prose into a *checkable*
+  decision. An ADR whose Confirmation names no falsifying test is incomplete.
 - C4 Level 1: System Context
 - C4 Level 2: Container
 - C4 Level 3: Component
@@ -342,12 +420,15 @@ idea2prd-manual/
 
 ## ADRs Summary
 
-| ADR | Decision | Status |
-|-----|----------|--------|
-| ADR-001 | [Architecture]: [choice] | Accepted |
-| ADR-002 | [Database]: [choice] | Accepted |
+| ADR | Decision | Status | Load-bearing property | Falsifying test |
+|-----|----------|--------|-----------------------|-----------------|
+| ADR-001 | [Architecture]: [choice] | Accepted | [property] | FF-0NN / [feature].feature |
+| ADR-002 | [Database]: [choice] | Accepted | [property] | FF-0NN / [feature].feature |
 ...
 
+> **Confirmation check:** every row above MUST name a load-bearing property and a real falsifying test
+> (a `FF-NNN` fitness function or a Gherkin `.feature` scenario). A blank = an incomplete ADR — go back.
+
 ## C4 Diagrams
 
 - Level 1: System Context ✅
@@ -403,7 +484,7 @@ idea2prd-manual/
 
 **Reference:** `references/pseudocode-style.md`
 
-**КРИТИЧЕСКИ ВАЖНО для качества генерации кода (+99% по исследованиям).**
+**Псевдокод фиксирует алгоритмическую логику ДО кодогенерации — меньше неоднозначности при реализации.** (Никаких неподтверждённых процентов: любые метрики качества эмитятся только с честным тегом — см. раздел «Claim Discipline».)
 
 **Действие Claude:**
 ```
@@ -552,7 +633,31 @@ Feature: Order Placement
 
 **Output file:** `docs/completion/COMPLETION_CHECKLIST.md`
 
-**После Phase 6 — финальный Executive Summary (без checkpoint).**
+**После Phase 6 — Brain Teach, затем финальный Executive Summary (без checkpoint).**
+
+---
+
+## Closing: Brain Teach (run AFTER Phase 6, only if `dz` present — else skip silently)
+
+Close the learning loop: teach the genuinely NEW lessons from this run to the SAME canonical brain store
+that Step 0 recalled from — the SAME ABSOLUTE `<BRAIN>` path (the project root), pinned with `--project`
+so nothing fragments.
+
+**Action:**
+1. Compare the run's candidate lessons (a reusable PRD/ADR/DDD decision, a domain constraint that bit, a
+   fitness-function pattern) against the `{LEARNED_PATTERNS}` text recalled in Step 0.
+2. For a lesson ALREADY covered by a recalled pattern → do NOT re-teach it (it is already in the store).
+3. For each genuinely NEW lesson, via Bash run VERBATIM (one call per lesson):
+
+```bash
+cd <BRAIN> && dz teach "<one-line reusable lesson>" --reward 0.7 --domain idea2prd --project <BRAIN>
+```
+
+4. Log how many lessons were taught (0 is a valid, honest result on a run that surfaced nothing new).
+
+> **Pin discipline:** Step 0 recall and this teach MUST hit the SAME `<BRAIN>` (project root) via
+> `--project` — if recall reads one store and teach writes another, the two stores stay separate and
+> the loop does not accumulate in a single place. This mirrors the feature-adr `args.brain` rule.
 
 ---
 

package/templates/.claude/skills/idea2prd-manual/references/adr-catalog.md

@@ -43,10 +43,32 @@
 ### Risks
 - [Risk]: Mitigation: [approach]
 
+## Confirmation
+<!-- REQUIRED. An ADR without this stanza is incomplete. -->
+- **Load-bearing property:** [the single property that, if it silently regressed, makes this decision wrong]
+- **Required automated check:** [`FF-NNN` fitness function OR `docs/tests/<feature>.feature` Gherkin scenario that FAILS if the property is violated]
+- **Verification method:** [how the check is run — e.g. CI stage, fitness_validator.py, test runner]
+- **Monitoring:** [what to watch in production to detect drift — metric/log/alert]
+- **Success metric:** [the threshold that says the property still holds — tag it MEASURED / ESTIMATED]
+- **Owner:** [role/team accountable for the check]
+
 ## Related ADRs
 - ADR-XXX: [relationship]
 ```
 
+> **Confirmation stanza is load-bearing (idea2prd v3).** Every generated ADR MUST carry `## Confirmation`.
+> Its `Required automated check` MUST name a REAL Phase-5 artifact — a `FF-NNN` fitness function
+> (`references/fitness-functions-catalog.md` / `scripts/fitness_validator.py`) or a Gherkin `.feature`
+> scenario — so the decision's load-bearing property is *falsifiable*, not prose. This wires Phase 3 (ADR)
+> to Phase 5 (fitness/tests): a property an ADR names is often the one that ships untested (a recurring
+> lesson in this repo), so the Confirmation stanza forces it to name its falsifying test.
+> An ADR whose Confirmation names no falsifying check is **incomplete** — do not accept it at Checkpoint 3.
+
+### Supersession discipline
+
+Never edit an Accepted/Rejected ADR's decision in place. A changed decision **mints a new ADR** that
+supersedes the old one (`Status: Superseded by ADR-XXX`), and the new ADR carries its own `## Confirmation`.
+
 ---
 
 ## Standard ADRs (Required)

package/templates/.claude/skills/idea2prd-manual/references/pseudocode-style.md

@@ -4,7 +4,7 @@
 
 Pseudocode в idea2prd используется для:
 1. Точного описания алгоритмов до написания кода
-2. Улучшения качества генерации кода в Claude Code (+99% по исследованиям)
+2. Снижения неоднозначности при кодогенерации в Claude Code (алгоритм зафиксирован до кода)
 3. Документирования business logic
 
 ## Syntax Conventions