rdap-q 1.2.1

package/marketplace.json

@@ -0,0 +1,112 @@
+{
+  "$schema": "https://raw.githubusercontent.com/agent-skills/spec/main/marketplace.schema.json",
+  "name": "rdap-q",
+  "displayName": "RDAP-Q: Adaptive Planning with Quality Gates",
+  "version": "1.2.1",
+  "protocol": "RDAP-Q Agent Engineering Protocol",
+  "summary": "Universal AI agent engineering protocol for evidence-first software development, calibrated scoring, and quality gates across Codex, Grok, Copilot, Antigravity, Goose, Claude, Cline, and Cursor.",
+  "description": "Vendor-neutral Research-Driven Adaptive Planning with Quality Gates (RDAP-Q) enables autonomous AI coding agents to execute non-trivial software tasks with disciplined evidence collection, deterministic phase execution, persistent project state, calibrated quality scoring (0-10 scale), and diminishing-return exit logic. Native support for OpenAI Codex, xAI Grok, GitHub Copilot, Google Antigravity, Block Goose, Anthropic Claude, Cline, and Cursor.",
+  "author": {
+    "name": "coldcanuk",
+    "url": "https://github.com/coldcanuk"
+  },
+  "license": "GPL-3.0-or-later",
+  "repository": "https://github.com/coldcanuk/rdapq",
+  "categories": [
+    "Software Engineering",
+    "Agent Protocols",
+    "Quality Assurance",
+    "Productivity",
+    "Developer Tools"
+  ],
+  "tags": [
+    "rdap-q",
+    "agent-skill",
+    "quality-gates",
+    "adaptive-planning",
+    "codex",
+    "grok",
+    "copilot",
+    "antigravity",
+    "goose",
+    "claude",
+    "cline",
+    "cursor",
+    "evidence-first"
+  ],
+  "entrypoint": "rdap-q-skill/SKILL.md",
+  "invocation": "/rdapq",
+  "supported_harnesses": [
+    {
+      "id": "codex",
+      "name": "OpenAI Codex / Agents",
+      "status": "supported",
+      "configuration": "AGENTS.md",
+      "marketplace_identifier": "rdapq-codex-skill"
+    },
+    {
+      "id": "grok",
+      "name": "xAI Grok",
+      "status": "supported",
+      "configuration": ".grok/rules.md",
+      "marketplace_identifier": "rdapq-grok-skill"
+    },
+    {
+      "id": "copilot",
+      "name": "GitHub Copilot",
+      "status": "supported",
+      "configuration": ".github/copilot-instructions.md",
+      "marketplace_identifier": "coldcanuk.rdapq-copilot"
+    },
+    {
+      "id": "antigravity",
+      "name": "Google Antigravity",
+      "status": "supported",
+      "configuration": "GEMINI.md",
+      "marketplace_identifier": "rdap-q"
+    },
+    {
+      "id": "goose",
+      "name": "Block Goose",
+      "status": "supported",
+      "configuration": ".goosehints",
+      "marketplace_identifier": "rdapq-goose-toolkit"
+    },
+    {
+      "id": "claude",
+      "name": "Anthropic Claude / Claude Code",
+      "status": "supported",
+      "configuration": "CLAUDE.md",
+      "marketplace_identifier": "rdapq-claude-plugin"
+    },
+    {
+      "id": "cline",
+      "name": "Cline & Roo Code",
+      "status": "supported",
+      "configuration": ".clinerules",
+      "marketplace_identifier": "coldcanuk.rdapq-cline"
+    },
+    {
+      "id": "cursor",
+      "name": "Cursor",
+      "status": "supported",
+      "configuration": ".agents/skills/rdap-q/SKILL.md",
+      "marketplace_identifier": "rdap-q"
+    }
+  ],
+  "commands": {
+    "/rdapq": "Execute task using RDAP-Q protocol with evidence gathering and adaptive quality gates.",
+    "/rdapq status": "Inspect current lifecycle phase, quality scorecard, confidence levels, and active gates.",
+    "/rdapq score": "Calculate or display the current calibrated 8-dimension scorecard.",
+    "/rdapq audit": "Trigger the adversarial final-audit verification checklist.",
+    "/rdapq resume": "Safely reload persistent project state and verify environment drift before continuing.",
+    "/rdapq memory": "Query durable cross-session patterns, lessons, and constraints.",
+    "/rdapq research": "Initiate structured evidence gathering and discovery for the current task.",
+    "/rdapq explain": "Provide transparent rationale for the current quality decision or state transition."
+  },
+  "links": {
+    "documentation": "https://github.com/coldcanuk/rdapq/blob/main/rdap-q-skill/README.md",
+    "specification": "https://github.com/coldcanuk/rdapq/blob/main/rdap-q-skill/SKILL.md",
+    "issues": "https://github.com/coldcanuk/rdapq/issues"
+  }
+}

