rdap-q 1.2.1

package/.agents/plugins/rdap-q/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "rdap-q",
+  "version": "1.2.1",
+  "description": "RDAP-Q Agent Engineering Protocol plugin with progressive disclosure playbooks and calibrated scoring.",
+  "rules": [
+    "../../../AGENTS.md"
+  ],
+  "skills": [
+    "../../skills/rdap-q"
+  ]
+}

package/.agents/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/.agents/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/.agents/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/.agents/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/.agents/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/.agents/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/.agents/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/.agents/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/.agents/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/.agents/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/.agents/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/.agents/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/.agents/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]

package/.agents/skills/rdap-q/diagrams/rdapq-selective-loading.mmd

@@ -0,0 +1,40 @@
+flowchart LR
+    CMD[/rdapq/] --> S[SKILL.md]
+    S --> P{Current Phase}
+
+    P --> B[Bootstrap]
+    P --> D[Discovery]
+    P --> PL[Planning]
+    P --> A[Architecture]
+    P --> I[Implementation]
+    P --> V[Verification]
+    P --> F[Final Audit]
+
+    EVT{Event} --> C[Constitution]
+    EVT --> SC[Scoring]
+    EVT --> G[Gates]
+    EVT --> E[Exit Logic]
+    EVT --> M[Memory Protocol]
+    EVT --> CTRL[Controller]
+
+    H[RDAPQ_HOME] --> GM[(Global / Project Memory)]
+    R[Repository] --> RS[(.rdapq/state)]
+
+    GM --> AG[Agent]
+    RS --> AG
+    S --> AG
+    B --> AG
+    D --> AG
+    PL --> AG
+    A --> AG
+    I --> AG
+    V --> AG
+    F --> AG
+    C --> AG
+    SC --> AG
+    G --> AG
+    E --> AG
+    M --> AG
+    CTRL --> AG
+
+    AG --> X[Repository / Runtime / Tools]

package/.agents/skills/rdap-q/install/install-unix.sh

@@ -0,0 +1,48 @@
+#!/usr/bin/env sh
+# Install the skill tree into $RDAPQ_HOME. Stage first, swap only after SKILL.md
+# is present, so a failed copy cannot delete a working install.
+# Prefer the repo installer (./install.sh or npx --yes github:coldcanuk/rdapq) when you have the full checkout.
+set -eu
+
+SOURCE_DIR="$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)"
+if [ ! -f "$SOURCE_DIR/SKILL.md" ]; then
+  echo "error: SKILL.md not found next to this installer ($SOURCE_DIR)" >&2
+  exit 1
+fi
+
+TARGET="${RDAPQ_HOME:-${HOME}/.rdapq}"
+SKILLS="$TARGET/skills"
+DEST="$SKILLS/rdap-q"
+STAGE="$SKILLS/.rdap-q.staging.$$"
+BACKUP="$SKILLS/.rdap-q.backup.$$"
+
+mkdir -p "$SKILLS" "$TARGET/memory" "$TARGET/projects" "$TARGET/registry"
+rm -rf "$STAGE"
+cp -R "$SOURCE_DIR" "$STAGE"
+
+if [ ! -f "$STAGE/SKILL.md" ]; then
+  rm -rf "$STAGE"
+  echo "error: staged copy is missing SKILL.md; existing install left untouched" >&2
+  exit 1
+fi
+
+moved=0
+if [ -e "$DEST" ]; then
+  rm -rf "$BACKUP"
+  mv "$DEST" "$BACKUP"
+  moved=1
+fi
+
+if ! mv "$STAGE" "$DEST"; then
+  if [ "$moved" -eq 1 ]; then
+    mv "$BACKUP" "$DEST"
+  fi
+  echo "error: failed to publish staged skill; previous install restored if it existed" >&2
+  exit 1
+fi
+
+if [ "$moved" -eq 1 ]; then
+  rm -rf "$BACKUP"
+fi
+
+printf 'Installed RDAP-Q to %s\n' "$DEST"

package/.agents/skills/rdap-q/install/install-windows.ps1

