@lifeaitools/rdc-skills 0.9.36 → 0.9.37

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "rdc",
-  "version": "0.9.36",
+  "version": "0.9.37",
   "description": "RDC typed-agent dispatch skill suite for Claude Code — plan, build, review, overnight unattended builds with work-item tracking and TDD enforcement.",
   "author": {
     "name": "LIFEAI",

package/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## v0.9.37 — RDC hook loop guard and behavior tests
+
+### Fixed
+
+- **Stop hook reentry.** `rdc-output-contract-gate.js` now exits cleanly when Claude is already inside an active Stop-hook retry, preventing noncompliant-but-legitimate turns from hard-looping the session.
+- **Marker deduplication.** `rdc-invocation-marker.js` now preserves the original marker when `UserPromptExpansion` and `UserPromptSubmit` both fire for the same RDC command within the same second.
+
+### Added
+
+- **Hook behavioral tests.** New `scripts/test-rdc-hooks.mjs` executes the marker and Stop hooks against real JSON payloads, and `self-test --strict` now fails if those behavioral checks fail.
+
+---
+
 ## v0.9.36 — Portable installer profiles and startup onboarding
 
 ### Added

package/hooks/rdc-invocation-marker.js

@@ -76,7 +76,7 @@ function detectRdc(raw) {
 
   if (event === 'UserPromptSubmit') {
     const prompt = String(raw.prompt || '').trim();
-    const m = prompt.match(/^\/(?:rdc[:-])?([a-z][a-z0-9-]*)\b/i);
+    const m = prompt.match(/^\/rdc[:-]([a-z][a-z0-9-]*)\b/i);
     if (!m) return null;
     const command = normalizeCommandName(m[1]);
     if (RDC_COMMANDS.has(command)) return command;
@@ -87,6 +87,20 @@ function detectRdc(raw) {
 
 function writeMarker(raw, command) {
   fs.mkdirSync(markerDir(), { recursive: true });
+  const p = markerPath(raw.session_id);
+  if (fs.existsSync(p)) {
+    try {
+      const existing = JSON.parse(fs.readFileSync(p, 'utf8'));
+      const started = Date.parse(existing.started_at || '');
+      const isRecentDuplicate = Number.isFinite(started) &&
+        Date.now() - started <= 1000 &&
+        existing.session_id === (raw.session_id || null) &&
+        existing.command === command;
+      if (isRecentDuplicate) {
+        return { ...existing, deduped: true };
+      }
+    } catch {}
+  }
   const marker = {
     session_id: raw.session_id || null,
     command,
@@ -98,7 +112,7 @@ function writeMarker(raw, command) {
     started_at: new Date().toISOString(),
     hook_event_name: raw.hook_event_name || null,
   };
-  fs.writeFileSync(markerPath(raw.session_id), JSON.stringify(marker, null, 2));
+  fs.writeFileSync(p, JSON.stringify(marker, null, 2));
   return marker;
 }
 
@@ -127,7 +141,7 @@ async function main() {
 
   try {
     const marker = writeMarker(raw, command);
-    hookLog('rdc-invocation-marker', raw.hook_event_name || 'unknown', 'marked', {
+    hookLog('rdc-invocation-marker', raw.hook_event_name || 'unknown', marker.deduped ? 'deduped' : 'marked', {
       command,
       session_id: marker.session_id,
     });

package/hooks/rdc-output-contract-gate.js

@@ -60,6 +60,14 @@ function pass(marker) {
   process.exit(0);
 }
 
+function passReentry(marker) {
+  try { fs.unlinkSync(marker.path); } catch {}
+  hookLog('rdc-output-contract-gate', 'Stop', 'pass-reentry', {
+    command: marker.data.command || null,
+  });
+  process.exit(0);
+}
+
 async function main() {
   let raw;
   try { raw = JSON.parse(await readStdin()); } catch { process.exit(0); }
@@ -70,6 +78,7 @@ async function main() {
   const checklist = hasChecklist(message);
   const verdict = hasVerdict(message);
   if (checklist && verdict) pass(marker);
+  if (raw.stop_hook_active === true) passReentry(marker);
 
   const command = marker.data.command || 'rdc';
   const missing = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifeaitools/rdc-skills",
-  "version": "0.9.36",
+  "version": "0.9.37",
   "description": "RDC typed-agent dispatch skill suite for Claude Code - plan, build, review, overnight builds",
   "keywords": [
     "claude-code",
@@ -19,7 +19,7 @@
     "type": "plugin",
     "skills": "skills/",
     "guides": "guides/",
-    "version": "0.9.36",
+    "version": "0.9.37",
     "commands": "commands/"
   },
   "scripts": {
@@ -27,6 +27,7 @@
     "uninstall:win": "powershell -ExecutionPolicy Bypass -File scripts/uninstall.ps1",
     "uninstall:unix": "bash scripts/uninstall.sh",
     "validate": "node tests/validate-skills.js",
-    "rdc-design": "node scripts/rdc-design-cli.mjs"
+    "rdc-design": "node scripts/rdc-design-cli.mjs",
+    "test:hooks": "node scripts/test-rdc-hooks.mjs"
   }
 }

package/scripts/self-test.mjs

@@ -31,6 +31,7 @@
 import { readFileSync, readdirSync, existsSync, writeFileSync, appendFileSync, renameSync, mkdirSync, statSync } from "node:fs";
 import { join, basename, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
 import { loadAllManifests } from "./lib/manifest-schema.mjs";
 import { runManifest } from "./lib/runner.mjs";
 import {
@@ -802,6 +803,19 @@ function auditRequiredHookWiring() {
   return findings;
 }
 
+function runHookBehaviorTests() {
+  const result = spawnSync(process.execPath, [join(REPO_ROOT, "scripts", "test-rdc-hooks.mjs")], {
+    cwd: REPO_ROOT,
+    encoding: "utf8",
+  });
+  return {
+    ok: result.status === 0,
+    status: result.status,
+    stdout: (result.stdout || "").trim(),
+    stderr: (result.stderr || "").trim(),
+  };
+}
+
 // ─── Tier 2 behavioral runner ──────────────────────────────────────────────
 
 async function runPool(items, concurrency, worker) {
@@ -1038,6 +1052,7 @@ function main() {
     }
 
     const guideValidatorResultJson = !ONLY_SKILL ? runGuideContentValidator() : null;
+    const hookBehaviorResultJson = !ONLY_SKILL ? runHookBehaviorTests() : null;
 
     const failed = results.filter((r) => r.errors.length > 0);
     const warned = results.filter((r) => r.warnings.length > 0 && r.errors.length === 0);
@@ -1050,6 +1065,11 @@ function main() {
       ...duplicateFindings.filter((f) => f.level === "error"),
       ...orphanHookFindings.filter((f) => f.level === "error"),
       ...(guideValidatorResultJson ? guideValidatorResultJson.errors : []),
+      ...(hookBehaviorResultJson && !hookBehaviorResultJson.ok ? [{
+        level: "error",
+        code: "hook-behavior-test-failed",
+        message: hookBehaviorResultJson.stderr || hookBehaviorResultJson.stdout || `exit ${hookBehaviorResultJson.status}`,
+      }] : []),
     ];
     const globalWarnings = [
       ...manifestAudit.findings.filter((f) => f.level === "warn"),
@@ -1092,6 +1112,7 @@ function main() {
                 findings: guideValidatorResultJson.findings,
               }
             : null,
+          hook_behavior_tests: hookBehaviorResultJson,
           results: results.map((r) => ({
             skill: r.skill,
             file: r.file,
@@ -1217,10 +1238,12 @@ function main() {
   let duplicateFindings = [];
   let orphanHookFindings = [];
   let requiredHookFindings = [];
+  let hookBehaviorResult = null;
   if (!ONLY_SKILL) {
     duplicateFindings = auditDuplicates(results);
     orphanHookFindings = auditOrphanHooks(results);
     requiredHookFindings = auditRequiredHookWiring();
+    hookBehaviorResult = runHookBehaviorTests();
   }
 
   if (duplicateFindings.length + orphanHookFindings.length + requiredHookFindings.length > 0) {
@@ -1230,6 +1253,14 @@ function main() {
     }
   }
 
+  if (hookBehaviorResult) {
+    console.log("\nhook behavior tests\n");
+    console.log("─".repeat(80));
+    console.log(hookBehaviorResult.ok ? "  pass  rdc marker/gate behavioral smoke tests" : "  FAIL  rdc marker/gate behavioral smoke tests");
+    if (hookBehaviorResult.stdout) console.log(`  ${hookBehaviorResult.stdout}`);
+    if (hookBehaviorResult.stderr) console.log(`  ${hookBehaviorResult.stderr}`);
+  }
+
   if (FIXED_FILES.length > 0) {
     console.log("\nfixed files (review with git diff):");
     for (const p of FIXED_FILES) console.log(`  ${p}`);
@@ -1243,6 +1274,11 @@ function main() {
     ...orphanHookFindings.filter((f) => f.level === "error"),
     ...requiredHookFindings.filter((f) => f.level === "error"),
     ...(guideValidatorResult ? guideValidatorResult.errors : []),
+    ...(hookBehaviorResult && !hookBehaviorResult.ok ? [{
+      level: "error",
+      code: "hook-behavior-test-failed",
+      message: hookBehaviorResult.stderr || hookBehaviorResult.stdout || `exit ${hookBehaviorResult.status}`,
+    }] : []),
   ];
   const globalWarnings = [
     ...manifestAudit.findings.filter((f) => f.level === "warn"),

package/scripts/test-rdc-hooks.mjs

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+// Behavioral smoke tests for the RDC marker and Stop output-contract hooks.
+
+import { mkdtempSync, rmSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(__dirname, "..");
+const MARKER_HOOK = join(REPO_ROOT, "hooks", "rdc-invocation-marker.js");
+const STOP_HOOK = join(REPO_ROOT, "hooks", "rdc-output-contract-gate.js");
+
+const tmpHome = mkdtempSync(join(tmpdir(), "rdc-hooks-"));
+const env = { ...process.env, HOME: tmpHome, USERPROFILE: tmpHome };
+const failures = [];
+
+function markerPath(sessionId) {
+  return join(tmpHome, ".claude", "rdc-active", `${sessionId}.json`);
+}
+
+function runHook(script, payload) {
+  return spawnSync(process.execPath, [script], {
+    input: JSON.stringify(payload),
+    encoding: "utf8",
+    env,
+  });
+}
+
+function assert(name, condition, detail = "") {
+  if (!condition) failures.push(`${name}${detail ? `: ${detail}` : ""}`);
+}
+
+function readMarker(sessionId) {
+  return JSON.parse(readFileSync(markerPath(sessionId), "utf8"));
+}
+
+try {
+  const expansion = runHook(MARKER_HOOK, {
+    hook_event_name: "UserPromptExpansion",
+    session_id: "s-expansion",
+    command_source: "plugin",
+    command_name: "rdc:design",
+    prompt: "/rdc:design palette audit",
+  });
+  assert("expansion exits zero", expansion.status === 0, expansion.stderr);
+  assert("expansion emits context", /RDC CONTRACT ACTIVE/.test(expansion.stdout), expansion.stdout);
+  assert("expansion writes marker", existsSync(markerPath("s-expansion")));
+  assert("expansion marker event preserved", readMarker("s-expansion").hook_event_name === "UserPromptExpansion");
+
+  const builtin = runHook(MARKER_HOOK, {
+    hook_event_name: "UserPromptExpansion",
+    session_id: "s-builtin",
+    command_source: "builtin",
+    command_name: "help",
+    prompt: "/help",
+  });
+  assert("builtin exits zero", builtin.status === 0, builtin.stderr);
+  assert("builtin emits no context", builtin.stdout.trim() === "", builtin.stdout);
+  assert("builtin writes no marker", !existsSync(markerPath("s-builtin")));
+
+  const submit1 = runHook(MARKER_HOOK, {
+    hook_event_name: "UserPromptExpansion",
+    session_id: "s-dedup",
+    command_source: "plugin",
+    command_name: "rdc:design",
+    prompt: "/rdc:design button audit",
+  });
+  assert("dedup first mark exits zero", submit1.status === 0, submit1.stderr);
+  const first = readMarker("s-dedup");
+  const submit2 = runHook(MARKER_HOOK, {
+    hook_event_name: "UserPromptSubmit",
+    session_id: "s-dedup",
+    prompt: "/rdc:design button audit",
+  });
+  assert("dedup second mark exits zero", submit2.status === 0, submit2.stderr);
+  const second = readMarker("s-dedup");
+  assert("dedup preserves started_at", second.started_at === first.started_at);
+  assert("dedup preserves hook event", second.hook_event_name === "UserPromptExpansion");
+
+  const genericHelp = runHook(MARKER_HOOK, {
+    hook_event_name: "UserPromptSubmit",
+    session_id: "s-help",
+    prompt: "/help",
+  });
+  assert("generic help exits zero", genericHelp.status === 0, genericHelp.stderr);
+  assert("generic help writes no marker", !existsSync(markerPath("s-help")));
+
+  const noMarker = runHook(STOP_HOOK, {
+    hook_event_name: "Stop",
+    session_id: "s-no-marker",
+    last_assistant_message: "plain chat",
+  });
+  assert("stop without marker exits zero", noMarker.status === 0, noMarker.stderr);
+  assert("stop without marker is silent", noMarker.stdout.trim() === "", noMarker.stdout);
+
+  writeFileSync(markerPath("s-block"), JSON.stringify({
+    session_id: "s-block",
+    command: "design",
+    started_at: new Date().toISOString(),
+  }, null, 2));
+  const blocked = runHook(STOP_HOOK, {
+    hook_event_name: "Stop",
+    session_id: "s-block",
+    last_assistant_message: "No contract artifacts here.",
+  });
+  assert("noncompliant stop exits zero", blocked.status === 0, blocked.stderr);
+  assert("noncompliant stop blocks", /"decision"\s*:\s*"block"/.test(blocked.stdout), blocked.stdout);
+  assert("noncompliant stop retains marker", existsSync(markerPath("s-block")));
+
+  const reentry = runHook(STOP_HOOK, {
+    hook_event_name: "Stop",
+    session_id: "s-block",
+    stop_hook_active: true,
+    last_assistant_message: "Still no contract artifacts.",
+  });
+  assert("stop reentry exits zero", reentry.status === 0, reentry.stderr);
+  assert("stop reentry allows silent pass", reentry.stdout.trim() === "", reentry.stdout);
+  assert("stop reentry clears marker", !existsSync(markerPath("s-block")));
+
+  writeFileSync(markerPath("s-pass"), JSON.stringify({
+    session_id: "s-pass",
+    command: "review",
+    started_at: new Date().toISOString(),
+  }, null, 2));
+  const compliant = runHook(STOP_HOOK, {
+    hook_event_name: "Stop",
+    session_id: "s-pass",
+    last_assistant_message: "[x] Verified hook behavior\n\n✅ Complete in 2s",
+  });
+  assert("compliant stop exits zero", compliant.status === 0, compliant.stderr);
+  assert("compliant stop is silent", compliant.stdout.trim() === "", compliant.stdout);
+  assert("compliant stop clears marker", !existsSync(markerPath("s-pass")));
+} finally {
+  rmSync(tmpHome, { recursive: true, force: true });
+}
+
+if (failures.length > 0) {
+  console.error("\nrdc hook behavior tests — FAIL\n");
+  for (const failure of failures) console.error(`  - ${failure}`);
+  process.exit(1);
+}
+
+console.log("rdc hook behavior tests — PASS");