package/package.json

@@ -0,0 +1,102 @@
+{
+  "name": "rdap-q",
+  "version": "1.2.1",
+  "description": "Research-Driven Adaptive Planning with Quality Gates (RDAP-Q) — Vendor-neutral AI agent engineering protocol & skill for Codex, Grok, Copilot, Antigravity, Goose, Claude, Cline, and Cursor. Evidence-first software engineering, persistent memory, and calibrated quality gates.",
+  "main": "rdap-q-skill/SKILL.md",
+  "bin": {
+    "rdapq": "./bin/rdapq.js",
+    "rdap-q": "./bin/rdapq.js",
+    "rdapq-install": "./bin/rdapq.js"
+  },
+  "author": "coldcanuk",
+  "license": "GPL-3.0-or-later",
+  "homepage": "https://github.com/coldcanuk/rdapq#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/coldcanuk/rdapq.git"
+  },
+  "bugs": {
+    "url": "https://github.com/coldcanuk/rdapq/issues"
+  },
+  "keywords": [
+    "rdap-q",
+    "rdapq",
+    "ai-agent",
+    "agent-skills",
+    "copilot-extension",
+    "github-copilot",
+    "claude-code",
+    "claude-skill",
+    "claude-plugin",
+    "anthropic-claude",
+    "openai-codex",
+    "codex-skill",
+    "xai-grok",
+    "grok-skill",
+    "google-antigravity",
+    "antigravity-skill",
+    "block-goose",
+    "goose-toolkit",
+    "cursor",
+    "cursor-skill",
+    "cline",
+    "cline-rules",
+    "roo-code",
+    "quality-gates",
+    "adaptive-planning",
+    "software-engineering-protocol",
+    "evidence-first",
+    "autonomous-agent",
+    "sdlc-automation",
+    "slash-commands",
+    "llm-code-quality",
+    "marketplace"
+  ],
+  "scripts": {
+    "start": "node bin/rdapq.js",
+    "init": "node bin/rdapq.js init",
+    "status": "node bin/rdapq.js status",
+    "test": "node scripts/check-versions.js && node scripts/check-static.js && node --test --test-concurrency=1 test/*.js",
+    "check": "node scripts/check-versions.js && node scripts/check-static.js",
+    "prepack": "node scripts/materialize-skill-links.js materialize",
+    "postpack": "node scripts/materialize-skill-links.js restore",
+    "install:all": "node bin/rdapq.js install --all",
+    "install:claude": "node bin/rdapq.js install --claude",
+    "install:cline": "node bin/rdapq.js install --cline",
+    "install:copilot": "node bin/rdapq.js install --copilot",
+    "install:antigravity": "node bin/rdapq.js install --antigravity",
+    "install:codex": "node bin/rdapq.js install --codex",
+    "install:grok": "node bin/rdapq.js install --grok",
+    "install:goose": "node bin/rdapq.js install --goose",
+    "install:cursor": "node bin/rdapq.js install --cursor"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "bin",
+    "rdap-q-skill",
+    "marketplace.json",
+    "manifest.json",
+    "skills.json",
+    "agentskills.json",
+    "plugin.json",
+    "install.sh",
+    "install.ps1",
+    "lib",
+    "scripts",
+    "AGENTS.md",
+    "CLAUDE.md",
+    "GEMINI.md",
+    ".clinerules",
+    ".goosehints",
+    ".claude-plugin",
+    ".claude",
+    ".grok-plugin",
+    ".github",
+    ".grok",
+    ".codex",
+    ".agents",
+    "plugins"
+  ]
+}