@@ -0,0 +1,65 @@
+# Install the skill tree into $env:RDAPQ_HOME. Stage first, swap only after SKILL.md
+# is present, so a failed copy cannot delete a working install.
+$ErrorActionPreference = "Stop"
+
+if (-not $PSCommandPath) {
+    Write-Error "refusing a piped install. Run this script from the skill directory."
+    exit 1
+}
+
+$SourceDir = Split-Path -Parent (Split-Path -Parent $PSCommandPath)
+$SkillFile = Join-Path $SourceDir "SKILL.md"
+if (-not (Test-Path -LiteralPath $SkillFile)) {
+    throw "SKILL.md not found in $SourceDir"
+}
+
+if ($env:RDAPQ_HOME) {
+    $Target = $env:RDAPQ_HOME
+} else {
+    $Target = Join-Path $env:USERPROFILE ".rdapq"
+}
+
+$SkillsDir = Join-Path $Target "skills"
+$Dest = Join-Path $SkillsDir "rdap-q"
+$Stage = Join-Path $SkillsDir ".rdap-q.staging-$PID"
+$Backup = Join-Path $SkillsDir ".rdap-q.backup-$PID"
+
+New-Item -ItemType Directory -Force -Path $SkillsDir | Out-Null
+New-Item -ItemType Directory -Force -Path (Join-Path $Target "memory") | Out-Null
+New-Item -ItemType Directory -Force -Path (Join-Path $Target "projects") | Out-Null
+New-Item -ItemType Directory -Force -Path (Join-Path $Target "registry") | Out-Null
+
+if (Test-Path -LiteralPath $Stage) {
+    Remove-Item -LiteralPath $Stage -Recurse -Force
+}
+Copy-Item -LiteralPath $SourceDir -Destination $Stage -Recurse -Force
+
+$StagedSkill = Join-Path $Stage "SKILL.md"
+if (-not (Test-Path -LiteralPath $StagedSkill)) {
+    Remove-Item -LiteralPath $Stage -Recurse -Force
+    throw "Staged copy is missing SKILL.md; existing install left untouched."
+}
+
+$moved = $false
+if (Test-Path -LiteralPath $Dest) {
+    if (Test-Path -LiteralPath $Backup) {
+        Remove-Item -LiteralPath $Backup -Recurse -Force
+    }
+    Move-Item -LiteralPath $Dest -Destination $Backup
+    $moved = $true
+}
+
+try {
+    Move-Item -LiteralPath $Stage -Destination $Dest
+} catch {
+    if ($moved -and -not (Test-Path -LiteralPath $Dest) -and (Test-Path -LiteralPath $Backup)) {
+        Move-Item -LiteralPath $Backup -Destination $Dest
+    }
+    throw
+}
+
+if ($moved -and (Test-Path -LiteralPath $Backup)) {
+    Remove-Item -LiteralPath $Backup -Recurse -Force
+}
+
+Write-Output "Installed RDAP-Q to $Dest"

package/.agents/skills/rdap-q/manifest.json

@@ -0,0 +1,87 @@
+{
+  "name": "rdap-q",
+  "version": "1.2.1",
+  "protocol_name": "RDAP-Q Agent Engineering Protocol",
+  "entrypoint": "SKILL.md",
+  "invocation": "/rdapq",
+  "home_env": "RDAPQ_HOME",
+  "home_defaults": {
+    "windows": "%USERPROFILE%\\.rdapq",
+    "unix": "${HOME}/.rdapq"
+  },
+  "repository_state": ".rdapq/state",
+  "always_load": [
+    "SKILL.md"
+  ],
+  "phase_load": {
+    "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"
+    ]
+  },
+  "event_load": {
+    "controller_ambiguity": [
+      "core/controller.md"
+    ],
+    "tool_mapping": [
+      "core/capabilities.md"
+    ],
+    "memory_read_write_invalidate": [
+      "core/memory.md"
+    ],
+    "gate_evaluation": [
+      "core/gates.md"
+    ],
+    "score_calculation": [
+      "core/scoring.md"
+    ],
+    "milestone_quality_decision": [
+      "core/scoring.md",
+      "core/gates.md",
+      "core/exit-logic.md"
+    ],
+    "terminal_decision": [
+      "core/scoring.md",
+      "core/gates.md",
+      "core/exit-logic.md"
+    ],
+    "git_mutation": [
+      "playbooks/07-git-worktree.md"
+    ]
+  },
+  "commands": {
+    "/rdapq": "Start or continue RDAP-Q execution on the supplied task.",
+    "/rdapq status": "Show phase, quality, confidence, gates, blockers, and iteration state.",
+    "/rdapq score": "Calculate or display the current evidence-linked scorecard.",
+    "/rdapq audit": "Run the adversarial final-audit procedure.",
+    "/rdapq resume": "Reload persistent memory/state, inspect drift, and resume safely.",
+    "/rdapq memory": "Show relevant RDAP-Q memory and its validity status.",
+    "/rdapq research": "Enter or re-enter discovery/research.",
+    "/rdapq explain": "Explain the current RDAP-Q phase/decision."
+  },
+  "terminal_states": [
+    "COMPLETE",
+    "BLOCKED",
+    "STALLED",
+    "CONSTRAINT_LIMITED",
+    "FAILED_VERIFICATION"
+  ]
+}