package/plugin.json

@@ -0,0 +1,12 @@
+{
+  "name": "rdap-q",
+  "version": "1.2.1",
+  "description": "Research-Driven Adaptive Planning with Quality Gates protocol plugin for Google Antigravity & AI agents.",
+  "rules": [
+    "GEMINI.md",
+    "AGENTS.md"
+  ],
+  "skills": [
+    "rdap-q-skill"
+  ]
+}

package/plugins/rdap-q/plugin.json

@@ -0,0 +1,21 @@
+{
+  "name": "rdap-q",
+  "version": "1.2.1",
+  "description": "Research-Driven Adaptive Planning with Quality Gates protocol for evidence-first software engineering and diminishing-return exit gates.",
+  "author": {
+    "name": "coldcanuk"
+  },
+  "homepage": "https://github.com/coldcanuk/rdapq",
+  "keywords": [
+    "rdap-q",
+    "adaptive-planning",
+    "quality-gates",
+    "evidence-first",
+    "scoring",
+    "sdlc"
+  ],
+  "license": "GPL-3.0-or-later",
+  "skills": [
+    "skills/rdap-q"
+  ]
+}

package/plugins/rdap-q/skills/rdap-q/README.md

@@ -0,0 +1,171 @@
+# RDAP-Q Skill v1.2.1
+
+`SKILL.md` is the instruction source. This README is not a second copy of the protocol.
+
+**Research-Driven Adaptive Planning with Quality Gates**
+
+RDAP-Q is a portable agent-engineering protocol for evidence-first software
+development.
+
+It uses:
+
+- deterministic phase loading;
+- persistent repository state;
+- durable Markdown memory;
+- evidence-linked scoring;
+- hard quality gates;
+- diminishing-return exit logic;
+- vendor-neutral capability names;
+- a collision-resistant `/rdapq` command namespace.
+
+## Canonical namespace
+
+```text
+Protocol:          RDAP-Q Agent Engineering Protocol
+Skill:             RDAP-Q Skill
+Slash command:     /rdapq
+Environment:       RDAPQ_HOME
+Unix home:         ~/.rdapq
+Windows home:      %USERPROFILE%\.rdapq
+Repository state:  <repo>/.rdapq/state/
+```
+
+## RDAPQ_HOME
+
+Resolution order:
+
+```text
+1. Explicit RDAPQ_HOME
+2. Windows: %USERPROFILE%\.rdapq
+3. Unix-like: ${HOME}/.rdapq
+```
+
+This works cleanly with normal hosts, containers, CI, and bubblewrap sandboxes
+because `RDAPQ_HOME` may be redirected explicitly.
+
+## Storage model
+
+Global:
+
+```text
+$RDAPQ_HOME/
+├── config.md
+├── memory/
+├── projects/
+├── registry/
+└── skills/
+```
+
+Repository-local:
+
+```text
+<repo>/.rdapq/state/
+├── scope.md
+├── assumptions.md
+├── evidence.md
+├── research.md
+├── plan.md
+├── scorecard.md
+├── risks.md
+├── decisions.md
+└── iteration-log.md
+```
+
+## Memory versus state
+
+**State** is transient project/build working memory.
+
+**Memory** is durable reusable knowledge.
+
+Do not promote something to durable memory unless it is:
+
+- durable;
+- reusable;
+- material;
+- safe;
+- grounded.
+
+Never persist secret values.
+
+## Slash commands
+
+```text
+/rdapq <task>
+/rdapq status
+/rdapq score
+/rdapq audit
+/rdapq resume
+/rdapq memory
+/rdapq research
+/rdapq explain
+```
+
+## Package layout
+
+```text
+rdap-q-skill/
+├── SKILL.md
+├── README.md
+├── manifest.json
+├── core/
+│   ├── controller.md
+│   ├── capabilities.md
+│   ├── memory.md
+│   ├── scoring.md
+│   ├── gates.md
+│   └── exit-logic.md
+├── playbooks/
+│   ├── 00-bootstrap.md
+│   ├── 01-discovery.md
+│   ├── 02-planning.md
+│   ├── 03-architecture.md
+│   ├── 04-implementation.md
+│   ├── 05-verification.md
+│   ├── 06-final-audit.md
+│   └── 07-git-worktree.md
+├── state/
+│   ├── README.md
+│   ├── scope.md
+│   ├── assumptions.md
+│   ├── evidence.md
+│   ├── research.md
+│   ├── plan.md
+│   ├── scorecard.md
+│   ├── risks.md
+│   ├── decisions.md
+│   └── iteration-log.md
+├── memory/
+│   ├── README.md
+│   ├── engineering-preferences.md
+│   ├── tooling.md
+│   ├── lessons.md
+│   ├── patterns.md
+│   └── constraints.md
+├── projects/
+│   ├── project.md
+│   ├── architecture.md
+│   ├── lessons.md
+│   └── decisions.md
+├── templates/
+│   ├── task.md
+│   ├── milestone.md
+│   └── final-report.md
+└── diagrams/
+    ├── rdapq-control-loop.mmd
+    ├── rdapq-selective-loading.mmd
+    ├── rdapq-score-decision.mmd
+    ├── rdapq-evidence-flow.mmd
+    ├── rdapq-memory-model.mmd
+    └── rdapq-command-flow.mmd
+```
+
+## Loader recommendation
+
+Always load only `SKILL.md`.
+
+Load phase playbooks and event references deterministically as needed.
+
+Do not use embeddings as the primary retrieval mechanism for governance rules.
+
+Embeddings remain useful for source code, docs, issues, logs, and semantic
+repository knowledge.

package/plugins/rdap-q/skills/rdap-q/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: rdap-q
+description: Run the RDAP-Q evidence-first engineering protocol. Invoke with /rdap-q or /rdapq. Load this file, then the current phase playbook only.
+disable-model-invocation: true
+---
+name: rdap-q
+version: "1.2.1"
+description: Evidence-first engineering protocol. Load this file, then the current phase playbook only.
+invocation: /rdapq
+home_env: RDAPQ_HOME
+home: RDAPQ_HOME else ~/.rdapq (Windows %USERPROFILE%\.rdapq)
+state: .rdapq/state
+memory: $RDAPQ_HOME/memory
+facts: [OBSERVED, USER_SPECIFIED, VERIFIED_EXTERNAL, INFERRED, UNKNOWN]
+rules:
+  - evidence before inference; never invent paths, APIs, versions, flags, tests, env, or architecture
+  - INFERRED or UNKNOWN cannot decide implementation when verification is possible
+  - hard gates override scores; a score never means COMPLETE
+  - scores need evidence ids; steps of 0.5; 8.x is a valid stop
+  - small reversible milestones; verify before claiming success
+  - task state stays in .rdapq/state; memory is reusable only; current evidence beats memory
+  - never store secret values; a source plus an identifier is allowed
+  - do not load manifest.json, other playbooks, diagrams, or bulk memory
+commands:
+  status: phase, quality, confidence, gates, blockers, iteration
+  score: evidence-linked scorecard
+  audit: adversarial final audit
+  resume: reload memory and state, then check drift
+  memory: relevant memories and status; never print secrets
+  research: discovery
+  explain: why this phase or exit
+weights: {correctness: 25, coverage: 15, verification: 15, integration: 10, security: 10, maintainability: 10, architecture: 8, operability: 7}
+anchors: {0: absent, "1-2": broken, "3-4": deficient, 5: unverified, 6: gaps, 7: solid, 8: production, 9: exceptional, 10: reference}
+caps: {unverified: 5, inferred_dependency: 5, known_defect: 4}
+hard_fail: [required_test_fail, unexercised_integration]
+risk_target: {LOW: 7.2, MODERATE: 7.6, HIGH: 8.0, CRITICAL: 8.3}
+exit: {iterate_dQ: ">=0.20", diminish_dQ: "<0.15", stall_dQ: "<0.10", done: "Vibe Code Build complete."}
+terminal: [COMPLETE, BLOCKED, STALLED, CONSTRAINT_LIMITED, FAILED_VERIFICATION]
+tools: [SEARCH, FETCH, INSPECT, EXECUTE, EDIT, TEST, VCS]
+phases:
+  BOOTSTRAP: [playbooks/00-bootstrap.md]
+  DISCOVERY: [playbooks/01-discovery.md]
+  PLAN: [playbooks/02-planning.md]
+  ARCHITECTURE: [playbooks/03-architecture.md]
+  IMPLEMENT: [playbooks/04-implementation.md]
+  VERIFY: [playbooks/05-verification.md]
+  AUDIT: [playbooks/06-final-audit.md, playbooks/07-git-worktree.md]
+on:
+  memory: core/memory.md
+  gates: core/gates.md
+  score: core/scoring.md
+  milestone_or_exit: [core/scoring.md, core/gates.md, core/exit-logic.md]
+  git_mutation: playbooks/07-git-worktree.md
+  controller_ambiguity: core/controller.md
+  tool_mapping: core/capabilities.md

package/plugins/rdap-q/skills/rdap-q/core/capabilities.md

@@ -0,0 +1,9 @@
+map:
+  SEARCH: discover external information
+  FETCH: authoritative docs, specs, source
+  INSPECT: repo, env, logs, history, config
+  EXECUTE: commands, code, experiments
+  EDIT: modify files
+  TEST: verification
+  VCS: version control
+if_missing: [record constraint, check whether a gate is affected, use a real alternative, never fabricate evidence]

package/plugins/rdap-q/skills/rdap-q/core/controller.md

@@ -0,0 +1,14 @@
+when: whole_loop_or_ambiguous_next_state
+order:
+  - resolve home; if unwritable, record it and use repo state
+  - load SKILL.md, repo root, relevant memory, then .rdapq/state if present
+  - load the current playbook only; observe before acting
+  - update facts, assumptions, evidence, risks, decisions
+  - milestone: verify, review, score, gate, decide, persist
+  - invalid plan -> PLAN; worthwhile fix -> iterate
+  - gates pass and diminishing -> audit, then COMPLETE
+  - else emit the accurate non-complete terminal state
+  - promote only durable lessons
+precedence: [user_intent, direct_evidence, repo_state, project_memory, global_memory, external_for_this_version, inference]
+replan_if_changes: [scope, architecture, dependencies, sequencing, risk, verification, success_criteria]
+context: targeted reads; do not replay chat or load the whole skill tree

package/plugins/rdap-q/skills/rdap-q/core/exit-logic.md

@@ -0,0 +1,9 @@
+# numeric thresholds: SKILL.md exit
+effort: {1: trivial, 2: small, 3: moderate, 5: substantial, 8: major}
+candidate: [severity, dQ, risk, effort, confidence, blocker]
+iterate_if: [gate_fail_with_fix, high_or_critical_defect, "dQ>=0.20", material_risk_reduction]
+diminish_if: gates_pass AND (last_two_dQ<0.15 OR best_remaining_dQ<0.20_and_no_risk_reduction)
+stall_if: [deficiency_remains, two_tries_dQ<0.10, no_new_action]
+blocked_if_missing: [user_decision, credentials, environment, external_system, spec, permission, hardware]
+constraint_limited: external_cap; not automatically complete
+aqc: late ceiling estimate; never excuses a failed gate

package/plugins/rdap-q/skills/rdap-q/core/gates.md

@@ -0,0 +1,12 @@
+complete: all_applicable_pass
+score_never_completes: true
+gates:
+  scope: [goal, success_criteria, non_goals, no_silent_drop]
+  evidence: [no_unsupported_inference, critical_assumptions_resolved, high_assumptions_resolved_or_accepted]
+  correctness: [no_open_critical_or_high, required_verification_pass]
+  integration: [material_paths_exercised, compatibility_checked]
+  regression: [existing_tests_pass, no_known_material_regression]
+  security: [no_new_material_issue, no_secrets_stored, destructive_safeguards, risk_proportional_checks]
+  repository: [diff_reviewed, no_unintended_files, no_conflicts, state_understood, unrelated_work_kept]
+  memory: [no_secrets, promotion_test, stale_handled, state_not_promoted_as_global]
+  quality: target_met_or_diminishing_returns_and_other_gates_pass

package/plugins/rdap-q/skills/rdap-q/core/memory.md

@@ -0,0 +1,11 @@
+scopes:
+  global: "$RDAPQ_HOME/memory/{engineering-preferences,tooling,lessons,patterns,constraints}.md"
+  project: "$RDAPQ_HOME/projects/<id>/{project,architecture,lessons,decisions}.md"
+  task: .rdapq/state
+promote_if_all: [durable, reusable, material, safe, grounded]
+record: {id: M-<id>, scope: "global|project:<id>", status: [ACTIVE, STALE, SUPERSEDED, INVALID], class: [USER_SPECIFIED, OBSERVED, VERIFIED_EXTERNAL, INFERRED], confidence: "0-10", verified: YYYY-MM-DD, supersedes: "id|none", superseded_by: "id|none", fact: str, evidence: str}
+secrets: never values; source plus identifier only
+on_conflict: trust direct evidence; mark STALE, SUPERSEDED, or INVALID; link ids; do not silent-delete
+load: relevant project, then relevant global
+memory_cmd: relevant entries, status, conflicts; never print secrets
+resume: home, project memory, repo state, last phase, inspect drift, continue at first unverified step

package/plugins/rdap-q/skills/rdap-q/core/scoring.md

@@ -0,0 +1,7 @@
+# weights, anchors, caps, risk_target: SKILL.md
+formula: sum(score_i * weight_i) / 100
+confidence_weights: {runtime: 35, repo: 25, external: 15, claims: 15, repro: 10}
+coverage: verified_material_claims / total_material_claims
+report: [quality, confidence, coverage, gates, critical, high, unknowns, previous, delta, target, remaining, aqc]
+row: [dimension, weight, score, weighted, evidence_ids, gap]
+forbid: looks_good

package/plugins/rdap-q/skills/rdap-q/diagrams/rdapq-command-flow.mmd

@@ -0,0 +1,9 @@
+flowchart LR
+    C[/rdapq/] --> T[Execute Task]
+    S[/rdapq status/] --> ST[Show Phase / Gates / Scores / Blockers]
+    Q[/rdapq score/] --> SC[Calculate / Show Scorecard]
+    A[/rdapq audit/] --> AU[Run Adversarial Audit]
+    R[/rdapq resume/] --> RE[Reload Memory + State + Detect Drift]
+    M[/rdapq memory/] --> ME[Show Relevant Memory / Status]
+    D[/rdapq research/] --> DI[Enter or Re-enter Discovery]
+    E[/rdapq explain/] --> EX[Explain Current RDAP-Q Decision]

package/plugins/rdap-q/skills/rdap-q/diagrams/rdapq-control-loop.mmd

@@ -0,0 +1,31 @@
+flowchart TD
+    A[/rdapq task or resume/] --> B[Resolve RDAPQ_HOME]
+    B --> C[Load Relevant Memory]
+    C --> D[Load Repository State]
+    D --> E[Bootstrap / Observe]
+    E --> F[Establish Facts]
+    F --> G[Identify Unknowns]
+    G --> H[Research / Verify]
+    H --> I[Define Scope]
+    I --> J[Plan]
+    J --> K[Score Plan]
+    K --> L{Plan Gates Pass?}
+    L -- No --> M[Improve / Research]
+    M --> J
+    L -- Yes --> N[Implement Milestone]
+    N --> O[Verify]
+    O --> P[Audit]
+    P --> Q[Score Quality + Confidence]
+    Q --> R{Hard Gates Pass?}
+    R -- No, resolvable --> S[Fix]
+    S --> O
+    R -- No, blocked --> T[BLOCKED / STALLED]
+    R -- Yes --> U{Material Value Remaining?}
+    U -- Yes --> N
+    U -- No --> V[Diminishing Return Exit]
+    V --> W[Adversarial Final Audit]
+    W --> X[Memory Promotion / Invalidation]
+    X --> Y{Completion Gates Pass?}
+    Y -- No --> N
+    Y -- Yes --> Z[Merge / Cleanup]
+    Z --> AA[COMPLETE]

package/plugins/rdap-q/skills/rdap-q/diagrams/rdapq-evidence-flow.mmd

@@ -0,0 +1,31 @@
+flowchart LR
+    U[User-Specified Facts] --> L[Fact / Assumption Ledger]
+    RM[Relevant RDAP-Q Memory] --> L
+    R[Repository Inspection] --> E[Evidence Register]
+    X[External Primary Sources] --> E
+    T[Tests / Runtime / Experiments] --> E
+
+    L --> Q{Material Fact Status}
+    E --> Q
+
+    Q --> O[OBSERVED]
+    Q --> V[VERIFIED_EXTERNAL]
+    Q --> I[INFERRED]
+    Q --> N[UNKNOWN]
+
+    O --> D[Implementation Decision]
+    V --> D
+    I --> C{Can It Be Verified?}
+    N --> C
+
+    C -- Yes --> R2[Research / Inspect / Test]
+    R2 --> E
+    C -- No --> B[Record Constraint / Blocker]
+
+    D --> S[Scorecard]
+    E --> S
+    S --> G[Hard Gates + Exit Decision]
+
+    E --> MC{Durable + Reusable + Material + Safe?}
+    MC -- Yes --> MEM[Promote to RDAP-Q Memory]
+    MC -- No --> ST[Keep in Project State Only]

package/plugins/rdap-q/skills/rdap-q/diagrams/rdapq-memory-model.mmd

@@ -0,0 +1,26 @@
+flowchart TD
+    ENV[RDAPQ_HOME set?] -->|Yes| H[Use RDAPQ_HOME]
+    ENV -->|No| OS{Platform}
+    OS -->|Windows| W[%USERPROFILE%/.rdapq]
+    OS -->|Unix-like| U[${HOME}/.rdapq]
+
+    H --> GH[Global RDAP-Q Home]
+    W --> GH
+    U --> GH
+
+    GH --> GM[memory/]
+    GH --> PM[projects/project-id/]
+    GH --> REG[registry/]
+    GH --> SK[skills/]
+
+    REPO[Repository] --> LS[.rdapq/state/]
+
+    GM --> A[Agent]
+    PM --> A
+    LS --> A
+
+    A --> C{New Information}
+    C -->|Transient build state| LS
+    C -->|Durable reusable material fact| P[Memory Promotion Test]
+    P -->|Pass| GM2[Global or Project Memory]
+    P -->|Fail| LS2[Remain Local State]

package/plugins/rdap-q/skills/rdap-q/diagrams/rdapq-score-decision.mmd

@@ -0,0 +1,24 @@
+flowchart TD
+    A[Collect Evidence] --> B[Apply Evidence Caps]
+    B --> C[Score Quality Dimensions]
+    C --> D[Compute Weighted Quality]
+    D --> E[Score Confidence]
+    E --> F[Calculate Evidence Coverage]
+    F --> G[Evaluate Hard Gates]
+
+    G --> H{Any Gate Fails?}
+    H -- Yes --> I{Credible Fix?}
+    I -- Yes --> J[ITERATE]
+    I -- No --> K[BLOCKED / STALLED / FAILED]
+
+    H -- No --> L[Rank Improvements]
+    L --> M{HIGH/CRITICAL Defect?}
+    M -- Yes --> J
+    M -- No --> N{Expected ΔQ >= 0.20?}
+    N -- Yes --> J
+    N -- No --> O{Material Risk Reduction?}
+    O -- Yes --> J
+    O -- No --> P{Diminishing Return Reached?}
+    P -- No --> J
+    P -- Yes --> Q[Memory Finalization]
+    Q --> R[COMPLETE]