fix(traffic): require a traffic-capable PAT for the archive workflow (#265)

* fix(traffic): use a traffic-capable PAT for the archive workflow

The daily Archive GitHub Traffic run has failed since creation: the
TRAFFIC_ARCHIVE_TOKEN secret was never provisioned, so the workflow fell
back to github.token, which GitHub categorically rejects on traffic
endpoints (403 "Resource not accessible by integration").

- Fall back to the existing POLL_NVD_CVES_PAT automation token instead
  of github.token, keeping TRAFFIC_ARCHIVE_TOKEN as the preferred
  override once provisioned.
- Fail fast with an actionable error when no traffic-capable token is
  configured.
- Explain token requirements in the script's 401/403 errors.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

* fix(traffic): require dedicated TRAFFIC_ARCHIVE_TOKEN, drop expired PAT fallback

A live dispatch confirmed POLL_NVD_CVES_PAT is expired (401 Bad
credentials), so falling back to it only trades one daily failure for
another. Require the dedicated secret and fail fast with setup
instructions instead.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

.claude-plugin/marketplace.json

@@ -0,0 +1,56 @@
+{
+  "plugins": [
+    {
+      "name": "global-skills",
+      "source": "./",
+      "skills": [
+        "./skills/clawtributor"
+      ]
+    },
+    {
+      "name": "hermes-skills",
+      "source": "./",
+      "skills": [
+        "./skills/hermes-attestation-guardian",
+        "./skills/hermes-traffic-guardian"
+      ]
+    },
+    {
+      "name": "nano-claw-skills",
+      "source": "./",
+      "skills": [
+        "./skills/clawsec-nanoclaw",
+        "./skills/nanoclaw-traffic-guardian"
+      ]
+    },
+    {
+      "name": "open-claw-skills",
+      "source": "./",
+      "skills": [
+        "./skills/clawsec-clawhub-checker",
+        "./skills/clawsec-feed",
+        "./skills/clawsec-scanner",
+        "./skills/clawsec-suite",
+        "./skills/openclaw-audit-watchdog",
+        "./skills/openclaw-traffic-guardian",
+        "./skills/soul-guardian"
+      ]
+    },
+    {
+      "name": "pico-claw-skills",
+      "source": "./",
+      "skills": [
+        "./skills/picoclaw-security-guardian",
+        "./skills/picoclaw-self-pen-testing",
+        "./skills/picoclaw-traffic-guardian"
+      ]
+    },
+    {
+      "name": "repo-internal-skills",
+      "source": "./",
+      "skills": [
+        "./skills/claw-release"
+      ]
+    }
+  ]
+}

.github/requirements-lint-python.txt

@@ -1,2 +1,2 @@
-ruff==0.15.12
+ruff==0.15.13
 bandit==1.9.4

.github/workflows/archive-traffic.yml

@@ -0,0 +1,86 @@
+name: Archive GitHub Traffic
+
+on:
+  schedule:
+    - cron: '17 3 * * *'
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+concurrency:
+  group: traffic-archive
+  cancel-in-progress: false
+
+env:
+  TRAFFIC_ARCHIVE_BRANCH: traffic-archive
+  TRAFFIC_ARCHIVE_DIR: ../traffic-archive/traffic
+
+jobs:
+  archive:
+    name: Capture traffic snapshot
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout source
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Setup Node
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Prepare archive branch
+        env:
+          ARCHIVE_PUSH_TOKEN: ${{ github.token }}
+        run: |
+          set -euo pipefail
+
+          git config --global user.name "github-actions[bot]"
+          git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"
+
+          server="${GITHUB_SERVER_URL#https://}"
+          archive_remote="https://x-access-token:${ARCHIVE_PUSH_TOKEN}@${server}/${GITHUB_REPOSITORY}.git"
+
+          if git ls-remote --exit-code --heads "${archive_remote}" "${TRAFFIC_ARCHIVE_BRANCH}" >/dev/null 2>&1; then
+            git clone --branch "${TRAFFIC_ARCHIVE_BRANCH}" --depth 1 "${archive_remote}" ../traffic-archive
+          else
+            git init -b "${TRAFFIC_ARCHIVE_BRANCH}" ../traffic-archive
+            git -C ../traffic-archive remote add origin "${archive_remote}"
+          fi
+
+          mkdir -p "${TRAFFIC_ARCHIVE_DIR}"
+
+      - name: Collect traffic
+        env:
+          # Traffic endpoints reject the Actions GITHUB_TOKEN ("Resource not
+          # accessible by integration") — a PAT from a user with push access
+          # is required: classic with repo scope, or fine-grained with read
+          # access to Administration on this repository.
+          GH_TRAFFIC_TOKEN: ${{ secrets.TRAFFIC_ARCHIVE_TOKEN }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+        run: |
+          set -euo pipefail
+
+          if [ -z "${GH_TRAFFIC_TOKEN}" ]; then
+            echo "::error::No traffic-capable token configured. Set the TRAFFIC_ARCHIVE_TOKEN secret to a PAT with push access (classic: repo scope; fine-grained: Administration read)."
+            exit 1
+          fi
+
+          node scripts/archive-github-traffic.mjs --archive-dir "${TRAFFIC_ARCHIVE_DIR}"
+
+      - name: Commit archive
+        run: |
+          set -euo pipefail
+
+          cd ../traffic-archive
+          git add traffic/archive.json traffic/summary.json
+          git rm --ignore-unmatch traffic/README.md
+
+          if git diff --cached --quiet; then
+            echo "No traffic archive changes."
+            exit 0
+          fi
+
+          git commit -m "chore(traffic): archive repository traffic $(date -u +%F)"
+          git push origin HEAD:${TRAFFIC_ARCHIVE_BRANCH}

.github/workflows/ci.yml

@@ -93,6 +93,35 @@ jobs:
       - name: Check for outdated deps
         run: npm outdated || true
 
+  advisory-feed-tests:
+    name: Advisory Feed Tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        with:
+          node-version: '20'
+          cache: 'npm'
+      - run: npm ci
+      - name: GHSA Without CVE Feed Tests
+        run: node scripts/test-ghsa-without-cve-feed.mjs
+      - name: GHSA Poll Workflow Tests
+        run: node scripts/test-ghsa-poll-workflow.mjs
+      - name: NVD GHSA Consolidation Workflow Tests
+        run: node scripts/test-nvd-ghsa-consolidation-workflow.mjs
+      - name: NVD + GHSA Pipeline Dry Run
+        run: node scripts/test-nvd-ghsa-pipeline-dry-run.mjs
+      - name: Skill Release Tooling Tests
+        run: |
+          set -euo pipefail
+          for test_file in scripts/test-skill-*.mjs; do
+            node "$test_file"
+          done
+      - name: Deploy Pages Advisory Checksums Tests
+        run: node scripts/test-deploy-pages-checksums.mjs
+      - name: GitHub Traffic Archive Tests
+        run: node scripts/test-github-traffic-archive.mjs
+
   clawsec-suite-tests:
     name: ClawSec Suite Verification Tests
     runs-on: ubuntu-latest

.github/workflows/codeql.yml

@@ -27,7 +27,7 @@ jobs:
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@68bde559dea0fdcac2102bfdf6230c5f70eb485e # v4
+        uses: github/codeql-action/init@7211b7c8077ea37d8641b6271f6a365a22a5fbfa # v4
         with:
           languages: ${{ matrix.language }}
           config-file: ./.github/codeql/codeql-config.yml
@@ -38,4 +38,4 @@ jobs:
       - name: Build project
         run: npm run build
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@68bde559dea0fdcac2102bfdf6230c5f70eb485e # v4
+        uses: github/codeql-action/analyze@7211b7c8077ea37d8641b6271f6a365a22a5fbfa # v4

.github/workflows/deploy-pages.yml

@@ -249,16 +249,51 @@ jobs:
           set -euo pipefail
           mkdir -p public/advisories
           cp advisories/feed.json public/advisories/feed.json
+          if [ -f advisories/ghsa-without-cve.json ]; then
+            cp advisories/ghsa-without-cve.json public/advisories/ghsa-without-cve.json
+          fi
           echo "Copied advisory feed to public/advisories/"
           cat public/advisories/feed.json | jq '.advisories | length' | xargs -I {} echo "Feed contains {} advisories"
+          if [ -f public/advisories/ghsa-without-cve.json ]; then
+            cat public/advisories/ghsa-without-cve.json | jq '.advisories | length' | xargs -I {} echo "GHSA provisional feed contains {} advisories"
+          fi
+
+      - name: Sign advisory feed and verify
+        uses: ./.github/actions/sign-and-verify
+        with:
+          private_key: ${{ secrets.CLAWSEC_SIGNING_PRIVATE_KEY }}
+          private_key_passphrase: ${{ secrets.CLAWSEC_SIGNING_PRIVATE_KEY_PASSPHRASE }}
+          input_file: public/advisories/feed.json
+          signature_file: public/advisories/feed.json.sig
+          public_key_output: public/signing-public.pem
+
+      - name: Sign provisional GHSA feed and verify
+        if: hashFiles('public/advisories/ghsa-without-cve.json') != ''
+        uses: ./.github/actions/sign-and-verify
+        with:
+          private_key: ${{ secrets.CLAWSEC_SIGNING_PRIVATE_KEY }}
+          private_key_passphrase: ${{ secrets.CLAWSEC_SIGNING_PRIVATE_KEY_PASSPHRASE }}
+          input_file: public/advisories/ghsa-without-cve.json
+          signature_file: public/advisories/ghsa-without-cve.json.sig
 
       - name: Generate advisory checksums manifest
         run: |
           set -euo pipefail
 
-          FEED_FILE="public/advisories/feed.json"
-          FEED_SHA=$(sha256sum "$FEED_FILE" | awk '{print $1}')
-          FEED_SIZE=$(stat -c%s "$FEED_FILE" 2>/dev/null || stat -f%z "$FEED_FILE")
+          FILES_JSON="{}"
+          ADVISORY_ARTIFACTS=(public/advisories/*.json public/advisories/*.json.sig)
+          for file in "${ADVISORY_ARTIFACTS[@]}"; do
+            [ -e "$file" ] || continue
+            REL_PATH="${file#public/}"
+            FILE_SHA=$(sha256sum "$file" | awk '{print $1}')
+            FILE_SIZE=$(stat -c%s "$file" 2>/dev/null || stat -f%z "$file")
+            FILES_JSON=$(jq \
+              --arg path "$REL_PATH" \
+              --arg sha "$FILE_SHA" \
+              --argjson size "$FILE_SIZE" \
+              '. + {($path): {sha256: $sha, size: $size, path: $path, url: ("https://clawsec.prompt.security/" + $path)}}' \
+              <<< "$FILES_JSON")
+          done
 
           # Generate checksums manifest conforming to parseChecksumsManifest expectations:
           # - schema_version: "1" (manifest format version)
@@ -272,36 +307,19 @@ jobs:
             --arg version "1.1.0" \
             --arg generated "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
             --arg repo "${{ github.repository }}" \
-            --arg sha "$FEED_SHA" \
-            --argjson size "$FEED_SIZE" \
+            --argjson files "$FILES_JSON" \
             '{
               schema_version: $schema_version,
               algorithm: $algorithm,
               version: $version,
               generated_at: $generated,
               repository: $repo,
-              files: {
-                "advisories/feed.json": {
-                  sha256: $sha,
-                  size: $size,
-                  path: "advisories/feed.json",
-                  url: "https://clawsec.prompt.security/advisories/feed.json"
-                }
-              }
+              files: $files
             }' > public/checksums.json
 
           echo "Generated public/checksums.json"
           jq . public/checksums.json
 
-      - name: Sign advisory feed and verify
-        uses: ./.github/actions/sign-and-verify
-        with:
-          private_key: ${{ secrets.CLAWSEC_SIGNING_PRIVATE_KEY }}
-          private_key_passphrase: ${{ secrets.CLAWSEC_SIGNING_PRIVATE_KEY_PASSPHRASE }}
-          input_file: public/advisories/feed.json
-          signature_file: public/advisories/feed.json.sig
-          public_key_output: public/signing-public.pem
-
       - name: Sign checksums and verify
         uses: ./.github/actions/sign-and-verify
         with:
@@ -334,7 +352,7 @@ jobs:
       - name: Show signed advisory artifacts
         run: |
           echo "Signed advisory artifacts:"
-          ls -la public/advisories/feed.json*
+          ls -la public/advisories/*.json*
           ls -la public/checksums.json public/checksums.sig public/signing-public.pem
 
       - name: Setup Node.js
@@ -387,6 +405,16 @@ jobs:
               cp "public/advisories/feed.json.sig" "$MIRROR_LATEST_DIR/advisories/feed.json.sig"
               cp "public/advisories/feed.json.sig" "$MIRROR_LATEST_DIR/feed.json.sig"
             fi
+            if [ -f "public/advisories/ghsa-without-cve.json" ]; then
+              mkdir -p "$MIRROR_LATEST_DIR/advisories"
+              cp "public/advisories/ghsa-without-cve.json" "$MIRROR_LATEST_DIR/advisories/ghsa-without-cve.json"
+              cp "public/advisories/ghsa-without-cve.json" "$MIRROR_LATEST_DIR/ghsa-without-cve.json"
+            fi
+            if [ -f "public/advisories/ghsa-without-cve.json.sig" ]; then
+              mkdir -p "$MIRROR_LATEST_DIR/advisories"
+              cp "public/advisories/ghsa-without-cve.json.sig" "$MIRROR_LATEST_DIR/advisories/ghsa-without-cve.json.sig"
+              cp "public/advisories/ghsa-without-cve.json.sig" "$MIRROR_LATEST_DIR/ghsa-without-cve.json.sig"
+            fi
             if [ -f "public/checksums.json" ]; then
               cp "public/checksums.json" "$MIRROR_LATEST_DIR/checksums.json"
             fi

.github/workflows/pages-verify.yml

@@ -27,14 +27,26 @@ jobs:
           set -euo pipefail
           mkdir -p public/advisories
           cp advisories/feed.json public/advisories/feed.json
+          if [ -f advisories/ghsa-without-cve.json ]; then
+            cp advisories/ghsa-without-cve.json public/advisories/ghsa-without-cve.json
+          fi
 
       - name: Generate advisory checksums manifest
         run: |
           set -euo pipefail
 
-          FEED_FILE="public/advisories/feed.json"
-          FEED_SHA=$(sha256sum "$FEED_FILE" | awk '{print $1}')
-          FEED_SIZE=$(stat -c%s "$FEED_FILE" 2>/dev/null || stat -f%z "$FEED_FILE")
+          FILES_JSON="{}"
+          for file in public/advisories/*.json; do
+            REL_PATH="${file#public/}"
+            FILE_SHA=$(sha256sum "$file" | awk '{print $1}')
+            FILE_SIZE=$(stat -c%s "$file" 2>/dev/null || stat -f%z "$file")
+            FILES_JSON=$(jq \
+              --arg path "$REL_PATH" \
+              --arg sha "$FILE_SHA" \
+              --argjson size "$FILE_SIZE" \
+              '. + {($path): {sha256: $sha, size: $size, path: $path, url: ("https://clawsec.prompt.security/" + $path)}}' \
+              <<< "$FILES_JSON")
+          done
 
           jq -n \
             --arg schema_version "1" \
@@ -42,22 +54,14 @@ jobs:
             --arg version "1.1.0" \
             --arg generated "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
             --arg repo "${{ github.repository }}" \
-            --arg sha "$FEED_SHA" \
-            --argjson size "$FEED_SIZE" \
+            --argjson files "$FILES_JSON" \
             '{
               schema_version: $schema_version,
               algorithm: $algorithm,
               version: $version,
               generated_at: $generated,
               repository: $repo,
-              files: {
-                "advisories/feed.json": {
-                  sha256: $sha,
-                  size: $size,
-                  path: "advisories/feed.json",
-                  url: "https://clawsec.prompt.security/advisories/feed.json"
-                }
-              }
+              files: $files
             }' > public/checksums.json
 
       - name: Generate ephemeral signing key for PR verification
@@ -81,6 +85,14 @@ jobs:
           signature_file: public/advisories/feed.json.sig
           public_key_output: public/signing-public.pem
 
+      - name: Sign provisional GHSA feed and verify
+        if: hashFiles('public/advisories/ghsa-without-cve.json') != ''
+        uses: ./.github/actions/sign-and-verify
+        with:
+          private_key: ${{ steps.test_key.outputs.private_key }}
+          input_file: public/advisories/ghsa-without-cve.json
+          signature_file: public/advisories/ghsa-without-cve.json.sig
+
       - name: Sign checksums and verify
         uses: ./.github/actions/sign-and-verify
         with:
@@ -107,5 +119,8 @@ jobs:
           set -euo pipefail
           test -f dist/index.html
           test -f public/advisories/feed.json.sig
+          if [ -f public/advisories/ghsa-without-cve.json ]; then
+            test -f public/advisories/ghsa-without-cve.json.sig
+          fi
           test -f public/checksums.sig
           test -f public/signing-public.pem

.github/workflows/poll-ghsa-without-cve.yml

@@ -0,0 +1,158 @@
+name: Poll GHSA Without CVE
+
+on:
+  workflow_dispatch:
+
+permissions: read-all
+
+concurrency:
+  group: poll-ghsa-without-cve
+  cancel-in-progress: false
+
+env:
+  FEED_PATH: advisories/feed.json
+  FEED_SIG_PATH: advisories/feed.json.sig
+  GHSA_FEED_PATH: advisories/ghsa-without-cve.json
+  GHSA_FEED_SIG_PATH: advisories/ghsa-without-cve.json.sig
+  SKILL_FEED_PATH: skills/clawsec-feed/advisories/feed.json
+  SKILL_FEED_SIG_PATH: skills/clawsec-feed/advisories/feed.json.sig
+
+jobs:
+  poll-and-update:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    steps:
+      - name: Checkout
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Setup Node.js
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - name: Run GHSA feed tests
+        run: node scripts/test-ghsa-without-cve-feed.mjs
+
+      - name: Poll GitHub Security Advisories
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        run: |
+          set -euo pipefail
+          node scripts/ghsa-without-cve-feed.mjs \
+            --output "$GHSA_FEED_PATH" \
+            --consolidated-feed "$FEED_PATH" \
+            --existing-feed "$GHSA_FEED_PATH" \
+            --nvd-feed "$FEED_PATH" \
+            --stale-after-days 60
+
+      - name: Sync consolidated feed to clawsec-feed skill
+        run: |
+          set -euo pipefail
+          mkdir -p "$(dirname "$SKILL_FEED_PATH")"
+          cp "$FEED_PATH" "$SKILL_FEED_PATH"
+
+      - name: Detect feed changes
+        id: changes
+        run: |
+          set -euo pipefail
+
+          GHSA_CHANGED=false
+          AGENT_CHANGED=false
+
+          if ! git diff --quiet -- "$GHSA_FEED_PATH" || [ ! -f "$GHSA_FEED_SIG_PATH" ]; then
+            GHSA_CHANGED=true
+          fi
+
+          if ! git diff --quiet -- "$FEED_PATH" "$SKILL_FEED_PATH" || [ ! -f "$FEED_SIG_PATH" ] || [ ! -f "$SKILL_FEED_SIG_PATH" ]; then
+            AGENT_CHANGED=true
+          fi
+
+          echo "ghsa_changed=$GHSA_CHANGED" >> "$GITHUB_OUTPUT"
+          echo "agent_changed=$AGENT_CHANGED" >> "$GITHUB_OUTPUT"
+
+          if [ "$GHSA_CHANGED" = "true" ] || [ "$AGENT_CHANGED" = "true" ]; then
+            echo "changed=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "changed=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Sign GHSA feed and verify
+        if: steps.changes.outputs.ghsa_changed == 'true'
+        uses: ./.github/actions/sign-and-verify
+        with:
+          private_key: ${{ secrets.CLAWSEC_SIGNING_PRIVATE_KEY }}
+          private_key_passphrase: ${{ secrets.CLAWSEC_SIGNING_PRIVATE_KEY_PASSPHRASE }}
+          input_file: ${{ env.GHSA_FEED_PATH }}
+          signature_file: ${{ env.GHSA_FEED_SIG_PATH }}
+
+      - name: Sign consolidated agent feed and verify
+        if: steps.changes.outputs.agent_changed == 'true'
+        uses: ./.github/actions/sign-and-verify
+        with:
+          private_key: ${{ secrets.CLAWSEC_SIGNING_PRIVATE_KEY }}
+          private_key_passphrase: ${{ secrets.CLAWSEC_SIGNING_PRIVATE_KEY_PASSPHRASE }}
+          input_file: ${{ env.FEED_PATH }}
+          signature_file: ${{ env.FEED_SIG_PATH }}
+          verify_files: |
+            ${{ env.FEED_PATH }}
+            ${{ env.SKILL_FEED_PATH }}
+
+      - name: Sync consolidated signature to clawsec-feed skill
+        if: steps.changes.outputs.agent_changed == 'true'
+        run: cp "$FEED_SIG_PATH" "$SKILL_FEED_SIG_PATH"
+
+      - name: Create Pull Request
+        if: steps.changes.outputs.changed == 'true'
+        id: create-pr
+        uses: peter-evans/create-pull-request@5f6978faf089d4d20b00c7766989d076bb2fc7f1 # v8.1.1
+        with:
+          token: ${{ github.token }}
+          branch: automated/ghsa-without-cve-feed
+          delete-branch: true
+          title: 'chore: update provisional GHSA advisory feed'
+          body: |
+            ## Summary
+            Updates the provisional GHSA advisory feed and the consolidated agent advisory feed.
+
+            - Feed: `${{ env.GHSA_FEED_PATH }}`
+            - Agent feed: `${{ env.FEED_PATH }}`
+            - Stale threshold: 60 days without a CVE
+            - Statuses: `active`, `matured`, `stale`
+
+            ---
+            *This PR was automatically generated by the GHSA-without-CVE polling workflow.*
+          commit-message: |
+            chore: update provisional GHSA advisory feed
+
+            Poll public GitHub Security Advisories without CVE identifiers.
+          add-paths: |
+            ${{ env.FEED_PATH }}
+            ${{ env.FEED_SIG_PATH }}
+            ${{ env.GHSA_FEED_PATH }}
+            ${{ env.GHSA_FEED_SIG_PATH }}
+            ${{ env.SKILL_FEED_PATH }}
+            ${{ env.SKILL_FEED_SIG_PATH }}
+
+      - name: Summary
+        run: |
+          set -euo pipefail
+          echo "## GHSA Without CVE Poll Summary" >> "$GITHUB_STEP_SUMMARY"
+          echo "" >> "$GITHUB_STEP_SUMMARY"
+          echo "| Metric | Value |" >> "$GITHUB_STEP_SUMMARY"
+          echo "|--------|-------|" >> "$GITHUB_STEP_SUMMARY"
+          echo "| Feed changed | ${{ steps.changes.outputs.changed }} |" >> "$GITHUB_STEP_SUMMARY"
+          echo "| Agent feed changed | ${{ steps.changes.outputs.agent_changed }} |" >> "$GITHUB_STEP_SUMMARY"
+          echo "| GHSA source feed changed | ${{ steps.changes.outputs.ghsa_changed }} |" >> "$GITHUB_STEP_SUMMARY"
+          echo "| Feed path | $GHSA_FEED_PATH |" >> "$GITHUB_STEP_SUMMARY"
+          echo "| Agent feed path | $FEED_PATH |" >> "$GITHUB_STEP_SUMMARY"
+          echo "| Total advisories | $(jq '.advisories | length' "$GHSA_FEED_PATH") |" >> "$GITHUB_STEP_SUMMARY"
+          echo "| Active | $(jq '[.advisories[] | select(.status == "active")] | length' "$GHSA_FEED_PATH") |" >> "$GITHUB_STEP_SUMMARY"
+          echo "| Matured | $(jq '[.advisories[] | select(.status == "matured")] | length' "$GHSA_FEED_PATH") |" >> "$GITHUB_STEP_SUMMARY"
+          echo "| Stale | $(jq '[.advisories[] | select(.status == "stale")] | length' "$GHSA_FEED_PATH") |" >> "$GITHUB_STEP_SUMMARY"
+          if [ -n "${{ steps.create-pr.outputs.pull-request-url }}" ]; then
+            echo "" >> "$GITHUB_STEP_SUMMARY"
+            echo "Upserted PR: ${{ steps.create-pr.outputs.pull-request-url }}" >> "$GITHUB_STEP_SUMMARY"
+          fi

.github/workflows/poll-nvd-cves.yml

@@ -21,6 +21,8 @@ concurrency:
 env:
   FEED_PATH: advisories/feed.json
   FEED_SIG_PATH: advisories/feed.json.sig
+  GHSA_FEED_PATH: advisories/ghsa-without-cve.json
+  GHSA_FEED_SIG_PATH: advisories/ghsa-without-cve.json.sig
   SKILL_FEED_PATH: skills/clawsec-feed/advisories/feed.json
   SKILL_FEED_SIG_PATH: skills/clawsec-feed/advisories/feed.json.sig
 
@@ -833,8 +835,54 @@ jobs:
             exit 1
           fi
 
+      - name: Poll GHSA without CVE and consolidate feed
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+        run: |
+          set -euo pipefail
+          node scripts/ghsa-without-cve-feed.mjs \
+            --output "$GHSA_FEED_PATH" \
+            --consolidated-feed "$FEED_PATH" \
+            --existing-feed "$GHSA_FEED_PATH" \
+            --nvd-feed "$FEED_PATH" \
+            --stale-after-days 60
+
+          mkdir -p "$(dirname "$SKILL_FEED_PATH")"
+          cp "$FEED_PATH" "$SKILL_FEED_PATH"
+
+      - name: Detect advisory feed changes
+        id: feed_changes
+        run: |
+          set -euo pipefail
+
+          NVD_CHANGED=false
+          GHSA_CHANGED=false
+          AGENT_CHANGED=false
+
+          if [ "${{ steps.transform.outputs.new_count }}" != "0" ] || [ "${{ steps.updates.outputs.update_count }}" != "0" ]; then
+            NVD_CHANGED=true
+          fi
+
+          if ! git diff --quiet -- "$GHSA_FEED_PATH" || [ ! -f "$GHSA_FEED_SIG_PATH" ]; then
+            GHSA_CHANGED=true
+          fi
+
+          if ! git diff --quiet -- "$FEED_PATH" "$SKILL_FEED_PATH" || [ ! -f "$FEED_SIG_PATH" ] || [ ! -f "$SKILL_FEED_SIG_PATH" ]; then
+            AGENT_CHANGED=true
+          fi
+
+          echo "nvd_changed=$NVD_CHANGED" >> "$GITHUB_OUTPUT"
+          echo "ghsa_changed=$GHSA_CHANGED" >> "$GITHUB_OUTPUT"
+          echo "agent_changed=$AGENT_CHANGED" >> "$GITHUB_OUTPUT"
+
+          if [ "$GHSA_CHANGED" = "true" ] || [ "$AGENT_CHANGED" = "true" ]; then
+            echo "changed=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "changed=false" >> "$GITHUB_OUTPUT"
+          fi
+
       - name: Guard dependency manifests from NVD updates
-        if: steps.transform.outputs.new_count != '0' || steps.updates.outputs.update_count != '0'
+        if: steps.feed_changes.outputs.changed == 'true'
         run: |
           set -euo pipefail
 
@@ -851,8 +899,17 @@ jobs:
             exit 1
           fi
 
+      - name: Sign GHSA feed and verify
+        if: steps.feed_changes.outputs.ghsa_changed == 'true'
+        uses: ./.github/actions/sign-and-verify
+        with:
+          private_key: ${{ secrets.CLAWSEC_SIGNING_PRIVATE_KEY }}
+          private_key_passphrase: ${{ secrets.CLAWSEC_SIGNING_PRIVATE_KEY_PASSPHRASE }}
+          input_file: ${{ env.GHSA_FEED_PATH }}
+          signature_file: ${{ env.GHSA_FEED_SIG_PATH }}
+
       - name: Sign advisory feed and verify
-        if: steps.transform.outputs.new_count != '0' || steps.updates.outputs.update_count != '0'
+        if: steps.feed_changes.outputs.agent_changed == 'true'
         uses: ./.github/actions/sign-and-verify
         with:
           private_key: ${{ secrets.CLAWSEC_SIGNING_PRIVATE_KEY }}
@@ -864,18 +921,18 @@ jobs:
             ${{ env.SKILL_FEED_PATH }}
 
       - name: Sync advisory signature to skill feed
-        if: steps.transform.outputs.new_count != '0' || steps.updates.outputs.update_count != '0'
+        if: steps.feed_changes.outputs.agent_changed == 'true'
         run: cp "$FEED_SIG_PATH" "$SKILL_FEED_SIG_PATH"
 
       - name: Clean workspace for PR
-        if: steps.transform.outputs.new_count != '0' || steps.updates.outputs.update_count != '0'
+        if: steps.feed_changes.outputs.changed == 'true'
         run: |
           # Reset any unintended changes, keep only feed files
           git checkout -- .github/ 2>/dev/null || true
           git clean -fd .github/ 2>/dev/null || true
 
       - name: Upsert NVD advisory PR
-        if: steps.transform.outputs.new_count != '0' || steps.updates.outputs.update_count != '0'
+        if: steps.feed_changes.outputs.changed == 'true'
         id: upsert-pr
         env:
           GH_TOKEN: ${{ github.token }}
@@ -884,9 +941,14 @@ jobs:
 
           BRANCH_PREFIX="automated/nvd-cve-update"
           PR_COMMENT="Superseded by newer automated NVD advisory update."
-          TITLE="chore: CVE advisories - ${{ steps.transform.outputs.new_count }} new, ${{ steps.updates.outputs.update_count }} updated"
+          TITLE="chore: update NVD/GHSA advisories - ${{ steps.transform.outputs.new_count }} NVD new, ${{ steps.updates.outputs.update_count }} NVD updated"
           COMMIT_SUBJECT="$TITLE"
-          COMMIT_BODY=$'Automated update from NVD CVE feed.\nKeywords: ${{ env.KEYWORDS }}\nPoll window: ${{ steps.dates.outputs.start_date }} to ${{ steps.dates.outputs.end_date }}'
+          COMMIT_BODY=$'Automated update from NVD CVE and GHSA advisory feeds.\nKeywords: ${{ env.KEYWORDS }}\nPoll window: ${{ steps.dates.outputs.start_date }} to ${{ steps.dates.outputs.end_date }}'
+
+          GHSA_TOTAL="$(jq '.advisories | length' "$GHSA_FEED_PATH")"
+          GHSA_ACTIVE="$(jq '[.advisories[] | select(.status == "active")] | length' "$GHSA_FEED_PATH")"
+          GHSA_MATURED="$(jq '[.advisories[] | select(.status == "matured")] | length' "$GHSA_FEED_PATH")"
+          GHSA_STALE="$(jq '[.advisories[] | select(.status == "stale")] | length' "$GHSA_FEED_PATH")"
 
           if [ "${{ inputs.force_full_scan }}" = "true" ]; then
             MODE="full-rebuild (ignore feed state)"
@@ -897,16 +959,19 @@ jobs:
           BODY_FILE="$(mktemp)"
           cat > "$BODY_FILE" <<EOF
           ## Summary
-          Automated update from NVD CVE feed.
+          Automated update from NVD CVE and GHSA advisory feeds.
 
           - **Mode:** ${MODE}
-          - **New advisories:** ${{ steps.transform.outputs.new_count }}
-          - **Updated advisories:** ${{ steps.updates.outputs.update_count }}
+          - **New NVD advisories:** ${{ steps.transform.outputs.new_count }}
+          - **Updated NVD advisories:** ${{ steps.updates.outputs.update_count }}
+          - **GHSA source feed changed:** ${{ steps.feed_changes.outputs.ghsa_changed }}
+          - **Consolidated agent feed changed:** ${{ steps.feed_changes.outputs.agent_changed }}
+          - **GHSA provisional advisories:** ${GHSA_TOTAL} total (${GHSA_ACTIVE} active, ${GHSA_MATURED} matured, ${GHSA_STALE} stale)
           - **Poll window:** ${{ steps.dates.outputs.start_date }} → ${{ steps.dates.outputs.end_date }}
           - **Keywords:** ${{ env.KEYWORDS }}
 
           ---
-          *This PR was automatically generated by the NVD CVE polling workflow.*
+          *This PR was automatically generated by the NVD CVE polling workflow with GHSA consolidation.*
           EOF
 
           PR_LIST_JSON="$(
@@ -953,7 +1018,7 @@ jobs:
           git fetch origin main
           git checkout -B "$TARGET_BRANCH" origin/main
 
-          git add "$FEED_PATH" "$FEED_SIG_PATH" "$SKILL_FEED_PATH" "$SKILL_FEED_SIG_PATH"
+          git add "$FEED_PATH" "$FEED_SIG_PATH" "$GHSA_FEED_PATH" "$GHSA_FEED_SIG_PATH" "$SKILL_FEED_PATH" "$SKILL_FEED_SIG_PATH"
           if git diff --cached --quiet; then
             echo "::error::Expected advisory feed changes but none were staged."
             exit 1
@@ -990,7 +1055,10 @@ jobs:
             exit 1
           fi
 
-          echo "Dispatching CodeQL for branch: $BRANCH"
+          EXPECTED_HEAD_SHA="$(git rev-parse HEAD)"
+          DISPATCHED_AT="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
+
+          echo "Dispatching CodeQL for branch: $BRANCH (head: $EXPECTED_HEAD_SHA, dispatched_at: $DISPATCHED_AT)"
           gh workflow run codeql.yml --ref "$BRANCH"
 
           RUN_ID=""
@@ -999,8 +1067,13 @@ jobs:
               --workflow "CodeQL" \
               --branch "$BRANCH" \
               --event workflow_dispatch \
-              --json databaseId,createdAt \
-              --jq 'sort_by(.createdAt) | last | .databaseId // empty')
+              --limit 50 \
+              --json databaseId,createdAt,headSha \
+              | jq -r --arg since "$DISPATCHED_AT" --arg sha "$EXPECTED_HEAD_SHA" '
+                map(select(.createdAt >= $since and .headSha == $sha))
+                | sort_by(.createdAt)
+                | last
+                | .databaseId // empty')
             if [ -n "$RUN_ID" ]; then
               break
             fi
@@ -1008,7 +1081,13 @@ jobs:
           done
 
           if [ -z "$RUN_ID" ]; then
-            echo "::error::Unable to locate dispatched CodeQL run for branch $BRANCH"
+            echo "::error::Unable to locate dispatched CodeQL run for branch $BRANCH after $DISPATCHED_AT (head: $EXPECTED_HEAD_SHA)"
+            gh run list \
+              --workflow "CodeQL" \
+              --branch "$BRANCH" \
+              --event workflow_dispatch \
+              --limit 5 \
+              --json databaseId,createdAt,headSha,status,conclusion || true
             exit 1
           fi
 
@@ -1033,6 +1112,9 @@ jobs:
           echo "| CVEs Found (filtered) | ${{ steps.process.outputs.filtered_count }} |" >> $GITHUB_STEP_SUMMARY
           echo "| New Advisories | ${{ steps.transform.outputs.new_count }} |" >> $GITHUB_STEP_SUMMARY
           echo "| Updated Advisories | ${{ steps.updates.outputs.update_count }} |" >> $GITHUB_STEP_SUMMARY
+          echo "| GHSA source feed changed | ${{ steps.feed_changes.outputs.ghsa_changed }} |" >> $GITHUB_STEP_SUMMARY
+          echo "| Consolidated agent feed changed | ${{ steps.feed_changes.outputs.agent_changed }} |" >> $GITHUB_STEP_SUMMARY
+          echo "| GHSA provisional advisories | $(jq '.advisories | length' "$GHSA_FEED_PATH") |" >> $GITHUB_STEP_SUMMARY
 
           if [ "${{ steps.transform.outputs.new_count }}" != "0" ]; then
             echo "" >> $GITHUB_STEP_SUMMARY

.github/workflows/scorecard.yml

@@ -84,6 +84,6 @@ jobs:
       # Upload the results to GitHub's code scanning dashboard (optional).
       # Commenting out will disable upload of results to your repo's Code Scanning dashboard
       - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@68bde559dea0fdcac2102bfdf6230c5f70eb485e # v4.35.4
+        uses: github/codeql-action/upload-sarif@7211b7c8077ea37d8641b6271f6a365a22a5fbfa # v4.36.0
         with:
           sarif_file: results.sarif

.github/workflows/skill-release.yml

@@ -6,8 +6,10 @@ on:
       - '*-v[0-9]*.[0-9]*.[0-9]*'
   pull_request:
     paths:
-      - 'skills/*/skill.json'
-      - 'skills/*/SKILL.md'
+      - 'skills/**'
+      - '.github/workflows/skill-release.yml'
+      - 'scripts/ci/**'
+      - 'scripts/test-skill-*.mjs'
   workflow_dispatch:
     inputs:
       tag:
@@ -36,10 +38,15 @@ jobs:
         with:
           fetch-depth: 0
 
+      - name: Setup Node
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        with:
+          node-version: 20
+
       - name: Verify signing key consistency (repo + docs)
         run: ./scripts/ci/verify_signing_key_consistency.sh
 
-      - name: Validate version parity for bumped skills
+      - name: Validate version parity for changed skills
         env:
           BASE_SHA: ${{ github.event.pull_request.base.sha }}
           HEAD_SHA: ${{ github.event.pull_request.head.sha }}
@@ -79,12 +86,15 @@ jobs:
           }
 
           touched_skills_file="$(mktemp)"
-          git diff --name-only "${BASE_SHA}...${HEAD_SHA}" -- 'skills/*/skill.json' 'skills/*/SKILL.md' \
+          git diff --name-only "${BASE_SHA}...${HEAD_SHA}" -- \
+            'skills/*/**' \
+            ':(exclude)skills/*/test/**' \
+            ':(exclude)skills/*/tests/**' \
             | awk -F/ 'NF >= 3 {print $1 "/" $2}' \
             | sort -u > "${touched_skills_file}"
 
           if [ ! -s "${touched_skills_file}" ]; then
-            echo "No skill metadata files changed in this PR."
+            echo "No release-relevant skill package files changed in this PR."
             rm -f "${touched_skills_file}"
             exit 0
           fi
@@ -129,6 +139,8 @@ jobs:
               continue
             fi
 
+            checked_skills=$((checked_skills + 1))
+
             json_version_changed=false
             md_version_changed=false
 
@@ -140,14 +152,6 @@ jobs:
               md_version_changed=true
             fi
 
-            if [ "${json_version_changed}" != "true" ] && [ "${md_version_changed}" != "true" ]; then
-              echo "No version bump detected for ${skill_dir}; skipping."
-              continue
-            fi
-
-            checked_skills=$((checked_skills + 1))
-            echo "Version bump detected for ${skill_dir} (skill.json changed: ${json_version_changed}, SKILL.md changed: ${md_version_changed})"
-
             if [ ! -f "${json_path}" ]; then
               echo "::error file=${json_path}::Missing skill.json after version bump."
               failures=$((failures + 1))
@@ -178,6 +182,20 @@ jobs:
               continue
             fi
 
+            skill_release_name="$(basename "${skill_dir}")"
+            release_tag="${skill_release_name}-v${head_json_version}"
+            if [ "${json_version_changed}" != "true" ] && [ "${md_version_changed}" != "true" ]; then
+              if git show-ref --verify --quiet "refs/tags/${release_tag}"; then
+                echo "::error file=${skill_dir}::Changed skill package has no version bump and release tag ${release_tag} already exists. Update skill.json and SKILL.md versions and add CHANGELOG.md release notes."
+                failures=$((failures + 1))
+                continue
+              fi
+
+              echo "No version bump detected for ${skill_dir}, but release tag ${release_tag} does not exist; treating ${head_json_version} as unreleased."
+            else
+              echo "Version bump detected for ${skill_dir} (skill.json changed: ${json_version_changed}, SKILL.md changed: ${md_version_changed})"
+            fi
+
             echo "Version parity OK for ${skill_dir}: ${head_json_version}"
 
             changelog_path="${skill_dir}/CHANGELOG.md"
@@ -219,11 +237,17 @@ jobs:
           fi
 
           if [ "${failures}" -gt 0 ]; then
-            echo "::error::Found ${failures} skill metadata/release-notes issue(s) across ${checked_skills} bumped skill(s)."
+            echo "::error::Found ${failures} skill metadata/release-notes issue(s) across ${checked_skills} changed skill(s)."
             exit 1
           fi
 
-          echo "Validated ${checked_skills} bumped skill(s): version parity and changelog release notes are present."
+          echo "Validated ${checked_skills} changed skill(s): version parity and changelog release notes are present."
+
+      - name: Validate npx skills install docs
+        env:
+          BASE_SHA: ${{ github.event.pull_request.base.sha }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
+        run: node scripts/ci/validate_skill_install_docs.mjs --base "$BASE_SHA" --head "$HEAD_SHA"
 
   release:
     if: github.event_name == 'pull_request'
@@ -237,6 +261,21 @@ jobs:
         with:
           fetch-depth: 0
 
+      - name: Setup Node
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        with:
+          node-version: 20
+
+      - name: Install SkillSpector
+        run: |
+          set -euo pipefail
+          python3 -m venv /tmp/skillspector-venv
+          . /tmp/skillspector-venv/bin/activate
+          git clone --depth 1 https://github.com/NVIDIA/SkillSpector.git /tmp/skillspector
+          make -C /tmp/skillspector install
+          echo "/tmp/skillspector-venv/bin" >> "$GITHUB_PATH"
+          skillspector --help >/dev/null
+
       - name: Generate test signing key for dry-run
         run: |
           set -euo pipefail
@@ -395,6 +434,50 @@ jobs:
             [[ "$lower" == test/* || "$lower" == tests/* || "$lower" == */test/* || "$lower" == */tests/* ]]
           }
 
+          generate_skillspector_report() {
+            local skill_dir="$1"
+            local report_path="$2"
+
+            set +e
+            skillspector scan "${skill_dir}" --no-llm --format markdown --output "${report_path}"
+            local status=$?
+            set -e
+
+            if [ ! -s "${report_path}" ]; then
+              echo "::error file=${skill_dir}::SkillSpector did not produce a report."
+              return 1
+            fi
+
+            if [ "${status}" -ne 0 ]; then
+              echo "::warning file=${report_path}::SkillSpector returned exit code ${status}; report is included for review."
+            fi
+          }
+
+          add_release_asset_checksum() {
+            local out_assets="$1"
+            local asset="$2"
+            local file_path="${out_assets}/${asset}"
+            local sha256
+            local size
+            local tmp_json
+
+            if [ ! -s "${file_path}" ]; then
+              echo "::error file=${file_path}::Required release trust artifact is missing or empty."
+              return 1
+            fi
+
+            sha256="$(sha256sum "${file_path}" | awk '{print $1}')"
+            size="$(stat -c%s "${file_path}" 2>/dev/null || stat -f%z "${file_path}")"
+            tmp_json="$(mktemp)"
+            jq \
+              --arg key "${asset}" \
+              --arg sha "${sha256}" \
+              --argjson sz "${size}" \
+              '.files += {($key): {sha256: $sha, size: $sz, path: $key}}' \
+              "${out_assets}/checksums.json" > "${tmp_json}"
+            mv "${tmp_json}" "${out_assets}/checksums.json"
+          }
+
           while IFS= read -r skill_dir; do
             json_path="${skill_dir}/skill.json"
             md_path="${skill_dir}/SKILL.md"
@@ -530,6 +613,9 @@ jobs:
               echo "  [Dry-run] Removed test signatures from release staging"
             fi
 
+            # --- Verify staged runtime import closure before archiving ---
+            python3 scripts/ci/verify_skill_release_import_closure.py "${inner_dir}"
+
             # --- Create zip preserving directory structure ---
             zip_name="${skill_name}-v${version}.zip"
             (cd "${staging_dir}" && zip -qr "${OLDPWD}/${out_assets}/${zip_name}" .)
@@ -615,6 +701,58 @@ jobs:
               continue
             fi
 
+            # --- Generate release trust packet and include it in signed checksums ---
+            node scripts/ci/generate_skill_release_trust_packet.mjs \
+              "${skill_dir}" \
+              "${out_assets}" \
+              --repository "${{ github.repository }}" \
+              --tag "${tag}" \
+              --source-ref "${HEAD_SHA}"
+
+            # --- Generate SkillSpector report ---
+            if ! generate_skillspector_report "${inner_dir}" "${out_assets}/skillspector-report.md"; then
+              failures=$((failures + 1))
+              rm -rf "${staging_dir}"
+              echo "::endgroup::"
+              continue
+            fi
+
+            if ! add_release_asset_checksum "${out_assets}" "skill-card.md"; then
+              failures=$((failures + 1))
+              rm -rf "${staging_dir}"
+              echo "::endgroup::"
+              continue
+            fi
+
+            if ! add_release_asset_checksum "${out_assets}" "permissions.json"; then
+              failures=$((failures + 1))
+              rm -rf "${staging_dir}"
+              echo "::endgroup::"
+              continue
+            fi
+
+            if ! add_release_asset_checksum "${out_assets}" "install.md"; then
+              failures=$((failures + 1))
+              rm -rf "${staging_dir}"
+              echo "::endgroup::"
+              continue
+            fi
+
+            if ! add_release_asset_checksum "${out_assets}" "skillspector-report.md"; then
+              failures=$((failures + 1))
+              rm -rf "${staging_dir}"
+              echo "::endgroup::"
+              continue
+            fi
+
+            if ! jq -e . "${out_assets}/checksums.json" >/dev/null 2>&1; then
+              echo "::error::Generated checksums.json is invalid JSON after adding release trust artifacts."
+              failures=$((failures + 1))
+              rm -rf "${staging_dir}"
+              echo "::endgroup::"
+              continue
+            fi
+
             # --- Copy skill.json and root-level docs alongside the zip ---
             cp "${json_path}" "${out_assets}/skill.json"
             if [ -f "${skill_dir}/SKILL.md" ]; then
@@ -645,6 +783,56 @@ jobs:
 
           echo "Release dry-run completed successfully for ${dry_run_count} changed skill(s)."
 
+  simulate-tag-release-build:
+    if: github.event_name == 'pull_request'
+    needs: validate-pr-version-sync
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - name: Checkout
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          fetch-depth: 0
+
+      - name: Setup Node
+        uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
+        with:
+          node-version: 20
+
+      - name: Install SkillSpector
+        run: |
+          set -euo pipefail
+          python3 -m venv /tmp/skillspector-venv
+          . /tmp/skillspector-venv/bin/activate
+          git clone --depth 1 https://github.com/NVIDIA/SkillSpector.git /tmp/skillspector
+          make -C /tmp/skillspector install
+          echo "/tmp/skillspector-venv/bin" >> "$GITHUB_PATH"
+          skillspector --help >/dev/null
+
+      - name: Simulate tag release build
+        run: |
+          set -euo pipefail
+          mkdir -p dist/tag-release-simulation
+
+          for skill_json in skills/*/skill.json; do
+            skill_dir="${skill_json%/skill.json}"
+            skill_name="$(basename "${skill_dir}")"
+            echo "::group::Simulate tag release build for ${skill_name}"
+            node scripts/ci/simulate_skill_tag_release.mjs \
+              "${skill_dir}" \
+              "dist/tag-release-simulation/${skill_name}" \
+              --repository "${{ github.repository }}" \
+              --source-ref "${{ github.event.pull_request.head.sha }}"
+            jq -e '.simulated_version | test("^[0-9]+\\.[0-9]+\\.[0-9]+(-[a-zA-Z0-9]+)?$")' \
+              "dist/tag-release-simulation/${skill_name}/simulation-summary.json" >/dev/null
+            test -s "dist/tag-release-simulation/${skill_name}/release-assets/checksums.json"
+            test -s "dist/tag-release-simulation/${skill_name}/release-assets/checksums.sig"
+            test -s "dist/tag-release-simulation/${skill_name}/release-assets/signing-public.pem"
+            test -s "dist/tag-release-simulation/${skill_name}/release-assets/skillspector-report.md"
+            echo "::endgroup::"
+          done
+
   release-tag:
     if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
     runs-on: ubuntu-latest
@@ -657,6 +845,7 @@ jobs:
       publishable: ${{ steps.publishable.outputs.publishable }}
       openclaw_skill: ${{ steps.publishable.outputs.openclaw_skill }}
       publish_clawhub: ${{ steps.publishable.outputs.publish_clawhub }}
+      clawhub_slug: ${{ steps.publishable.outputs.clawhub_slug }}
     steps:
       - name: Parse tag
         id: parse
@@ -754,16 +943,32 @@ jobs:
             PUBLISH_CLAWHUB=true
           fi
 
+          CLAWHUB_SLUG=$(node scripts/ci/resolve_clawhub_slug.mjs "$SKILL_PATH")
+
           echo "internal=${INTERNAL}" >> $GITHUB_OUTPUT
           echo "openclaw_skill=${OPENCLAW_SKILL}" >> $GITHUB_OUTPUT
           echo "publish_clawhub=${PUBLISH_CLAWHUB}" >> $GITHUB_OUTPUT
           echo "publishable=${PUBLISHABLE}" >> $GITHUB_OUTPUT
+          echo "clawhub_slug=${CLAWHUB_SLUG}" >> $GITHUB_OUTPUT
 
       - name: Setup Node
         uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
         with:
           node-version: 20
 
+      - name: Validate npx skills install docs
+        run: node scripts/ci/validate_skill_install_docs.mjs --skills "${{ steps.parse.outputs.skill_path }}"
+
+      - name: Install SkillSpector
+        run: |
+          set -euo pipefail
+          python3 -m venv /tmp/skillspector-venv
+          . /tmp/skillspector-venv/bin/activate
+          git clone --depth 1 https://github.com/NVIDIA/SkillSpector.git /tmp/skillspector
+          make -C /tmp/skillspector install
+          echo "/tmp/skillspector-venv/bin" >> "$GITHUB_PATH"
+          skillspector --help >/dev/null
+
       - name: Sign embedded advisory feed and verify
         if: hashFiles(format('skills/{0}/advisories/feed.json', steps.parse.outputs.skill_name)) != ''
         uses: ./.github/actions/sign-and-verify
@@ -863,6 +1068,49 @@ jobs:
             [[ "$lower" == test/* || "$lower" == tests/* || "$lower" == */test/* || "$lower" == */tests/* ]]
           }
 
+          generate_skillspector_report() {
+            local skill_dir="$1"
+            local report_path="$2"
+
+            set +e
+            skillspector scan "${skill_dir}" --no-llm --format markdown --output "${report_path}"
+            local status=$?
+            set -e
+
+            if [ ! -s "${report_path}" ]; then
+              echo "::error file=${skill_dir}::SkillSpector did not produce a report."
+              return 1
+            fi
+
+            if [ "${status}" -ne 0 ]; then
+              echo "::warning file=${report_path}::SkillSpector returned exit code ${status}; report is included for review."
+            fi
+          }
+
+          add_release_asset_checksum() {
+            local asset="$1"
+            local file_path="release-assets/${asset}"
+            local sha256
+            local size
+            local tmp_json
+
+            if [ ! -s "${file_path}" ]; then
+              echo "::error file=${file_path}::Required release trust artifact is missing or empty."
+              return 1
+            fi
+
+            sha256="$(sha256sum "${file_path}" | awk '{print $1}')"
+            size="$(stat -c%s "${file_path}" 2>/dev/null || stat -f%z "${file_path}")"
+            tmp_json="$(mktemp)"
+            jq \
+              --arg key "${asset}" \
+              --arg sha "${sha256}" \
+              --argjson sz "${size}" \
+              '.files += {($key): {sha256: $sha, size: $sz, path: $key}}' \
+              release-assets/checksums.json > "${tmp_json}"
+            mv "${tmp_json}" release-assets/checksums.json
+          }
+
           # --- Stage SBOM files preserving directory structure ---
           STAGING_DIR="$(mktemp -d)"
           INNER_DIR="$STAGING_DIR/$SKILL_NAME"
@@ -892,6 +1140,9 @@ jobs:
 
           cp "$SKILL_PATH/skill.json" "$INNER_DIR/skill.json"
 
+          # --- Verify staged runtime import closure before archiving ---
+          python3 scripts/ci/verify_skill_release_import_closure.py "$INNER_DIR"
+
           # --- Create zip preserving directory structure ---
           ZIP_NAME="${SKILL_NAME}-v${VERSION}.zip"
           (cd "$STAGING_DIR" && zip -qr "$OLDPWD/release-assets/$ZIP_NAME" .)
@@ -961,6 +1212,32 @@ jobs:
               files: $files
             }' > "release-assets/checksums.json"
 
+          # --- Generate release trust packet and include it in signed checksums ---
+          node scripts/ci/generate_skill_release_trust_packet.mjs \
+            "$SKILL_PATH" \
+            release-assets \
+            --repository "${{ github.repository }}" \
+            --tag "$TAG" \
+            --source-ref "$TAG"
+
+          # --- Generate SkillSpector report ---
+          generate_skillspector_report "$INNER_DIR" "release-assets/skillspector-report.md"
+
+          test -s release-assets/skill-card.md
+          test -s release-assets/permissions.json
+          test -s release-assets/install.md
+          test -s release-assets/skillspector-report.md
+
+          add_release_asset_checksum "skill-card.md"
+          add_release_asset_checksum "permissions.json"
+          add_release_asset_checksum "install.md"
+          add_release_asset_checksum "skillspector-report.md"
+
+          if ! jq -e . "release-assets/checksums.json" >/dev/null 2>&1; then
+            echo "::error::Generated checksums.json is invalid JSON after adding release trust artifacts."
+            exit 1
+          fi
+
           # --- Copy skill.json and root-level docs alongside the zip ---
           cp "$SKILL_PATH/skill.json" release-assets/skill.json
           if [ -f "$SKILL_PATH/SKILL.md" ]; then
@@ -1045,6 +1322,7 @@ jobs:
         run: |
           set -euo pipefail
           SKILL_NAME="${{ steps.parse.outputs.skill_name }}"
+          CLAWHUB_SLUG="${{ steps.publishable.outputs.clawhub_slug }}"
           VERSION="${{ steps.parse.outputs.version }}"
           REPO="${{ github.repository }}"
           TAG="${{ github.ref_name }}"
@@ -1052,13 +1330,33 @@ jobs:
           {
             echo "quick_install<<INSTALL_EOF"
 
+            cat <<EOF
+          ### Agent Skills CLI
+
+          **Codex global install:**
+          \`\`\`bash
+          npx skills add ${REPO} --skill ${SKILL_NAME} --agent codex --global --yes
+          \`\`\`
+
+          **OpenClaw global install:**
+          \`\`\`bash
+          npx skills add ${REPO} --skill ${SKILL_NAME} --agent openclaw --global --yes
+          \`\`\`
+
+          **Update an installed skill:**
+          \`\`\`bash
+          npx skills update ${SKILL_NAME}
+          \`\`\`
+
+          EOF
+
             if [ "${{ steps.publishable.outputs.publish_clawhub }}" = "true" ] && [ "${{ steps.publishable.outputs.openclaw_skill }}" = "true" ]; then
               cat <<EOF
           ### Quick Install
 
           **Via ClawHub (recommended):**
           \`\`\`bash
-          npx clawhub@latest install ${SKILL_NAME}
+          npx clawhub@latest install ${CLAWHUB_SLUG}
           \`\`\`
 
           **If you already have \`clawsec-suite\` installed:**
@@ -1105,38 +1403,63 @@ jobs:
             echo "INSTALL_EOF"
           } >> "$GITHUB_OUTPUT"
 
+      - name: Prepare GitHub release body
+        env:
+          SKILL_NAME: ${{ steps.parse.outputs.skill_name }}
+          VERSION: ${{ steps.parse.outputs.version }}
+          CHANGELOG: ${{ steps.changelog.outputs.changelog }}
+          QUICK_INSTALL: ${{ steps.install.outputs.quick_install }}
+          REPO: ${{ github.repository }}
+          TAG: ${{ github.ref_name }}
+        run: |
+          set -euo pipefail
+          node -e '
+          const { readFileSync, writeFileSync } = require("node:fs");
+          const bodyPath = `${process.env.RUNNER_TEMP}/skill-release-body.md`;
+          const report = readFileSync("release-assets/skillspector-report.md", "utf8").trimEnd();
+          const body = [
+            `## ${process.env.SKILL_NAME} ${process.env.VERSION}`,
+            "",
+            process.env.CHANGELOG || "",
+            "",
+            process.env.QUICK_INSTALL || "",
+            "",
+            "### SkillSpector Security Report",
+            "",
+            report,
+            "",
+            `Download the generated release-payload scan: [skillspector-report.md](https://github.com/${process.env.REPO}/releases/download/${process.env.TAG}/skillspector-report.md)`,
+            "",
+            "### Verification",
+            "",
+            "`checksums.json` is cryptographically signed (`checksums.sig`) using the ClawSec CI signing key.",
+            "Verify the signature first, then trust hashes from `checksums.json`:",
+            "```bash",
+            `curl -sLO https://github.com/${process.env.REPO}/releases/download/${process.env.TAG}/checksums.json`,
+            `curl -sLO https://github.com/${process.env.REPO}/releases/download/${process.env.TAG}/checksums.sig`,
+            `curl -sLO https://github.com/${process.env.REPO}/releases/download/${process.env.TAG}/signing-public.pem`,
+            "openssl base64 -d -A -in checksums.sig -out checksums.sig.bin",
+            "openssl pkeyutl -verify -rawin -pubin -inkey signing-public.pem -sigfile checksums.sig.bin -in checksums.json",
+            "```",
+            "",
+            "### Files",
+            "",
+            "See `checksums.json` for the complete file manifest with SHA256 hashes.",
+            "The zip archive preserves the full directory structure of the skill.",
+            "",
+            "---",
+            "*Released by ClawSec skill distribution pipeline*",
+          ].join("\n");
+          writeFileSync(bodyPath, `${body}\n`);
+          '
+
       - name: Create GitHub Release
         uses: softprops/action-gh-release@b4309332981a82ec1c5618f44dd2e27cc8bfbfda # v3.0.0
         with:
           name: "${{ steps.parse.outputs.skill_name }} ${{ steps.parse.outputs.version }}"
           tag_name: ${{ github.ref_name }}
           files: release-assets/*
-          body: |
-            ## ${{ steps.parse.outputs.skill_name }} ${{ steps.parse.outputs.version }}
-
-            ${{ steps.changelog.outputs.changelog }}
-
-            ${{ steps.install.outputs.quick_install }}
-
-            ### Verification
-
-            `checksums.json` is cryptographically signed (`checksums.sig`) using the ClawSec CI signing key.
-            Verify the signature first, then trust hashes from `checksums.json`:
-            ```bash
-            curl -sLO https://github.com/${{ github.repository }}/releases/download/${{ github.ref_name }}/checksums.json
-            curl -sLO https://github.com/${{ github.repository }}/releases/download/${{ github.ref_name }}/checksums.sig
-            curl -sLO https://github.com/${{ github.repository }}/releases/download/${{ github.ref_name }}/signing-public.pem
-            openssl base64 -d -A -in checksums.sig -out checksums.sig.bin
-            openssl pkeyutl -verify -rawin -pubin -inkey signing-public.pem -sigfile checksums.sig.bin -in checksums.json
-            ```
-
-            ### Files
-
-            See `checksums.json` for the complete file manifest with SHA256 hashes.
-            The zip archive preserves the full directory structure of the skill.
-
-            ---
-            *Released by ClawSec skill distribution pipeline*
+          body_path: ${{ runner.temp }}/skill-release-body.md
           draft: false
           prerelease: ${{ contains(github.ref_name, 'alpha') || contains(github.ref_name, 'beta') || contains(github.ref_name, 'rc') }}
         env:
@@ -1274,23 +1597,24 @@ jobs:
           SITE=${CLAWHUB_SITE:-https://clawhub.ai}
           REGISTRY=${CLAWHUB_REGISTRY:-$SITE}
           SKILL_NAME="${{ needs.release-tag.outputs.skill_name }}"
+          CLAWHUB_SLUG="${{ needs.release-tag.outputs.clawhub_slug }}"
           VERSION="${{ needs.release-tag.outputs.version }}"
           export CLAWHUB_CONFIG_PATH="$HOME/.clawhub-ci/config.json"
 
           set +e
           CLAWHUB_DISABLE_TELEMETRY=1 CLAWHUB_SITE="$SITE" CLAWHUB_REGISTRY="$REGISTRY" \
-            clawhub inspect "$SKILL_NAME" --version "$VERSION" --json \
+            clawhub inspect "$CLAWHUB_SLUG" --version "$VERSION" --json \
             > /tmp/clawhub-existing-version.json 2> /tmp/clawhub-existing-version.err
           STATUS=$?
           set -e
 
           if [ "$STATUS" -eq 0 ]; then
-            echo "::error::ClawHub already contains ${SKILL_NAME}@${VERSION}. Bump the version before tagging."
+            echo "::error::ClawHub already contains ${CLAWHUB_SLUG}@${VERSION}. Bump the version before tagging."
             exit 1
           fi
 
           if grep -Eqi "Version not found|Skill not found" /tmp/clawhub-existing-version.err; then
-            echo "No existing ${SKILL_NAME}@${VERSION} detected in ClawHub. Proceeding."
+            echo "No existing ${CLAWHUB_SLUG}@${VERSION} detected in ClawHub. Proceeding."
           else
             echo "::error::Failed to verify ClawHub version precondition."
             cat /tmp/clawhub-existing-version.err
@@ -1305,6 +1629,7 @@ jobs:
           REGISTRY=${CLAWHUB_REGISTRY:-$SITE}
           SKILL_PATH="${{ needs.release-tag.outputs.skill_path }}"
           SKILL_NAME="${{ needs.release-tag.outputs.skill_name }}"
+          CLAWHUB_SLUG="${{ needs.release-tag.outputs.clawhub_slug }}"
           VERSION="${{ needs.release-tag.outputs.version }}"
           NAME=$(jq -r '.name' "$SKILL_PATH/skill.json")
           CHANGELOG="Release ${VERSION} via CI"
@@ -1313,7 +1638,7 @@ jobs:
 
           if ! CLAWHUB_DISABLE_TELEMETRY=1 CLAWHUB_SITE="$SITE" CLAWHUB_REGISTRY="$REGISTRY" \
             clawhub publish "$SKILL_PATH" \
-              --slug "$SKILL_NAME" \
+              --slug "$CLAWHUB_SLUG" \
               --name "$NAME" \
               --version "$VERSION" \
               --changelog "$CHANGELOG" \
@@ -1323,7 +1648,7 @@ jobs:
             exit 1
           fi
 
-          echo "✓ Successfully published $SKILL_NAME@$VERSION to ClawHub"
+          echo "✓ Successfully published $SKILL_NAME@$VERSION to ClawHub as $CLAWHUB_SLUG"
 
   republish-clawhub:
     # Manual workflow to republish a specific tag to ClawHub
@@ -1350,6 +1675,12 @@ jobs:
 
           echo "Parsed tag: skill=${SKILL_NAME}, version=${VERSION}"
 
+      - name: Checkout workflow helpers
+        uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+      - name: Prepare ClawHub slug helper
+        run: cp scripts/ci/resolve_clawhub_slug.mjs "$RUNNER_TEMP/resolve_clawhub_slug.mjs"
+
       - name: Checkout tag
         uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
         with:
@@ -1379,6 +1710,8 @@ jobs:
             exit 1
           fi
 
+          CLAWHUB_SLUG=$(node "$RUNNER_TEMP/resolve_clawhub_slug.mjs" "$SKILL_PATH")
+          echo "clawhub_slug=${CLAWHUB_SLUG}" >> $GITHUB_OUTPUT
           echo "Skill is publishable to ClawHub"
 
       - name: Setup Node
@@ -1386,6 +1719,9 @@ jobs:
         with:
           node-version: 20
 
+      - name: Validate npx skills install docs
+        run: node scripts/ci/validate_skill_install_docs.mjs --skills "${{ steps.parse.outputs.skill_path }}"
+
       - name: Install clawhub CLI
         run: npm install -g clawhub@${CLAWHUB_CLI_VERSION}
 
@@ -1454,18 +1790,19 @@ jobs:
           REGISTRY=${CLAWHUB_REGISTRY:-$SITE}
           SKILL_PATH="${{ steps.parse.outputs.skill_path }}"
           SKILL_NAME="${{ steps.parse.outputs.skill_name }}"
+          CLAWHUB_SLUG="${{ steps.publishable.outputs.clawhub_slug }}"
           VERSION="${{ steps.parse.outputs.version }}"
           NAME=$(jq -r '.name' "$SKILL_PATH/skill.json")
           CHANGELOG="Manual republish of ${VERSION} via workflow_dispatch"
 
           export CLAWHUB_CONFIG_PATH="$HOME/.clawhub-ci/config.json"
 
-          echo "Publishing $SKILL_NAME@$VERSION to ClawHub..."
+          echo "Publishing $SKILL_NAME@$VERSION to ClawHub as $CLAWHUB_SLUG..."
 
           # Publish with idempotent retry handling
           if ! CLAWHUB_DISABLE_TELEMETRY=1 CLAWHUB_SITE="$SITE" CLAWHUB_REGISTRY="$REGISTRY" \
             clawhub publish "$SKILL_PATH" \
-              --slug "$SKILL_NAME" \
+              --slug "$CLAWHUB_SLUG" \
               --name "$NAME" \
               --version "$VERSION" \
               --changelog "$CHANGELOG" \

CITATION.cff

@@ -0,0 +1,30 @@
+cff-version: 1.2.0
+message: "If you use ClawSec in research or security tooling, please cite it as below."
+title: "ClawSec"
+version: "0.1.0"
+date-released: "2026-05-26"
+abstract: >-
+  ClawSec is a security skill suite for AI agent platforms. It provides
+  advisory monitoring, cryptographic signature verification, guarded skill
+  installation, file integrity checks, and platform-specific security
+  capabilities for OpenClaw, NanoClaw, Hermes, and Picoclaw deployments.
+type: software
+license: "AGPL-3.0-or-later"
+url: "https://clawsec.prompt.security/"
+repository-code: "https://github.com/prompt-security/clawsec"
+keywords:
+  - ai-security
+  - agent-security
+  - prompt-injection
+  - security-advisories
+  - software-supply-chain
+  - integrity-verification
+  - openclaw
+  - nanoclaw
+  - hermes
+  - picoclaw
+authors:
+  - given-names: David
+    family-names: Abutbul
+    affiliation: "Prompt Security"
+    orcid: "https://orcid.org/0009-0001-7883-3593"

README.md

@@ -58,7 +58,7 @@ ClawSec is a **complete security skill suite for AI agent platforms**. It provid
 | clawsec-nanoclaw | NanoClaw | Yes | Yes | Yes | Yes | No |
 | clawsec-scanner | OpenClaw | Yes | No | Yes | Yes | No |
 | clawsec-suite | OpenClaw | Yes | Yes | No | Yes | No |
-| clawtributor | OpenClaw | Yes | No | No | No | No |
+| clawtributor | All core platforms | No | No | No | No | No |
 | hermes-attestation-guardian | Hermes | Yes (signed advisory feed verification) | Yes | No | Limited (advisory preflight gating only; no artifact signature/provenance install verification) | No |
 | hermes-traffic-guardian | Hermes | No | Planned posture export only | No | No | Spec baseline |
 | nanoclaw-traffic-guardian | NanoClaw | No | No | No | No | Spec baseline |

advisories/feed.json.sig

@@ -1 +1 @@
-fOD6OdSmOgXBD/4N8OkDZvIWxt9GFQiVoG8WlR5/siZxNrABqiy2/IVM/RyJdsIRsjcms7evB0mnaVziW/eOBA==
+agiAAFvzM1vNHxH2+bGtyeKqFScLWJHnNreBcPpTODUqD0xqFi0cnyP/ZaZX+Rsw1Y9uZ7pGdFdA93pD4lh2BQ==

advisories/ghsa-without-cve.json.sig

@@ -0,0 +1 @@
+q1EyZ75QcdG2X6FVDkUoAyBtQE3ONA+7k9cmNFmXFgOOuGRPOpSDFUtbSvy86HPqnii26DMoeFJ1hatWJ0lBCQ==

index.html

@@ -7,7 +7,7 @@
     ClawSec
     Security skill suite for AI agents (integrity checks, drift detection, advisory feed).
     Agent install:
-    Available via clawhub: npx clawhub@latest install clawsec-suite
+    Available via npx skills: npx skills add prompt-security/clawsec --skill clawsec-suite -a openclaw -y
     OR
     curl -sL https://clawsec.prompt.security/releases/latest/download/SKILL.md
     -->
@@ -141,7 +141,7 @@
 ClawSec
 Security skill suite for AI agents (integrity checks, drift detection, advisory feed).
 Agent install:
-Available via clawhub: npx clawhub@latest install clawsec-suite
+Available via npx skills: npx skills add prompt-security/clawsec --skill clawsec-suite -a openclaw -y
 OR
 curl -sL https://clawsec.prompt.security/releases/latest/download/SKILL.md
     </noscript>

package-lock.json

@@ -13,12 +13,12 @@
         "react": "^19.2.4",
         "react-dom": "^19.2.5",
         "react-markdown": "^10.1.0",
-        "react-router-dom": "^7.13.1",
+        "react-router-dom": "^7.16.0",
         "remark-gfm": "^4.0.1"
       },
       "devDependencies": {
         "@eslint/js": "~9.39.4",
-        "@types/node": "^25.4.0",
+        "@types/node": "^25.8.0",
         "@typescript-eslint/eslint-plugin": "^8.55.0",
         "@typescript-eslint/parser": "^8.58.1",
         "@vitejs/plugin-react": "^5.1.4",
@@ -1362,13 +1362,13 @@
       "integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA=="
     },
     "node_modules/@types/node": {
-      "version": "25.4.0",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.4.0.tgz",
-      "integrity": "sha512-9wLpoeWuBlcbBpOY3XmzSTG3oscB6xjBEEtn+pYXTfhyXhIxC5FsBer2KTopBlvKEiW9l13po9fq+SJY/5lkhw==",
+      "version": "25.8.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-25.8.0.tgz",
+      "integrity": "sha512-TCFSk8IZh+iLX1xtksoBVtdmgL+1IX0fC9BeU4QqFSuNdN/K+HUlhqOzEmSYYpZUVsLYcPqc9KX+60iDuninSQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "undici-types": "~7.18.0"
+        "undici-types": ">=7.24.0 <7.24.7"
       }
     },
     "node_modules/@types/react": {
@@ -1997,10 +1997,11 @@
       }
     },
     "node_modules/brace-expansion": {
-      "version": "5.0.5",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.5.tgz",
-      "integrity": "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==",
+      "version": "5.0.6",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.6.tgz",
+      "integrity": "sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "balanced-match": "^4.0.2"
       },
@@ -4652,12 +4653,13 @@
       ]
     },
     "node_modules/minimatch": {
-      "version": "10.2.4",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz",
-      "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==",
+      "version": "10.2.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz",
+      "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==",
       "dev": true,
+      "license": "BlueOak-1.0.0",
       "dependencies": {
-        "brace-expansion": "^5.0.2"
+        "brace-expansion": "^5.0.5"
       },
       "engines": {
         "node": "18 || 20 || >=22"
@@ -5073,9 +5075,9 @@
       }
     },
     "node_modules/react-router": {
-      "version": "7.13.1",
-      "resolved": "https://registry.npmjs.org/react-router/-/react-router-7.13.1.tgz",
-      "integrity": "sha512-td+xP4X2/6BJvZoX6xw++A2DdEi++YypA69bJUV5oVvqf6/9/9nNlD70YO1e9d3MyamJEBQFEzk6mbfDYbqrSA==",
+      "version": "7.16.0",
+      "resolved": "https://registry.npmjs.org/react-router/-/react-router-7.16.0.tgz",
+      "integrity": "sha512-wArC8lVyJb3+jM9OpDyW6hLCizACWkvQR/sSGqSs+o5uEXEtGlqdZ4v8hENR3Jad6i+LRkK93q/+bQAcvl6V1A==",
       "license": "MIT",
       "dependencies": {
         "cookie": "^1.0.1",
@@ -5095,12 +5097,12 @@
       }
     },
     "node_modules/react-router-dom": {
-      "version": "7.13.1",
-      "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-7.13.1.tgz",
-      "integrity": "sha512-UJnV3Rxc5TgUPJt2KJpo1Jpy0OKQr0AjgbZzBFjaPJcFOb2Y8jA5H3LT8HUJAiRLlWrEXWHbF1Z4SCZaQjWDHw==",
+      "version": "7.16.0",
+      "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-7.16.0.tgz",
+      "integrity": "sha512-kMUAbimWB5FVbF4Bce4bJsiKJWLIUHq/mEG8+CFDnCSgltptBiG5nguducmsJeGKytlCvQud9Qhzpn49iduTlA==",
       "license": "MIT",
       "dependencies": {
-        "react-router": "7.13.1"
+        "react-router": "7.16.0"
       },
       "engines": {
         "node": ">=20.0.0"
@@ -5814,9 +5816,9 @@
       }
     },
     "node_modules/undici-types": {
-      "version": "7.18.2",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz",
-      "integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==",
+      "version": "7.24.6",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.24.6.tgz",
+      "integrity": "sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg==",
       "dev": true,
       "license": "MIT"
     },

package.json

@@ -23,12 +23,12 @@
     "react": "^19.2.4",
     "react-dom": "^19.2.5",
     "react-markdown": "^10.1.0",
-    "react-router-dom": "^7.13.1",
+    "react-router-dom": "^7.16.0",
     "remark-gfm": "^4.0.1"
   },
   "devDependencies": {
     "@eslint/js": "~9.39.4",
-    "@types/node": "^25.4.0",
+    "@types/node": "^25.8.0",
     "@typescript-eslint/eslint-plugin": "^8.55.0",
     "@typescript-eslint/parser": "^8.58.1",
     "@vitejs/plugin-react": "^5.1.4",
@@ -42,8 +42,8 @@
   "overrides": {
     "ajv": "6.14.0",
     "balanced-match": "4.0.3",
-    "brace-expansion": "5.0.5",
-    "minimatch": "10.2.4",
+    "brace-expansion": "5.0.6",
+    "minimatch": "10.2.5",
     "picomatch": "4.0.4"
   }
 }

pages/Home.tsx

@@ -13,7 +13,7 @@ export const Home: React.FC = () => {
   const [currentFileIndex, setCurrentFileIndex] = useState(0);
   const [currentPlatformIndex, setCurrentPlatformIndex] = useState(0);
 
-  const curlCommand = `npx clawhub@latest install clawsec-suite`;
+  const curlCommand = `npx skills add prompt-security/clawsec --skill clawsec-suite -a openclaw -y`;
 
   // Rotate file names every 2-3 seconds
   useEffect(() => {
@@ -44,7 +44,7 @@ export const Home: React.FC = () => {
     };
   }, []);
 
-  const humanInstruction = `Please install clawsec-suite from clawhubnpx clawhub@latest install clawsec-suite`;
+  const humanInstruction = `Please install clawsec-suite with npx skills add prompt-security/clawsec --skill clawsec-suite -a openclaw -y`;
 
   const handleCopyCurl = () => {
     navigator.clipboard.writeText(curlCommand);
@@ -285,6 +285,18 @@ export const Home: React.FC = () => {
                 </div>
               </>
             )}
+            <p className="mt-4 text-center text-xs leading-relaxed text-gray-500">
+              * For harnesses other than OpenClaw, consult the{' '}
+              <a
+                href="https://github.com/prompt-security/clawsec#skill-feature-matrix"
+                target="_blank"
+                rel="noreferrer"
+                className="text-clawd-accent hover:text-clawd-accent/80 underline underline-offset-2"
+              >
+                README Skill Feature Matrix
+              </a>
+              .
+            </p>
           </div>
         </div>
       </section>

scripts/archive-github-traffic.mjs

@@ -0,0 +1,493 @@
+#!/usr/bin/env node
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = path.resolve(__dirname, '..');
+const API_ROOT = 'https://api.github.com';
+const GITHUB_API_VERSION = '2022-11-28';
+const ARCHIVE_VERSION = 1;
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+const SUMMARY_WINDOWS = [
+  ['last_14_days', 14],
+  ['last_30_days', 30],
+  ['last_90_days', 90],
+  ['last_365_days', 365],
+];
+
+const toIsoString = (value, label) => {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(`Invalid ${label}: ${value}`);
+  }
+  return date.toISOString();
+};
+
+const toDailyTimestamp = (value) => `${toIsoString(value, 'traffic timestamp').slice(0, 10)}T00:00:00Z`;
+const toDateKey = (value) => toIsoString(value, 'capture timestamp').slice(0, 10);
+
+const toNonNegativeInteger = (value, label) => {
+  const number = Number(value);
+  if (!Number.isFinite(number) || number < 0) {
+    throw new Error(`Invalid ${label}: ${value}`);
+  }
+  return Math.trunc(number);
+};
+
+const toRequiredString = (value, label) => {
+  if (typeof value !== 'string') {
+    throw new Error(`${label} must be a non-empty string`);
+  }
+
+  const trimmed = value.trim();
+  if (!trimmed) {
+    throw new Error(`${label} must be a non-empty string`);
+  }
+
+  return trimmed;
+};
+
+const normalizeRepository = (repo) => {
+  const normalized = String(repo || '').trim();
+  if (!/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(normalized)) {
+    throw new Error(`Repository must be in owner/name form, received: ${repo || '(empty)'}`);
+  }
+  return normalized;
+};
+
+const normalizeDailyEntries = (entries, label) => {
+  if (!Array.isArray(entries)) {
+    throw new Error(`${label} must be an array`);
+  }
+
+  return entries
+    .map((entry) => ({
+      timestamp: toDailyTimestamp(entry.timestamp),
+      count: toNonNegativeInteger(entry.count, `${label}.count`),
+      uniques: toNonNegativeInteger(entry.uniques, `${label}.uniques`),
+    }))
+    .sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+};
+
+const normalizeReferrers = (entries) => {
+  if (!Array.isArray(entries)) {
+    throw new Error('referrers must be an array');
+  }
+
+  return entries.map((entry) => ({
+    referrer: toRequiredString(entry.referrer, 'referrers.referrer'),
+    count: toNonNegativeInteger(entry.count, 'referrers.count'),
+    uniques: toNonNegativeInteger(entry.uniques, 'referrers.uniques'),
+  }));
+};
+
+const normalizePaths = (entries) => {
+  if (!Array.isArray(entries)) {
+    throw new Error('paths must be an array');
+  }
+
+  return entries.map((entry) => ({
+    path: toRequiredString(entry.path, 'paths.path'),
+    title: toRequiredString(entry.title, 'paths.title'),
+    count: toNonNegativeInteger(entry.count, 'paths.count'),
+    uniques: toNonNegativeInteger(entry.uniques, 'paths.uniques'),
+  }));
+};
+
+const upsertByKey = (existing, incoming, key) => {
+  const entriesByKey = new Map();
+
+  for (const entry of existing || []) {
+    entriesByKey.set(entry[key], entry);
+  }
+  for (const entry of incoming || []) {
+    entriesByKey.set(entry[key], entry);
+  }
+
+  return [...entriesByKey.values()].sort((a, b) => String(a[key]).localeCompare(String(b[key])));
+};
+
+const latestEntry = (entries) => {
+  if (!entries?.length) {
+    return null;
+  }
+  return entries[entries.length - 1];
+};
+
+const sumSeries = (entries) => entries.reduce(
+  (totals, entry) => ({
+    count: totals.count + entry.count,
+    sum_daily_uniques: totals.sum_daily_uniques + entry.uniques,
+  }),
+  { count: 0, sum_daily_uniques: 0 },
+);
+
+const startOfUtcDay = (date) => Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+
+const summarizeWindow = (entries, days, now) => {
+  const cutoff = new Date(startOfUtcDay(now) - ((days - 1) * DAY_MS));
+  const filtered = entries.filter((entry) => new Date(entry.timestamp) >= cutoff);
+  const totals = sumSeries(filtered);
+
+  return {
+    days,
+    count: totals.count,
+    sum_daily_uniques: totals.sum_daily_uniques,
+    unique_semantics: 'sum_of_daily_uniques',
+    first_date: filtered[0]?.timestamp.slice(0, 10) ?? null,
+    last_date: filtered.at(-1)?.timestamp.slice(0, 10) ?? null,
+  };
+};
+
+const summarizeAllTime = (entries) => {
+  const totals = sumSeries(entries);
+
+  return {
+    count: totals.count,
+    sum_daily_uniques: totals.sum_daily_uniques,
+    unique_semantics: 'sum_of_daily_uniques',
+    first_date: entries[0]?.timestamp.slice(0, 10) ?? null,
+    last_date: entries.at(-1)?.timestamp.slice(0, 10) ?? null,
+  };
+};
+
+const normalizeExistingArchive = (archive, repository, capturedAt) => {
+  if (!archive) {
+    return {
+      version: ARCHIVE_VERSION,
+      repository,
+      archive_started_at: capturedAt,
+      updated_at: capturedAt,
+      daily: {
+        views: [],
+        clones: [],
+      },
+      snapshots: {
+        referrers: [],
+        paths: [],
+      },
+      captures: [],
+    };
+  }
+
+  if (archive.repository && archive.repository !== repository) {
+    throw new Error(`Archive repository mismatch: ${archive.repository} != ${repository}`);
+  }
+
+  return {
+    version: ARCHIVE_VERSION,
+    repository,
+    archive_started_at: archive.archive_started_at || capturedAt,
+    updated_at: archive.updated_at || capturedAt,
+    daily: {
+      views: normalizeDailyEntries(archive.daily?.views || [], 'daily.views'),
+      clones: normalizeDailyEntries(archive.daily?.clones || [], 'daily.clones'),
+    },
+    snapshots: {
+      referrers: (archive.snapshots?.referrers || []).map((snapshot) => ({
+        captured_at: toIsoString(snapshot.captured_at, 'referrer snapshot timestamp'),
+        date: snapshot.date || toDateKey(snapshot.captured_at),
+        entries: normalizeReferrers(snapshot.entries || []),
+      })),
+      paths: (archive.snapshots?.paths || []).map((snapshot) => ({
+        captured_at: toIsoString(snapshot.captured_at, 'path snapshot timestamp'),
+        date: snapshot.date || toDateKey(snapshot.captured_at),
+        entries: normalizePaths(snapshot.entries || []),
+      })),
+    },
+    captures: (archive.captures || []).map((capture) => ({
+      captured_at: toIsoString(capture.captured_at, 'capture timestamp'),
+      date: capture.date || toDateKey(capture.captured_at),
+      views_window: {
+        count: toNonNegativeInteger(capture.views_window?.count || 0, 'captures.views_window.count'),
+        uniques: toNonNegativeInteger(capture.views_window?.uniques || 0, 'captures.views_window.uniques'),
+      },
+      clones_window: {
+        count: toNonNegativeInteger(capture.clones_window?.count || 0, 'captures.clones_window.count'),
+        uniques: toNonNegativeInteger(capture.clones_window?.uniques || 0, 'captures.clones_window.uniques'),
+      },
+    })),
+  };
+};
+
+export const mergeTrafficArchive = (existingArchive, snapshot) => {
+  const repository = normalizeRepository(snapshot.repository);
+  const capturedAt = toIsoString(snapshot.captured_at, 'capture timestamp');
+  const captureDate = toDateKey(capturedAt);
+  const archive = normalizeExistingArchive(existingArchive, repository, capturedAt);
+
+  const views = normalizeDailyEntries(snapshot.views?.views || [], 'views');
+  const clones = normalizeDailyEntries(snapshot.clones?.clones || [], 'clones');
+  const referrerSnapshot = {
+    captured_at: capturedAt,
+    date: captureDate,
+    entries: normalizeReferrers(snapshot.referrers || []),
+  };
+  const pathSnapshot = {
+    captured_at: capturedAt,
+    date: captureDate,
+    entries: normalizePaths(snapshot.paths || []),
+  };
+  const capture = {
+    captured_at: capturedAt,
+    date: captureDate,
+    views_window: {
+      count: toNonNegativeInteger(snapshot.views?.count ?? sumSeries(views).count, 'views.count'),
+      uniques: toNonNegativeInteger(snapshot.views?.uniques ?? sumSeries(views).sum_daily_uniques, 'views.uniques'),
+    },
+    clones_window: {
+      count: toNonNegativeInteger(snapshot.clones?.count ?? sumSeries(clones).count, 'clones.count'),
+      uniques: toNonNegativeInteger(snapshot.clones?.uniques ?? sumSeries(clones).sum_daily_uniques, 'clones.uniques'),
+    },
+  };
+
+  return {
+    ...archive,
+    updated_at: capturedAt,
+    daily: {
+      views: upsertByKey(archive.daily.views, views, 'timestamp'),
+      clones: upsertByKey(archive.daily.clones, clones, 'timestamp'),
+    },
+    snapshots: {
+      referrers: upsertByKey(archive.snapshots.referrers, [referrerSnapshot], 'date'),
+      paths: upsertByKey(archive.snapshots.paths, [pathSnapshot], 'date'),
+    },
+    captures: upsertByKey(archive.captures, [capture], 'date'),
+  };
+};
+
+export const buildTrafficSummary = (archive, options = {}) => {
+  const now = new Date(options.now || new Date().toISOString());
+  if (Number.isNaN(now.getTime())) {
+    throw new Error(`Invalid summary date: ${options.now}`);
+  }
+
+  const views = archive.daily?.views || [];
+  const clones = archive.daily?.clones || [];
+  const buildMetrics = (entries) => {
+    const metrics = Object.fromEntries(SUMMARY_WINDOWS.map(([key, days]) => [
+      key,
+      summarizeWindow(entries, days, now),
+    ]));
+    metrics.all_time = summarizeAllTime(entries);
+    return metrics;
+  };
+
+  return {
+    version: ARCHIVE_VERSION,
+    repository: archive.repository,
+    generated_at: now.toISOString(),
+    archive_started_at: archive.archive_started_at || null,
+    updated_at: archive.updated_at || null,
+    source: {
+      api: 'GitHub REST repository traffic endpoints',
+      retention_limit: 'GitHub exposes roughly the last 14 days; this archive keeps daily snapshots long term.',
+      unique_semantics: 'GitHub daily unique values are retained as sum_daily_uniques for longer windows, not deduplicated visitors.',
+    },
+    metrics: {
+      views: buildMetrics(views),
+      clones: buildMetrics(clones),
+    },
+    daily: {
+      views,
+      clones,
+    },
+    latest_snapshots: {
+      referrers: latestEntry(archive.snapshots?.referrers || []),
+      paths: latestEntry(archive.snapshots?.paths || []),
+    },
+    snapshot_counts: {
+      referrers: archive.snapshots?.referrers?.length || 0,
+      paths: archive.snapshots?.paths?.length || 0,
+      captures: archive.captures?.length || 0,
+    },
+  };
+};
+
+const fetchJson = async ({ repo, token, pathname, fetchImpl }) => {
+  const url = new URL(pathname, API_ROOT);
+  const response = await fetchImpl(url, {
+    headers: {
+      Accept: 'application/vnd.github+json',
+      Authorization: `Bearer ${token}`,
+      'User-Agent': 'clawsec-traffic-archive',
+      'X-GitHub-Api-Version': GITHUB_API_VERSION,
+    },
+  });
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => '');
+    const suffix = body ? ` ${body.slice(0, 500)}` : '';
+    const lacksPushAccess = response.status === 403
+      && /resource not accessible|must have push access/i.test(body);
+    const hint = lacksPushAccess
+      ? ' Traffic endpoints require a token with push access to the repository; the Actions GITHUB_TOKEN is always rejected. Use a classic PAT with the repo scope or a fine-grained PAT with read access to Administration.'
+      : response.status === 401
+        ? ' The token was rejected as invalid — it may be expired or revoked. Rotate the TRAFFIC_ARCHIVE_TOKEN secret.'
+        : '';
+    throw new Error(`GitHub traffic API request failed for ${repo}: ${url.pathname}${url.search} returned ${response.status}.${suffix}${hint}`);
+  }
+
+  return response.json();
+};
+
+export const fetchGitHubTraffic = async ({
+  repo,
+  token,
+  capturedAt = new Date().toISOString(),
+  fetchImpl = globalThis.fetch,
+}) => {
+  const repository = normalizeRepository(repo);
+  if (!token) {
+    throw new Error('A GitHub token is required to read repository traffic.');
+  }
+  if (typeof fetchImpl !== 'function') {
+    throw new Error('fetch is not available in this Node runtime.');
+  }
+
+  const encodedRepo = repository.split('/').map(encodeURIComponent).join('/');
+  const request = (pathname) => fetchJson({
+    repo: repository,
+    token,
+    pathname: `/repos/${encodedRepo}${pathname}`,
+    fetchImpl,
+  });
+
+  const [views, clones, referrers, paths] = await Promise.all([
+    request('/traffic/views?per=day'),
+    request('/traffic/clones?per=day'),
+    request('/traffic/popular/referrers'),
+    request('/traffic/popular/paths'),
+  ]);
+
+  return {
+    repository,
+    captured_at: toIsoString(capturedAt, 'capture timestamp'),
+    views,
+    clones,
+    referrers,
+    paths,
+  };
+};
+
+const readJsonIfPresent = async (file) => {
+  try {
+    return JSON.parse(await fs.readFile(file, 'utf8'));
+  } catch (error) {
+    if (error?.code === 'ENOENT') {
+      return undefined;
+    }
+    throw error;
+  }
+};
+
+const writeTextAtomic = async (file, content) => {
+  const dir = path.dirname(file);
+  const tempFile = path.join(dir, `.${path.basename(file)}.${process.pid}.${Date.now()}.tmp`);
+  let handle;
+
+  await fs.mkdir(dir, { recursive: true });
+
+  try {
+    handle = await fs.open(tempFile, 'w');
+    await handle.writeFile(content, 'utf8');
+    await handle.sync();
+    await handle.close();
+    handle = undefined;
+    await fs.rename(tempFile, file);
+  } catch (error) {
+    if (handle) {
+      await handle.close().catch(() => {});
+    }
+    await fs.unlink(tempFile).catch(() => {});
+    throw error;
+  }
+};
+
+export const writeJson = async (file, value) => {
+  await writeTextAtomic(file, `${JSON.stringify(value, null, 2)}\n`);
+};
+
+const parseArgs = (args) => {
+  const options = {};
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--archive-dir') {
+      options.archiveDir = args[index + 1];
+      index += 1;
+    } else if (arg === '--repo') {
+      options.repo = args[index + 1];
+      index += 1;
+    } else if (arg === '--captured-at') {
+      options.capturedAt = args[index + 1];
+      index += 1;
+    } else if (arg === '--help' || arg === '-h') {
+      options.help = true;
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+  return options;
+};
+
+const printHelp = () => {
+  console.log(`Usage: node scripts/archive-github-traffic.mjs [options]
+
+Options:
+  --archive-dir <dir>   Directory that will receive archive.json and summary.json.
+  --repo <owner/repo>   Repository to archive. Defaults to GITHUB_REPOSITORY.
+  --captured-at <iso>   Override capture time for tests or backfills.
+`);
+};
+
+const main = async () => {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.help) {
+    printHelp();
+    return;
+  }
+
+  const archiveDir = path.resolve(
+    REPO_ROOT,
+    options.archiveDir || process.env.TRAFFIC_ARCHIVE_DIR || 'traffic',
+  );
+  const archiveFile = path.join(archiveDir, 'archive.json');
+  const summaryFile = path.join(archiveDir, 'summary.json');
+  const repository = normalizeRepository(options.repo || process.env.GITHUB_REPOSITORY);
+  const token = process.env.GH_TRAFFIC_TOKEN
+    || process.env.TRAFFIC_ARCHIVE_TOKEN
+    || process.env.GITHUB_TOKEN
+    || process.env.GH_TOKEN;
+  const capturedAt = options.capturedAt || new Date().toISOString();
+
+  const snapshot = await fetchGitHubTraffic({
+    repo: repository,
+    token,
+    capturedAt,
+  });
+  const existingArchive = await readJsonIfPresent(archiveFile);
+  const archive = mergeTrafficArchive(existingArchive, snapshot);
+  const summary = buildTrafficSummary(archive, { now: archive.updated_at });
+
+  await writeJson(archiveFile, archive);
+  await writeJson(summaryFile, summary);
+
+  console.log(`Archived GitHub traffic for ${repository} at ${archive.updated_at}`);
+  console.log(`Daily views retained: ${archive.daily.views.length}`);
+  console.log(`Daily clones retained: ${archive.daily.clones.length}`);
+  console.log(`Referrer snapshots retained: ${archive.snapshots.referrers.length}`);
+  console.log(`Path snapshots retained: ${archive.snapshots.paths.length}`);
+};
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  try {
+    await main();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Failed to archive GitHub traffic: ${message}`);
+    process.exit(1);
+  }
+}

scripts/ci/generate_skill_release_trust_packet.mjs

@@ -0,0 +1,359 @@
+#!/usr/bin/env node
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { installAgentForSkill, PLATFORM_KEYS } from "./skill_platforms.mjs";
+
+const KNOWN_AGENT_TYPES = new Set(["codex", "hermes-agent", "openclaw", "universal"]);
+
+function usage() {
+  return [
+    "Usage: node scripts/ci/generate_skill_release_trust_packet.mjs <skill-dir> <output-dir> [options]",
+    "",
+    "Options:",
+    "  --repository <owner/repo>  Source repository used in install instructions",
+    "  --tag <tag>                Release tag for this skill",
+    "  --source-ref <ref>         Source ref for npx skills examples",
+  ].join("\n");
+}
+
+function parseArgs(argv) {
+  const positional = [];
+  const options = {
+    repository: "prompt-security/clawsec",
+    tag: "",
+    sourceRef: "main",
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === "--repository") {
+      options.repository = argv[++i];
+    } else if (token === "--tag") {
+      options.tag = argv[++i];
+    } else if (token === "--source-ref") {
+      options.sourceRef = argv[++i];
+    } else if (token === "--help" || token === "-h") {
+      console.log(usage());
+      process.exit(0);
+    } else if (token.startsWith("--")) {
+      throw new Error(`Unknown option: ${token}`);
+    } else {
+      positional.push(token);
+    }
+  }
+
+  if (positional.length !== 2) {
+    throw new Error(usage());
+  }
+
+  return {
+    skillDir: positional[0],
+    outputDir: positional[1],
+    ...options,
+  };
+}
+
+function parseFrontmatter(markdown) {
+  if (!markdown.startsWith("---\n")) {
+    return {};
+  }
+
+  const end = markdown.indexOf("\n---", 4);
+  if (end === -1) {
+    return {};
+  }
+
+  const result = {};
+  const frontmatter = markdown.slice(4, end).split("\n");
+  for (const line of frontmatter) {
+    const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (match) {
+      result[match[1]] = match[2].replace(/^["']|["']$/g, "").trim();
+    }
+  }
+  return result;
+}
+
+function asArray(value) {
+  if (Array.isArray(value)) {
+    return value.filter((item) => item !== null && item !== undefined).map(String);
+  }
+  if (typeof value === "string" && value.trim()) {
+    return [value.trim()];
+  }
+  return [];
+}
+
+function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+function detectPlatform(skill) {
+  for (const key of PLATFORM_KEYS) {
+    if (skill[key] && typeof skill[key] === "object") {
+      return key;
+    }
+  }
+  return skill.platform || "agent-skills";
+}
+
+function platformMetadata(skill, platform) {
+  const direct = skill[platform];
+  return direct && typeof direct === "object" ? direct : {};
+}
+
+function collectRequiredBinaries(metadata) {
+  const requires = metadata.requires && typeof metadata.requires === "object" ? metadata.requires : {};
+  const bins = asArray(requires.bins);
+
+  for (const [key, value] of Object.entries(requires)) {
+    if (key !== "bins" && typeof value === "string") {
+      bins.push(key);
+    }
+  }
+
+  return unique(bins);
+}
+
+function collectOptionalBinaries(metadata) {
+  return unique([
+    ...asArray(metadata.runtime?.optional_bins),
+    ...asArray(metadata.runtime?.optionalBins),
+  ]);
+}
+
+function collectRequiredEnv(metadata) {
+  const requires = metadata.requires && typeof metadata.requires === "object" ? metadata.requires : {};
+  return unique([
+    ...asArray(requires.env),
+    ...asArray(metadata.runtime?.required_env),
+    ...asArray(metadata.runtime?.requiredEnv),
+  ]);
+}
+
+function collectOptionalEnv(metadata) {
+  return unique([
+    ...asArray(metadata.runtime?.optional_env),
+    ...asArray(metadata.runtime?.optionalEnv),
+  ]);
+}
+
+function stringifyCapabilities(skill, metadata) {
+  const capabilities = metadata.capabilities ?? skill.capabilities ?? {};
+  if (Array.isArray(capabilities)) {
+    return capabilities;
+  }
+  if (capabilities && typeof capabilities === "object") {
+    return Object.entries(capabilities).map(([key, value]) => `${key}: ${String(value)}`);
+  }
+  if (typeof capabilities === "string") {
+    return [capabilities];
+  }
+  return [];
+}
+
+function requireField(skill, fieldName) {
+  if (!skill[fieldName] || typeof skill[fieldName] !== "string" || !skill[fieldName].trim()) {
+    throw new Error(`skill.json missing required trust-packet field: ${fieldName}`);
+  }
+  return skill[fieldName].trim();
+}
+
+function codeBlock(command) {
+  return ["```bash", command, "```"].join("\n");
+}
+
+function buildPermissions({ skill, metadata, platform, generatedAt }) {
+  const execution = metadata.execution && typeof metadata.execution === "object" ? metadata.execution : {};
+  const permissions = {
+    schema_version: "1",
+    generated_at: generatedAt,
+    skill: skill.name,
+    version: skill.version,
+    platform,
+    required_binaries: collectRequiredBinaries(metadata),
+    optional_binaries: collectOptionalBinaries(metadata),
+    required_env: collectRequiredEnv(metadata),
+    optional_env: collectOptionalEnv(metadata),
+    network_egress: execution.network_egress || "Not declared in skill metadata.",
+    persistence: execution.persistence || "Not declared in skill metadata.",
+    automatic_execution: typeof execution.always === "boolean" ? execution.always : "Not declared in skill metadata.",
+    capabilities: stringifyCapabilities(skill, metadata),
+    operator_review: asArray(metadata.operator_review),
+  };
+
+  return permissions;
+}
+
+function buildSkillCard({ skill, frontmatter, permissions, repository, tag, sourceRef }) {
+  const homepage = skill.homepage || frontmatter.homepage || `https://github.com/${repository}`;
+  const supportRef = `${repository}@${tag || sourceRef}`;
+  const licenseRef = `https://github.com/${repository}/blob/${tag || sourceRef}/LICENSE`;
+  const outputTypes = ["Markdown instructions", "release artifact files"];
+  if (permissions.capabilities.length > 0) {
+    outputTypes.push("local security findings or status reports");
+  }
+
+  return `# Skill Card
+
+## Description
+
+The \`${skill.name}\` skill provides this capability: ${skill.description}
+
+This skill is intended for operator-reviewed security workflows, not unattended production mutation without the review steps declared in the skill instructions.
+
+## Owner
+
+prompt-security
+
+## License/Terms of Use
+
+${skill.license}
+
+License reference: ${licenseRef}
+
+Project homepage: ${homepage}
+
+## Use Case
+
+Use this skill for ${permissions.platform} workflows where an agent or operator needs the capability described in \`${skill.name}\`.
+
+## Deployment Geography for Use
+
+Global, subject to the operator's local compliance, network, and data-handling requirements.
+
+## Known Risks and Mitigations
+
+Risk: The skill may run commands, inspect local files, install hooks, or fetch remote security metadata depending on the workflow.
+
+Mitigation: Review \`permissions.json\`, \`SKILL.md\`, and the signed \`checksums.json\` before enabling the skill. Keep high-impact actions approval-gated.
+
+Risk: Security findings and remediation guidance can be incomplete or wrong.
+
+Mitigation: Treat output as operator guidance. Review proposed removals, installs, configuration changes, and reports before acting.
+
+## References
+
+- Source release: ${supportRef}
+- Skill instructions: SKILL.md
+- Permission summary: permissions.json
+- SkillSpector scan: skillspector-report.md
+- Signed release manifest: checksums.json and checksums.sig
+
+## Skill Output
+
+Output type(s): ${outputTypes.join(", ")}
+
+Output format: Markdown, JSON, shell commands, or local files as documented by the skill.
+
+Output parameters: See \`SKILL.md\`, \`permissions.json\`, and release checksums for exact files and side effects.
+
+Other properties: Release assets are covered by signed SHA-256 checksums.
+
+## Skill Version
+
+${skill.version}${tag ? ` (${tag})` : ""}
+
+## Ethical Considerations
+
+Use this skill only on systems, agents, repositories, and workspaces where you have authorization. Review generated security reports before sharing them because they may contain operational details.
+`;
+}
+
+function buildInstallDoc({ skill, repository, tag, sourceRef }) {
+  const refSuffix = sourceRef && sourceRef !== "main" ? `#${sourceRef}` : "";
+  const source = `${repository}${refSuffix}`;
+  const releaseUrl = tag ? `https://github.com/${repository}/releases/tag/${tag}` : `https://github.com/${repository}`;
+  const agent = installAgentForSkill(skill, KNOWN_AGENT_TYPES);
+
+  return `# Install and Update ${skill.name}
+
+## Install With Agent Skills CLI
+
+Harness-aware global install:
+
+${codeBlock(`npx skills add ${source} --skill ${skill.name} --agent ${agent} --global --yes`)}
+
+Project-local install for compatible agents:
+
+${codeBlock(`npx skills add ${source} --skill ${skill.name} --yes`)}
+
+## Update
+
+Update this skill when installed through the Skills CLI:
+
+${codeBlock(`npx skills update ${skill.name}`)}
+
+List installed skills:
+
+${codeBlock("npx skills list")}
+
+## Verify Release Artifact
+
+When installing from a GitHub release instead of the Skills CLI, download the archive, \`checksums.json\`, \`checksums.sig\`, and \`signing-public.pem\` from:
+
+${releaseUrl}
+
+Verify \`checksums.json\` before trusting the archive or standalone files.
+`;
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const skillDir = path.resolve(args.skillDir);
+  const outputDir = path.resolve(args.outputDir);
+
+  const skillJsonPath = path.join(skillDir, "skill.json");
+  const skillMdPath = path.join(skillDir, "SKILL.md");
+  const [skillJsonRaw, skillMdRaw] = await Promise.all([
+    readFile(skillJsonPath, "utf8"),
+    readFile(skillMdPath, "utf8"),
+  ]);
+
+  const skill = JSON.parse(skillJsonRaw);
+  const frontmatter = parseFrontmatter(skillMdRaw);
+  skill.name = requireField(skill, "name");
+  skill.version = requireField(skill, "version");
+  skill.description = requireField(skill, "description");
+  skill.license = requireField(skill, "license");
+
+  const platform = detectPlatform(skill);
+  const metadata = platformMetadata(skill, platform);
+  const generatedAt = new Date().toISOString();
+  const permissions = buildPermissions({ skill, metadata, platform, generatedAt });
+
+  await mkdir(outputDir, { recursive: true });
+  await Promise.all([
+    writeFile(
+      path.join(outputDir, "permissions.json"),
+      `${JSON.stringify(permissions, null, 2)}\n`,
+    ),
+    writeFile(
+      path.join(outputDir, "skill-card.md"),
+      buildSkillCard({
+        skill,
+        frontmatter,
+        permissions,
+        repository: args.repository,
+        tag: args.tag,
+        sourceRef: args.sourceRef,
+      }),
+    ),
+    writeFile(
+      path.join(outputDir, "install.md"),
+      buildInstallDoc({
+        skill,
+        repository: args.repository,
+        tag: args.tag,
+        sourceRef: args.sourceRef,
+      }),
+    ),
+  ]);
+
+  console.log(`Generated release trust packet for ${skill.name} in ${outputDir}`);
+}
+
+main().catch((error) => {
+  console.error(error.message);
+  process.exit(1);
+});

scripts/ci/resolve_clawhub_slug.mjs

@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { collectDeclaredPlatforms, PLATFORM_KEYS } from "./skill_platforms.mjs";
+
+const EXPLICIT_SLUGS = new Map([
+  ["openclaw-traffic-guardian", "clawsec-openclaw-traffic-guardian"],
+  ["openclaw-audit-watchdog", "clawsec-openclaw-audit-watchdog"],
+  ["soul-guardian", "clawsec-openclaw-soul-guardian"],
+  ["hermes-attestation-guardian", "clawsec-hermes-attestation-guardian"],
+  ["hermes-traffic-guardian", "clawsec-hermes-traffic-guardian"],
+  ["nanoclaw-traffic-guardian", "clawsec-nanoclaw-traffic-guardian"],
+  ["picoclaw-security-guardian", "clawsec-picoclaw-security-guardian"],
+  ["picoclaw-self-pen-testing", "clawsec-picoclaw-self-pen-testing"],
+  ["picoclaw-traffic-guardian", "clawsec-picoclaw-traffic-guardian"],
+  ["clawtributor", "clawsec-clawtributor"],
+]);
+
+function usage() {
+  return [
+    "Usage: node scripts/ci/resolve_clawhub_slug.mjs <skill-dir-or-name>",
+    "",
+    "Prints the ClawHub slug for a skill without changing the GitHub release tag or skill package name.",
+  ].join("\n");
+}
+
+function loadSkill(input) {
+  const skillJsonPath = existsSync(path.join(input, "skill.json")) ? path.join(input, "skill.json") : null;
+  if (!skillJsonPath) {
+    return { name: input, platforms: [] };
+  }
+
+  const skill = JSON.parse(readFileSync(skillJsonPath, "utf8"));
+  if (!skill.name || typeof skill.name !== "string") {
+    throw new Error(`${skillJsonPath} missing string field: name`);
+  }
+
+  return { name: skill.name, platforms: collectDeclaredPlatforms(skill) };
+}
+
+export function resolveClawHubSlug({ name, platforms = [] }) {
+  if (!/^[a-z0-9-]+$/.test(name)) {
+    throw new Error(`Invalid skill name for ClawHub slug mapping: ${name}`);
+  }
+
+  if (name.startsWith("clawsec-")) {
+    return name;
+  }
+
+  if (EXPLICIT_SLUGS.has(name)) {
+    return EXPLICIT_SLUGS.get(name);
+  }
+
+  if (PLATFORM_KEYS.some((platform) => name.startsWith(`${platform}-`))) {
+    return `clawsec-${name}`;
+  }
+
+  const declaredPlatforms = collectDeclaredPlatforms({ platforms });
+  if (declaredPlatforms.length === 1 && PLATFORM_KEYS.includes(declaredPlatforms[0])) {
+    return `clawsec-${declaredPlatforms[0]}-${name}`;
+  }
+
+  return `clawsec-${name}`;
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const input = process.argv[2];
+  if (!input || input === "--help" || input === "-h") {
+    console.log(usage());
+    process.exit(input ? 0 : 1);
+  }
+
+  try {
+    console.log(resolveClawHubSlug(loadSkill(input)));
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}

scripts/ci/simulate_skill_tag_release.mjs

@@ -0,0 +1,520 @@
+#!/usr/bin/env node
+import { createHash } from "node:crypto";
+import { spawnSync } from "node:child_process";
+import {
+  cp,
+  mkdir,
+  mkdtemp,
+  readFile,
+  rm,
+  stat,
+  writeFile,
+} from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+const TRUST_ARTIFACTS = [
+  "skill-card.md",
+  "permissions.json",
+  "install.md",
+  "skillspector-report.md",
+];
+
+function usage() {
+  return [
+    "Usage: node scripts/ci/simulate_skill_tag_release.mjs <skill-dir> <output-dir> [options]",
+    "",
+    "Options:",
+    "  --repository <owner/repo>       Source repository used in release metadata",
+    "  --source-ref <ref>              Source ref used in npx skills examples",
+    "  --skillspector-bin <path>       SkillSpector executable to run",
+  ].join("\n");
+}
+
+function parseArgs(argv) {
+  const positional = [];
+  const options = {
+    repository: "prompt-security/clawsec",
+    sourceRef: "main",
+    skillspectorBin: "skillspector",
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === "--repository") {
+      options.repository = argv[++i];
+    } else if (token === "--source-ref") {
+      options.sourceRef = argv[++i];
+    } else if (token === "--skillspector-bin") {
+      options.skillspectorBin = argv[++i];
+    } else if (token === "--help" || token === "-h") {
+      console.log(usage());
+      process.exit(0);
+    } else if (token.startsWith("--")) {
+      throw new Error(`Unknown option: ${token}`);
+    } else {
+      positional.push(token);
+    }
+  }
+
+  if (positional.length !== 2) {
+    throw new Error(usage());
+  }
+
+  return {
+    skillDir: positional[0],
+    outputDir: positional[1],
+    ...options,
+  };
+}
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, {
+    encoding: "utf8",
+    ...options,
+  });
+
+  if (result.status !== 0) {
+    throw new Error(
+      [
+        `Command failed: ${command} ${args.join(" ")}`,
+        result.stdout ? `stdout:\n${result.stdout}` : "",
+        result.stderr ? `stderr:\n${result.stderr}` : "",
+      ].filter(Boolean).join("\n"),
+    );
+  }
+
+  return result.stdout;
+}
+
+function runAllowFailure(command, args, options = {}) {
+  return spawnSync(command, args, {
+    encoding: "utf8",
+    ...options,
+  });
+}
+
+function nextSimulatedReleaseVersion(version) {
+  const versionMatch = version.match(/^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9]+))?$/);
+  if (!versionMatch) {
+    throw new Error(`Cannot derive simulated release version from unsupported version: ${version}`);
+  }
+
+  const [, major, minor, patch, prerelease] = versionMatch;
+  if (!prerelease) {
+    return `${major}.${minor}.${Number(patch) + 1}`;
+  }
+
+  const prereleaseMatch = prerelease.match(/^(.*?)(\d+)$/);
+  if (prereleaseMatch) {
+    const [, label, number] = prereleaseMatch;
+    return `${major}.${minor}.${patch}-${label}${Number(number) + 1}`;
+  }
+
+  return `${major}.${minor}.${patch}-${prerelease}1`;
+}
+
+function normalizeReleasePath(rawPath) {
+  let releasePath = rawPath.replaceAll("\\", "/");
+  while (releasePath.startsWith("./")) {
+    releasePath = releasePath.slice(2);
+  }
+  while (releasePath.includes("//")) {
+    releasePath = releasePath.replaceAll("//", "/");
+  }
+
+  if (
+    releasePath === "" ||
+    releasePath.startsWith("/") ||
+    /^[A-Za-z]:/.test(releasePath) ||
+    releasePath === ".." ||
+    releasePath.startsWith("../") ||
+    releasePath.endsWith("/..") ||
+    releasePath.includes("/../")
+  ) {
+    throw new Error(`Unsafe release path: ${rawPath}`);
+  }
+
+  return releasePath;
+}
+
+function isTestReleasePath(releasePath) {
+  const lower = releasePath.toLowerCase();
+  return lower === "test" ||
+    lower === "tests" ||
+    lower.startsWith("test/") ||
+    lower.startsWith("tests/") ||
+    lower.includes("/test/") ||
+    lower.includes("/tests/");
+}
+
+async function sha256File(filePath) {
+  const buffer = await readFile(filePath);
+  return createHash("sha256").update(buffer).digest("hex");
+}
+
+async function fileSize(filePath) {
+  return (await stat(filePath)).size;
+}
+
+async function checksumEntry(filePath, releasePath) {
+  return {
+    sha256: await sha256File(filePath),
+    size: await fileSize(filePath),
+    path: releasePath,
+  };
+}
+
+function replaceSkillMarkdownVersion(markdown, version) {
+  if (!markdown.startsWith("---\n")) {
+    throw new Error("SKILL.md is missing YAML frontmatter");
+  }
+
+  const end = markdown.indexOf("\n---", 4);
+  if (end === -1) {
+    throw new Error("SKILL.md frontmatter is not closed");
+  }
+
+  const frontmatter = markdown.slice(0, end);
+  if (!/^version:\s*.+$/m.test(frontmatter)) {
+    throw new Error("SKILL.md frontmatter is missing a version field");
+  }
+
+  return markdown.replace(/^version:\s*.+$/m, `version: ${version}`);
+}
+
+async function addSimulatedChangelogEntry(skillDir, version) {
+  const changelogPath = path.join(skillDir, "CHANGELOG.md");
+  if (!existsSync(changelogPath)) {
+    return;
+  }
+
+  const today = new Date().toISOString().slice(0, 10);
+  const original = await readFile(changelogPath, "utf8");
+  if (original.includes(`## [${version}] -`)) {
+    return;
+  }
+
+  const entry = [
+    `## [${version}] - ${today}`,
+    "",
+    "- Simulated prerelease build for release-pipeline validation.",
+    "",
+    "---",
+    "",
+  ].join("\n");
+
+  await writeFile(changelogPath, `${entry}${original}`);
+}
+
+async function writeJson(filePath, value) {
+  await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+async function signFileBase64({ keyPath, inputPath, outputPath, tempRoot }) {
+  const sigBin = path.join(tempRoot, `${path.basename(outputPath)}.bin`);
+  run("openssl", ["pkeyutl", "-sign", "-rawin", "-inkey", keyPath, "-in", inputPath, "-out", sigBin]);
+  run("openssl", ["base64", "-A", "-in", sigBin, "-out", outputPath]);
+  await rm(sigBin, { force: true });
+}
+
+async function verifyFileBase64Signature({ publicKeyPath, inputPath, signaturePath, tempRoot }) {
+  const sigBin = path.join(tempRoot, `${path.basename(signaturePath)}.verify.bin`);
+  run("openssl", ["base64", "-d", "-A", "-in", signaturePath, "-out", sigBin]);
+  run("openssl", [
+    "pkeyutl",
+    "-verify",
+    "-rawin",
+    "-pubin",
+    "-inkey",
+    publicKeyPath,
+    "-sigfile",
+    sigBin,
+    "-in",
+    inputPath,
+  ]);
+  await rm(sigBin, { force: true });
+}
+
+async function createSigningKeyPair(tempRoot) {
+  const keyDir = await mkdtemp(path.join(tempRoot, "signing-"));
+  const privateKeyPath = path.join(keyDir, "private.pem");
+  const publicKeyPath = path.join(keyDir, "public.pem");
+
+  run("openssl", ["genpkey", "-algorithm", "ED25519", "-out", privateKeyPath]);
+  run("openssl", ["pkey", "-in", privateKeyPath, "-pubout", "-out", publicKeyPath]);
+
+  return { privateKeyPath, publicKeyPath };
+}
+
+async function signAdvisoryArtifacts(skillDir, tempRoot) {
+  const advisoryDir = path.join(skillDir, "advisories");
+  const feedPath = path.join(advisoryDir, "feed.json");
+  if (!existsSync(feedPath)) {
+    return;
+  }
+
+  const { privateKeyPath, publicKeyPath } = await createSigningKeyPair(tempRoot);
+  const feedSignaturePath = path.join(advisoryDir, "feed.json.sig");
+  const checksumsPath = path.join(advisoryDir, "checksums.json");
+  const checksumsSignaturePath = path.join(advisoryDir, "checksums.json.sig");
+  const publicKeyOutputPath = path.join(advisoryDir, "feed-signing-public.pem");
+
+  await signFileBase64({
+    keyPath: privateKeyPath,
+    inputPath: feedPath,
+    outputPath: feedSignaturePath,
+    tempRoot,
+  });
+  await verifyFileBase64Signature({
+    publicKeyPath,
+    inputPath: feedPath,
+    signaturePath: feedSignaturePath,
+    tempRoot,
+  });
+
+  await writeJson(checksumsPath, {
+    schema_version: "1",
+    algorithm: "sha256",
+    version: "simulation",
+    generated_at: new Date().toISOString(),
+    files: {
+      "advisories/feed.json": await checksumEntry(feedPath, "advisories/feed.json"),
+      "advisories/feed.json.sig": await checksumEntry(feedSignaturePath, "advisories/feed.json.sig"),
+    },
+  });
+
+  await signFileBase64({
+    keyPath: privateKeyPath,
+    inputPath: checksumsPath,
+    outputPath: checksumsSignaturePath,
+    tempRoot,
+  });
+  await verifyFileBase64Signature({
+    publicKeyPath,
+    inputPath: checksumsPath,
+    signaturePath: checksumsSignaturePath,
+    tempRoot,
+  });
+
+  await cp(publicKeyPath, publicKeyOutputPath);
+}
+
+async function addReleaseAssetChecksum({ releaseAssetsDir, manifest, asset }) {
+  const filePath = path.join(releaseAssetsDir, asset);
+  if (!existsSync(filePath) || (await fileSize(filePath)) === 0) {
+    throw new Error(`Required release trust artifact is missing or empty: ${filePath}`);
+  }
+
+  manifest.files[asset] = await checksumEntry(filePath, asset);
+}
+
+async function stageSbomFiles({ skillDir, innerDir, sbomFiles }) {
+  for (const entry of sbomFiles) {
+    const releasePath = normalizeReleasePath(entry.path);
+    if (isTestReleasePath(releasePath)) {
+      continue;
+    }
+
+    const fullPath = path.join(skillDir, releasePath);
+    if (!existsSync(fullPath)) {
+      throw new Error(`SBOM references missing file: ${releasePath}`);
+    }
+
+    const destination = path.join(innerDir, releasePath);
+    await mkdir(path.dirname(destination), { recursive: true });
+    await cp(fullPath, destination);
+  }
+}
+
+async function buildFilesManifest({ skillDir, skillJsonPath, sbomFiles }) {
+  const files = {};
+  for (const entry of sbomFiles) {
+    const releasePath = normalizeReleasePath(entry.path);
+    if (isTestReleasePath(releasePath)) {
+      continue;
+    }
+
+    const fullPath = path.join(skillDir, releasePath);
+    if (existsSync(fullPath)) {
+      files[releasePath] = await checksumEntry(fullPath, releasePath);
+    }
+  }
+
+  files["skill.json"] = {
+    sha256: await sha256File(skillJsonPath),
+    size: await fileSize(skillJsonPath),
+  };
+
+  return files;
+}
+
+async function runSkillSpector({ skillspectorBin, skillDir, reportPath }) {
+  const result = runAllowFailure(skillspectorBin, [
+    "scan",
+    skillDir,
+    "--no-llm",
+    "--format",
+    "markdown",
+    "--output",
+    reportPath,
+  ]);
+
+  if (!existsSync(reportPath) || (await fileSize(reportPath)) === 0) {
+    throw new Error(
+      [
+        "SkillSpector did not produce a report.",
+        result.stdout ? `stdout:\n${result.stdout}` : "",
+        result.stderr ? `stderr:\n${result.stderr}` : "",
+      ].filter(Boolean).join("\n"),
+    );
+  }
+
+  if (result.status !== 0) {
+    console.warn(`SkillSpector returned exit code ${result.status}; report is included for review.`);
+  }
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const sourceSkillDir = path.resolve(args.skillDir);
+  const outputDir = path.resolve(args.outputDir);
+  const releaseAssetsDir = path.join(outputDir, "release-assets");
+  const tempRoot = await mkdtemp(path.join(tmpdir(), "clawsec-release-sim-"));
+
+  try {
+    const skillName = path.basename(sourceSkillDir);
+    const tempSkillDir = path.join(tempRoot, skillName);
+    await cp(sourceSkillDir, tempSkillDir, { recursive: true });
+
+    const skillJsonPath = path.join(tempSkillDir, "skill.json");
+    const skillMdPath = path.join(tempSkillDir, "SKILL.md");
+    const skill = JSON.parse(await readFile(skillJsonPath, "utf8"));
+    const originalVersion = skill.version;
+    const simulatedVersion = nextSimulatedReleaseVersion(originalVersion);
+    const tag = `${skillName}-v${simulatedVersion}`;
+    const zipName = `${tag}.zip`;
+
+    skill.version = simulatedVersion;
+    await writeJson(skillJsonPath, skill);
+    await writeFile(
+      skillMdPath,
+      replaceSkillMarkdownVersion(await readFile(skillMdPath, "utf8"), simulatedVersion),
+    );
+    await addSimulatedChangelogEntry(tempSkillDir, simulatedVersion);
+    await signAdvisoryArtifacts(tempSkillDir, tempRoot);
+
+    if (!skill.sbom || !Array.isArray(skill.sbom.files)) {
+      throw new Error(`skill.json missing required release field: sbom.files`);
+    }
+
+    await mkdir(releaseAssetsDir, { recursive: true });
+
+    const stagingDir = await mkdtemp(path.join(tempRoot, "staging-"));
+    const innerDir = path.join(stagingDir, skillName);
+    await mkdir(innerDir, { recursive: true });
+    await stageSbomFiles({
+      skillDir: tempSkillDir,
+      innerDir,
+      sbomFiles: skill.sbom.files,
+    });
+    await cp(skillJsonPath, path.join(innerDir, "skill.json"));
+
+    run("python3", ["scripts/ci/verify_skill_release_import_closure.py", innerDir], {
+      cwd: process.cwd(),
+    });
+
+    run("zip", ["-qr", path.join(releaseAssetsDir, zipName), "."], {
+      cwd: stagingDir,
+    });
+
+    const zipContents = run("unzip", ["-Z1", path.join(releaseAssetsDir, zipName)]);
+    if (zipContents.split("\n").some((entry) => /(^|\/)(test|tests)\//i.test(entry))) {
+      throw new Error(`Simulated release archive contains test-only files: ${zipName}`);
+    }
+
+    const manifest = {
+      skill: skillName,
+      version: simulatedVersion,
+      generated_at: new Date().toISOString(),
+      repository: args.repository,
+      tag,
+      archive: {
+        filename: zipName,
+        sha256: await sha256File(path.join(releaseAssetsDir, zipName)),
+        size: await fileSize(path.join(releaseAssetsDir, zipName)),
+        url: `https://github.com/${args.repository}/releases/download/${tag}/${zipName}`,
+      },
+      files: await buildFilesManifest({
+        skillDir: tempSkillDir,
+        skillJsonPath,
+        sbomFiles: skill.sbom.files,
+      }),
+    };
+
+    await writeJson(path.join(releaseAssetsDir, "checksums.json"), manifest);
+
+    run(process.execPath, [
+      "scripts/ci/generate_skill_release_trust_packet.mjs",
+      tempSkillDir,
+      releaseAssetsDir,
+      "--repository",
+      args.repository,
+      "--tag",
+      tag,
+      "--source-ref",
+      args.sourceRef,
+    ]);
+
+    await runSkillSpector({
+      skillspectorBin: args.skillspectorBin,
+      skillDir: innerDir,
+      reportPath: path.join(releaseAssetsDir, "skillspector-report.md"),
+    });
+
+    for (const artifact of TRUST_ARTIFACTS) {
+      await addReleaseAssetChecksum({ releaseAssetsDir, manifest, asset: artifact });
+    }
+    await writeJson(path.join(releaseAssetsDir, "checksums.json"), manifest);
+
+    await cp(skillJsonPath, path.join(releaseAssetsDir, "skill.json"));
+    await cp(skillMdPath, path.join(releaseAssetsDir, "SKILL.md"));
+    if (existsSync(path.join(tempSkillDir, "README.md"))) {
+      await cp(path.join(tempSkillDir, "README.md"), path.join(releaseAssetsDir, "README.md"));
+    }
+
+    const { privateKeyPath, publicKeyPath } = await createSigningKeyPair(tempRoot);
+    await signFileBase64({
+      keyPath: privateKeyPath,
+      inputPath: path.join(releaseAssetsDir, "checksums.json"),
+      outputPath: path.join(releaseAssetsDir, "checksums.sig"),
+      tempRoot,
+    });
+    await verifyFileBase64Signature({
+      publicKeyPath,
+      inputPath: path.join(releaseAssetsDir, "checksums.json"),
+      signaturePath: path.join(releaseAssetsDir, "checksums.sig"),
+      tempRoot,
+    });
+    await cp(publicKeyPath, path.join(releaseAssetsDir, "signing-public.pem"));
+
+    await writeJson(path.join(outputDir, "simulation-summary.json"), {
+      skill: skillName,
+      original_version: originalVersion,
+      simulated_version: simulatedVersion,
+      tag,
+      release_assets: path.relative(outputDir, releaseAssetsDir),
+      archive: `release-assets/${zipName}`,
+    });
+
+    console.log(`Simulated tag release build for ${skillName}: ${tag}`);
+  } finally {
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+}
+
+main().catch((error) => {
+  console.error(error.message);
+  process.exit(1);
+});

scripts/ci/skill_platforms.mjs

@@ -0,0 +1,52 @@
+export const PLATFORM_KEYS = Object.freeze(["openclaw", "nanoclaw", "hermes", "picoclaw"]);
+
+const PLATFORM_AGENT_ALIASES = new Map([["hermes", "hermes-agent"]]);
+
+function asStringArray(value) {
+  if (Array.isArray(value)) {
+    return value.filter((item) => typeof item === "string" && item.trim()).map((item) => item.trim());
+  }
+  if (typeof value === "string" && value.trim()) {
+    return [value.trim()];
+  }
+  return [];
+}
+
+export function collectDeclaredPlatforms(skill) {
+  const platforms = new Set([
+    ...asStringArray(skill.platform),
+    ...asStringArray(skill.platforms),
+  ]);
+
+  for (const key of PLATFORM_KEYS) {
+    if (skill[key] && typeof skill[key] === "object") {
+      platforms.add(key);
+    }
+  }
+
+  return [...platforms];
+}
+
+export function installAgentForSkill(skill, agentTypes, fallback = "openclaw") {
+  const platforms = collectDeclaredPlatforms(skill);
+  if (platforms.length === 0) {
+    return fallback;
+  }
+
+  const matchedAgents = new Set();
+  let allPlatformsMatched = true;
+  for (const platform of platforms) {
+    const candidate = PLATFORM_AGENT_ALIASES.get(platform) || platform;
+    if (agentTypes.has(candidate)) {
+      matchedAgents.add(candidate);
+    } else {
+      allPlatformsMatched = false;
+    }
+  }
+
+  if (allPlatformsMatched && matchedAgents.size === 1) {
+    return [...matchedAgents][0];
+  }
+
+  return fallback;
+}

scripts/ci/test_verify_skill_release_import_closure.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import importlib.util
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+
+def _load_module():
+    module_path = Path(__file__).with_name("verify_skill_release_import_closure.py")
+    spec = importlib.util.spec_from_file_location("verify_skill_release_import_closure", module_path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"Unable to load {module_path}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+class VerifySkillReleaseImportClosureTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        cls.module = _load_module()
+
+    def test_empty_directory_does_not_satisfy_relative_import(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            (root / "runtime-lib").mkdir()
+            (root / "main.mjs").write_text("import './runtime-lib';\n", encoding="utf-8")
+
+            failures = self.module.verify_import_closure(root)
+
+            self.assertEqual(len(failures), 1)
+            self.assertIn("main.mjs imports ./runtime-lib", failures[0])
+
+    def test_directory_import_requires_index_file(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            runtime_lib = root / "runtime-lib"
+            runtime_lib.mkdir()
+            (runtime_lib / "index.mjs").write_text("export {};\n", encoding="utf-8")
+            (root / "main.mjs").write_text("import './runtime-lib';\n", encoding="utf-8")
+
+            failures = self.module.verify_import_closure(root)
+
+            self.assertEqual(failures, [])
+
+    def test_ts_source_accepts_js_import_specifier(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            (root / "types.ts").write_text("export type Value = string;\n", encoding="utf-8")
+            (root / "main.ts").write_text("import type { Value } from './types.js';\n", encoding="utf-8")
+
+            failures = self.module.verify_import_closure(root)
+
+            self.assertEqual(failures, [])
+
+    def test_comment_import_examples_are_ignored(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            (root / "main.ts").write_text(
+                "/*\n"
+                " * Example integration:\n"
+                " * import { Missing } from '../external/project/file';\n"
+                " */\n"
+                "export {};\n",
+                encoding="utf-8",
+            )
+
+            failures = self.module.verify_import_closure(root)
+
+            self.assertEqual(failures, [])
+
+    def test_url_string_does_not_hide_following_relative_import(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            (root / "main.ts").write_text(
+                'const feedUrl = "https://example.test/feed.json"; import value from "./missing.js";\n',
+                encoding="utf-8",
+            )
+
+            failures = self.module.verify_import_closure(root)
+
+            self.assertEqual(len(failures), 1)
+            self.assertIn("main.ts imports ./missing.js", failures[0])
+
+    def test_remote_import_spec_survives_comment_stripping(self) -> None:
+        source = 'import remote from "https://example.test/module.mjs";\n'
+        stripped = self.module.strip_js_ts_comments(source)
+
+        specs = [match.group("spec") for match in self.module.IMPORT_RE.finditer(stripped)]
+
+        self.assertEqual(specs, ["https://example.test/module.mjs"])
+
+    def test_remote_runtime_import_is_rejected(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            root = Path(tmpdir)
+            (root / "main.mjs").write_text(
+                'import remote from "https://example.test/module.mjs";\n',
+                encoding="utf-8",
+            )
+
+            failures = self.module.verify_import_closure(root)
+
+            self.assertEqual(len(failures), 1)
+            self.assertIn("remote runtime import https://example.test/module.mjs", failures[0])
+
+
+if __name__ == "__main__":
+    unittest.main()

scripts/ci/validate_skill_install_docs.mjs

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+import { readFile, readdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import https from "node:https";
+import path from "node:path";
+import { installAgentForSkill } from "./skill_platforms.mjs";
+
+const DEFAULT_REPOSITORY = "prompt-security/clawsec";
+const DEFAULT_AGENT_TYPES_URL = "https://raw.githubusercontent.com/vercel-labs/skills/main/src/types.ts";
+const DOC_FILENAMES = ["README.md", "SKILL.md"];
+
+function usage() {
+  return [
+    "Usage: node scripts/ci/validate_skill_install_docs.mjs [options]",
+    "",
+    "Options:",
+    "  --root <dir>              Repository root. Defaults to current working directory.",
+    "  --repository <owner/repo> Expected npx skills source. Defaults to prompt-security/clawsec.",
+    "  --base <sha>              Base ref for changed-skill detection.",
+    "  --head <sha>              Head ref for changed-skill detection.",
+    "  --skills <dir[,dir...]>   Skill directories to validate.",
+    "  --all                     Validate every skill directory with skill.json.",
+    "  --agent-types-file <path> Read Vercel AgentType source from a local file.",
+    "  --agent-types-url <url>   Read Vercel AgentType source from a URL.",
+  ].join("\n");
+}
+
+function parseArgs(argv) {
+  const options = {
+    root: process.cwd(),
+    repository: DEFAULT_REPOSITORY,
+    base: process.env.BASE_SHA || "",
+    head: process.env.HEAD_SHA || "",
+    skillDirs: [],
+    all: false,
+    agentTypesFile: "",
+    agentTypesUrl: DEFAULT_AGENT_TYPES_URL,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === "--root") {
+      options.root = argv[++i];
+    } else if (token === "--repository") {
+      options.repository = argv[++i];
+    } else if (token === "--base") {
+      options.base = argv[++i];
+    } else if (token === "--head") {
+      options.head = argv[++i];
+    } else if (token === "--skills") {
+      options.skillDirs.push(...argv[++i].split(",").map((item) => item.trim()).filter(Boolean));
+    } else if (token === "--all") {
+      options.all = true;
+    } else if (token === "--agent-types-file") {
+      options.agentTypesFile = argv[++i];
+    } else if (token === "--agent-types-url") {
+      options.agentTypesUrl = argv[++i];
+    } else if (token === "--help" || token === "-h") {
+      console.log(usage());
+      process.exit(0);
+    } else {
+      throw new Error(`Unknown option: ${token}\n${usage()}`);
+    }
+  }
+
+  return {
+    ...options,
+    root: path.resolve(options.root),
+  };
+}
+
+function fetchText(url) {
+  return new Promise((resolve, reject) => {
+    https
+      .get(url, (response) => {
+        if (response.statusCode !== 200) {
+          reject(new Error(`Failed to fetch ${url}: HTTP ${response.statusCode}`));
+          response.resume();
+          return;
+        }
+
+        response.setEncoding("utf8");
+        let body = "";
+        response.on("data", (chunk) => {
+          body += chunk;
+        });
+        response.on("end", () => resolve(body));
+      })
+      .on("error", reject);
+  });
+}
+
+async function readAgentTypeSource(options) {
+  if (options.agentTypesFile) {
+    return readFile(path.resolve(options.agentTypesFile), "utf8");
+  }
+
+  return fetchText(options.agentTypesUrl);
+}
+
+function parseAgentTypes(source) {
+  const match = source.match(/export\s+type\s+AgentType\s*=\s*([\s\S]*?);/);
+  if (!match) {
+    throw new Error("Could not find export type AgentType in Vercel skills type source.");
+  }
+
+  const agents = new Set();
+  const agentTypeBody = match[1];
+  for (const agentMatch of agentTypeBody.matchAll(/['"]([^'"]+)['"]/g)) {
+    agents.add(agentMatch[1]);
+  }
+
+  if (agents.size === 0) {
+    throw new Error("Vercel AgentType list was empty.");
+  }
+
+  return agents;
+}
+
+async function listAllSkillDirs(root) {
+  const skillsRoot = path.join(root, "skills");
+  const entries = await readdir(skillsRoot, { withFileTypes: true });
+  return entries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => `skills/${entry.name}`)
+    .filter((skillDir) => existsSync(path.join(root, skillDir, "skill.json")))
+    .sort();
+}
+
+function changedSkillDirs({ root, base, head }) {
+  if (!base || !head) {
+    throw new Error("Provide --skills, --all, or both --base and --head for changed-skill detection.");
+  }
+
+  const result = spawnSync(
+    "git",
+    [
+      "-C",
+      root,
+      "diff",
+      "--name-only",
+      `${base}...${head}`,
+      "--",
+      "skills/*/**",
+      ":(exclude)skills/*/test/**",
+      ":(exclude)skills/*/tests/**",
+    ],
+    { encoding: "utf8" },
+  );
+
+  if (result.status !== 0) {
+    throw new Error(`git diff failed\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`);
+  }
+
+  return [
+    ...new Set(
+      result.stdout
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((filePath) => filePath.split("/").slice(0, 2).join("/"))
+        .filter((skillDir) => /^skills\/[^/]+$/.test(skillDir)),
+    ),
+  ].sort();
+}
+
+async function readJson(filePath) {
+  return JSON.parse(await readFile(filePath, "utf8"));
+}
+
+function hasRequiredCommand(markdown, { repository, skillName, agent }) {
+  return markdown
+    .split("\n")
+    .map((line) => line.replace(/\s+/g, " ").trim())
+    .filter((line) => line.includes("npx skills add"))
+    .some((line) => {
+      return (
+        line.includes(`npx skills add ${repository}`) &&
+        line.includes(`--skill ${skillName}`) &&
+        (line.includes(`-a ${agent}`) || line.includes(`--agent ${agent}`)) &&
+        (line.includes(" -y") || line.includes(" --yes"))
+      );
+    });
+}
+
+async function validateSkill({ root, skillDir, repository, agentTypes }) {
+  const skillJsonPath = path.join(root, skillDir, "skill.json");
+  const skill = await readJson(skillJsonPath);
+  const skillName = skill.name || path.basename(skillDir);
+  const agent = installAgentForSkill(skill, agentTypes);
+  const command = `npx skills add ${repository} --skill ${skillName} -a ${agent} -y`;
+  const failures = [];
+
+  for (const filename of DOC_FILENAMES) {
+    const docPath = path.join(root, skillDir, filename);
+    if (!existsSync(docPath)) {
+      failures.push(`Missing required install documentation file: ${path.join(skillDir, filename)}`);
+      continue;
+    }
+
+    const markdown = await readFile(docPath, "utf8");
+    if (!hasRequiredCommand(markdown, { repository, skillName, agent })) {
+      failures.push(`Missing required npx skills install command in ${path.join(skillDir, filename)}: ${command}`);
+    }
+  }
+
+  return {
+    skillDir,
+    skillName,
+    agent,
+    failures,
+  };
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const agentTypes = parseAgentTypes(await readAgentTypeSource(options));
+  let skillDirs = options.skillDirs;
+
+  if (options.all) {
+    skillDirs = await listAllSkillDirs(options.root);
+  } else if (skillDirs.length === 0) {
+    skillDirs = changedSkillDirs(options);
+  }
+
+  if (skillDirs.length === 0) {
+    console.log("No skill install docs to validate.");
+    return;
+  }
+
+  const results = [];
+  for (const skillDir of skillDirs) {
+    const skillJsonPath = path.join(options.root, skillDir, "skill.json");
+    if (!existsSync(skillJsonPath)) {
+      console.log(`Skipping removed skill directory: ${skillDir}`);
+      continue;
+    }
+
+    results.push(
+      await validateSkill({
+        root: options.root,
+        skillDir,
+        repository: options.repository,
+        agentTypes,
+      }),
+    );
+  }
+
+  const failures = results.flatMap((result) => result.failures);
+  if (failures.length > 0) {
+    for (const failure of failures) {
+      console.error(`::error::${failure}`);
+    }
+    throw new Error(`Found ${failures.length} npx skills install documentation issue(s).`);
+  }
+
+  for (const result of results) {
+    console.log(`npx skills install docs OK for ${result.skillName}: -a ${result.agent}`);
+  }
+}
+
+main().catch((error) => {
+  console.error(error.message);
+  process.exit(1);
+});

scripts/ci/verify_skill_release_import_closure.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+"""Verify staged skill release JS/TS imports are self-contained.
+
+The skill release workflow builds archives from `skill.json.sbom.files`. If a
+runtime helper exists in the repo but is omitted from the SBOM, the staged
+release can contain files whose relative imports point at missing files or
+remote runtime imports. This script checks the staged payload, not the source
+tree, so it catches exactly what would ship.
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+IMPORT_RE = re.compile(
+    r"(?:"
+    r"\bimport\s+(?:type\s+)?(?:[^'\";]+?\s+from\s+)?"
+    r"|\bexport\s+(?:type\s+)?[^'\";]+?\s+from\s+"
+    r"|\bimport\s*\(\s*"
+    r"|\brequire\s*\(\s*"
+    r")"
+    r"['\"](?P<spec>(?:\.{1,2}/|https?://)[^'\"]+)['\"]",
+    re.MULTILINE,
+)
+
+SOURCE_SUFFIXES = {".js", ".mjs", ".cjs", ".ts", ".mts", ".cts"}
+RESOLUTION_SUFFIXES = ["", ".mjs", ".js", ".cjs", ".mts", ".ts", ".cts", ".json"]
+INDEX_FILENAMES = ["index.mjs", "index.js", "index.cjs", "index.mts", "index.ts", "index.cts", "index.json"]
+TS_IMPORTER_SUFFIXES = {".ts", ".mts", ".cts"}
+JS_TO_TS_SUFFIX = {".js": ".ts", ".mjs": ".mts", ".cjs": ".cts"}
+
+
+def strip_js_ts_comments(text: str) -> str:
+    stripped: list[str] = []
+    state = "code"
+    i = 0
+
+    while i < len(text):
+        char = text[i]
+        next_char = text[i + 1] if i + 1 < len(text) else ""
+
+        if state == "line_comment":
+            if char in "\r\n":
+                stripped.append(char)
+                state = "code"
+            i += 1
+            continue
+
+        if state == "block_comment":
+            if char == "*" and next_char == "/":
+                state = "code"
+                i += 2
+                continue
+            if char in "\r\n":
+                stripped.append(char)
+            i += 1
+            continue
+
+        if state in {"single", "double", "template"}:
+            stripped.append(char)
+            if char == "\\" and i + 1 < len(text):
+                stripped.append(text[i + 1])
+                i += 2
+                continue
+            if (state == "single" and char == "'") or (state == "double" and char == '"') or (
+                state == "template" and char == "`"
+            ):
+                state = "code"
+            i += 1
+            continue
+
+        if char == "/" and next_char == "/":
+            stripped.append(" ")
+            state = "line_comment"
+            i += 2
+            continue
+        if char == "/" and next_char == "*":
+            stripped.append(" ")
+            state = "block_comment"
+            i += 2
+            continue
+
+        stripped.append(char)
+        if char == "'":
+            state = "single"
+        elif char == '"':
+            state = "double"
+        elif char == "`":
+            state = "template"
+        i += 1
+
+    return "".join(stripped)
+
+
+def is_remote_spec(spec: str) -> bool:
+    return spec.startswith(("http://", "https://"))
+
+
+def candidate_paths(importer: Path, spec: str) -> list[Path]:
+    base = (importer.parent / spec).resolve()
+    candidates = [base]
+    if importer.suffix in TS_IMPORTER_SUFFIXES and base.suffix in JS_TO_TS_SUFFIX:
+        candidates.append(base.with_suffix(JS_TO_TS_SUFFIX[base.suffix]))
+    candidates.extend(base.with_suffix(suffix) for suffix in RESOLUTION_SUFFIXES if suffix and base.suffix == "")
+    candidates.extend(base / name for name in INDEX_FILENAMES)
+    return candidates
+
+
+def is_within(path: Path, root: Path) -> bool:
+    try:
+        path.resolve().relative_to(root)
+        return True
+    except ValueError:
+        return False
+
+
+def is_resolved_file(candidate: Path, root: Path) -> bool:
+    return candidate.is_file() and is_within(candidate, root)
+
+
+def verify_import_closure(root: Path) -> list[str]:
+    root = root.resolve()
+    failures: list[str] = []
+
+    for source in sorted(p for p in root.rglob("*") if p.is_file() and p.suffix in SOURCE_SUFFIXES):
+        text = source.read_text(encoding="utf-8", errors="ignore")
+        text = strip_js_ts_comments(text)
+        for match in IMPORT_RE.finditer(text):
+            spec = match.group("spec")
+            rel_source = source.relative_to(root).as_posix()
+            if is_remote_spec(spec):
+                failures.append(f"{rel_source} imports remote runtime import {spec}")
+                continue
+
+            candidates = candidate_paths(source, spec)
+            if any(is_resolved_file(candidate, root) for candidate in candidates):
+                continue
+
+            display_target = (source.parent / spec).resolve()
+            try:
+                rel_target = display_target.relative_to(root).as_posix()
+            except ValueError:
+                rel_target = str(display_target)
+            failures.append(f"{rel_source} imports {spec} but {rel_target} is absent from staged release")
+
+    return failures
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("staged_skill_dir", type=Path, help="Staged skill payload directory, e.g. $INNER_DIR")
+    args = parser.parse_args()
+
+    root = args.staged_skill_dir
+    if not root.is_dir():
+        print(f"error: staged skill directory not found: {root}", file=sys.stderr)
+        return 2
+
+    failures = verify_import_closure(root)
+    if failures:
+        print("Release import-closure check failed:", file=sys.stderr)
+        for failure in failures:
+            print(f"  - {failure}", file=sys.stderr)
+        print("Add the missing runtime file(s) to skill.json sbom.files or remove the stale import.", file=sys.stderr)
+        return 1
+
+    print(f"Release import-closure check OK: {root}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/ghsa-without-cve-feed.mjs

@@ -0,0 +1,514 @@
+#!/usr/bin/env node
+
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const DEFAULT_REPOSITORIES = [
+  'openclaw/openclaw',
+  'qwibitai/nanoclaw',
+  'softwarepub/hermes',
+  'nousresearch/hermes-agent',
+  'sipeed/picoclaw',
+];
+
+export const DEFAULT_STALE_AFTER_DAYS = 60;
+export const FEED_VERSION = '0.1.0';
+
+const PLATFORM_BY_REPOSITORY = new Map([
+  ['openclaw/openclaw', 'openclaw'],
+  ['qwibitai/nanoclaw', 'nanoclaw'],
+  ['softwarepub/hermes', 'hermes'],
+  ['nousresearch/hermes-agent', 'hermes'],
+  ['sipeed/picoclaw', 'picoclaw'],
+]);
+
+const CWE_TYPE_BY_ID = new Map([
+  ['CWE-22', 'path_traversal'],
+  ['CWE-78', 'os_command_injection'],
+  ['CWE-79', 'cross_site_scripting'],
+  ['CWE-94', 'code_injection'],
+  ['CWE-200', 'exposure_of_sensitive_information'],
+  ['CWE-284', 'improper_access_control'],
+  ['CWE-287', 'improper_authentication'],
+  ['CWE-306', 'missing_authentication_for_critical_function'],
+  ['CWE-352', 'cross_site_request_forgery'],
+  ['CWE-400', 'uncontrolled_resource_consumption'],
+  ['CWE-502', 'deserialization_of_untrusted_data'],
+  ['CWE-862', 'missing_authorization'],
+  ['CWE-863', 'incorrect_authorization'],
+  ['CWE-918', 'server_side_request_forgery'],
+]);
+
+function cleanText(value) {
+  return String(value ?? '')
+    .replace(/\r/g, '')
+    .replace(/```[\s\S]*?```/g, ' ')
+    .replace(/`([^`]+)`/g, '$1')
+    .replace(/\[([^\]]+)\]\([^)]+\)/g, '$1')
+    .replace(/^#+\s+/gm, '')
+    .replace(/[*_>]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function daysBetween(startIso, endIso) {
+  const start = Date.parse(startIso);
+  const end = Date.parse(endIso);
+  if (!Number.isFinite(start) || !Number.isFinite(end) || end < start) {
+    return 0;
+  }
+  return Math.floor((end - start) / 86_400_000);
+}
+
+function toArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.length > 0))];
+}
+
+export function inferPlatforms(repository) {
+  const known = PLATFORM_BY_REPOSITORY.get(String(repository).toLowerCase());
+  return known ? [known] : [];
+}
+
+function nextLinkFromHeader(linkHeader) {
+  if (!linkHeader) {
+    return null;
+  }
+  for (const part of linkHeader.split(',')) {
+    const match = part.trim().match(/^<([^>]+)>;\s*rel="next"$/);
+    if (match) {
+      return match[1];
+    }
+  }
+  return null;
+}
+
+function affectedFromVulnerabilities(advisory, platforms) {
+  const affected = toArray(advisory.vulnerabilities).flatMap((vulnerability) => {
+    const packageName = vulnerability?.package?.name;
+    const versionRange = vulnerability?.vulnerable_version_range;
+    if (!packageName) {
+      return [];
+    }
+    return [`${packageName}@${versionRange || '*'}`];
+  });
+
+  if (affected.length > 0) {
+    return uniqueStrings(affected);
+  }
+
+  return platforms.length > 0 ? platforms.map((platform) => `${platform}@*`) : [];
+}
+
+function patchedFromVulnerabilities(advisory) {
+  return uniqueStrings(
+    toArray(advisory.vulnerabilities).flatMap((vulnerability) => {
+      const packageName = vulnerability?.package?.name;
+      const patchedVersions = vulnerability?.patched_versions;
+      if (!packageName || !patchedVersions) {
+        return [];
+      }
+      return [`${packageName}@${patchedVersions}`];
+    }),
+  );
+}
+
+function githubAdvisoryUrl(advisory) {
+  return advisory.html_url || advisory.url || `https://github.com/advisories/${advisory.ghsa_id}`;
+}
+
+function resolveCveId(advisory, cveIdByGhsa) {
+  return advisory.cve_id || cveIdByGhsa.get(advisory.ghsa_id) || null;
+}
+
+export function normalizeGhsaAdvisory(
+  advisory,
+  {
+    now,
+    repository,
+    staleAfterDays = DEFAULT_STALE_AFTER_DAYS,
+    cveId = advisory.cve_id || null,
+  },
+) {
+  const platforms = inferPlatforms(repository);
+  const published = advisory.published_at || advisory.created_at || advisory.updated_at || now;
+  const ageDays = daysBetween(published, now);
+  const stale = !cveId && ageDays >= staleAfterDays;
+  const status = cveId ? 'matured' : stale ? 'stale' : 'active';
+  const cweIds = uniqueStrings(toArray(advisory.cwe_ids));
+  const cvss = advisory.cvss || advisory.cvss_severities?.cvss_v3 || {};
+  const ghsaUrl = githubAdvisoryUrl(advisory);
+  const affected = affectedFromVulnerabilities(advisory, platforms);
+  const patched = patchedFromVulnerabilities(advisory);
+  const title = cleanText(advisory.summary) || advisory.ghsa_id;
+  const description = cleanText(advisory.description) || title;
+
+  return {
+    id: advisory.ghsa_id,
+    ghsa_id: advisory.ghsa_id,
+    cve_id: cveId,
+    status,
+    stale,
+    stale_after_days: staleAfterDays,
+    severity: advisory.severity || 'medium',
+    type: CWE_TYPE_BY_ID.get(cweIds[0]) || 'github_security_advisory',
+    nvd_category_id: cweIds[0] || null,
+    title,
+    description,
+    affected,
+    patched,
+    platforms,
+    action: cveId
+      ? `Track ${cveId} in the canonical CVE advisory feed and verify affected components.`
+      : 'Review the GitHub Security Advisory and update affected components; no CVE is assigned yet.',
+    published,
+    updated: advisory.updated_at || published,
+    references: uniqueStrings([ghsaUrl, cveId ? `https://nvd.nist.gov/vuln/detail/${cveId}` : null]),
+    source: 'GitHub Security Advisory',
+    repository,
+    github_advisory_url: ghsaUrl,
+    nvd_url: cveId ? `https://nvd.nist.gov/vuln/detail/${cveId}` : null,
+    cvss_score: cvss.score ?? null,
+    cvss_vector: cvss.vector_string ?? null,
+    cwe_ids: cweIds,
+    credits: uniqueStrings(toArray(advisory.credits).map((credit) => credit?.login)),
+    aliases: uniqueStrings([advisory.ghsa_id, cveId]),
+  };
+}
+
+function ghsaToCveMapFromNvdFeed(nvdFeed) {
+  const map = new Map();
+  for (const advisory of toArray(nvdFeed?.advisories)) {
+    const cveId = advisory?.id;
+    if (typeof cveId !== 'string' || !cveId.startsWith('CVE-')) {
+      continue;
+    }
+    const references = toArray(advisory.references).join('\n');
+    for (const match of references.matchAll(/GHSA-[a-z0-9]{4}-[a-z0-9]{4}-[a-z0-9]{4}/gi)) {
+      map.set(match[0], cveId);
+    }
+  }
+  return map;
+}
+
+function equivalentAdvisories(left, right) {
+  return JSON.stringify(left ?? []) === JSON.stringify(right ?? []);
+}
+
+function isCveId(value) {
+  return typeof value === 'string' && /^CVE-\d{4}-\d{4,}$/i.test(value);
+}
+
+function ghsaIdentifier(entry) {
+  if (typeof entry?.ghsa_id === 'string' && entry.ghsa_id.length > 0) {
+    return entry.ghsa_id.toLowerCase();
+  }
+  if (/^GHSA-/i.test(String(entry?.id || ''))) {
+    return String(entry.id).toLowerCase();
+  }
+  return null;
+}
+
+function refreshExistingEntry(entry, { now, staleAfterDays, cveIdByGhsa }) {
+  const cveId = entry.cve_id || cveIdByGhsa.get(entry.ghsa_id || entry.id) || null;
+  const ageDays = daysBetween(entry.published, now);
+  const stale = !cveId && ageDays >= staleAfterDays;
+  return {
+    ...entry,
+    cve_id: cveId,
+    status: cveId ? 'matured' : stale ? 'stale' : 'active',
+    stale,
+    stale_after_days: staleAfterDays,
+    references: uniqueStrings([
+      ...toArray(entry.references),
+      cveId ? `https://nvd.nist.gov/vuln/detail/${cveId}` : null,
+    ]),
+    nvd_url: cveId ? `https://nvd.nist.gov/vuln/detail/${cveId}` : null,
+    aliases: uniqueStrings([...(entry.aliases || []), entry.ghsa_id || entry.id, cveId]),
+  };
+}
+
+export function buildConsolidatedAdvisoryFeed({ canonicalFeed = {}, ghsaFeed = {}, now }) {
+  const canonicalFeedEntries = toArray(canonicalFeed.advisories);
+  const canonicalCveIds = new Set(canonicalFeedEntries.map((entry) => entry?.id).filter(isCveId));
+  const replacementGhsaIds = new Set(toArray(ghsaFeed.advisories).map(ghsaIdentifier).filter(Boolean));
+  const canonicalEntries = canonicalFeedEntries.filter((entry) => {
+    const ghsaId = ghsaIdentifier(entry);
+    if (!ghsaId) {
+      return true;
+    }
+    if (entry?.cve_id && canonicalCveIds.has(entry.cve_id)) {
+      return false;
+    }
+    return !replacementGhsaIds.has(ghsaId);
+  });
+  const ghsaEntries = toArray(ghsaFeed.advisories)
+    .filter((entry) => !(entry?.cve_id && canonicalCveIds.has(entry.cve_id)))
+    .map((entry) => ({
+      ...entry,
+      source_feed: 'ghsa-without-cve',
+    }));
+
+  const advisories = [...canonicalEntries, ...ghsaEntries].sort((a, b) => {
+    const published = Date.parse(b.published || '') - Date.parse(a.published || '');
+    if (Number.isFinite(published) && published !== 0) {
+      return published;
+    }
+    return String(a.id || '').localeCompare(String(b.id || ''));
+  });
+
+  return {
+    ...canonicalFeed,
+    version: canonicalFeed.version || '1.0.0',
+    updated: canonicalFeed.updated || now,
+    description: canonicalFeed.description || 'Community-driven security advisory feed for ClawSec',
+    advisories,
+  };
+}
+
+export function buildGhsaWithoutCveFeed({
+  fetched,
+  existingFeed = {},
+  nvdFeed = {},
+  now,
+  staleAfterDays = DEFAULT_STALE_AFTER_DAYS,
+}) {
+  const existingEntries = toArray(existingFeed.advisories);
+  const existingIds = new Set(existingEntries.map((entry) => entry.ghsa_id || entry.id));
+  const cveIdByGhsa = ghsaToCveMapFromNvdFeed(nvdFeed);
+  const entriesById = new Map();
+
+  for (const { repository, advisories } of fetched) {
+    for (const advisory of advisories) {
+      const ghsaId = advisory.ghsa_id;
+      if (!ghsaId) {
+        continue;
+      }
+      const cveId = resolveCveId(advisory, cveIdByGhsa);
+      if (cveId && !existingIds.has(ghsaId)) {
+        continue;
+      }
+      entriesById.set(
+        ghsaId,
+        normalizeGhsaAdvisory(advisory, {
+          now,
+          repository,
+          staleAfterDays,
+          cveId,
+        }),
+      );
+    }
+  }
+
+  for (const entry of existingEntries) {
+    const ghsaId = entry.ghsa_id || entry.id;
+    if (!ghsaId || entriesById.has(ghsaId)) {
+      continue;
+    }
+    entriesById.set(ghsaId, refreshExistingEntry(entry, { now, staleAfterDays, cveIdByGhsa }));
+  }
+
+  const advisories = [...entriesById.values()].sort((a, b) => {
+    const published = Date.parse(b.published) - Date.parse(a.published);
+    if (published !== 0) {
+      return published;
+    }
+    return a.id.localeCompare(b.id);
+  });
+
+  const updated = equivalentAdvisories(advisories, existingEntries)
+    ? existingFeed.updated || now
+    : now;
+
+  return {
+    version: FEED_VERSION,
+    updated,
+    description:
+      'Provisional ClawSec advisory feed for public GitHub Security Advisories that do not yet have CVE identifiers.',
+    stale_after_days: staleAfterDays,
+    semantics: {
+      active: 'GHSA is published and has no CVE identifier yet.',
+      matured: 'GHSA now has a CVE identifier and should be reconciled with the canonical CVE feed.',
+      stale: 'GHSA is older than stale_after_days and still has no CVE identifier.',
+    },
+    sources: DEFAULT_REPOSITORIES.map((repository) => ({
+      repository,
+      platform: inferPlatforms(repository)[0] || 'unknown',
+      url: `https://github.com/${repository}/security/advisories`,
+    })),
+    advisories,
+  };
+}
+
+export async function fetchGitHubSecurityAdvisories(repository, { token } = {}) {
+  const advisories = [];
+  let url = `https://api.github.com/repos/${repository}/security-advisories?per_page=100`;
+  const seenUrls = new Set();
+
+  while (url) {
+    if (seenUrls.has(url)) {
+      throw new Error(`GitHub advisory pagination loop detected for ${repository}: ${url}`);
+    }
+    seenUrls.add(url);
+
+    const response = await globalThis.fetch(url, {
+      headers: {
+        Accept: 'application/vnd.github+json',
+        'User-Agent': 'clawsec-ghsa-without-cve-poller',
+        'X-GitHub-Api-Version': '2022-11-28',
+        ...(token ? { Authorization: `Bearer ${token}` } : {}),
+      },
+    });
+
+    if (!response.ok) {
+      const message = await response.text();
+      throw new Error(
+        `GitHub advisory fetch failed for ${repository}: HTTP ${response.status} ${message.slice(0, 200)}`,
+      );
+    }
+
+    const pageItems = await response.json();
+    advisories.push(...pageItems);
+    if (!Array.isArray(pageItems)) {
+      break;
+    }
+    url = nextLinkFromHeader(response.headers.get('link'));
+  }
+  return advisories;
+}
+
+async function readJsonIfExists(path, fallback) {
+  if (!existsSync(path)) {
+    return fallback;
+  }
+  return JSON.parse(await readFile(path, 'utf8'));
+}
+
+async function writeJson(path, value) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(`${path}.tmp`, `${JSON.stringify(value, null, 2)}\n`);
+  await rename(`${path}.tmp`, path);
+}
+
+function parseArgs(argv) {
+  const options = {
+    output: 'advisories/ghsa-without-cve.json',
+    consolidatedFeed: null,
+    existingFeed: null,
+    nvdFeed: 'advisories/feed.json',
+    repositories: [...DEFAULT_REPOSITORIES],
+    staleAfterDays: DEFAULT_STALE_AFTER_DAYS,
+    token: process.env.GITHUB_TOKEN || process.env.GH_TOKEN || '',
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--output') {
+      options.output = argv[++index];
+    } else if (arg === '--consolidated-feed') {
+      options.consolidatedFeed = argv[++index];
+    } else if (arg === '--existing-feed') {
+      options.existingFeed = argv[++index];
+    } else if (arg === '--nvd-feed') {
+      options.nvdFeed = argv[++index];
+    } else if (arg === '--repo') {
+      options.repositories.push(argv[++index]);
+    } else if (arg === '--only-default-repos') {
+      options.repositories = [...DEFAULT_REPOSITORIES];
+    } else if (arg === '--stale-after-days') {
+      options.staleAfterDays = Number.parseInt(argv[++index], 10);
+    } else if (arg === '--help') {
+      options.help = true;
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+
+  if (!Number.isInteger(options.staleAfterDays) || options.staleAfterDays < 1) {
+    throw new Error('--stale-after-days must be a positive integer');
+  }
+
+  options.repositories = uniqueStrings(options.repositories.map((repo) => repo.toLowerCase()));
+  options.existingFeed ||= options.output;
+  return options;
+}
+
+function printHelp() {
+  console.log(`Usage: node scripts/ghsa-without-cve-feed.mjs [options]
+
+Options:
+  --output PATH             Feed output path (default: advisories/ghsa-without-cve.json)
+  --consolidated-feed PATH  Also merge active GHSA advisories into agent-facing feed PATH
+  --existing-feed PATH      Existing provisional feed path (default: output path)
+  --nvd-feed PATH           Canonical CVE feed path for GHSA-to-CVE reconciliation
+  --repo OWNER/NAME         Additional repository to poll
+  --only-default-repos      Reset repository list to built-in ClawSec sources
+  --stale-after-days N      Mark GHSA-only advisories stale after N days (default: 60)
+`);
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.help) {
+    printHelp();
+    return;
+  }
+
+  const now = new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
+  const fetched = [];
+  for (const repository of options.repositories) {
+    const advisories = await fetchGitHubSecurityAdvisories(repository, { token: options.token });
+    console.log(`Fetched ${advisories.length} GitHub Security Advisories from ${repository}`);
+    fetched.push({ repository, advisories });
+  }
+
+  const existingFeed = await readJsonIfExists(options.existingFeed, {});
+  const nvdFeed = await readJsonIfExists(options.nvdFeed, { advisories: [] });
+  const feed = buildGhsaWithoutCveFeed({
+    fetched,
+    existingFeed,
+    nvdFeed,
+    now,
+    staleAfterDays: options.staleAfterDays,
+  });
+
+  await writeJson(options.output, feed);
+  console.log(`Wrote ${feed.advisories.length} provisional GHSA advisories to ${options.output}`);
+
+  if (options.consolidatedFeed) {
+    const canonicalFeed = await readJsonIfExists(options.consolidatedFeed, {
+      version: '1.0.0',
+      advisories: [],
+    });
+    const consolidatedFeed = buildConsolidatedAdvisoryFeed({
+      canonicalFeed,
+      ghsaFeed: feed,
+      now,
+    });
+    await writeJson(options.consolidatedFeed, consolidatedFeed);
+    console.log(
+      `Wrote ${consolidatedFeed.advisories.length} consolidated agent advisories to ${options.consolidatedFeed}`,
+    );
+  }
+
+  console.log(
+    `Status counts: ${JSON.stringify(
+      feed.advisories.reduce((counts, advisory) => {
+        counts[advisory.status] = (counts[advisory.status] || 0) + 1;
+        return counts;
+      }, {}),
+    )}`,
+  );
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+}

scripts/test-deploy-pages-checksums.mjs

@@ -0,0 +1,54 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+
+const workflowPath = new URL("../.github/workflows/deploy-pages.yml", import.meta.url);
+const workflow = await readFile(workflowPath, "utf8");
+
+function stepIndex(name) {
+  const marker = `- name: ${name}`;
+  const index = workflow.indexOf(marker);
+  assert.notEqual(index, -1, `missing workflow step: ${name}`);
+  return index;
+}
+
+const signFeedIndex = stepIndex("Sign advisory feed and verify");
+const signGhsaIndex = stepIndex("Sign provisional GHSA feed and verify");
+const generateChecksumsIndex = stepIndex("Generate advisory checksums manifest");
+const signChecksumsIndex = stepIndex("Sign checksums and verify");
+
+assert.ok(
+  signFeedIndex < generateChecksumsIndex,
+  "advisory checksums manifest must be generated after feed.json.sig is created",
+);
+assert.ok(
+  signGhsaIndex < generateChecksumsIndex,
+  "advisory checksums manifest must be generated after ghsa-without-cve.json.sig is created",
+);
+assert.ok(
+  generateChecksumsIndex < signChecksumsIndex,
+  "checksums signature must be generated after checksums.json is refreshed",
+);
+
+const generateStepBody = workflow.slice(generateChecksumsIndex, signChecksumsIndex);
+assert.match(
+  generateStepBody,
+  /public\/advisories\/\*\.json\.sig/,
+  "advisory checksums manifest must include detached advisory signatures",
+);
+
+const mirrorBlockIndex = workflow.indexOf(
+  "# Mirror advisories feed + signatures at the path referenced by suite docs/heartbeat",
+);
+assert.notEqual(mirrorBlockIndex, -1, "missing advisory release mirror block");
+
+const mirrorBlock = workflow.slice(mirrorBlockIndex, workflow.indexOf("if [ -f \"public/checksums.json\"", mirrorBlockIndex));
+assert.match(
+  mirrorBlock,
+  /cp "public\/advisories\/ghsa-without-cve\.json" "\$MIRROR_LATEST_DIR\/ghsa-without-cve\.json"/,
+  "GHSA provisional feed must be mirrored at the release-root compatibility path",
+);
+assert.match(
+  mirrorBlock,
+  /cp "public\/advisories\/ghsa-without-cve\.json\.sig" "\$MIRROR_LATEST_DIR\/ghsa-without-cve\.json\.sig"/,
+  "GHSA provisional feed signature must be mirrored at the release-root compatibility path",
+);

scripts/test-ghsa-poll-workflow.mjs

@@ -0,0 +1,37 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+
+const workflowPath = new URL('../.github/workflows/poll-ghsa-without-cve.yml', import.meta.url);
+const workflow = await readFile(workflowPath, 'utf8');
+
+assert.match(workflow, /workflow_dispatch:/, 'GHSA poll workflow must remain runnable as a manual fallback');
+assert.doesNotMatch(
+  workflow,
+  /\n\s+schedule:/,
+  'Scheduled GHSA consolidation belongs to the NVD workflow to avoid duplicate automated feed PRs',
+);
+assert.match(
+  workflow,
+  /FEED_PATH:\s+advisories\/feed\.json/,
+  'GHSA poll workflow must know the consolidated agent feed path',
+);
+assert.match(
+  workflow,
+  /SKILL_FEED_PATH:\s+skills\/clawsec-feed\/advisories\/feed\.json/,
+  'GHSA poll workflow must sync the consolidated agent feed into clawsec-feed',
+);
+assert.match(
+  workflow,
+  /--consolidated-feed "\$FEED_PATH"/,
+  'GHSA poll workflow must merge GHSA advisories into the agent-facing feed',
+);
+assert.match(
+  workflow,
+  /input_file: \$\{\{ env\.FEED_PATH \}\}/,
+  'GHSA poll workflow must sign the consolidated agent feed when it changes',
+);
+assert.match(
+  workflow,
+  /cp "\$FEED_SIG_PATH" "\$SKILL_FEED_SIG_PATH"/,
+  'GHSA poll workflow must sync consolidated feed signature into clawsec-feed',
+);

scripts/test-ghsa-without-cve-feed.mjs

@@ -0,0 +1,425 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  buildConsolidatedAdvisoryFeed,
+  buildGhsaWithoutCveFeed,
+  fetchGitHubSecurityAdvisories,
+  inferPlatforms,
+  normalizeGhsaAdvisory,
+} from './ghsa-without-cve-feed.mjs';
+
+const fixedNow = '2026-05-24T00:00:00Z';
+
+function advisory(overrides = {}) {
+  return {
+    ghsa_id: 'GHSA-test-1111-2222',
+    cve_id: null,
+    html_url: 'https://github.com/openclaw/openclaw/security/advisories/GHSA-test-1111-2222',
+    summary: 'Workspace bridge allows sandbox escape',
+    description: 'OpenClaw before 2026.4.25 allowed a sandbox escape.',
+    severity: 'high',
+    published_at: '2026-04-24T00:00:00Z',
+    updated_at: '2026-04-25T00:00:00Z',
+    vulnerabilities: [
+      {
+        package: { ecosystem: 'npm', name: 'openclaw' },
+        vulnerable_version_range: '<2026.4.25',
+        patched_versions: '2026.4.25',
+      },
+    ],
+    cvss: {
+      vector_string: 'CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H',
+      score: 7.8,
+    },
+    cwe_ids: ['CWE-94'],
+    credits: [{ login: 'researcher', type: 'reporter' }],
+    ...overrides,
+  };
+}
+
+test('inferPlatforms maps known repositories to feed platforms', () => {
+  assert.deepEqual(inferPlatforms('openclaw/openclaw'), ['openclaw']);
+  assert.deepEqual(inferPlatforms('qwibitai/nanoclaw'), ['nanoclaw']);
+  assert.deepEqual(inferPlatforms('softwarepub/hermes'), ['hermes']);
+  assert.deepEqual(inferPlatforms('sipeed/picoclaw'), ['picoclaw']);
+});
+
+test('fetchGitHubSecurityAdvisories follows cursor pagination links', async (t) => {
+  const originalFetch = globalThis.fetch;
+  const nextUrl =
+    'https://api.github.com/repositories/1103012935/security-advisories?per_page=100&after=cursor';
+  const calls = [];
+
+  globalThis.fetch = async (url) => {
+    calls.push(String(url));
+    if (calls.length === 1) {
+      return new globalThis.Response(
+        JSON.stringify(
+          Array.from({ length: 100 }, (_, index) =>
+            advisory({ ghsa_id: `GHSA-page-1111-${String(index).padStart(4, '0')}` }),
+          ),
+        ),
+        {
+          status: 200,
+          headers: {
+            Link: `<${nextUrl}>; rel="next"`,
+          },
+        },
+      );
+    }
+    if (String(url) !== nextUrl) {
+      throw new Error(`unexpected pagination URL: ${url}`);
+    }
+    return new globalThis.Response(JSON.stringify([advisory({ ghsa_id: 'GHSA-next-1111-2222' })]), {
+      status: 200,
+    });
+  };
+  t.after(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  const advisories = await fetchGitHubSecurityAdvisories('openclaw/openclaw', {
+    token: 'test-token',
+  });
+
+  assert.equal(calls.length, 2);
+  assert.equal(calls[1], nextUrl);
+  assert.equal(advisories.length, 101);
+  assert.equal(advisories.at(-1).ghsa_id, 'GHSA-next-1111-2222');
+});
+
+test('normalizeGhsaAdvisory marks fresh GHSA-only advisories active', () => {
+  const normalized = normalizeGhsaAdvisory(advisory(), {
+    now: fixedNow,
+    repository: 'openclaw/openclaw',
+    staleAfterDays: 60,
+  });
+
+  assert.equal(normalized.id, 'GHSA-test-1111-2222');
+  assert.equal(normalized.status, 'active');
+  assert.equal(normalized.cve_id, null);
+  assert.equal(normalized.stale, false);
+  assert.deepEqual(normalized.platforms, ['openclaw']);
+  assert.deepEqual(normalized.affected, ['openclaw@<2026.4.25']);
+});
+
+test('normalizeGhsaAdvisory marks old GHSA-only advisories stale after threshold', () => {
+  const normalized = normalizeGhsaAdvisory(
+    advisory({ published_at: '2026-03-01T00:00:00Z' }),
+    {
+      now: fixedNow,
+      repository: 'openclaw/openclaw',
+      staleAfterDays: 60,
+    },
+  );
+
+  assert.equal(normalized.status, 'stale');
+  assert.equal(normalized.stale, true);
+  assert.equal(normalized.cve_id, null);
+});
+
+test('normalizeGhsaAdvisory marks existing GHSA entries matured when a CVE appears', () => {
+  const normalized = normalizeGhsaAdvisory(
+    advisory({ cve_id: 'CVE-2026-9999' }),
+    {
+      now: fixedNow,
+      repository: 'openclaw/openclaw',
+      staleAfterDays: 60,
+    },
+  );
+
+  assert.equal(normalized.status, 'matured');
+  assert.equal(normalized.stale, false);
+  assert.equal(normalized.cve_id, 'CVE-2026-9999');
+  assert.equal(normalized.nvd_url, 'https://nvd.nist.gov/vuln/detail/CVE-2026-9999');
+});
+
+test('buildGhsaWithoutCveFeed only imports CVE-backed advisories that were already tracked', () => {
+  const existing = {
+    version: '0.1.0',
+    advisories: [
+      normalizeGhsaAdvisory(advisory({ ghsa_id: 'GHSA-old-1111-2222' }), {
+        now: '2026-04-25T00:00:00Z',
+        repository: 'openclaw/openclaw',
+        staleAfterDays: 60,
+      }),
+    ],
+  };
+  const fetched = [
+    {
+      repository: 'openclaw/openclaw',
+      advisories: [
+        advisory({ ghsa_id: 'GHSA-new-1111-2222', cve_id: null }),
+        advisory({ ghsa_id: 'GHSA-old-1111-2222', cve_id: 'CVE-2026-1111' }),
+        advisory({ ghsa_id: 'GHSA-cve-only-1111-2222', cve_id: 'CVE-2026-2222' }),
+      ],
+    },
+  ];
+
+  const feed = buildGhsaWithoutCveFeed({
+    fetched,
+    existingFeed: existing,
+    nvdFeed: { advisories: [] },
+    now: fixedNow,
+    staleAfterDays: 60,
+  });
+
+  assert.deepEqual(
+    feed.advisories.map((entry) => [entry.id, entry.status, entry.cve_id]),
+    [
+      ['GHSA-new-1111-2222', 'active', null],
+      ['GHSA-old-1111-2222', 'matured', 'CVE-2026-1111'],
+    ],
+  );
+});
+
+test('buildGhsaWithoutCveFeed matures tracked GHSAs when the CVE feed references them', () => {
+  const existing = {
+    version: '0.1.0',
+    advisories: [
+      normalizeGhsaAdvisory(advisory({ ghsa_id: 'GHSA-oooo-3333-4444' }), {
+        now: '2026-04-25T00:00:00Z',
+        repository: 'openclaw/openclaw',
+        staleAfterDays: 60,
+      }),
+    ],
+  };
+  const feed = buildGhsaWithoutCveFeed({
+    fetched: [
+      {
+        repository: 'openclaw/openclaw',
+        advisories: [advisory({ ghsa_id: 'GHSA-oooo-3333-4444', cve_id: null })],
+      },
+    ],
+    existingFeed: existing,
+    nvdFeed: {
+      advisories: [
+        {
+          id: 'CVE-2026-3333',
+          references: [
+            'https://github.com/openclaw/openclaw/security/advisories/GHSA-oooo-3333-4444',
+          ],
+        },
+      ],
+    },
+    now: fixedNow,
+    staleAfterDays: 60,
+  });
+
+  assert.equal(feed.advisories[0].status, 'matured');
+  assert.equal(feed.advisories[0].cve_id, 'CVE-2026-3333');
+});
+
+test('buildConsolidatedAdvisoryFeed appends active GHSA advisories without moving the NVD poll cursor', () => {
+  const canonicalFeed = {
+    version: '1.0.0',
+    updated: '2026-05-23T00:00:00Z',
+    description: 'Community-driven security advisory feed for ClawSec',
+    advisories: [
+      {
+        id: 'CVE-2026-1111',
+        severity: 'high',
+        type: 'os_command_injection',
+        title: 'Existing CVE',
+        description: 'Existing CVE advisory',
+        affected: ['openclaw@*'],
+        platforms: ['openclaw'],
+        action: 'Review NVD.',
+        published: '2026-05-01T00:00:00Z',
+      },
+    ],
+  };
+  const ghsaFeed = {
+    advisories: [
+      normalizeGhsaAdvisory(advisory({ ghsa_id: 'GHSA-active-1111-2222', cve_id: null }), {
+        now: fixedNow,
+        repository: 'openclaw/openclaw',
+        staleAfterDays: 60,
+      }),
+    ],
+  };
+
+  const consolidated = buildConsolidatedAdvisoryFeed({
+    canonicalFeed,
+    ghsaFeed,
+    now: fixedNow,
+  });
+
+  assert.deepEqual(
+    consolidated.advisories.map((entry) => entry.id),
+    ['CVE-2026-1111', 'GHSA-active-1111-2222'],
+  );
+  assert.equal(consolidated.updated, canonicalFeed.updated);
+  assert.equal(consolidated.advisories[1].source_feed, 'ghsa-without-cve');
+});
+
+test('buildConsolidatedAdvisoryFeed keeps existing GHSA advisories when replacement feed is empty', () => {
+  const canonicalFeed = {
+    version: '1.0.0',
+    updated: '2026-05-23T00:00:00Z',
+    advisories: [
+      {
+        id: 'CVE-2026-1111',
+        published: '2026-05-01T00:00:00Z',
+      },
+      {
+        id: 'GHSA-keep-1111-2222',
+        ghsa_id: 'GHSA-keep-1111-2222',
+        status: 'active',
+        published: '2026-05-02T00:00:00Z',
+        source_feed: 'ghsa-without-cve',
+      },
+    ],
+  };
+
+  const consolidated = buildConsolidatedAdvisoryFeed({
+    canonicalFeed,
+    ghsaFeed: { advisories: [] },
+    now: fixedNow,
+  });
+
+  assert.deepEqual(
+    consolidated.advisories.map((entry) => entry.id),
+    ['GHSA-keep-1111-2222', 'CVE-2026-1111'],
+  );
+});
+
+test('buildConsolidatedAdvisoryFeed replaces only matching GHSA canonical entries', () => {
+  const canonicalFeed = {
+    version: '1.0.0',
+    updated: '2026-05-23T00:00:00Z',
+    advisories: [
+      {
+        id: 'GHSA-repl-1111-2222',
+        ghsa_id: 'GHSA-repl-1111-2222',
+        status: 'active',
+        title: 'Old GHSA payload',
+        published: '2026-05-01T00:00:00Z',
+        source_feed: 'ghsa-without-cve',
+      },
+      {
+        id: 'GHSA-keep-3333-4444',
+        ghsa_id: 'GHSA-keep-3333-4444',
+        status: 'active',
+        title: 'Retained GHSA payload',
+        published: '2026-05-02T00:00:00Z',
+        source_feed: 'ghsa-without-cve',
+      },
+    ],
+  };
+  const ghsaFeed = {
+    advisories: [
+      {
+        id: 'GHSA-repl-1111-2222',
+        ghsa_id: 'GHSA-repl-1111-2222',
+        status: 'stale',
+        title: 'Replacement GHSA payload',
+        published: '2026-05-03T00:00:00Z',
+      },
+    ],
+  };
+
+  const consolidated = buildConsolidatedAdvisoryFeed({
+    canonicalFeed,
+    ghsaFeed,
+    now: fixedNow,
+  });
+
+  assert.deepEqual(
+    consolidated.advisories.map((entry) => [entry.id, entry.title, entry.status]),
+    [
+      ['GHSA-repl-1111-2222', 'Replacement GHSA payload', 'stale'],
+      ['GHSA-keep-3333-4444', 'Retained GHSA payload', 'active'],
+    ],
+  );
+});
+
+test('buildConsolidatedAdvisoryFeed drops GHSA duplicate when matching CVE is present', () => {
+  const canonicalFeed = {
+    version: '1.0.0',
+    updated: '2026-05-23T00:00:00Z',
+    advisories: [
+      {
+        id: 'CVE-2026-2222',
+        severity: 'high',
+        type: 'code_injection',
+        title: 'Canonical CVE',
+        description: 'Canonical CVE advisory',
+        affected: ['openclaw@*'],
+        platforms: ['openclaw'],
+        action: 'Review NVD.',
+        published: '2026-05-02T00:00:00Z',
+      },
+      {
+        id: 'GHSA-old-duplicate',
+        ghsa_id: 'GHSA-old-duplicate',
+        cve_id: 'CVE-2026-2222',
+        status: 'matured',
+        source_feed: 'ghsa-without-cve',
+        severity: 'high',
+        type: 'github_security_advisory',
+        title: 'Old duplicate',
+        description: 'Old provisional duplicate',
+        affected: ['openclaw@*'],
+        platforms: ['openclaw'],
+        action: 'Track CVE.',
+        published: '2026-05-01T00:00:00Z',
+      },
+    ],
+  };
+  const ghsaFeed = {
+    advisories: [
+      normalizeGhsaAdvisory(
+        advisory({ ghsa_id: 'GHSA-new-duplicate', cve_id: 'CVE-2026-2222' }),
+        {
+          now: fixedNow,
+          repository: 'openclaw/openclaw',
+          staleAfterDays: 60,
+        },
+      ),
+    ],
+  };
+
+  const consolidated = buildConsolidatedAdvisoryFeed({
+    canonicalFeed,
+    ghsaFeed,
+    now: fixedNow,
+  });
+
+  assert.deepEqual(
+    consolidated.advisories.map((entry) => entry.id),
+    ['CVE-2026-2222'],
+  );
+});
+
+test('buildConsolidatedAdvisoryFeed keeps matured GHSA until CVE lands in canonical feed', () => {
+  const canonicalFeed = {
+    version: '1.0.0',
+    updated: '2026-05-23T00:00:00Z',
+    advisories: [],
+  };
+  const ghsaFeed = {
+    advisories: [
+      normalizeGhsaAdvisory(
+        advisory({ ghsa_id: 'GHSA-matured-1111-2222', cve_id: 'CVE-2026-4444' }),
+        {
+          now: fixedNow,
+          repository: 'openclaw/openclaw',
+          staleAfterDays: 60,
+        },
+      ),
+    ],
+  };
+
+  const consolidated = buildConsolidatedAdvisoryFeed({
+    canonicalFeed,
+    ghsaFeed,
+    now: fixedNow,
+  });
+
+  assert.deepEqual(
+    consolidated.advisories.map((entry) => [entry.id, entry.status, entry.cve_id]),
+    [['GHSA-matured-1111-2222', 'matured', 'CVE-2026-4444']],
+  );
+});

scripts/test-github-traffic-archive.mjs

@@ -0,0 +1,276 @@
+import assert from 'node:assert/strict';
+import { mkdtemp, readdir, readFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import {
+  buildTrafficSummary,
+  fetchGitHubTraffic,
+  mergeTrafficArchive,
+  writeJson,
+} from './archive-github-traffic.mjs';
+
+const TEST_REPOSITORY = 'prompt-security/clawsec';
+const TEST_CAPTURE_DATE = Date.UTC(2026, 5, 3);
+
+const utcDay = (offsetFromCaptureDate = 0) => {
+  const date = new Date(TEST_CAPTURE_DATE);
+  date.setUTCDate(date.getUTCDate() + offsetFromCaptureDate);
+  return `${date.toISOString().slice(0, 10)}T00:00:00Z`;
+};
+
+const captureAt = ({
+  offsetFromCaptureDate = 0,
+  hour = 3,
+  minute = 17,
+} = {}) => {
+  const date = new Date(TEST_CAPTURE_DATE);
+  date.setUTCDate(date.getUTCDate() + offsetFromCaptureDate);
+  date.setUTCHours(hour, minute, 0, 0);
+  return date.toISOString();
+};
+
+const capturedAt = captureAt();
+
+test('fetchGitHubTraffic requests the daily GitHub traffic endpoints with auth', async () => {
+  const calls = [];
+  const responses = {
+    [`/repos/${TEST_REPOSITORY}/traffic/views?per=day`]: {
+      count: 30,
+      uniques: 18,
+      views: [{ timestamp: utcDay(-1), count: 30, uniques: 18 }],
+    },
+    [`/repos/${TEST_REPOSITORY}/traffic/clones?per=day`]: {
+      count: 7,
+      uniques: 5,
+      clones: [{ timestamp: utcDay(-1), count: 7, uniques: 5 }],
+    },
+    [`/repos/${TEST_REPOSITORY}/traffic/popular/referrers`]: [
+      { referrer: 'github.com', count: 12, uniques: 9 },
+    ],
+    [`/repos/${TEST_REPOSITORY}/traffic/popular/paths`]: [
+      { path: `/${TEST_REPOSITORY}`, title: TEST_REPOSITORY, count: 16, uniques: 10 },
+    ],
+  };
+
+  const fetchImpl = async (url, options) => {
+    calls.push({ url: String(url), headers: options.headers });
+    const pathname = new URL(url).pathname;
+    const search = new URL(url).search;
+    const payload = responses[`${pathname}${search}`];
+    assert.ok(payload, `unexpected traffic endpoint: ${pathname}${search}`);
+    return new globalThis.Response(JSON.stringify(payload), { status: 200 });
+  };
+
+  const snapshot = await fetchGitHubTraffic({
+    repo: TEST_REPOSITORY,
+    token: 'test-token',
+    capturedAt,
+    fetchImpl,
+  });
+
+  assert.equal(calls.length, 4);
+  assert.ok(calls.every((call) => call.headers.Authorization === 'Bearer test-token'));
+  assert.deepEqual(snapshot.views.views, responses[`/repos/${TEST_REPOSITORY}/traffic/views?per=day`].views);
+  assert.deepEqual(snapshot.clones.clones, responses[`/repos/${TEST_REPOSITORY}/traffic/clones?per=day`].clones);
+});
+
+test('fetchGitHubTraffic explains traffic token requirements on 403', async () => {
+  const fetchImpl = async () => new globalThis.Response(
+    JSON.stringify({ message: 'Resource not accessible by integration' }),
+    { status: 403 },
+  );
+
+  await assert.rejects(
+    fetchGitHubTraffic({
+      repo: TEST_REPOSITORY,
+      token: 'installation-token',
+      capturedAt,
+      fetchImpl,
+    }),
+    /returned 403\..*push access/,
+  );
+});
+
+test('fetchGitHubTraffic flags invalid tokens on 401', async () => {
+  const fetchImpl = async () => new globalThis.Response(
+    JSON.stringify({ message: 'Bad credentials' }),
+    { status: 401 },
+  );
+
+  await assert.rejects(
+    fetchGitHubTraffic({
+      repo: TEST_REPOSITORY,
+      token: 'expired-token',
+      capturedAt,
+      fetchImpl,
+    }),
+    /returned 401\..*expired or revoked/,
+  );
+});
+
+test('mergeTrafficArchive upserts daily views and clones without double-counting overlapping windows', () => {
+  const archive = mergeTrafficArchive(
+    {
+      version: 1,
+      repository: TEST_REPOSITORY,
+      updated_at: captureAt({ offsetFromCaptureDate: -1 }),
+      daily: {
+        views: [
+          { timestamp: utcDay(-2), count: 10, uniques: 6 },
+          { timestamp: utcDay(-1), count: 20, uniques: 12 },
+        ],
+        clones: [
+          { timestamp: utcDay(-2), count: 2, uniques: 1 },
+        ],
+      },
+      snapshots: {
+        referrers: [],
+        paths: [],
+      },
+      captures: [],
+    },
+    {
+      repository: TEST_REPOSITORY,
+      captured_at: capturedAt,
+      views: {
+        views: [
+          { timestamp: utcDay(-1), count: 25, uniques: 14 },
+          { timestamp: utcDay(), count: 35, uniques: 21 },
+        ],
+      },
+      clones: {
+        clones: [
+          { timestamp: utcDay(-1), count: 3, uniques: 2 },
+          { timestamp: utcDay(), count: 5, uniques: 4 },
+        ],
+      },
+      referrers: [{ referrer: 'github.com', count: 12, uniques: 9 }],
+      paths: [{ path: `/${TEST_REPOSITORY}`, title: TEST_REPOSITORY, count: 16, uniques: 10 }],
+    },
+  );
+
+  assert.deepEqual(archive.daily.views, [
+    { timestamp: utcDay(-2), count: 10, uniques: 6 },
+    { timestamp: utcDay(-1), count: 25, uniques: 14 },
+    { timestamp: utcDay(), count: 35, uniques: 21 },
+  ]);
+  assert.deepEqual(archive.daily.clones, [
+    { timestamp: utcDay(-2), count: 2, uniques: 1 },
+    { timestamp: utcDay(-1), count: 3, uniques: 2 },
+    { timestamp: utcDay(), count: 5, uniques: 4 },
+  ]);
+});
+
+test('mergeTrafficArchive keeps one referrer/path snapshot per capture date', () => {
+  const first = mergeTrafficArchive(undefined, {
+    repository: TEST_REPOSITORY,
+    captured_at: capturedAt,
+    views: { views: [] },
+    clones: { clones: [] },
+    referrers: [{ referrer: 'github.com', count: 12, uniques: 9 }],
+    paths: [{ path: `/${TEST_REPOSITORY}`, title: TEST_REPOSITORY, count: 16, uniques: 10 }],
+  });
+
+  const second = mergeTrafficArchive(first, {
+    repository: TEST_REPOSITORY,
+    captured_at: captureAt({ hour: 4, minute: 0 }),
+    views: { views: [] },
+    clones: { clones: [] },
+    referrers: [{ referrer: 'google.com', count: 8, uniques: 6 }],
+    paths: [{ path: `/${TEST_REPOSITORY}/wiki`, title: 'Wiki', count: 11, uniques: 7 }],
+  });
+
+  assert.equal(second.snapshots.referrers.length, 1);
+  assert.equal(second.snapshots.paths.length, 1);
+  assert.deepEqual(second.snapshots.referrers[0].entries, [
+    { referrer: 'google.com', count: 8, uniques: 6 },
+  ]);
+  assert.deepEqual(second.snapshots.paths[0].entries, [
+    { path: `/${TEST_REPOSITORY}/wiki`, title: 'Wiki', count: 11, uniques: 7 },
+  ]);
+});
+
+test('mergeTrafficArchive rejects blank referrer and path fields instead of archiving empty strings', () => {
+  assert.throws(
+    () => mergeTrafficArchive(undefined, {
+      repository: TEST_REPOSITORY,
+      captured_at: capturedAt,
+      views: { views: [] },
+      clones: { clones: [] },
+      referrers: [{ count: 12, uniques: 9 }],
+      paths: [],
+    }),
+    /referrers\.referrer must be a non-empty string/,
+  );
+
+  assert.throws(
+    () => mergeTrafficArchive(undefined, {
+      repository: TEST_REPOSITORY,
+      captured_at: capturedAt,
+      views: { views: [] },
+      clones: { clones: [] },
+      referrers: [],
+      paths: [{ path: `/${TEST_REPOSITORY}`, title: ' ', count: 16, uniques: 10 }],
+    }),
+    /paths\.title must be a non-empty string/,
+  );
+});
+
+test('writeJson replaces JSON through a same-directory temporary file', async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), 'clawsec-traffic-json-'));
+  const file = path.join(dir, 'summary.json');
+
+  await writeJson(file, { version: 1, count: 1 });
+  await writeJson(file, { version: 1, count: 2 });
+
+  assert.equal(await readFile(file, 'utf8'), '{\n  "version": 1,\n  "count": 2\n}\n');
+  assert.deepEqual(await readdir(dir), ['summary.json']);
+});
+
+test('buildTrafficSummary reports count totals and labels summed daily uniques accurately', () => {
+  const archive = mergeTrafficArchive(undefined, {
+    repository: TEST_REPOSITORY,
+    captured_at: capturedAt,
+    views: {
+      views: [
+        { timestamp: utcDay(-33), count: 100, uniques: 80 },
+        { timestamp: utcDay(-1), count: 30, uniques: 18 },
+        { timestamp: utcDay(), count: 40, uniques: 22 },
+      ],
+    },
+    clones: {
+      clones: [
+        { timestamp: utcDay(-1), count: 7, uniques: 5 },
+        { timestamp: utcDay(), count: 9, uniques: 6 },
+      ],
+    },
+    referrers: [],
+    paths: [],
+  });
+
+  const summary = buildTrafficSummary(archive, { now: captureAt({ hour: 12, minute: 0 }) });
+
+  assert.equal(summary.metrics.views.last_30_days.count, 70);
+  assert.equal(summary.metrics.views.last_30_days.sum_daily_uniques, 40);
+  assert.equal(summary.metrics.views.last_30_days.unique_semantics, 'sum_of_daily_uniques');
+  assert.equal(summary.metrics.views.all_time.count, 170);
+  assert.equal(summary.metrics.clones.last_30_days.count, 16);
+  assert.equal(summary.daily.views.length, 3);
+});
+
+test('traffic archive workflow uses a daily schedule and a dedicated archive branch', async () => {
+  const workflowPath = new URL('../.github/workflows/archive-traffic.yml', import.meta.url);
+  const workflow = await readFile(workflowPath, 'utf8');
+
+  assert.match(workflow, /cron:\s+'17 3 \* \* \*'/);
+  assert.match(workflow, /TRAFFIC_ARCHIVE_BRANCH:\s+traffic-archive/);
+  assert.match(workflow, /GH_TRAFFIC_TOKEN:\s*\$\{\{\s*secrets\.TRAFFIC_ARCHIVE_TOKEN\b/);
+  assert.doesNotMatch(workflow, /GH_TRAFFIC_TOKEN:[^\n]*github\.token/);
+  assert.match(workflow, /node scripts\/archive-github-traffic\.mjs/);
+  assert.match(workflow, /git add traffic\/archive\.json traffic\/summary\.json/);
+  assert.match(workflow, /git rm --ignore-unmatch traffic\/README\.md/);
+  assert.doesNotMatch(workflow, /git add .*traffic\/README\.md/);
+  assert.match(workflow, /git push origin HEAD:\$\{TRAFFIC_ARCHIVE_BRANCH\}/);
+});

scripts/test-nvd-ghsa-consolidation-workflow.mjs

@@ -0,0 +1,98 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+
+const workflowPath = new URL('../.github/workflows/poll-nvd-cves.yml', import.meta.url);
+const workflow = await readFile(workflowPath, 'utf8');
+const ciWorkflowPath = new URL('../.github/workflows/ci.yml', import.meta.url);
+const ciWorkflow = await readFile(ciWorkflowPath, 'utf8');
+
+function requiredIndex(snippet, message) {
+  const index = workflow.indexOf(snippet);
+  assert.notEqual(index, -1, message);
+  return index;
+}
+
+assert.match(
+  workflow,
+  /GHSA_FEED_PATH:\s+advisories\/ghsa-without-cve\.json/,
+  'NVD workflow must write the provisional GHSA source feed',
+);
+assert.match(
+  workflow,
+  /GHSA_FEED_SIG_PATH:\s+advisories\/ghsa-without-cve\.json\.sig/,
+  'NVD workflow must sign the provisional GHSA source feed',
+);
+assert.match(
+  workflow,
+  /node scripts\/ghsa-without-cve-feed\.mjs[\s\S]*--output "\$GHSA_FEED_PATH"[\s\S]*--consolidated-feed "\$FEED_PATH"[\s\S]*--existing-feed "\$GHSA_FEED_PATH"[\s\S]*--nvd-feed "\$FEED_PATH"/,
+  'NVD workflow must merge GHSA advisories into the signed agent feed',
+);
+assert.match(
+  workflow,
+  /id: feed_changes[\s\S]*ghsa_changed=\$GHSA_CHANGED[\s\S]*agent_changed=\$AGENT_CHANGED[\s\S]*changed=true/,
+  'NVD workflow must detect GHSA and consolidated agent feed changes separately',
+);
+assert.match(
+  workflow,
+  /if: steps\.feed_changes\.outputs\.ghsa_changed == 'true'[\s\S]*input_file: \$\{\{ env\.GHSA_FEED_PATH \}\}[\s\S]*signature_file: \$\{\{ env\.GHSA_FEED_SIG_PATH \}\}/,
+  'NVD workflow must sign the provisional GHSA feed when it changes',
+);
+assert.match(
+  workflow,
+  /if: steps\.feed_changes\.outputs\.agent_changed == 'true'[\s\S]*input_file: \$\{\{ env\.FEED_PATH \}\}[\s\S]*signature_file: \$\{\{ env\.FEED_SIG_PATH \}\}/,
+  'NVD workflow must sign the consolidated agent feed when it changes',
+);
+assert.match(
+  workflow,
+  /git add "\$FEED_PATH" "\$FEED_SIG_PATH" "\$GHSA_FEED_PATH" "\$GHSA_FEED_SIG_PATH" "\$SKILL_FEED_PATH" "\$SKILL_FEED_SIG_PATH"/,
+  'NVD workflow PR must include both NVD and GHSA feed artifacts',
+);
+assert.doesNotMatch(
+  workflow,
+  /gh run list[\s\S]*--jq --arg/,
+  'CodeQL run lookup must not pass jq CLI flags through gh --jq',
+);
+assert.match(
+  workflow,
+  /gh run list[\s\S]*--json databaseId,createdAt,headSha \\\s*\n\s+\| jq -r --arg since "\$DISPATCHED_AT" --arg sha "\$EXPECTED_HEAD_SHA"/,
+  'CodeQL run lookup must filter the gh JSON output with jq variables',
+);
+assert.match(
+  ciWorkflow,
+  /name: NVD \+ GHSA Pipeline Dry Run[\s\S]*node scripts\/test-nvd-ghsa-pipeline-dry-run\.mjs/,
+  'CI must run the deterministic NVD + GHSA pipeline dry run before merge',
+);
+
+const updateFeedIndex = requiredIndex('name: Update feed.json', 'NVD workflow must update the CVE feed first');
+const pollGhsaIndex = requiredIndex(
+  'name: Poll GHSA without CVE and consolidate feed',
+  'NVD workflow must poll GHSA before signing',
+);
+const detectChangesIndex = requiredIndex(
+  'name: Detect advisory feed changes',
+  'NVD workflow must detect combined feed changes before signing',
+);
+const signGhsaIndex = requiredIndex(
+  'name: Sign GHSA feed and verify',
+  'NVD workflow must sign the GHSA source feed',
+);
+const signAgentIndex = requiredIndex(
+  'name: Sign advisory feed and verify',
+  'NVD workflow must sign the consolidated agent feed',
+);
+const upsertPrIndex = requiredIndex(
+  'name: Upsert NVD advisory PR',
+  'NVD workflow must upsert a PR for any feed change',
+);
+
+assert.ok(
+  updateFeedIndex < pollGhsaIndex,
+  'GHSA consolidation must run after the NVD update step so matured advisories can reconcile against new CVEs',
+);
+assert.ok(
+  pollGhsaIndex < detectChangesIndex,
+  'Combined feed change detection must run after GHSA consolidation',
+);
+assert.ok(detectChangesIndex < signGhsaIndex, 'GHSA signing must run after change detection');
+assert.ok(detectChangesIndex < signAgentIndex, 'Agent feed signing must run after change detection');
+assert.ok(signAgentIndex < upsertPrIndex, 'The PR must be created after feed signing');

scripts/test-nvd-ghsa-pipeline-dry-run.mjs

@@ -0,0 +1,187 @@
+import assert from 'node:assert/strict';
+import { generateKeyPairSync, sign, verify } from 'node:crypto';
+import { mkdtemp, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import {
+  buildConsolidatedAdvisoryFeed,
+  buildGhsaWithoutCveFeed,
+  normalizeGhsaAdvisory,
+} from './ghsa-without-cve-feed.mjs';
+
+const now = '2026-05-24T00:00:00Z';
+
+function cveAdvisory(overrides = {}) {
+  return {
+    id: 'CVE-2026-1111',
+    severity: 'high',
+    type: 'code_injection',
+    title: 'OpenClaw command execution advisory',
+    description: 'OpenClaw allowed unsafe tool execution in a guarded workspace.',
+    affected: ['openclaw@<2026.5.20'],
+    patched: ['openclaw@2026.5.20'],
+    platforms: ['openclaw'],
+    action: 'Update OpenClaw and verify guarded workspace execution.',
+    published: '2026-05-01T00:00:00Z',
+    updated: '2026-05-01T00:00:00Z',
+    references: ['https://nvd.nist.gov/vuln/detail/CVE-2026-1111'],
+    nvd_url: 'https://nvd.nist.gov/vuln/detail/CVE-2026-1111',
+    ...overrides,
+  };
+}
+
+function ghsaAdvisory(overrides = {}) {
+  return {
+    ghsa_id: 'GHSA-actv-1111-2222',
+    cve_id: null,
+    html_url: 'https://github.com/openclaw/openclaw/security/advisories/GHSA-actv-1111-2222',
+    summary: 'OpenClaw advisory without CVE',
+    description: 'OpenClaw published a public GitHub advisory before CVE assignment.',
+    severity: 'high',
+    published_at: '2026-05-20T00:00:00Z',
+    updated_at: '2026-05-21T00:00:00Z',
+    vulnerabilities: [
+      {
+        package: { ecosystem: 'npm', name: 'openclaw' },
+        vulnerable_version_range: '<2026.5.21',
+        patched_versions: '2026.5.21',
+      },
+    ],
+    cvss: {
+      vector_string: 'CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H',
+      score: 7.8,
+    },
+    cwe_ids: ['CWE-94'],
+    credits: [{ login: 'security-researcher', type: 'reporter' }],
+    ...overrides,
+  };
+}
+
+function signBuffer(data, privateKey) {
+  return sign(null, data, privateKey).toString('base64');
+}
+
+function verifySignature(data, signature, publicKey) {
+  return verify(null, data, publicKey, Buffer.from(signature, 'base64'));
+}
+
+async function writeJson(filePath, value) {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+const tempDir = await mkdtemp(path.join(tmpdir(), 'clawsec-nvd-ghsa-ci-dry-run-'));
+const canonicalFeedPath = path.join(tempDir, 'advisories/feed.json');
+const ghsaFeedPath = path.join(tempDir, 'advisories/ghsa-without-cve.json');
+const skillFeedPath = path.join(tempDir, 'skills/clawsec-feed/advisories/feed.json');
+
+const existingCanonicalFeed = {
+  version: '1.0.0',
+  updated: '2026-05-23T00:00:00Z',
+  description: 'Community-driven security advisory feed for ClawSec',
+  advisories: [
+    cveAdvisory({
+      id: 'CVE-2026-1111',
+      references: [
+        'https://nvd.nist.gov/vuln/detail/CVE-2026-1111',
+        'https://github.com/openclaw/openclaw/security/advisories/GHSA-matd-1111-2222',
+      ],
+    }),
+  ],
+};
+const nvdPollResultFeed = {
+  ...existingCanonicalFeed,
+  updated: now,
+  advisories: [
+    cveAdvisory({
+      id: 'CVE-2026-2222',
+      title: 'Fresh NVD advisory from the poll window',
+      published: '2026-05-24T00:00:00Z',
+      updated: '2026-05-24T00:00:00Z',
+      references: [
+        'https://nvd.nist.gov/vuln/detail/CVE-2026-2222',
+        'https://github.com/openclaw/openclaw/security/advisories/GHSA-cvea-1111-2222',
+      ],
+      nvd_url: 'https://nvd.nist.gov/vuln/detail/CVE-2026-2222',
+    }),
+    ...existingCanonicalFeed.advisories,
+  ],
+};
+const existingGhsaFeed = {
+  version: '0.1.0',
+  updated: '2026-05-20T00:00:00Z',
+  advisories: [
+    normalizeGhsaAdvisory(ghsaAdvisory({ ghsa_id: 'GHSA-matd-1111-2222' }), {
+      now: '2026-05-20T00:00:00Z',
+      repository: 'openclaw/openclaw',
+      staleAfterDays: 60,
+    }),
+  ],
+};
+const fetchedGhsaAdvisories = [
+  {
+    repository: 'openclaw/openclaw',
+    advisories: [
+      ghsaAdvisory({ ghsa_id: 'GHSA-actv-1111-2222' }),
+      ghsaAdvisory({ ghsa_id: 'GHSA-matd-1111-2222' }),
+      ghsaAdvisory({ ghsa_id: 'GHSA-cvea-1111-2222', cve_id: 'CVE-2026-2222' }),
+    ],
+  },
+];
+
+const ghsaFeed = buildGhsaWithoutCveFeed({
+  fetched: fetchedGhsaAdvisories,
+  existingFeed: existingGhsaFeed,
+  nvdFeed: nvdPollResultFeed,
+  now,
+  staleAfterDays: 60,
+});
+assert.deepEqual(
+  ghsaFeed.advisories.map((entry) => [entry.id, entry.status, entry.cve_id]),
+  [
+    ['GHSA-actv-1111-2222', 'active', null],
+    ['GHSA-matd-1111-2222', 'matured', 'CVE-2026-1111'],
+  ],
+  'GHSA dry run should retain active GHSA-only advisories and mature tracked GHSAs',
+);
+
+const consolidatedFeed = buildConsolidatedAdvisoryFeed({
+  canonicalFeed: nvdPollResultFeed,
+  ghsaFeed,
+  now,
+});
+assert.deepEqual(
+  consolidatedFeed.advisories.map((entry) => entry.id),
+  ['CVE-2026-2222', 'GHSA-actv-1111-2222', 'CVE-2026-1111'],
+  'Consolidated feed should include NVD CVEs plus active GHSA-only advisories without duplicate matured GHSAs',
+);
+assert.equal(consolidatedFeed.advisories[1].source_feed, 'ghsa-without-cve');
+assert.equal(consolidatedFeed.updated, nvdPollResultFeed.updated);
+
+await writeJson(canonicalFeedPath, consolidatedFeed);
+await writeJson(ghsaFeedPath, ghsaFeed);
+await writeJson(skillFeedPath, consolidatedFeed);
+
+const { privateKey, publicKey } = generateKeyPairSync('ed25519');
+const canonicalFeedBytes = await readFile(canonicalFeedPath);
+const ghsaFeedBytes = await readFile(ghsaFeedPath);
+const skillFeedBytes = await readFile(skillFeedPath);
+const canonicalSignature = signBuffer(canonicalFeedBytes, privateKey);
+const ghsaSignature = signBuffer(ghsaFeedBytes, privateKey);
+
+await writeFile(`${canonicalFeedPath}.sig`, `${canonicalSignature}\n`);
+await writeFile(`${ghsaFeedPath}.sig`, `${ghsaSignature}\n`);
+await writeFile(`${skillFeedPath}.sig`, `${canonicalSignature}\n`);
+
+assert.deepEqual(skillFeedBytes, canonicalFeedBytes, 'skill advisory feed must match the signed agent feed');
+assert.ok(
+  verifySignature(canonicalFeedBytes, canonicalSignature, publicKey),
+  'canonical consolidated feed signature must verify',
+);
+assert.ok(verifySignature(skillFeedBytes, canonicalSignature, publicKey), 'skill feed signature must verify');
+assert.ok(verifySignature(ghsaFeedBytes, ghsaSignature, publicKey), 'GHSA source feed signature must verify');
+
+console.log(
+  `NVD + GHSA dry run passed: ${consolidatedFeed.advisories.length} consolidated advisories, ${ghsaFeed.advisories.length} GHSA source advisories, signatures verified.`,
+);

scripts/test-skill-clawhub-slug.mjs

@@ -0,0 +1,45 @@
+import assert from "node:assert/strict";
+import { resolveClawHubSlug } from "./ci/resolve_clawhub_slug.mjs";
+import { collectDeclaredPlatforms, installAgentForSkill } from "./ci/skill_platforms.mjs";
+
+const cases = [
+  ["openclaw-traffic-guardian", ["openclaw"], "clawsec-openclaw-traffic-guardian"],
+  ["openclaw-audit-watchdog", ["openclaw"], "clawsec-openclaw-audit-watchdog"],
+  ["soul-guardian", ["openclaw"], "clawsec-openclaw-soul-guardian"],
+  ["hermes-attestation-guardian", ["hermes"], "clawsec-hermes-attestation-guardian"],
+  ["hermes-traffic-guardian", ["hermes"], "clawsec-hermes-traffic-guardian"],
+  ["nanoclaw-traffic-guardian", ["nanoclaw"], "clawsec-nanoclaw-traffic-guardian"],
+  ["picoclaw-security-guardian", ["picoclaw"], "clawsec-picoclaw-security-guardian"],
+  ["picoclaw-self-pen-testing", ["picoclaw"], "clawsec-picoclaw-self-pen-testing"],
+  ["picoclaw-traffic-guardian", ["picoclaw"], "clawsec-picoclaw-traffic-guardian"],
+  ["clawtributor", ["openclaw", "nanoclaw", "hermes", "picoclaw"], "clawsec-clawtributor"],
+  ["clawsec-feed", ["openclaw"], "clawsec-feed"],
+  ["clawsec-suite", ["openclaw"], "clawsec-suite"],
+];
+
+for (const [name, platforms, expected] of cases) {
+  assert.equal(resolveClawHubSlug({ name, platforms }), expected, `${name} should map to ${expected}`);
+  assert.equal(resolveClawHubSlug({ name }), expected, `${name} should map to ${expected} without metadata`);
+}
+
+assert.throws(
+  () => resolveClawHubSlug({ name: "../openclaw-traffic-guardian", platforms: ["openclaw"] }),
+  /Invalid skill name/,
+  "unsafe skill names must be rejected",
+);
+
+assert.deepEqual(
+  collectDeclaredPlatforms({
+    platform: "openclaw",
+    platforms: ["hermes", "openclaw", ""],
+    picoclaw: { requires: {} },
+  }),
+  ["openclaw", "hermes", "picoclaw"],
+  "declared platform parsing should combine legacy fields, arrays, and platform metadata keys",
+);
+
+assert.equal(
+  installAgentForSkill({ platform: "hermes" }, new Set(["codex", "hermes-agent", "openclaw"])),
+  "hermes-agent",
+  "install agent selection should reuse platform aliases",
+);

scripts/test-skill-install-docs.mjs

@@ -0,0 +1,137 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+const validator = "scripts/ci/validate_skill_install_docs.mjs";
+const workflow = await readFile(".github/workflows/skill-release.yml", "utf8");
+const tempRoot = await mkdtemp(path.join(tmpdir(), "clawsec-install-docs-"));
+const agentTypesPath = path.join(tempRoot, "vercel-types.ts");
+
+function runValidator(args) {
+  return spawnSync(
+    process.execPath,
+    [validator, "--root", tempRoot, "--agent-types-file", agentTypesPath, ...args],
+    {
+      encoding: "utf8",
+    },
+  );
+}
+
+async function writeSkill({ name, metadata, readme, skillMd }) {
+  const skillDir = path.join(tempRoot, "skills", name);
+  await mkdir(skillDir, { recursive: true });
+  await writeFile(
+    path.join(skillDir, "skill.json"),
+    JSON.stringify(
+      {
+        name,
+        version: "1.0.0",
+        description: `${name} test skill`,
+        license: "AGPL-3.0-or-later",
+        ...metadata,
+      },
+      null,
+      2,
+    ),
+  );
+  await writeFile(path.join(skillDir, "README.md"), readme);
+  await writeFile(path.join(skillDir, "SKILL.md"), skillMd);
+}
+
+try {
+  await writeFile(
+    agentTypesPath,
+    "export type AgentType = | 'codex' | 'hermes-agent' | 'openclaw' | 'universal';\n",
+  );
+
+  await writeSkill({
+    name: "hermes-example",
+    metadata: { hermes: { category: "security" } },
+    readme: "# Hermes Example\n\n## Installation\n\nMissing the Skills CLI command.\n",
+    skillMd: "---\nname: hermes-example\nversion: 1.0.0\n---\n\n## Installation\n\nMissing the Skills CLI command.\n",
+  });
+
+  const missingHermes = runValidator(["--skills", "skills/hermes-example"]);
+  assert.equal(missingHermes.status, 1, "missing Hermes install docs must fail validation");
+  assert.match(
+    missingHermes.stderr,
+    /npx skills add prompt-security\/clawsec --skill hermes-example -a hermes-agent -y/,
+    "Hermes skills must require the hermes-agent installer target",
+  );
+
+  await writeSkill({
+    name: "hermes-example",
+    metadata: { hermes: { category: "security" } },
+    readme:
+      "# Hermes Example\n\n## Vercel Skills Installation\n\n```bash\nnpx skills add prompt-security/clawsec --skill hermes-example -a hermes-agent -y\n```\n",
+    skillMd:
+      "---\nname: hermes-example\nversion: 1.0.0\n---\n\n## Vercel Skills Installation\n\n```bash\nnpx skills add prompt-security/clawsec --skill hermes-example -a hermes-agent -y\n```\n",
+  });
+
+  const validHermes = runValidator(["--skills", "skills/hermes-example"]);
+  assert.equal(
+    validHermes.status,
+    0,
+    `valid Hermes install docs should pass\nstdout:\n${validHermes.stdout}\nstderr:\n${validHermes.stderr}`,
+  );
+
+  await writeSkill({
+    name: "codex-example",
+    metadata: { platform: "codex" },
+    readme:
+      "# Codex Example\n\n## Vercel Skills Installation\n\n```bash\nnpx skills add prompt-security/clawsec --skill codex-example -a openclaw -y\n```\n",
+    skillMd:
+      "---\nname: codex-example\nversion: 1.0.0\n---\n\n## Vercel Skills Installation\n\n```bash\nnpx skills add prompt-security/clawsec --skill codex-example -a openclaw -y\n```\n",
+  });
+
+  const wrongExactTarget = runValidator(["--skills", "skills/codex-example"]);
+  assert.equal(wrongExactTarget.status, 1, "exact AgentType matches must use their matched target");
+  assert.match(
+    wrongExactTarget.stderr,
+    /npx skills add prompt-security\/clawsec --skill codex-example -a codex -y/,
+    "Exact AgentType matches must not fall back to openclaw",
+  );
+
+  await writeSkill({
+    name: "nanoclaw-example",
+    metadata: { platform: "nanoclaw", nanoclaw: { category: "security" } },
+    readme:
+      "# NanoClaw Example\n\n## Vercel Skills Installation\n\n```bash\nnpx skills add prompt-security/clawsec --skill nanoclaw-example -a hermes-agent -y\n```\n",
+    skillMd:
+      "---\nname: nanoclaw-example\nversion: 1.0.0\n---\n\n## Vercel Skills Installation\n\n```bash\nnpx skills add prompt-security/clawsec --skill nanoclaw-example -a hermes-agent -y\n```\n",
+  });
+
+  const wrongNanoTarget = runValidator(["--skills", "skills/nanoclaw-example"]);
+  assert.equal(wrongNanoTarget.status, 1, "NanoClaw docs must fail when they use the Hermes target");
+  assert.match(
+    wrongNanoTarget.stderr,
+    /npx skills add prompt-security\/clawsec --skill nanoclaw-example -a openclaw -y/,
+    "NanoClaw skills must install through the openclaw target",
+  );
+
+  await writeSkill({
+    name: "nanoclaw-example",
+    metadata: { platform: "nanoclaw", nanoclaw: { category: "security" } },
+    readme:
+      "# NanoClaw Example\n\n## Vercel Skills Installation\n\n```bash\nnpx skills add prompt-security/clawsec --skill nanoclaw-example -a openclaw -y\n```\n",
+    skillMd:
+      "---\nname: nanoclaw-example\nversion: 1.0.0\n---\n\n## Vercel Skills Installation\n\n```bash\nnpx skills add prompt-security/clawsec --skill nanoclaw-example -a openclaw -y\n```\n",
+  });
+
+  const validNano = runValidator(["--skills", "skills/nanoclaw-example"]);
+  assert.equal(
+    validNano.status,
+    0,
+    `valid NanoClaw install docs should pass\nstdout:\n${validNano.stdout}\nstderr:\n${validNano.stderr}`,
+  );
+
+  assert.match(
+    workflow,
+    /Validate npx skills install docs/,
+    "Skill release workflow must run the install-doc validator",
+  );
+} finally {
+  await rm(tempRoot, { recursive: true, force: true });
+}

scripts/test-skill-release-workflow.mjs

@@ -0,0 +1,259 @@
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+
+const workflowPath = new URL('../.github/workflows/skill-release.yml', import.meta.url);
+const ciWorkflowPath = new URL('../.github/workflows/ci.yml', import.meta.url);
+const workflow = await readFile(workflowPath, 'utf8');
+const ciWorkflow = await readFile(ciWorkflowPath, 'utf8');
+
+assert.match(
+  workflow,
+  /pull_request:[\s\S]*paths:[\s\S]*- 'skills\/\*\*'/,
+  'Skill release workflow must run when any skill package file changes',
+);
+
+assert.match(
+  workflow,
+  /pull_request:[\s\S]*paths:[\s\S]*- '\.github\/workflows\/skill-release\.yml'[\s\S]*- 'scripts\/ci\/\*\*'/,
+  'Skill release workflow must also run when the release pipeline itself changes',
+);
+
+assert.ok(
+  ciWorkflow.includes(`      - name: Skill Release Tooling Tests
+        run: |
+          set -euo pipefail
+          for test_file in scripts/test-skill-*.mjs; do
+            node "$test_file"
+          done`),
+  'CI must run every scripts/test-skill-*.mjs file so new skill release tests are not orphaned',
+);
+
+assert.match(
+  workflow,
+  /git diff --name-only "\$\{BASE_SHA\}\.\.\.\$\{HEAD_SHA\}" --[\s\S]*'skills\/\*\/\*\*'[\s\S]*':\(exclude\)skills\/\*\/test\/\*\*'[\s\S]*':\(exclude\)skills\/\*\/tests\/\*\*'/,
+  'Skill release validation must ignore test-only skill changes while inspecting release-relevant skill files',
+);
+
+assert.doesNotMatch(
+  workflow,
+  /No version bump detected for \$\{skill_dir\}; skipping\./,
+  'Changed skill directories without a version bump must not be skipped without release-tag validation',
+);
+
+assert.match(
+  workflow,
+  /skill_release_name="\$\(basename "\$\{skill_dir\}"\)"/,
+  'Skill release validation must derive the release tag prefix from the skill package directory',
+);
+
+assert.match(
+  workflow,
+  /release_tag="\$\{skill_release_name\}-v\$\{head_json_version\}"/,
+  'Skill release validation must use the skill package directory name for release tag checks',
+);
+
+assert.doesNotMatch(
+  workflow,
+  /release_tag="\$\{head_skill_name\}-v\$\{head_json_version\}"/,
+  'Skill release validation must not use skill.json name for release tag checks because release tags resolve to skill directories',
+);
+
+assert.match(
+  workflow,
+  /git show-ref --verify --quiet "refs\/tags\/\$\{release_tag\}"/,
+  'Skill release validation must check whether the current skill version has already been tagged',
+);
+
+assert.match(
+  workflow,
+  /No version bump detected for \$\{skill_dir\}, but release tag \$\{release_tag\} does not exist; treating \$\{head_json_version\} as unreleased\./,
+  'Skill release validation must allow edits to an unchanged version when that release tag does not exist yet',
+);
+
+assert.match(
+  workflow,
+  /::error file=\$\{skill_dir\}::Changed skill package has no version bump and release tag \$\{release_tag\} already exists\./,
+  'Skill release validation must still fail unchanged versions after their release tag exists',
+);
+
+assert.match(
+  workflow,
+  /Install SkillSpector/,
+  'Skill release workflow must install SkillSpector before publishing release evidence',
+);
+
+assert.match(
+  workflow,
+  /Generate SkillSpector report/,
+  'Skill release workflow must generate a SkillSpector report for each released skill',
+);
+
+assert.match(
+  workflow,
+  /### SkillSpector Security Report[\s\S]*\[skillspector-report\.md\]\(https:\/\/github\.com\/\$\{process\.env\.REPO\}\/releases\/download\/\$\{process\.env\.TAG\}\/skillspector-report\.md\)/,
+  'GitHub release notes must include a direct SkillSpector report link',
+);
+
+assert.match(
+  workflow,
+  /readFileSync\("release-assets\/skillspector-report\.md", "utf8"\)/,
+  'GitHub release notes must load the generated SkillSpector report content into the release body file',
+);
+
+assert.match(
+  workflow,
+  /body_path: \$\{\{ runner\.temp \}\}\/skill-release-body\.md/,
+  'GitHub release creation must use body_path for the generated release body file',
+);
+
+assert.doesNotMatch(
+  workflow,
+  /SKILLSPECTOR_REPORT_EOF|\$\{\{ steps\.skillspector_report\.outputs\.body \}\}|cat release-assets\/skillspector-report\.md[\s\S]*>> "\$GITHUB_OUTPUT"/,
+  'SkillSpector report content must not be sent through GitHub Actions step outputs',
+);
+
+assert.match(
+  workflow,
+  /generate_skillspector_report "\$\{inner_dir\}" "\$\{out_assets\}\/skillspector-report\.md"/,
+  'PR dry-run SkillSpector scan must target the staged release payload, not the source skill directory',
+);
+
+assert.doesNotMatch(
+  workflow,
+  /generate_skillspector_report "\$\{skill_dir\}" "\$\{out_assets\}\/skillspector-report\.md"/,
+  'PR dry-run SkillSpector scan must not include source-only test directories',
+);
+
+assert.match(
+  workflow,
+  /generate_skillspector_report "\$INNER_DIR" "release-assets\/skillspector-report\.md"/,
+  'Tag release SkillSpector scan must target the staged release payload, not the source skill directory',
+);
+
+assert.doesNotMatch(
+  workflow,
+  /generate_skillspector_report "\$SKILL_PATH" "release-assets\/skillspector-report\.md"/,
+  'Tag release SkillSpector scan must not include source-only test directories',
+);
+
+assert.match(
+  workflow,
+  /Generate release trust packet/,
+  'Skill release workflow must generate skill cards, permission summaries, and npx install instructions',
+);
+
+for (const artifact of ['skill-card.md', 'permissions.json', 'install.md', 'skillspector-report.md']) {
+  assert.match(
+    workflow,
+    new RegExp(`release-assets/${artifact.replace('.', '\\.')}`),
+    `Skill release workflow must publish ${artifact} in release assets`,
+  );
+}
+
+const escapeRegExp = (literal) => literal.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+for (const artifact of ['skill-card.md', 'permissions.json', 'install.md', 'skillspector-report.md']) {
+  assert.match(
+    workflow,
+    new RegExp(
+      String.raw`if ! add_release_asset_checksum "\$\{out_assets\}" "${escapeRegExp(artifact)}"; then` +
+        String.raw`[\s\S]*?failures=\$\(\(failures \+ 1\)\)[\s\S]*?continue[\s\S]*?fi`,
+    ),
+    `PR dry-run validation must aggregate and continue when ${artifact} cannot be checksummed`,
+  );
+}
+
+assert.match(
+  workflow,
+  /add_release_asset_checksum "skill-card\.md"/,
+  'Skill card must be included in the signed checksums manifest',
+);
+
+assert.match(
+  workflow,
+  /add_release_asset_checksum "permissions\.json"/,
+  'Permissions summary must be included in the signed checksums manifest',
+);
+
+assert.match(
+  workflow,
+  /add_release_asset_checksum "install\.md"/,
+  'npx install/update instructions must be included in the signed checksums manifest',
+);
+
+assert.match(
+  workflow,
+  /add_release_asset_checksum "skillspector-report\.md"/,
+  'SkillSpector report must be included in the signed checksums manifest',
+);
+
+assert.match(
+  workflow,
+  /Simulate tag release build/,
+  'Skill release workflow must simulate a tag release build during PR validation',
+);
+
+assert.match(
+  workflow,
+  /simulate_skill_tag_release\.mjs/,
+  'Skill release workflow must call the tag release simulation script',
+);
+
+assert.ok(
+  workflow.includes('simulated_version | test("^[0-9]+\\\\.[0-9]+\\\\.[0-9]+(-[a-zA-Z0-9]+)?$")'),
+  'Skill release workflow must accept every prerelease version format that release-skill.sh accepts',
+);
+
+assert.match(
+  workflow,
+  /clawhub_slug: \$\{\{ steps\.publishable\.outputs\.clawhub_slug \}\}/,
+  'Skill release workflow must expose the resolved ClawHub slug from release-tag outputs',
+);
+
+assert.match(
+  workflow,
+  /CLAWHUB_SLUG=\$\(node scripts\/ci\/resolve_clawhub_slug\.mjs "\$SKILL_PATH"\)/,
+  'Skill release workflow must resolve the ClawHub slug from the skill package path',
+);
+
+assert.match(
+  workflow,
+  /cp scripts\/ci\/resolve_clawhub_slug\.mjs "\$RUNNER_TEMP\/resolve_clawhub_slug\.mjs"/,
+  'Manual ClawHub republish must preserve the current slug helper before checking out an older release tag',
+);
+
+assert.match(
+  workflow,
+  /CLAWHUB_SLUG=\$\(node "\$RUNNER_TEMP\/resolve_clawhub_slug\.mjs" "\$SKILL_PATH"\)/,
+  'Manual ClawHub republish must resolve slugs with the preserved helper against the checked-out tag metadata',
+);
+
+assert.match(
+  workflow,
+  /npx clawhub@latest install \$\{CLAWHUB_SLUG\}/,
+  'GitHub release quick install instructions must use the resolved ClawHub slug',
+);
+
+assert.match(
+  workflow,
+  /clawhub inspect "\$CLAWHUB_SLUG" --version "\$VERSION" --json/,
+  'Duplicate ClawHub version guard must inspect the resolved ClawHub slug',
+);
+
+assert.match(
+  workflow,
+  /--slug "\$CLAWHUB_SLUG"/,
+  'ClawHub publish must use the resolved ClawHub slug',
+);
+
+assert.doesNotMatch(
+  workflow,
+  /clawhub inspect "\$SKILL_NAME" --version "\$VERSION" --json/,
+  'Duplicate ClawHub version guard must not inspect the raw skill package name',
+);
+
+assert.doesNotMatch(
+  workflow,
+  /--slug "\$SKILL_NAME"/,
+  'ClawHub publish must not use the raw skill package name as the ClawHub slug',
+);

scripts/test-skill-tag-release-simulation.mjs

@@ -0,0 +1,184 @@
+import assert from "node:assert/strict";
+import { chmod, cp, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+const tempRoot = await mkdtemp(path.join(tmpdir(), "clawsec-tag-release-sim-"));
+const fakeSkillspector = path.join(tempRoot, "skillspector");
+
+async function prereleaseFixture(sourceSkillDir, version, fixtureGroup) {
+  const fixtureDir = path.join(tempRoot, fixtureGroup, path.basename(sourceSkillDir));
+  await cp(sourceSkillDir, fixtureDir, { recursive: true });
+
+  const skillJsonPath = path.join(fixtureDir, "skill.json");
+  const skill = JSON.parse(await readFile(skillJsonPath, "utf8"));
+  skill.version = version;
+  await writeFile(skillJsonPath, `${JSON.stringify(skill, null, 2)}\n`);
+
+  const skillMdPath = path.join(fixtureDir, "SKILL.md");
+  const skillMd = await readFile(skillMdPath, "utf8");
+  await writeFile(skillMdPath, skillMd.replace(/^version:\s*.+$/m, `version: ${version}`));
+
+  return fixtureDir;
+}
+
+async function runSimulation({ skillDir, outputDir, expectedOriginal, expectedSimulated, expectedAgent }) {
+  const result = spawnSync(
+    process.execPath,
+    [
+      "scripts/ci/simulate_skill_tag_release.mjs",
+      skillDir,
+      outputDir,
+      "--repository",
+      "prompt-security/clawsec",
+      "--source-ref",
+      "pull-request-head",
+      "--skillspector-bin",
+      fakeSkillspector,
+    ],
+    { encoding: "utf8" },
+  );
+
+  assert.equal(
+    result.status,
+    0,
+    `tag release simulation failed\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`,
+  );
+
+  const skillName = path.basename(skillDir);
+  const expectedTag = `${skillName}-v${expectedSimulated}`;
+  const summary = JSON.parse(await readFile(path.join(outputDir, "simulation-summary.json"), "utf8"));
+  assert.equal(summary.skill, skillName);
+  assert.equal(summary.original_version, expectedOriginal);
+  assert.equal(summary.simulated_version, expectedSimulated);
+  assert.equal(summary.tag, expectedTag);
+
+  const releaseAssetsDir = path.join(outputDir, "release-assets");
+  const checksums = JSON.parse(await readFile(path.join(releaseAssetsDir, "checksums.json"), "utf8"));
+  assert.equal(checksums.skill, skillName);
+  assert.equal(checksums.version, expectedSimulated);
+  assert.equal(checksums.tag, expectedTag);
+  assert.equal(checksums.archive.filename, `${expectedTag}.zip`);
+
+  for (const artifact of [
+    "skill-card.md",
+    "permissions.json",
+    "install.md",
+    "skillspector-report.md",
+    "checksums.sig",
+    "signing-public.pem",
+  ]) {
+    assert.ok(
+      checksums.files[artifact] || artifact.endsWith(".sig") || artifact === "signing-public.pem",
+      `expected ${artifact} to be represented in the release output`,
+    );
+    const file = await readFile(path.join(releaseAssetsDir, artifact));
+    assert.ok(file.length > 0, `${artifact} should not be empty`);
+  }
+
+  const archive = await readFile(path.join(releaseAssetsDir, `${expectedTag}.zip`));
+  assert.ok(archive.length > 0, "release archive should not be empty");
+
+  const install = await readFile(path.join(releaseAssetsDir, "install.md"), "utf8");
+  assert.match(
+    install,
+    new RegExp(
+      `npx skills add prompt-security/clawsec#pull-request-head --skill ${skillName} --agent ${expectedAgent} --global --yes`,
+    ),
+  );
+  assert.match(install, new RegExp(`npx skills update ${skillName}`));
+}
+
+try {
+  await writeFile(
+    fakeSkillspector,
+    `#!/usr/bin/env node
+import { readdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+const scanIndex = process.argv.indexOf("scan");
+if (scanIndex === -1 || !process.argv[scanIndex + 1]) {
+  console.error("missing scan target");
+  process.exit(2);
+}
+
+function containsTestDirectory(dir) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const lowerName = entry.name.toLowerCase();
+    if (lowerName === "test" || lowerName === "tests") {
+      return true;
+    }
+    if (containsTestDirectory(path.join(dir, entry.name))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+const scanTarget = process.argv[scanIndex + 1];
+if (containsTestDirectory(scanTarget)) {
+  console.error("SkillSpector test fixture must scan the staged release payload, not source test directories.");
+  process.exit(42);
+}
+
+const outputIndex = process.argv.indexOf("--output");
+if (outputIndex === -1 || !process.argv[outputIndex + 1]) {
+  console.error("missing --output");
+  process.exit(2);
+}
+
+writeFileSync(process.argv[outputIndex + 1], "# Fake SkillSpector Report\\n\\nNo live scan executed in unit test.\\n");
+`,
+    { mode: 0o700 },
+  );
+  await chmod(fakeSkillspector, 0o700);
+
+  await runSimulation({
+    skillDir: "skills/clawsec-suite",
+    outputDir: path.join(tempRoot, "stable"),
+    expectedOriginal: "0.1.10",
+    expectedSimulated: "0.1.11",
+    expectedAgent: "openclaw",
+  });
+
+  await runSimulation({
+    skillDir: "skills/hermes-traffic-guardian",
+    outputDir: path.join(tempRoot, "beta"),
+    expectedOriginal: "0.0.1-beta3",
+    expectedSimulated: "0.0.1-beta4",
+    expectedAgent: "hermes-agent",
+  });
+
+  const alphaSkillDir = await prereleaseFixture("skills/picoclaw-self-pen-testing", "0.0.3-alpha1", "alpha-fixture");
+  await runSimulation({
+    skillDir: alphaSkillDir,
+    outputDir: path.join(tempRoot, "alpha"),
+    expectedOriginal: "0.0.3-alpha1",
+    expectedSimulated: "0.0.3-alpha2",
+    expectedAgent: "openclaw",
+  });
+
+  const rcSkillDir = await prereleaseFixture("skills/picoclaw-security-guardian", "0.0.4-rc1", "rc-fixture");
+  await runSimulation({
+    skillDir: rcSkillDir,
+    outputDir: path.join(tempRoot, "rc"),
+    expectedOriginal: "0.0.4-rc1",
+    expectedSimulated: "0.0.4-rc2",
+    expectedAgent: "openclaw",
+  });
+
+  const previewSkillDir = await prereleaseFixture("skills/openclaw-traffic-guardian", "0.0.1-preview", "preview-fixture");
+  await runSimulation({
+    skillDir: previewSkillDir,
+    outputDir: path.join(tempRoot, "preview"),
+    expectedOriginal: "0.0.1-preview",
+    expectedSimulated: "0.0.1-preview1",
+    expectedAgent: "openclaw",
+  });
+} finally {
+  await rm(tempRoot, { recursive: true, force: true });
+}

scripts/test-skill-trust-packet.mjs

@@ -0,0 +1,79 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+
+const outputDir = await mkdtemp(path.join(tmpdir(), "clawsec-trust-packet-"));
+
+function runTrustPacket(skillDir, targetDir, tag) {
+  return spawnSync(
+    process.execPath,
+    [
+      "scripts/ci/generate_skill_release_trust_packet.mjs",
+      skillDir,
+      targetDir,
+      "--repository",
+      "prompt-security/clawsec",
+      "--tag",
+      tag,
+      "--source-ref",
+      "main",
+    ],
+    { encoding: "utf8" },
+  );
+}
+
+try {
+  const result = runTrustPacket("skills/clawsec-suite", outputDir, "clawsec-suite-v0.1.10");
+
+  assert.equal(
+    result.status,
+    0,
+    `trust packet generator failed\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`,
+  );
+
+  const skillCard = await readFile(path.join(outputDir, "skill-card.md"), "utf8");
+  const permissions = JSON.parse(await readFile(path.join(outputDir, "permissions.json"), "utf8"));
+  const install = await readFile(path.join(outputDir, "install.md"), "utf8");
+
+  assert.match(skillCard, /^# Skill Card/m);
+  assert.match(skillCard, /## License\/Terms of Use/);
+  assert.match(skillCard, /AGPL-3\.0-or-later/);
+  assert.match(skillCard, /skillspector-report\.md/);
+  assert.match(skillCard, /clawsec-suite-v0\.1\.10/);
+
+  assert.equal(permissions.skill, "clawsec-suite");
+  assert.equal(permissions.version, "0.1.10");
+  assert.equal(permissions.platform, "openclaw");
+  assert.deepEqual(
+    permissions.required_binaries,
+    ["node", "npx", "openclaw", "curl", "jq", "shasum", "openssl", "unzip"],
+  );
+  assert.match(permissions.network_egress, /signed advisory feed/);
+  assert.match(permissions.persistence, /OpenClaw advisory hook/);
+  assert.ok(Array.isArray(permissions.operator_review));
+  assert.ok(permissions.operator_review.length > 0);
+
+  assert.match(install, /npx skills add prompt-security\/clawsec --skill clawsec-suite --agent openclaw --global --yes/);
+  assert.match(install, /npx skills update clawsec-suite/);
+
+  const hermesOutputDir = path.join(outputDir, "hermes");
+  const hermesResult = runTrustPacket(
+    "skills/hermes-attestation-guardian",
+    hermesOutputDir,
+    "hermes-attestation-guardian-v0.1.4",
+  );
+  assert.equal(
+    hermesResult.status,
+    0,
+    `Hermes trust packet generator failed\nstdout:\n${hermesResult.stdout}\nstderr:\n${hermesResult.stderr}`,
+  );
+  const hermesInstall = await readFile(path.join(hermesOutputDir, "install.md"), "utf8");
+  assert.match(
+    hermesInstall,
+    /npx skills add prompt-security\/clawsec --skill hermes-attestation-guardian --agent hermes-agent --global --yes/,
+  );
+} finally {
+  await rm(outputDir, { recursive: true, force: true });
+}

skills/claw-release/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.0.4] - 2026-06-10
+
+### Changed
+
+- Re-released skill package with updated marketplace grouping and signed release trust artifacts for Vercel-compatible skill installation.
+- Marked the release helper with top-level internal metadata so compatible installers can hide it from normal agent-facing discovery.
+
 ## [0.0.3] - 2026-05-14
 
 ### Security

skills/claw-release/README.md

@@ -0,0 +1,11 @@
+# Claw Release
+
+Release automation for Claw skills and website. Guides through version bumping, tagging, and release verification.
+
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill claw-release -a openclaw -y
+```

skills/claw-release/SKILL.md

@@ -1,9 +1,14 @@
 ---
 name: claw-release
-version: 0.0.3
+version: 0.0.4
 description: Release automation for Claw skills and website. Guides through version bumping, tagging, and release verification.
 homepage: https://clawsec.prompt.security
-metadata: {"openclaw":{"emoji":"🚀","category":"utility","internal":true}}
+metadata:
+  internal: true
+  openclaw:
+    emoji: "🚀"
+    category: "utility"
+    internal: true
 clawdis:
   emoji: "🚀"
   requires:
@@ -18,6 +23,14 @@ Internal tool for releasing skills and managing the ClawSec catalog.
 
 ---
 
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill claw-release -a openclaw -y
+```
+
 ## Operational Notes
 
 - Internal maintainer workflow only.
@@ -26,7 +39,6 @@ Internal tool for releasing skills and managing the ClawSec catalog.
 - Side effects: creates commits, tags, pushes to remote, and publishes GitHub Releases
 - Trust model: run only from a trusted checkout with a clean working tree and maintainer approval
 
-
 ## Release Artifact Verification
 
 For standalone installs, verify the signed release manifest before trusting `SKILL.md`, `skill.json`, or the archive. The `skill.json` file is the package metadata/SBOM source, and the release pipeline signs `checksums.json` with the ClawSec release key.
@@ -35,7 +47,7 @@ For standalone installs, verify the signed release manifest before trusting `SKI
 set -euo pipefail
 
 SKILL_NAME="claw-release"
-VERSION="0.0.3"
+VERSION="0.0.4"
 REPO="prompt-security/clawsec"
 TAG="${SKILL_NAME}-v${VERSION}"
 BASE="https://github.com/${REPO}/releases/download/${TAG}"

skills/claw-release/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "claw-release",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Release automation for Claw skills and website. Guides through version bumping, tagging, and release verification.",
   "author": "prompt-security",
   "license": "AGPL-3.0-or-later",

skills/clawsec-clawhub-checker/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.0.6] - 2026-06-10
+
+### Changed
+
+- Re-released skill package with updated marketplace grouping and signed release trust artifacts for Vercel-compatible skill installation.
+
+## [0.0.5] - 2026-06-07
+
+### Security
+- Treat explicit malicious ClawHub and VirusTotal verdicts as blocking signals regardless of the numeric reputation score.
+
 ## [0.0.4] - 2026-05-13
 
 ### Security

skills/clawsec-clawhub-checker/README.md

@@ -2,6 +2,14 @@
 
 A `clawsec-suite` companion skill that adds a standalone reputation gate before guarded installs.
 
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill clawsec-clawhub-checker -a openclaw -y
+```
+
 ## Operational Notes
 
 - Required runtime: `node`, `clawhub`, `openclaw`

skills/clawsec-clawhub-checker/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: clawsec-clawhub-checker
-version: 0.0.4
+version: 0.0.6
 description: ClawHub reputation checker for clawsec-suite. Adds a standalone reputation gate before guarded skill installation.
 homepage: https://clawsec.prompt.security
 clawdis:
@@ -14,6 +14,14 @@ clawdis:
 
 Adds a reputation gate on top of the `clawsec-suite` guarded installer.
 
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill clawsec-clawhub-checker -a openclaw -y
+```
+
 ## Operational Notes
 
 - Required runtime: `node`, `clawhub`, `openclaw`
@@ -45,7 +53,6 @@ Optional preflight check (validates local paths and prints recommended command):
 node ~/.openclaw/skills/clawsec-clawhub-checker/scripts/setup_reputation_hook.mjs
 ```
 
-
 ## Release Artifact Verification
 
 For standalone installs, verify the signed release manifest before trusting `SKILL.md`, `skill.json`, or the archive. The `skill.json` file is the package metadata/SBOM source, and the release pipeline signs `checksums.json` with the ClawSec release key.

skills/clawsec-clawhub-checker/scripts/check_clawhub_reputation.mjs

@@ -35,6 +35,12 @@ function blockOnMissingScannerData(result, warning) {
   result.blocked = true;
 }
 
+function blockOnMaliciousScannerData(result, warning) {
+  result.warnings.push(warning);
+  result.score = 0;
+  result.blocked = true;
+}
+
 function parseJson(raw, label, warnings) {
   try {
     return JSON.parse(raw);
@@ -58,7 +64,10 @@ function maybeApplyVersionSecuritySignals(result, versionDetails) {
     return;
   }
 
-  if (typeof security.status === "string" && security.status.toLowerCase() === "suspicious") {
+  const securityStatus = typeof security.status === "string" ? security.status.toLowerCase() : "";
+  if (securityStatus === "malicious") {
+    blockOnMaliciousScannerData(result, "ClawHub static moderation marked the version as malicious");
+  } else if (securityStatus === "suspicious") {
     result.warnings.push("ClawHub static moderation marked the version as suspicious");
     result.score -= 30;
   }
@@ -82,7 +91,15 @@ function maybeApplyVersionSecuritySignals(result, versionDetails) {
     "";
   const normalizedStatus = vtStatus.toLowerCase();
 
-  if (normalizedStatus === "suspicious") {
+  if (normalizedStatus === "malicious") {
+    result.virustotal.push("ClawHub VirusTotal scan returned malicious");
+    blockOnMaliciousScannerData(result, "ClawHub VirusTotal scan returned malicious");
+
+    const vtSummary = typeof vt.analysis === "string" ? vt.analysis.trim() : "";
+    if (vtSummary) {
+      result.virustotal.push(vtSummary.split("\n")[0]);
+    }
+  } else if (normalizedStatus === "suspicious") {
     result.virustotal.push("ClawHub VirusTotal scan returned suspicious");
     result.score -= 40;
 

skills/clawsec-clawhub-checker/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "clawsec-clawhub-checker",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "ClawHub reputation checker for clawsec-suite. Adds a standalone reputation gate before guarded skill installation.",
   "author": "abutbul",
   "license": "AGPL-3.0-or-later",

skills/clawsec-clawhub-checker/test/reputation_check.test.mjs

@@ -13,6 +13,8 @@
  */
 
 import { fileURLToPath } from "node:url";
+import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import { spawn } from "node:child_process";
 
@@ -58,6 +60,37 @@ function runScript(scriptPath, args, env) {
   });
 }
 
+async function createMockClawhub(payload) {
+  const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "clawhub-reputation-test-"));
+  const binDir = path.join(tmpDir, "bin");
+  const mockPath = path.join(binDir, "clawhub");
+  await fs.mkdir(binDir, { recursive: true });
+  await fs.writeFile(
+    mockPath,
+    `#!/usr/bin/env node
+const payload = ${JSON.stringify(JSON.stringify(payload))};
+const command = process.argv[2] || "";
+if (command === "inspect") {
+  process.stdout.write(payload);
+  process.exit(0);
+}
+if (command === "search") {
+  process.stdout.write("name\\nmock-skill\\nother-skill\\n");
+  process.exit(0);
+}
+process.stderr.write("unexpected clawhub command: " + process.argv.slice(2).join(" ") + "\\n");
+process.exit(2);
+`,
+    "utf8",
+  );
+  await fs.chmod(mockPath, 0o755);
+
+  return {
+    env: { PATH: `${binDir}:${process.env.PATH}` },
+    cleanup: async () => fs.rm(tmpDir, { recursive: true, force: true }),
+  };
+}
+
 // -----------------------------------------------------------------------------
 // Test: Invalid skill slug is rejected (command injection prevention)
 // -----------------------------------------------------------------------------
@@ -208,6 +241,59 @@ async function testPreReleaseVersionAccepted() {
   }
 }
 
+// -----------------------------------------------------------------------------
+// Test: Explicit malicious scanner verdict blocks regardless of score
+// -----------------------------------------------------------------------------
+async function testMaliciousVirusTotalVerdictBlocks() {
+  const testName = "reputation_check: malicious VirusTotal verdict blocks install";
+  const now = Date.now();
+  const mock = await createMockClawhub({
+    skill: {
+      createdAt: now - (120 * 24 * 60 * 60 * 1000),
+      updatedAt: now - (2 * 24 * 60 * 60 * 1000),
+      stats: { downloads: 1000 },
+    },
+    owner: { handle: "trusted-publisher" },
+    version: {
+      security: {
+        status: "clean",
+        scanners: {
+          vt: {
+            normalizedStatus: "malicious",
+            analysis: "malicious verdict from scanner",
+          },
+        },
+      },
+    },
+  });
+
+  try {
+    const result = await runScript(CHECKER_SCRIPT, ['malicious-skill', '1.0.0', '70'], mock.env);
+    let parsed;
+    try {
+      parsed = JSON.parse(result.stdout);
+    } catch {
+      fail(testName, `Could not parse output: ${result.stdout}`);
+      return;
+    }
+
+    if (
+      result.code === 43 &&
+      parsed.safe === false &&
+      parsed.warnings.some((w) => w.toLowerCase().includes("malicious")) &&
+      parsed.virustotal.some((v) => v.toLowerCase().includes("malicious"))
+    ) {
+      pass(testName);
+    } else {
+      fail(testName, `Expected malicious verdict to block, got code ${result.code}: ${JSON.stringify(parsed)}`);
+    }
+  } catch (error) {
+    fail(testName, error);
+  } finally {
+    await mock.cleanup();
+  }
+}
+
 // -----------------------------------------------------------------------------
 // Test: CLI entrypoint guard works when script path is relative
 // -----------------------------------------------------------------------------
@@ -411,6 +497,7 @@ async function runTests() {
   await testUppercaseSlugRejected();
   await testEmptySlugShowsUsage();
   await testPreReleaseVersionAccepted();
+  await testMaliciousVirusTotalVerdictBlocks();
   await testRelativePathCliEntrypointWorks();
   await testInvalidThresholdRejected();
   await testEnhancedInstallerRejectsInvalidSkill();

skills/clawsec-feed/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.0.9] - 2026-06-10
+
+### Changed
+
+- Re-released skill package with updated marketplace grouping and signed release trust artifacts for Vercel-compatible skill installation.
+
+## [0.0.8] - 2026-05-24
+
+### Changed
+- Documented the consolidated signed advisory feed as the default feed for NVD CVEs, approved community advisories, and provisional GHSA-without-CVE records.
+
 ## [0.0.7] - 2026-05-14
 
 ### Security

skills/clawsec-feed/README.md

@@ -2,6 +2,14 @@
 
 Security advisory feed monitoring for AI agents. Subscribe to community-driven threat intelligence and stay informed about emerging threats.
 
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill clawsec-feed -a openclaw -y
+```
+
 ## Operational Notes
 
 - Required runtime for standalone installation: `bash`, `curl`, `jq`, `shasum`, `unzip`

skills/clawsec-feed/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: clawsec-feed
-version: 0.0.7
+version: 0.0.9
 description: Security advisory feed package for OpenClaw-related threats and vulnerabilities. The upstream feed is updated daily; local automation is handled by clawsec-suite or the operator.
 homepage: https://clawsec.prompt.security
 metadata: {"openclaw":{"emoji":"📡","category":"security"}}
@@ -14,7 +14,15 @@ clawdis:
 
 Security advisory feed monitoring for AI agents. Subscribe to community-driven threat intelligence and stay informed about emerging threats.
 
-This feed is automatically updated daily with CVEs related to OpenClaw and Moltbot from the NIST National Vulnerability Database (NVD).
+The default `feed.json` is the consolidated agent feed. It includes NVD CVEs, approved community advisories, and provisional GitHub Security Advisories that do not have CVE IDs yet.
+
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill clawsec-feed -a openclaw -y
+```
 
 ## Operational Notes
 
@@ -66,7 +74,6 @@ Standalone installation is a network download workflow. Verify the release sourc
 Installation Steps:
 Agents should review scripts before execution!
 
-
 ```bash
 # Get latest clawsec-feed release tag
 LATEST_TAG=$(curl -sSL https://api.github.com/repos/prompt-security/ClawSec/releases | \
@@ -81,7 +88,6 @@ Once you have this skill file, proceed to **[Deploy ClawSec Feed](#deploy-clawse
 
 ---
 
-
 ## Release Artifact Verification
 
 For standalone installs, verify the signed release manifest before trusting `SKILL.md`, `skill.json`, or the archive. The `skill.json` file is the package metadata/SBOM source, and the release pipeline signs `checksums.json` with the ClawSec release key.
@@ -90,7 +96,7 @@ For standalone installs, verify the signed release manifest before trusting `SKI
 set -euo pipefail
 
 SKILL_NAME="clawsec-feed"
-VERSION="0.0.7"
+VERSION="0.0.9"
 REPO="prompt-security/clawsec"
 TAG="${SKILL_NAME}-v${VERSION}"
 BASE="https://github.com/${REPO}/releases/download/${TAG}"
@@ -783,7 +789,7 @@ fi
 
 | Variable | Description | Default |
 |----------|-------------|---------|
-| `CLAWSEC_FEED_URL` | Custom advisory feed URL | Raw GitHub (`main` branch) |
+| `CLAWSEC_FEED_URL` | Custom advisory feed URL | Consolidated signed feed |
 | `CLAWSEC_INSTALL_DIR` | Installation directory | `~/.openclaw/skills/clawsec-feed` |
 
 ---

skills/clawsec-feed/advisories/feed.json.sig

@@ -1 +1 @@
-fOD6OdSmOgXBD/4N8OkDZvIWxt9GFQiVoG8WlR5/siZxNrABqiy2/IVM/RyJdsIRsjcms7evB0mnaVziW/eOBA==
+agiAAFvzM1vNHxH2+bGtyeKqFScLWJHnNreBcPpTODUqD0xqFi0cnyP/ZaZX+Rsw1Y9uZ7pGdFdA93pD4lh2BQ==

skills/clawsec-feed/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "clawsec-feed",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Security advisory feed monitoring for AI agents. Subscribe to community-driven threat intelligence.",
   "author": "prompt-security",
   "license": "AGPL-3.0-or-later",

skills/clawsec-nanoclaw/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [0.0.8] - 2026-06-10
+
+### Changed
+
+- Re-released skill package with updated marketplace grouping and signed release trust artifacts for Vercel-compatible skill installation.
+
+## [0.0.7] - 2026-06-07
+
+### Security
+- Added comparator range support for NanoClaw advisory matching and fail-closed handling for malformed affected specifiers.
+- Added strict integrity IPC request ID validation and result path containment before host-side result writes.
+
+## [0.0.6] - 2026-05-24
+
+### Changed
+- Documented that NanoClaw consumes the consolidated signed advisory feed containing NVD CVEs, approved community advisories, and provisional GHSA-without-CVE records.
+- Added advisory metadata typing for GHSA lifecycle fields used by the consolidated feed.
+
 ## [0.0.5] - 2026-05-14
 
 ### Security

skills/clawsec-nanoclaw/README.md

@@ -2,6 +2,14 @@
 
 ClawSec now supports NanoClaw, a containerized WhatsApp bot powered by Claude agents.
 
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill clawsec-nanoclaw -a openclaw -y
+```
+
 ## What Changed
 
 ### Advisory Feed Monitoring

skills/clawsec-nanoclaw/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: clawsec-nanoclaw
-version: 0.0.5
+version: 0.0.8
 description: Use when checking for security vulnerabilities in NanoClaw skills, before installing new skills, or when asked about security advisories affecting the bot
 ---
 
@@ -8,6 +8,14 @@ description: Use when checking for security vulnerabilities in NanoClaw skills,
 
 Security advisory monitoring that protects your WhatsApp bot from known vulnerabilities in skills and dependencies.
 
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill clawsec-nanoclaw -a openclaw -y
+```
+
 ## Overview
 
 ClawSec provides MCP tools that check installed skills against a curated feed of security advisories. It prevents installation of vulnerable skills, includes exploitability context for triage, and alerts you to issues in existing ones.
@@ -183,6 +191,8 @@ if (advisory.exploitability_score === 'high' || advisory.severity === 'critical'
 
 **Feed Source**: https://clawsec.prompt.security/advisories/feed.json
 
+This signed feed is consolidated. NanoClaw receives NVD CVEs, approved community advisories, and provisional GHSA-without-CVE advisories through the same default URL.
+
 **Update Frequency**: Every 6 hours (automatic)
 
 **Signature Verification**: Ed25519 signed feeds
@@ -199,7 +209,6 @@ See [INSTALL.md](./INSTALL.md) for setup and [docs/](./docs/) for advanced usage
 - Provides actionable remediation steps
 - Zero false positives (curated feed only)
 
-
 ## Release Artifact Verification
 
 For standalone installs, verify the signed release manifest before trusting `SKILL.md`, `skill.json`, or the archive. The `skill.json` file is the package metadata/SBOM source, and the release pipeline signs `checksums.json` with the ClawSec release key.
@@ -208,7 +217,7 @@ For standalone installs, verify the signed release manifest before trusting `SKI
 set -euo pipefail
 
 SKILL_NAME="clawsec-nanoclaw"
-VERSION="0.0.5"
+VERSION="0.0.6"
 REPO="prompt-security/clawsec"
 TAG="${SKILL_NAME}-v${VERSION}"
 BASE="https://github.com/${REPO}/releases/download/${TAG}"

skills/clawsec-nanoclaw/host-services/integrity-handler.ts

@@ -11,6 +11,9 @@ import fs from 'fs';
 import path from 'path';
 import { IntegrityMonitor } from '../guardian/integrity-monitor';
 
+const RESULT_DIR = '/workspace/ipc/clawsec_results';
+const REQUEST_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+
 // ============================================================================
 // Integrity Service (Singleton)
 // ============================================================================
@@ -84,15 +87,21 @@ export async function handleIntegrityIpc(
   logger: any
 ): Promise<void> {
   const { type, requestId, groupFolder: _groupFolder } = task;
+  const validatedRequestId = validateRequestId(requestId);
+
+  if (!validatedRequestId) {
+    logger.warn({ type, requestId }, 'Invalid integrity IPC request id');
+    return;
+  }
+
+  const safeTask = { ...task, requestId: validatedRequestId };
 
   if (!deps.integrityService) {
     logger.warn({ task }, 'IntegrityService not available');
-    if (requestId) {
-      writeResult(requestId, {
-        success: false,
-        error: 'IntegrityService not initialized'
-      });
-    }
+    writeResult(validatedRequestId, {
+      success: false,
+      error: 'IntegrityService not initialized'
+    });
     return;
   }
 
@@ -103,31 +112,29 @@ export async function handleIntegrityIpc(
       await service.initialize();
     } catch (error) {
       logger.error({ error }, 'Failed to initialize IntegrityService');
-      if (requestId) {
-        writeResult(requestId, {
-          success: false,
-          error: `Initialization failed: ${error instanceof Error ? error.message : String(error)}`
-        });
-      }
+      writeResult(validatedRequestId, {
+        success: false,
+        error: `Initialization failed: ${error instanceof Error ? error.message : String(error)}`
+      });
       return;
     }
   }
 
   switch (type) {
     case 'integrity_check':
-      await handleIntegrityCheck(task, service, logger);
+      await handleIntegrityCheck(safeTask, service, logger);
       break;
 
     case 'integrity_approve':
-      await handleIntegrityApprove(task, service, logger);
+      await handleIntegrityApprove(safeTask, service, logger);
       break;
 
     case 'integrity_status':
-      await handleIntegrityStatus(task, service, logger);
+      await handleIntegrityStatus(safeTask, service, logger);
       break;
 
     case 'integrity_verify_audit':
-      await handleIntegrityVerifyAudit(task, service, logger);
+      await handleIntegrityVerifyAudit(safeTask, service, logger);
       break;
 
     default:
@@ -280,15 +287,40 @@ async function handleIntegrityVerifyAudit(
 // Helper Functions
 // ============================================================================
 
+function validateRequestId(requestId: unknown): string | null {
+  if (typeof requestId !== 'string') return null;
+  const normalized = requestId.trim();
+  if (!REQUEST_ID_PATTERN.test(normalized)) return null;
+  return normalized;
+}
+
+function resolveResultPath(requestId: string): string {
+  const safeRequestId = validateRequestId(requestId);
+  if (!safeRequestId) {
+    throw new Error('Invalid integrity IPC request id');
+  }
+
+  const resultDir = RESULT_DIR;
+  const normalizedResultDir = path.resolve(resultDir);
+  const resultPath = path.resolve(normalizedResultDir, `${safeRequestId}.json`);
+  const relativePath = path.relative(normalizedResultDir, resultPath);
+
+  if (relativePath.startsWith('..') || path.isAbsolute(relativePath)) {
+    throw new Error('Integrity IPC result path escapes result directory');
+  }
+
+  return resultPath;
+}
+
 function writeResult(requestId: string, result: any): void {
-  const resultDir = '/workspace/ipc/clawsec_results';
+  const resultPath = resolveResultPath(requestId);
+  const resultDir = path.dirname(resultPath);
 
   // Ensure directory exists
   if (!fs.existsSync(resultDir)) {
     fs.mkdirSync(resultDir, { recursive: true });
   }
 
-  const resultPath = path.join(resultDir, `${requestId}.json`);
   fs.writeFileSync(resultPath, JSON.stringify(result, null, 2));
 }
 

skills/clawsec-nanoclaw/lib/advisories.ts

@@ -86,39 +86,146 @@ export function versionMatches(version: string, versionSpec: string): boolean {
   if (v === spec) return true;
 
   // Parse semver components
-  const parseVersion = (ver: string): number[] => {
-    const match = ver.match(/^(\d+)\.(\d+)\.(\d+)/);
-    if (!match) return [];
-    return [parseInt(match[1], 10), parseInt(match[2], 10), parseInt(match[3], 10)];
+  type ParsedVersion = {
+    major: number;
+    minor: number;
+    patch: number;
+    prerelease: string[];
+  };
+
+  const semverPattern = String.raw`v?\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?`;
+  const semverRegex = new RegExp(
+    String.raw`^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$`
+  );
+
+  const parseVersion = (ver: string): ParsedVersion | null => {
+    const match = ver.match(semverRegex);
+    if (!match) return null;
+
+    return {
+      major: parseInt(match[1], 10),
+      minor: parseInt(match[2], 10),
+      patch: parseInt(match[3], 10),
+      prerelease: match[4] ? match[4].split('.') : [],
+    };
+  };
+
+  const comparePrereleaseIdentifiers = (left: string, right: string): number => {
+    const leftIsNumeric = /^\d+$/.test(left);
+    const rightIsNumeric = /^\d+$/.test(right);
+
+    if (leftIsNumeric && rightIsNumeric) {
+      const leftValue = parseInt(left, 10);
+      const rightValue = parseInt(right, 10);
+      if (leftValue > rightValue) return 1;
+      if (leftValue < rightValue) return -1;
+      return 0;
+    }
+
+    if (leftIsNumeric) return -1;
+    if (rightIsNumeric) return 1;
+    if (left > right) return 1;
+    if (left < right) return -1;
+    return 0;
+  };
+
+  const compareVersions = (left: ParsedVersion, right: ParsedVersion): number => {
+    if (left.major > right.major) return 1;
+    if (left.major < right.major) return -1;
+    if (left.minor > right.minor) return 1;
+    if (left.minor < right.minor) return -1;
+    if (left.patch > right.patch) return 1;
+    if (left.patch < right.patch) return -1;
+
+    if (left.prerelease.length === 0 && right.prerelease.length === 0) return 0;
+    if (left.prerelease.length === 0) return 1;
+    if (right.prerelease.length === 0) return -1;
+
+    const identifierCount = Math.max(left.prerelease.length, right.prerelease.length);
+    for (let index = 0; index < identifierCount; index += 1) {
+      const leftIdentifier = left.prerelease[index];
+      const rightIdentifier = right.prerelease[index];
+
+      if (leftIdentifier === undefined) return -1;
+      if (rightIdentifier === undefined) return 1;
+
+      const comparison = comparePrereleaseIdentifiers(leftIdentifier, rightIdentifier);
+      if (comparison !== 0) return comparison;
+    }
+
+    return 0;
+  };
+
+  const evaluateComparator = (comparator: string): boolean => {
+    const match = comparator.trim().match(new RegExp(`^(<=|>=|<|>|=)?\\s*(${semverPattern})$`));
+    if (!match) return false;
+
+    const operator = match[1] || '=';
+    const comparatorParts = parseVersion(match[2]);
+    if (!comparatorParts) return false;
+
+    const comparison = compareVersions(vParts, comparatorParts);
+    if (operator === '<') return comparison < 0;
+    if (operator === '<=') return comparison <= 0;
+    if (operator === '>') return comparison > 0;
+    if (operator === '>=') return comparison >= 0;
+    return comparison === 0;
+  };
+
+  const extractComparatorTokens = (range: string): string[] | null => {
+    const tokenPattern = new RegExp(`(?:<=|>=|<|>|=)?\\s*${semverPattern}`, 'g');
+    const tokens: string[] = [];
+    let cursor = 0;
+    let match = tokenPattern.exec(range);
+
+    while (match) {
+      const gap = range.slice(cursor, match.index);
+      if (!/^[\s,]*$/.test(gap)) return null;
+
+      tokens.push(match[0].trim());
+      cursor = match.index + match[0].length;
+      match = tokenPattern.exec(range);
+    }
+
+    if (!/^[\s,]*$/.test(range.slice(cursor))) return null;
+    return tokens.length > 0 ? tokens : null;
   };
 
   const vParts = parseVersion(v);
-  const specParts = parseVersion(spec.replace(/^[~^]/, ''));
+  if (!vParts) return true;
 
-  if (vParts.length === 0 || specParts.length === 0) return false;
+  if (/(?:<=|>=|<|>|=)/.test(spec)) {
+    const comparatorTokens = extractComparatorTokens(spec);
+    if (!comparatorTokens) return false;
+    return comparatorTokens.every((token) => evaluateComparator(token));
+  }
+
+  const specParts = parseVersion(spec.replace(/^[~^]/, ''));
+  if (!specParts) return true;
 
   // Caret range (^1.2.3): compatible with 1.x.x where x >= 2.3
   if (spec.startsWith('^')) {
-    if (vParts[0] !== specParts[0]) return false;
-    if (vParts[0] === 0) {
-      // ^0.2.3 means 0.2.x where x >= 3
-      if (vParts[1] !== specParts[1]) return false;
-      return vParts[2] >= specParts[2];
-    }
-    // ^1.2.3 means 1.x.x where x.x >= 2.3
-    if (vParts[1] > specParts[1]) return true;
-    if (vParts[1] < specParts[1]) return false;
-    return vParts[2] >= specParts[2];
+    const upperBound =
+      specParts.major > 0
+        ? { major: specParts.major + 1, minor: 0, patch: 0, prerelease: [] }
+        : specParts.minor > 0
+          ? { major: 0, minor: specParts.minor + 1, patch: 0, prerelease: [] }
+          : { major: 0, minor: 0, patch: specParts.patch + 1, prerelease: [] };
+
+    return compareVersions(vParts, specParts) >= 0 && compareVersions(vParts, upperBound) < 0;
   }
 
   // Tilde range (~1.2.3): patch-level compatibility (1.2.x where x >= 3)
   if (spec.startsWith('~')) {
-    if (vParts[0] !== specParts[0]) return false;
-    if (vParts[1] !== specParts[1]) return false;
-    return vParts[2] >= specParts[2];
+    const upperBound = { major: specParts.major, minor: specParts.minor + 1, patch: 0, prerelease: [] };
+    return compareVersions(vParts, specParts) >= 0 && compareVersions(vParts, upperBound) < 0;
   }
 
-  return false;
+  if (new RegExp(`^${semverPattern}$`).test(spec)) {
+    return compareVersions(vParts, specParts) === 0;
+  }
+
+  return true;
 }
 
 /**

skills/clawsec-nanoclaw/lib/types.ts

@@ -5,6 +5,11 @@
 
 export interface Advisory {
   id: string;
+  ghsa_id?: string;
+  cve_id?: string | null;
+  status?: 'active' | 'matured' | 'stale' | string;
+  stale?: boolean;
+  source_feed?: string;
   severity: 'critical' | 'high' | 'medium' | 'low';
   type: 'vulnerable_skill' | 'malicious_skill' | 'prompt_injection' | string;
   title: string;
@@ -14,7 +19,10 @@ export interface Advisory {
   published: string;
   references: string[];
   cvss_score?: number;
+  cvss_vector?: string | null;
   nvd_url?: string;
+  github_advisory_url?: string;
+  platforms?: string[];
   exploitability_score?: 'high' | 'medium' | 'low' | 'unknown';
   exploitability_rationale?: string;
   source?: string;

skills/clawsec-nanoclaw/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "clawsec-nanoclaw",
-  "version": "0.0.5",
+  "version": "0.0.8",
   "description": "ClawSec security suite for NanoClaw - Advisory feed monitoring, MCP tools for vulnerability checking, and Ed25519 signature verification for containerized WhatsApp bot agents",
   "author": "prompt-security",
   "license": "AGPL-3.0-or-later",

skills/clawsec-nanoclaw/test/security-hardening.test.mjs

@@ -1,7 +1,9 @@
 import assert from 'node:assert/strict';
 import fs from 'node:fs';
+import ts from 'typescript';
 import path from 'node:path';
 import test from 'node:test';
+import vm from 'node:vm';
 import { fileURLToPath } from 'node:url';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -12,6 +14,45 @@ function readSkillFile(relativePath) {
   return fs.readFileSync(path.join(SKILL_ROOT, relativePath), 'utf8');
 }
 
+function extractFunctionSource(source, functionName) {
+  const marker = `export function ${functionName}`;
+  const start = source.indexOf(marker);
+  assert.notEqual(start, -1, `missing ${functionName} export`);
+
+  const bodyStart = source.indexOf('{', start);
+  assert.notEqual(bodyStart, -1, `missing ${functionName} body`);
+
+  let depth = 0;
+  for (let index = bodyStart; index < source.length; index += 1) {
+    const char = source[index];
+    if (char === '{') depth += 1;
+    if (char === '}') depth -= 1;
+    if (depth === 0) {
+      return source.slice(start, index + 1).replace('export ', '');
+    }
+  }
+
+  throw new Error(`unterminated ${functionName} body`);
+}
+
+function loadVersionMatcher() {
+  const source = readSkillFile('lib/advisories.ts');
+  const fnSource = extractFunctionSource(source, 'versionMatches');
+  const js = ts.transpileModule(
+    `${fnSource}\nglobalThis.versionMatches = versionMatches;`,
+    {
+      compilerOptions: {
+        module: ts.ModuleKind.ESNext,
+        target: ts.ScriptTarget.ES2022,
+      },
+    }
+  ).outputText;
+
+  const context = { globalThis: {} };
+  vm.runInNewContext(js, context);
+  return context.globalThis.versionMatches;
+}
+
 test('signature verifier enforces pinned key and path policy', () => {
   const source = readSkillFile('host-services/skill-signature-handler.ts');
 
@@ -55,3 +96,39 @@ test('integrity targets and baselines use normalized absolute paths', () => {
   assert.ok(source.includes('const normalizedFilePath = path.resolve(filePath);'), 'status/approval lookups must normalize file paths');
   assert.ok(source.includes('normalizedFiles[path.resolve(filePath)] = baseline;'), 'loaded baselines must be normalized to absolute keys');
 });
+
+test('advisory matcher handles comparator ranges and fails closed on malformed specs', () => {
+  const versionMatches = loadVersionMatcher();
+
+  assert.equal(versionMatches('2026.4.20', '<2026.5.18'), true, 'less-than comparator must match vulnerable versions');
+  assert.equal(versionMatches('2026.5.18', '<2026.5.18'), false, 'less-than comparator must exclude patched versions');
+  assert.equal(versionMatches('2026.5.18', '<=2026.5.18'), true, 'less-than-or-equal comparator must match boundary versions');
+  assert.equal(versionMatches('1.4.0', '>=1.2.0 <2.0.0'), true, 'composite comparator ranges must match all clauses');
+  assert.equal(versionMatches('2.0.0', '>=1.2.0 <2.0.0'), false, 'composite comparator ranges must reject failed clauses');
+  assert.equal(versionMatches('0.0.2', '<= 0.0.2'), true, 'spaced comparators must match boundary versions');
+  assert.equal(versionMatches('0.0.3', '<= 0.0.2'), false, 'spaced comparators must reject versions outside range');
+  assert.equal(versionMatches('1.2.3', '>= 1.0.0 <'), false, 'partially parsed comparator ranges must not match everything');
+  assert.equal(versionMatches('1.2.3', 'not-a-range'), true, 'unparseable advisory specifiers must fail closed');
+});
+
+test('advisory matcher preserves semver prerelease precedence', () => {
+  const versionMatches = loadVersionMatcher();
+
+  assert.equal(versionMatches('1.2.3-beta.1', '1.2.3'), false, 'prereleases must not collapse into releases');
+  assert.equal(versionMatches('1.2.3-beta.1', '=1.2.3'), false, 'explicit equality must honor prerelease data');
+  assert.equal(versionMatches('1.2.3-beta.1', '<1.2.3'), true, 'prereleases must compare lower than releases');
+  assert.equal(versionMatches('1.2.3', '>1.2.3-beta.1'), true, 'releases must compare higher than prereleases');
+  assert.equal(versionMatches('1.2.3-beta.2', '<1.2.3-beta.10'), true, 'numeric prerelease identifiers must compare numerically');
+  assert.equal(versionMatches('1.2.3+build.1', '=1.2.3+build.2'), true, 'build metadata must not affect precedence');
+  assert.equal(versionMatches('1.2.3-beta.1', '^1.2.3'), false, 'caret lower bounds must honor prerelease precedence');
+  assert.equal(versionMatches('1.2.3-beta.1', '~1.2.3'), false, 'tilde lower bounds must honor prerelease precedence');
+});
+
+test('integrity IPC result writer validates request ids and result path containment', () => {
+  const source = readSkillFile('host-services/integrity-handler.ts');
+
+  assert.ok(source.includes('validateRequestId(requestId)'), 'writeResult must validate request ids before writing');
+  assert.ok(source.includes('resolveResultPath(requestId)'), 'writeResult must resolve result paths through a boundary helper');
+  assert.ok(source.includes('path.resolve(resultDir)'), 'result directory must be normalized before containment checks');
+  assert.ok(source.includes('path.relative(normalizedResultDir, resultPath)'), 'result path must be compared relative to the intended directory');
+});

skills/clawsec-scanner/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.0.5] - 2026-06-10
+
+### Changed
+
+- Re-released skill package with updated marketplace grouping and signed release trust artifacts for Vercel-compatible skill installation.
+
+## [0.0.4] - 2026-06-07
+
+### Security
+- Replaced DAST target hook execution with static hook source inspection so scanner runs never import, transpile, or invoke untrusted handler code.
+
 ## [0.0.3] - 2026-05-13
 
 ### Changed

skills/clawsec-scanner/README.md

@@ -0,0 +1,11 @@
+# Clawsec Scanner
+
+Automated vulnerability scanner for agent platforms. Performs dependency scanning (npm audit, pip-audit), multi-database CVE lookup (OSV, NVD, GitHub Advisory), SAST analysis (Semgrep, Bandit), and agent-specific static hook inspection for OpenClaw hooks.
+
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill clawsec-scanner -a openclaw -y
+```

skills/clawsec-scanner/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: clawsec-scanner
-version: 0.0.3
-description: Automated vulnerability scanner for agent platforms. Performs dependency scanning (npm audit, pip-audit), multi-database CVE lookup (OSV, NVD, GitHub Advisory), SAST analysis (Semgrep, Bandit), and agent-specific DAST hook execution testing for OpenClaw hooks.
+version: 0.0.5
+description: Automated vulnerability scanner for agent platforms. Performs dependency scanning (npm audit, pip-audit), multi-database CVE lookup (OSV, NVD, GitHub Advisory), SAST analysis (Semgrep, Bandit), and agent-specific static hook inspection for OpenClaw hooks.
 homepage: https://clawsec.prompt.security
 clawdis:
   emoji: "🔍"
@@ -16,10 +16,18 @@ Comprehensive security scanner for agent platforms that automates vulnerability
 - **Dependency Scanning**: Analyzes npm and Python dependencies using `npm audit` and `pip-audit` with structured JSON output parsing
 - **CVE Database Integration**: Queries OSV (primary), NVD 2.0, and GitHub Advisory Database for vulnerability enrichment
 - **SAST Analysis**: Static code analysis using Semgrep (JavaScript/TypeScript) and Bandit (Python) to detect hardcoded secrets, command injection, path traversal, and unsafe deserialization
-- **DAST Framework**: Agent-specific dynamic analysis with real OpenClaw hook execution harness (malicious input, timeout, output bounds, event mutation safety)
+- **DAST Framework**: Agent-specific static analysis of OpenClaw hook metadata and handler source without importing or invoking target code
 - **Unified Reporting**: Consolidated vulnerability reports with severity classification and remediation guidance
 - **Continuous Monitoring**: OpenClaw hook integration for automated periodic scanning
 
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill clawsec-scanner -a openclaw -y
+```
+
 ## Features
 
 ### Multi-Engine Scanning
@@ -43,8 +51,8 @@ The scanner orchestrates four complementary scan types to provide comprehensive
    - Identifies: hardcoded secrets (API keys, tokens), command injection (`eval`, `exec`), path traversal, unsafe deserialization
 
 4. **Dynamic Analysis (DAST)**
-   - Real hook execution harness for OpenClaw hook handlers discovered from `HOOK.md` metadata
-   - Verifies: malicious input resilience, timeout behavior, output amplification bounds, and core event mutation safety
+   - Static hook inspection for OpenClaw hook handlers discovered from `HOOK.md` metadata
+   - Verifies coverage and source-level risk signals without importing, transpiling, or invoking target handlers
    - Note: Traditional web DAST tools (ZAP, Burp) do not apply to agent platforms - this provides agent-specific testing
 
 ### Unified Reporting
@@ -248,8 +256,8 @@ scripts/runner.sh              # Orchestration layer
 ├── scan_dependencies.mjs      # npm audit + pip-audit
 ├── query_cve_databases.mjs    # OSV/NVD/GitHub API queries
 ├── sast_analyzer.mjs          # Semgrep + Bandit static analysis
-├── dast_runner.mjs            # Dynamic security testing orchestration
-└── dast_hook_executor.mjs     # Isolated real hook execution harness
+├── dast_runner.mjs            # Static hook inspection orchestration
+└── dast_hook_executor.mjs     # Static hook source inspection helper
 
 lib/
 ├── report.mjs                 # Result aggregation and formatting
@@ -326,10 +334,10 @@ proc.on('close', code => {
 - Requires Python 3.8+ runtime
 - Alternative: use Docker image `returntocorp/semgrep`
 
-**"TypeScript hook not executable in DAST harness"**
-- The DAST harness executes real hook handlers and transpiles `handler.ts` files when a TypeScript compiler is available
-- Install TypeScript in the scanner environment: `npm install -D typescript` (or provide `handler.js`/`handler.mjs`)
-- Without a compiler, scanner reports an `info`-level coverage finding instead of a high-severity vulnerability
+**"DAST static coverage finding"**
+- The DAST harness does not execute target hook handlers.
+- JavaScript and TypeScript hook files are read as source and reported with `info`-level static coverage findings.
+- Review any listed static signals manually when deciding whether a hook needs deeper sandboxed testing.
 
 **"Concurrent scan detected"**
 - Lockfile exists: `/tmp/clawsec-scanner.lock`
@@ -371,7 +379,7 @@ done
 node test/dependency_scanner.test.mjs  # Dependency scanning
 node test/cve_integration.test.mjs     # CVE database APIs
 node test/sast_engine.test.mjs         # Static analysis
-node test/dast_harness.test.mjs        # DAST harness execution
+node test/dast_harness.test.mjs        # DAST static hook inspection
 ```
 
 ### Linting
@@ -456,11 +464,11 @@ npx clawhub@latest install clawsec-suite
 
 ## Roadmap
 
-### v0.0.2 (Current)
+### v0.0.4 (Current)
 - [x] Dependency scanning (npm audit, pip-audit)
 - [x] CVE database integration (OSV, NVD, GitHub Advisory)
 - [x] SAST analysis (Semgrep, Bandit)
-- [x] Real OpenClaw hook execution harness for DAST
+- [x] Static OpenClaw hook inspection for DAST without target code execution
 - [x] Unified JSON reporting
 - [x] OpenClaw hook integration
 

skills/clawsec-scanner/hooks/clawsec-scanner-hook/handler.ts

@@ -196,7 +196,7 @@ function buildAlertMessage(report: ScanReport, format: string): string {
 }
 
 const handler = async (event: HookEvent, _context: HookContext): Promise<void> => {
-  // DAST harness mode executes hook handlers directly; skip recursive scanner runs.
+  // Preserve the legacy DAST guard so older scanner harnesses cannot recurse.
   if (process.env.CLAWSEC_DAST_HARNESS === "1" || _context?.dastMode === true) {
     return;
   }

skills/clawsec-scanner/scripts/dast_hook_executor.mjs

@@ -2,8 +2,6 @@
 
 import fs from "node:fs/promises";
 import path from "node:path";
-import { createRequire } from "node:module";
-import { pathToFileURL } from "node:url";
 
 function parseArgs(argv) {
   const parsed = {
@@ -47,26 +45,9 @@ function parseArgs(argv) {
     throw new Error("Missing required --handler");
   }
 
-  if (!parsed.eventB64) {
-    throw new Error("Missing required --event");
-  }
-
-  if (!parsed.contextB64) {
-    throw new Error("Missing required --context");
-  }
-
   return parsed;
 }
 
-function decodeBase64Json(value, label) {
-  try {
-    const decoded = Buffer.from(value, "base64").toString("utf8");
-    return JSON.parse(decoded);
-  } catch (error) {
-    throw new Error(`Failed to decode ${label}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
 async function fileExists(filePath) {
   try {
     await fs.access(filePath);
@@ -76,69 +57,7 @@ async function fileExists(filePath) {
   }
 }
 
-async function loadTypeScriptCompiler() {
-  if (process.env.CLAWSEC_DAST_DISABLE_TYPESCRIPT === "1") {
-    return null;
-  }
-
-  try {
-    const imported = await import("typescript");
-    return imported.default || imported;
-  } catch {
-    // Ignore and try require path next.
-  }
-
-  try {
-    const req = createRequire(import.meta.url);
-    return req("typescript");
-  } catch {
-    return null;
-  }
-}
-
-async function importTypeScriptModule(tsPath) {
-  const tsCompiler = await loadTypeScriptCompiler();
-  if (!tsCompiler || typeof tsCompiler.transpileModule !== "function") {
-    throw new Error(
-      `Cannot execute TypeScript hook (${tsPath}): typescript compiler not available. ` +
-        "Install 'typescript' or provide a JavaScript handler file.",
-    );
-  }
-
-  const source = await fs.readFile(tsPath, "utf8");
-  const transpiled = tsCompiler.transpileModule(source, {
-    compilerOptions: {
-      module: tsCompiler.ModuleKind.ESNext,
-      target: tsCompiler.ScriptTarget.ES2022,
-      moduleResolution: tsCompiler.ModuleResolutionKind.NodeNext,
-      esModuleInterop: true,
-      sourceMap: false,
-      inlineSourceMap: false,
-      declaration: false,
-    },
-    fileName: tsPath,
-    reportDiagnostics: false,
-  });
-
-  const tempFile = path.join(
-    path.dirname(tsPath),
-    `.clawsec-dast-${path.basename(tsPath, ".ts")}-${process.pid}-${Date.now()}.mjs`,
-  );
-
-  await fs.writeFile(tempFile, transpiled.outputText, "utf8");
-
-  try {
-    return await import(`${pathToFileURL(tempFile).href}?ts=${Date.now()}`);
-  } finally {
-    try {
-      await fs.unlink(tempFile);
-    } catch {
-      // best-effort cleanup
-    }
-  }
-}
-
-async function loadHookModule(handlerPath) {
+async function readHookSource(handlerPath) {
   const fullPath = path.resolve(handlerPath);
   const exists = await fileExists(fullPath);
   if (!exists) {
@@ -146,120 +65,71 @@ async function loadHookModule(handlerPath) {
   }
 
   const ext = path.extname(fullPath).toLowerCase();
-
-  if (ext === ".ts") {
-    return importTypeScriptModule(fullPath);
+  const allowedExtensions = new Set([".cjs", ".js", ".mjs", ".ts"]);
+  if (!allowedExtensions.has(ext)) {
+    throw new Error(`Unsupported hook handler extension: ${ext || "(none)"}`);
   }
 
-  return import(`${pathToFileURL(fullPath).href}?v=${Date.now()}`);
+  const source = await fs.readFile(fullPath, "utf8");
+  return { fullPath, ext, source };
 }
 
-function resolveHandlerExport(mod, exportName) {
+function detectHandlerExport(source, exportName) {
   if (exportName && exportName !== "default") {
-    if (typeof mod?.[exportName] === "function") {
-      return mod[exportName];
-    }
-    throw new Error(`Hook export '${exportName}' is not a function`);
+    const escaped = exportName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`export\\s+(?:async\\s+)?function\\s+${escaped}\\b|export\\s*\\{[^}]*\\b${escaped}\\b`, "m").test(source);
   }
 
-  if (typeof mod?.default === "function") {
-    return mod.default;
-  }
-
-  if (typeof mod?.handler === "function") {
-    return mod.handler;
-  }
-
-  throw new Error("Hook module does not export a handler function");
+  return (
+    /\bexport\s+default\b/m.test(source) ||
+    /\bexport\s+(?:async\s+)?function\s+handler\b/m.test(source) ||
+    /\bmodule\.exports\s*=|\bexports\.handler\s*=/m.test(source)
+  );
 }
 
-function normalizeTimestamp(event) {
-  const timestamp = event?.timestamp;
-  if (typeof timestamp === "string" || typeof timestamp === "number") {
-    const parsed = new Date(timestamp);
-    if (!Number.isNaN(parsed.getTime())) {
-      event.timestamp = parsed;
+function collectRiskSignals(source) {
+  const rules = [
+    ["child_process", /\bchild_process\b|\bfrom\s+["']node:child_process["']|\brequire\(["']child_process["']\)/m],
+    ["dynamic-import", /\bimport\s*\(/m],
+    ["eval", /\beval\s*\(|\bnew\s+Function\s*\(/m],
+    ["shell-command", /\b(?:exec|spawn|execFile|fork)\s*\(/m],
+    ["environment-access", /\bprocess\.env\b/m],
+  ];
+
+  const signals = [];
+  for (const [name, pattern] of rules) {
+    if (pattern.test(source)) {
+      signals.push(name);
     }
   }
-}
-
-function summarizeMessages(messages) {
-  if (!Array.isArray(messages)) {
-    return {
-      count: 0,
-      charCount: 0,
-    };
-  }
-
-  let charCount = 0;
-
-  for (const message of messages) {
-    if (typeof message === "string") {
-      charCount += message.length;
-      continue;
-    }
-
-    try {
-      charCount += JSON.stringify(message).length;
-    } catch {
-      charCount += 0;
-    }
-  }
-
-  return {
-    count: messages.length,
-    charCount,
-  };
-}
-
-function coreEventShape(event) {
-  return {
-    type: event?.type ?? null,
-    action: event?.action ?? null,
-    sessionKey: event?.sessionKey ?? null,
-  };
+  return signals;
 }
 
 async function main() {
   const args = parseArgs(process.argv.slice(2));
-  const event = decodeBase64Json(args.eventB64, "event payload");
-  const context = decodeBase64Json(args.contextB64, "context payload");
-
-  normalizeTimestamp(event);
-
   const startedAt = Date.now();
-  const before = coreEventShape(event);
 
   try {
-    const mod = await loadHookModule(args.handler);
-    const handler = resolveHandlerExport(mod, args.exportName);
-
-    await handler(event, context);
-
-    const after = coreEventShape(event);
-    const messageSummary = summarizeMessages(event?.messages);
+    const inspected = await readHookSource(args.handler);
 
     const payload = {
       ok: true,
+      static_only: true,
       duration_ms: Date.now() - startedAt,
-      core_before: before,
-      core_after: after,
-      messages_count: messageSummary.count,
-      messages_char_count: messageSummary.charCount,
+      handler_path: inspected.fullPath,
+      handler_extension: inspected.ext,
+      source_bytes: Buffer.byteLength(inspected.source, "utf8"),
+      source_lines: inspected.source.split(/\r?\n/).length,
+      handler_export_declared: detectHandlerExport(inspected.source, args.exportName),
+      risk_signals: collectRiskSignals(inspected.source),
     };
 
     process.stdout.write(JSON.stringify(payload));
   } catch (error) {
-    const after = coreEventShape(event);
-    const messageSummary = summarizeMessages(event?.messages);
-
     const payload = {
       ok: false,
+      static_only: true,
       duration_ms: Date.now() - startedAt,
-      core_before: before,
-      core_after: after,
-      messages_count: messageSummary.count,
-      messages_char_count: messageSummary.charCount,
       error: error instanceof Error ? error.message : String(error),
     };
 

skills/clawsec-scanner/scripts/dast_runner.mjs

@@ -24,8 +24,6 @@ import { getTimestamp } from "../lib/utils.mjs";
  */
 
 const DEFAULT_TIMEOUT_MS = 30000;
-const MAX_OUTPUT_MESSAGES = 25;
-const MAX_OUTPUT_CHARS = 20000;
 const SKIP_DIR_NAMES = new Set([
   ".git",
   ".github",
@@ -38,17 +36,6 @@ const SKIP_DIR_NAMES = new Set([
   ".openclaw",
 ]);
 
-const MALICIOUS_PAYLOADS = [
-  "<script>alert('XSS')</script>",
-  "'; DROP TABLE users; --",
-  "; rm -rf /",
-  "$(whoami)",
-  "..\\..\\..\\windows\\system32\\config\\sam",
-  "../../../etc/passwd",
-  "test\0malicious",
-  "A".repeat(200000),
-];
-
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const HOOK_EXECUTOR_PATH = path.join(__dirname, "dast_hook_executor.mjs");
@@ -320,43 +307,6 @@ export async function discoverHooks(targetPath) {
   return hooks;
 }
 
-/**
- * @param {string} eventKey
- * @returns {{type: string, action: string}}
- */
-function splitEventKey(eventKey) {
-  const parts = String(eventKey ?? "").split(":");
-  const type = parts.shift() || "command";
-  const action = parts.join(":") || "new";
-  return { type, action };
-}
-
-/**
- * @param {string} eventKey
- * @param {string} payload
- * @param {string} targetPath
- * @returns {Record<string, unknown>}
- */
-export function buildEvent(eventKey, payload, targetPath) {
-  const { type, action } = splitEventKey(eventKey);
-
-  return {
-    type,
-    action,
-    sessionKey: "clawsec-dast-session",
-    timestamp: new Date().toISOString(),
-    messages: [],
-    context: {
-      content: payload,
-      transcript: payload,
-      workspaceDir: path.resolve(targetPath),
-      channelId: "dast-harness",
-      commandSource: "dast",
-      bootstrapFiles: [],
-    },
-  };
-}
-
 /**
  * @typedef {Object} HarnessInvocationResult
  * @property {boolean} timedOut
@@ -368,33 +318,24 @@ export function buildEvent(eventKey, payload, targetPath) {
 
 /**
  * @param {HookDescriptor} hook
- * @param {Record<string, unknown>} event
- * @param {Record<string, unknown>} context
  * @param {number} timeoutMs
  * @returns {Promise<HarnessInvocationResult>}
  */
-async function invokeHookHarness(hook, event, context, timeoutMs) {
-  const encodedEvent = Buffer.from(JSON.stringify(event), "utf8").toString("base64");
-  const encodedContext = Buffer.from(JSON.stringify(context), "utf8").toString("base64");
-
+async function inspectHookHandler(hook, timeoutMs) {
   const args = [
     HOOK_EXECUTOR_PATH,
     "--handler",
     hook.handlerPath,
     "--export",
     hook.exportName || "default",
-    "--event",
-    encodedEvent,
-    "--context",
-    encodedContext,
   ];
 
   return new Promise((resolve) => {
     const proc = spawn("node", args, {
       stdio: ["ignore", "pipe", "pipe"],
       env: {
-        ...process.env,
-        CLAWSEC_DAST_HARNESS: "1",
+        PATH: process.env.PATH || "",
+        CLAWSEC_DAST_STATIC_INSPECTION: "1",
       },
     });
 
@@ -462,31 +403,33 @@ function isObject(value) {
 
 /**
  * @param {unknown} parsed
- * @returns {{ok: boolean, error: string, messagesCount: number, messagesCharCount: number, coreAfter: Record<string, unknown>}}
+ * @returns {{ok: boolean, error: string, staticOnly: boolean, riskSignals: string[], handlerExportDeclared: boolean}}
  */
-function normalizeHarnessPayload(parsed) {
+function normalizeStaticPayload(parsed) {
   if (!isObject(parsed)) {
     return {
       ok: false,
       error: "Harness output is not an object",
-      messagesCount: 0,
-      messagesCharCount: 0,
-      coreAfter: {},
+      staticOnly: false,
+      riskSignals: [],
+      handlerExportDeclared: false,
     };
   }
 
   const ok = parsed.ok === true;
   const error = typeof parsed.error === "string" ? parsed.error : "";
-  const messagesCount = Number(parsed.messages_count ?? 0) || 0;
-  const messagesCharCount = Number(parsed.messages_char_count ?? 0) || 0;
-  const coreAfter = isObject(parsed.core_after) ? parsed.core_after : {};
+  const staticOnly = parsed.static_only === true;
+  const riskSignals = Array.isArray(parsed.risk_signals)
+    ? parsed.risk_signals.filter((signal) => typeof signal === "string")
+    : [];
+  const handlerExportDeclared = parsed.handler_export_declared === true;
 
   return {
     ok,
     error,
-    messagesCount,
-    messagesCharCount,
-    coreAfter,
+    staticOnly,
+    riskSignals,
+    handlerExportDeclared,
   };
 }
 
@@ -502,19 +445,6 @@ function slug(input) {
     .slice(0, 60);
 }
 
-/**
- * @param {string} reason
- * @returns {boolean}
- */
-function isHarnessCapabilityError(reason) {
-  const normalized = String(reason ?? "").toLowerCase();
-  return (
-    normalized.includes("typescript compiler not available")
-    || normalized.includes("does not export a handler function")
-    || normalized.includes("is not a function")
-  );
-}
-
 /**
  * @param {Vulnerability[]} bucket
  * @param {string} id
@@ -541,178 +471,74 @@ function pushHookVulnerability(bucket, id, severity, hook, eventKey, title, desc
 
 /**
  * @param {HookDescriptor} hook
- * @param {string} targetPath
+ * @param {string} _targetPath
  * @param {number} timeoutMs
  * @returns {Promise<Vulnerability[]>}
  */
-async function evaluateHook(hook, targetPath, timeoutMs) {
+async function evaluateHook(hook, _targetPath, timeoutMs) {
   const findings = [];
   const invocationTimeoutMs = Math.max(1000, timeoutMs);
+  // Static inspection depends only on the handler source/export, so reuse it for all hook events.
+  const inspection = await inspectHookHandler(hook, invocationTimeoutMs);
 
   for (const eventKey of hook.events) {
-    const safeEvent = buildEvent(eventKey, "safe baseline input", targetPath);
-    const safeContext = {
-      skillPath: hook.hookDir,
-      agentPlatform: "openclaw",
-      dastMode: true,
-      targetPath: path.resolve(targetPath),
-      event: eventKey,
-    };
-
-    const safeResult = await invokeHookHarness(hook, safeEvent, safeContext, invocationTimeoutMs);
-
-    if (safeResult.timedOut) {
+    if (inspection.timedOut) {
       pushHookVulnerability(
         findings,
-        `DAST-TIMEOUT-${slug(`${hook.name}-${eventKey}`)}`,
-        "high",
-        hook,
-        eventKey,
-        "Hook times out under baseline input",
-        `Hook execution exceeded ${invocationTimeoutMs}ms for event '${eventKey}' under safe baseline input.`,
-      );
-      continue;
-    }
-
-    if (safeResult.parseError) {
-      pushHookVulnerability(
-        findings,
-        `DAST-HARNESS-${slug(`${hook.name}-${eventKey}`)}`,
+        `DAST-STATIC-TIMEOUT-${slug(`${hook.name}-${eventKey}`)}`,
         "medium",
         hook,
         eventKey,
-        "Hook harness output invalid",
-        `Could not parse harness output for event '${eventKey}': ${safeResult.parseError}. stderr: ${safeResult.stderr || "(empty)"}`,
+        "Hook static inspection timed out",
+        `Static hook inspection exceeded ${invocationTimeoutMs}ms for event '${eventKey}'. Target code was not executed.`,
       );
       continue;
     }
 
-    const normalizedSafe = normalizeHarnessPayload(safeResult.parsed);
-    if (!normalizedSafe.ok) {
-      const reason = normalizedSafe.error || safeResult.stderr || "unknown error";
-
-      if (isHarnessCapabilityError(reason)) {
-        pushHookVulnerability(
-          findings,
-          `DAST-COVERAGE-${slug(`${hook.name}-${eventKey}`)}`,
-          "info",
-          hook,
-          eventKey,
-          "Hook not executable in local DAST harness",
-          `DAST harness could not execute hook for event '${eventKey}' due to runtime capability limits: ${reason}`,
-        );
-      } else {
-        pushHookVulnerability(
-          findings,
-          `DAST-CRASH-${slug(`${hook.name}-${eventKey}`)}`,
-          "high",
-          hook,
-          eventKey,
-          "Hook throws on baseline input",
-          `Hook execution failed for event '${eventKey}' under safe baseline input: ${reason}`,
-        );
-      }
-      continue;
-    }
-
-    const mutationObserved =
-      normalizedSafe.coreAfter.type !== safeEvent.type ||
-      normalizedSafe.coreAfter.action !== safeEvent.action ||
-      normalizedSafe.coreAfter.sessionKey !== safeEvent.sessionKey;
-
-    if (mutationObserved) {
+    if (inspection.parseError) {
       pushHookVulnerability(
         findings,
-        `DAST-MUTATION-${slug(`${hook.name}-${eventKey}`)}`,
-        "low",
-        hook,
-        eventKey,
-        "Hook mutates core event identity fields",
-        `Hook changed one or more of type/action/sessionKey for event '${eventKey}'. This can cause routing side effects in OpenClaw hooks.`,
-      );
-    }
-
-    if (
-      normalizedSafe.messagesCount > MAX_OUTPUT_MESSAGES ||
-      normalizedSafe.messagesCharCount > MAX_OUTPUT_CHARS
-    ) {
-      pushHookVulnerability(
-        findings,
-        `DAST-OUTPUT-${slug(`${hook.name}-${eventKey}`)}`,
+        `DAST-STATIC-HARNESS-${slug(`${hook.name}-${eventKey}`)}`,
         "medium",
         hook,
         eventKey,
-        "Hook output exceeds safe bounds",
-        `Hook generated ${normalizedSafe.messagesCount} messages and ${normalizedSafe.messagesCharCount} chars for baseline input. Limits: ${MAX_OUTPUT_MESSAGES} messages / ${MAX_OUTPUT_CHARS} chars.`,
+        "Hook static inspection output invalid",
+        `Could not parse static inspection output for event '${eventKey}': ${inspection.parseError}. stderr: ${inspection.stderr || "(empty)"}`,
       );
+      continue;
     }
 
-    const maliciousFailures = [];
-    const maliciousTimeouts = [];
-
-    for (const payload of MALICIOUS_PAYLOADS) {
-      const event = buildEvent(eventKey, payload, targetPath);
-      const context = {
-        ...safeContext,
-        payloadLength: payload.length,
-      };
-
-      const result = await invokeHookHarness(hook, event, context, invocationTimeoutMs);
-
-      if (result.timedOut) {
-        maliciousTimeouts.push(`len=${payload.length}`);
-        continue;
-      }
-
-      if (result.parseError) {
-        maliciousFailures.push(`parse-error(${result.parseError})`);
-        continue;
-      }
-
-      const normalized = normalizeHarnessPayload(result.parsed);
-      if (!normalized.ok) {
-        maliciousFailures.push(normalized.error || "execution-error");
-      }
-
-      if (
-        normalized.messagesCount > MAX_OUTPUT_MESSAGES ||
-        normalized.messagesCharCount > MAX_OUTPUT_CHARS
-      ) {
-        pushHookVulnerability(
-          findings,
-          `DAST-OUTPUT-${slug(`${hook.name}-${eventKey}`)}-${payload.length}`,
-          "medium",
-          hook,
-          eventKey,
-          "Hook output amplification under malicious input",
-          `Hook generated ${normalized.messagesCount} messages and ${normalized.messagesCharCount} chars for payload length ${payload.length}.`,
-        );
-      }
-    }
-
-    if (maliciousTimeouts.length > 0) {
+    const normalized = normalizeStaticPayload(inspection.parsed);
+    if (!normalized.ok || !normalized.staticOnly) {
+      const reason = normalized.error || inspection.stderr || "unknown static inspection error";
       pushHookVulnerability(
         findings,
-        `DAST-MALICIOUS-TIMEOUT-${slug(`${hook.name}-${eventKey}`)}`,
-        "high",
+        `DAST-STATIC-COVERAGE-${slug(`${hook.name}-${eventKey}`)}`,
+        "info",
         hook,
         eventKey,
-        "Hook times out on malicious input",
-        `Hook exceeded ${invocationTimeoutMs}ms for malicious payloads (${maliciousTimeouts.slice(0, 3).join(", ")}${maliciousTimeouts.length > 3 ? `, +${maliciousTimeouts.length - 3} more` : ""}).`,
+        "Hook not executed during DAST static inspection",
+        `DAST did not execute hook code for event '${eventKey}'. Static inspection failed with: ${reason}`,
       );
+      continue;
     }
 
-    if (maliciousFailures.length > 0) {
-      pushHookVulnerability(
-        findings,
-        `DAST-MALICIOUS-CRASH-${slug(`${hook.name}-${eventKey}`)}`,
-        "high",
-        hook,
-        eventKey,
-        "Hook crashes on malicious input",
-        `Hook raised unhandled errors for malicious payloads. Sample errors: ${maliciousFailures.slice(0, 3).join(" | ")}${maliciousFailures.length > 3 ? ` (+${maliciousFailures.length - 3} more)` : ""}`,
-      );
-    }
+    const signalSuffix = normalized.riskSignals.length > 0
+      ? ` Static signals observed: ${normalized.riskSignals.join(", ")}.`
+      : "";
+    const exportSuffix = normalized.handlerExportDeclared
+      ? ""
+      : " The configured handler export was not obvious from static source inspection.";
+
+    pushHookVulnerability(
+      findings,
+      `DAST-STATIC-COVERAGE-${slug(`${hook.name}-${eventKey}`)}`,
+      "info",
+      hook,
+      eventKey,
+      "Hook inspected statically without executing target code",
+      `DAST inspected the hook source for event '${eventKey}' without importing, transpiling, or invoking the handler.${signalSuffix}${exportSuffix}`,
+    );
   }
 
   return findings;
@@ -778,8 +604,6 @@ async function main() {
   }
 }
 
-export { MALICIOUS_PAYLOADS };
-
 if (import.meta.url === `file://${process.argv[1]}`) {
   main();
 }

skills/clawsec-scanner/skill.json

@@ -1,7 +1,7 @@
 {
   "name": "clawsec-scanner",
-  "version": "0.0.3",
-  "description": "Automated vulnerability scanner for agent platforms. Performs dependency scanning (npm audit, pip-audit), multi-database CVE lookup (OSV, NVD, GitHub Advisory), SAST analysis (Semgrep, Bandit), and agent-specific DAST hook execution testing for OpenClaw hooks.",
+  "version": "0.0.5",
+  "description": "Automated vulnerability scanner for agent platforms. Performs dependency scanning (npm audit, pip-audit), multi-database CVE lookup (OSV, NVD, GitHub Advisory), SAST analysis (Semgrep, Bandit), and agent-specific static hook inspection for OpenClaw hooks.",
   "author": "prompt-security",
   "license": "AGPL-3.0-or-later",
   "homepage": "https://clawsec.prompt.security/",
@@ -57,12 +57,12 @@
       {
         "path": "scripts/dast_runner.mjs",
         "required": true,
-        "description": "Dynamic analysis harness executing OpenClaw hook handlers with malicious-input and timeout checks"
+        "description": "Static OpenClaw hook inspection harness that does not execute target handlers"
       },
       {
         "path": "scripts/dast_hook_executor.mjs",
         "required": true,
-        "description": "Isolated hook execution helper used by DAST for real OpenClaw harness testing"
+        "description": "Static hook source inspection helper used by DAST without importing target handlers"
       },
       {
         "path": "scripts/setup_scanner_hook.mjs",

skills/clawsec-scanner/test/dast_harness.test.mjs

@@ -89,8 +89,13 @@ metadata: { "openclaw": { "events": [${eventsLiteral}] } }
   await fs.writeFile(path.join(hookDir, handlerFile), handlerSource, "utf8");
 }
 
-async function testSafeHookExecutesAndDoesNotReportMisleadingHigh() {
-  const testName = "DAST harness: executes real hook and reports no misleading high findings";
+async function writeExecutable(filePath, content) {
+  await fs.writeFile(filePath, content, "utf8");
+  await fs.chmod(filePath, 0o755);
+}
+
+async function testSafeHookIsInspectedWithoutExecution() {
+  const testName = "DAST harness: inspects hooks without executing target code";
   const tmp = await createTempDir();
 
   try {
@@ -125,19 +130,20 @@ export default handler;
       .then(() => true)
       .catch(() => false);
 
-    const cleanSummary =
+    const noHighSummary =
       result.report?.summary?.critical === 0
       && result.report?.summary?.high === 0
       && result.report?.summary?.medium === 0
-      && result.report?.summary?.low === 0
-      && result.report?.summary?.info === 0;
+      && result.report?.summary?.low === 0;
+    const hasStaticCoverageInfo = Array.isArray(result.report?.vulnerabilities)
+      && result.report.vulnerabilities.some((v) => String(v.id || "").includes("DAST-STATIC-COVERAGE"));
 
-    if (result.code === 0 && markerExists && cleanSummary) {
+    if (result.code === 0 && !markerExists && noHighSummary && hasStaticCoverageInfo) {
       pass(testName);
     } else {
       fail(
         testName,
-        `Expected exit=0, markerExists=true, clean summary. Got exit=${result.code}, markerExists=${markerExists}, summary=${JSON.stringify(result.report?.summary)} stderr=${result.stderr}`,
+        `Expected exit=0, markerExists=false, static coverage info, and no high findings. Got exit=${result.code}, markerExists=${markerExists}, summary=${JSON.stringify(result.report?.summary)} findings=${JSON.stringify(result.report?.vulnerabilities || [])} stderr=${result.stderr}`,
       );
     }
   } catch (error) {
@@ -147,18 +153,24 @@ export default handler;
   }
 }
 
-async function testMaliciousCrashProducesHighFinding() {
-  const testName = "DAST harness: malicious input crash is reported as high";
+async function testMaliciousHandlerIsNotExecutedForPayloadChecks() {
+  const testName = "DAST harness: malicious payload checks do not execute hook code";
   const tmp = await createTempDir();
 
   try {
     const targetPath = path.join(tmp.path, "skill");
     const hookDir = path.join(targetPath, "hooks", "crashy-hook");
+    const markerFile = path.join(hookDir, "executed.marker");
 
     await writeHookFixture(
       hookDir,
       '"message:preprocessed"',
-      `const handler = async (event) => {
+      `import fs from "node:fs";
+import path from "node:path";
+
+fs.writeFileSync(path.join(path.dirname(new URL(import.meta.url).pathname), "executed.marker"), "top-level");
+
+const handler = async (event) => {
   const payload = String(event?.context?.content || "");
   if (payload.includes("<script>")) {
     throw new Error("Unhandled payload path");
@@ -170,16 +182,21 @@ export default handler;
     );
 
     const result = await runDast(targetPath, 2500);
-    const hasHigh = Number(result.report?.summary?.high || 0) > 0;
-    const hasCrashFinding = Array.isArray(result.report?.vulnerabilities)
-      && result.report.vulnerabilities.some((v) => String(v.id || "").includes("DAST-MALICIOUS-CRASH"));
+    const markerExists = await fs
+      .access(markerFile)
+      .then(() => true)
+      .catch(() => false);
+    const noHigh = Number(result.report?.summary?.high || 0) === 0
+      && Number(result.report?.summary?.critical || 0) === 0;
+    const hasStaticCoverageInfo = Array.isArray(result.report?.vulnerabilities)
+      && result.report.vulnerabilities.some((v) => String(v.id || "").includes("DAST-STATIC-COVERAGE"));
 
-    if (result.code === 1 && hasHigh && hasCrashFinding) {
+    if (result.code === 0 && !markerExists && noHigh && hasStaticCoverageInfo) {
       pass(testName);
     } else {
       fail(
         testName,
-        `Expected exit=1 and malicious crash high finding. Got exit=${result.code}, summary=${JSON.stringify(result.report?.summary)}, findings=${JSON.stringify(result.report?.vulnerabilities || [])}`,
+        `Expected static inspection without marker/high findings. Got exit=${result.code}, markerExists=${markerExists}, summary=${JSON.stringify(result.report?.summary)}, findings=${JSON.stringify(result.report?.vulnerabilities || [])}`,
       );
     }
   } catch (error) {
@@ -189,8 +206,8 @@ export default handler;
   }
 }
 
-async function testMissingTypeScriptCompilerIsCoverageInfo() {
-  const testName = "DAST harness: missing TypeScript compiler reports coverage info, not high";
+async function testTypeScriptHookIsStaticallyInspectedWithoutCompiler() {
+  const testName = "DAST harness: TypeScript hooks are statically inspected without compiler execution";
   const tmp = await createTempDir();
 
   try {
@@ -220,7 +237,7 @@ export default handler;
     const noHigh = Number(result.report?.summary?.high || 0) === 0
       && Number(result.report?.summary?.critical || 0) === 0;
     const hasCoverageInfo = Array.isArray(result.report?.vulnerabilities)
-      && result.report.vulnerabilities.some((v) => String(v.id || "").includes("DAST-COVERAGE"));
+      && result.report.vulnerabilities.some((v) => String(v.id || "").includes("DAST-STATIC-COVERAGE"));
     const hasInfoCount = Number(result.report?.summary?.info || 0) > 0;
 
     if (result.code === 0 && noHigh && hasCoverageInfo && hasInfoCount) {
@@ -238,10 +255,76 @@ export default handler;
   }
 }
 
+async function testStaticInspectionRunsOncePerHook() {
+  const testName = "DAST harness: static inspection runs once per hook across events";
+  const tmp = await createTempDir();
+
+  try {
+    const targetPath = path.join(tmp.path, "skill");
+    const hookDir = path.join(targetPath, "hooks", "multi-event-hook");
+    const binDir = path.join(tmp.path, "bin");
+    const nodeLogPath = path.join(tmp.path, "node-invocations.log");
+
+    await writeHookFixture(
+      hookDir,
+      '"agent:bootstrap", "command:new", "message:preprocessed"',
+      `export default async function handler() {
+  return;
+}
+`,
+    );
+
+    await fs.mkdir(binDir, { recursive: true });
+    await writeExecutable(
+      path.join(binDir, "node"),
+      `#!${process.execPath}
+import fs from "node:fs";
+import { spawnSync } from "node:child_process";
+
+fs.appendFileSync(${JSON.stringify(nodeLogPath)}, JSON.stringify(process.argv.slice(2)) + "\\n");
+const result = spawnSync(${JSON.stringify(process.execPath)}, process.argv.slice(2), {
+  env: process.env,
+  stdio: ["ignore", "inherit", "inherit"],
+});
+process.exit(result.status ?? 1);
+`,
+    );
+
+    const result = await runDast(targetPath, 2500, {
+      PATH: `${binDir}:${process.env.PATH}`,
+    });
+
+    const log = await fs.readFile(nodeLogPath, "utf8");
+    const invocations = log
+      .trim()
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => JSON.parse(line));
+    const executorCount = invocations.filter((args) => String(args[0] || "").endsWith("dast_hook_executor.mjs")).length;
+    const staticCoverageCount = Array.isArray(result.report?.vulnerabilities)
+      ? result.report.vulnerabilities.filter((v) => String(v.id || "").includes("DAST-STATIC-COVERAGE")).length
+      : 0;
+
+    if (result.code === 0 && executorCount === 1 && staticCoverageCount === 3) {
+      pass(testName);
+    } else {
+      fail(
+        testName,
+        `Expected one executor spawn and three per-event findings. Got exit=${result.code}, executorCount=${executorCount}, staticCoverageCount=${staticCoverageCount}, invocations=${JSON.stringify(invocations)}`,
+      );
+    }
+  } catch (error) {
+    fail(testName, error);
+  } finally {
+    await tmp.cleanup();
+  }
+}
+
 async function main() {
-  await testSafeHookExecutesAndDoesNotReportMisleadingHigh();
-  await testMaliciousCrashProducesHighFinding();
-  await testMissingTypeScriptCompilerIsCoverageInfo();
+  await testSafeHookIsInspectedWithoutExecution();
+  await testMaliciousHandlerIsNotExecutedForPayloadChecks();
+  await testTypeScriptHookIsStaticallyInspectedWithoutCompiler();
+  await testStaticInspectionRunsOncePerHook();
 
   report();
   exitWithResults();

skills/clawsec-suite/CHANGELOG.md

@@ -1,10 +1,29 @@
 # Changelog
 
+## [0.1.10] - 2026-06-10
+
+### Changed
+
+- Re-released skill package with updated marketplace grouping and signed release trust artifacts for Vercel-compatible skill installation.
+
 All notable changes to the ClawSec Suite will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.9] - 2026-05-24
+
+### Changed
+
+- Documented the remote advisory feed as a consolidated feed containing NVD CVEs, approved community advisories, and provisional GHSA-without-CVE records.
+- Added advisory guardian type coverage for GHSA lifecycle metadata used by the consolidated feed.
+
+## [0.1.8] - 2026-05-16
+
+### Fixed
+
+- Added the advisory scope and suppression runtime helpers to `skill.json` SBOM metadata so release archives include every file required by the advisory guardian hook.
+
 ## [0.1.7] - 2026-04-16
 
 ### Changed

skills/clawsec-suite/README.md

@@ -0,0 +1,11 @@
+# Clawsec Suite
+
+ClawSec suite manager with embedded advisory-feed monitoring, cryptographic signature verification, approval-gated malicious-skill response, and guided setup for additional security skills.
+
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill clawsec-suite -a openclaw -y
+```

skills/clawsec-suite/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: clawsec-suite
-version: 0.1.7
+version: 0.1.10
 description: ClawSec suite manager with embedded advisory-feed monitoring, cryptographic signature verification, approval-gated malicious-skill response, and guided setup for additional security skills.
 homepage: https://clawsec.prompt.security
 clawdis:
@@ -11,6 +11,14 @@ clawdis:
 
 # ClawSec Suite
 
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill clawsec-suite -a openclaw -y
+```
+
 ## Operational Notes
 
 - Required runtime: `node`, `npx`, `openclaw`, `curl`, `jq`, `shasum`, `openssl`, `unzip`
@@ -28,7 +36,7 @@ This means `clawsec-suite` can:
 ## Included vs Optional Protections
 
 ### Built into clawsec-suite
-- Embedded feed seed file: `advisories/feed.json`
+- Embedded consolidated advisory feed seed file: `advisories/feed.json`
 - Portable heartbeat workflow in `HEARTBEAT.md`
 - Advisory polling + state tracking + affected-skill checks
 - OpenClaw advisory guardian hook package: `hooks/clawsec-advisory-guardian/`
@@ -200,7 +208,8 @@ This enforces:
 
 The embedded feed logic uses these defaults:
 
-- Remote feed URL: `https://clawsec.prompt.security/advisories/feed.json`
+- Remote consolidated feed URL: `https://clawsec.prompt.security/advisories/feed.json`
+- Feed contents: NVD CVEs, approved community advisories, and provisional GHSA-without-CVE advisories.
 - Remote feed signature URL: `${CLAWSEC_FEED_URL}.sig` (override with `CLAWSEC_FEED_SIG_URL`)
 - Remote checksums manifest URL: sibling `checksums.json` (override with `CLAWSEC_FEED_CHECKSUMS_URL`)
 - Local seed fallback: `~/.openclaw/skills/clawsec-suite/advisories/feed.json`

skills/clawsec-suite/hooks/clawsec-advisory-guardian/lib/types.ts

@@ -6,6 +6,11 @@ export type HookEvent = {
 
 export type Advisory = {
   id?: string;
+  ghsa_id?: string;
+  cve_id?: string | null;
+  status?: string;
+  stale?: boolean;
+  source_feed?: string;
   severity?: string;
   type?: string;
   application?: string | string[];
@@ -15,6 +20,10 @@ export type Advisory = {
   published?: string;
   updated?: string;
   affected?: string[];
+  platforms?: string[];
+  references?: string[];
+  nvd_url?: string | null;
+  github_advisory_url?: string;
 };
 
 export type FeedPayload = {

skills/clawsec-suite/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "clawsec-suite",
-  "version": "0.1.7",
+  "version": "0.1.10",
   "description": "ClawSec suite manager with embedded advisory-feed monitoring, cryptographic signature verification, approval-gated malicious-skill response, and guided setup for additional security skills.",
   "author": "prompt-security",
   "license": "AGPL-3.0-or-later",
@@ -85,6 +85,11 @@
         "required": true,
         "description": "Shared semver parsing and version matching logic"
       },
+      {
+        "path": "hooks/clawsec-advisory-guardian/lib/advisory_scope.mjs",
+        "required": true,
+        "description": "Advisory application-scope filtering helper for OpenClaw-facing flows"
+      },
       {
         "path": "hooks/clawsec-advisory-guardian/lib/feed.mjs",
         "required": true,
@@ -110,6 +115,11 @@
         "required": true,
         "description": "Advisory-to-skill matching and alert message generation"
       },
+      {
+        "path": "hooks/clawsec-advisory-guardian/lib/suppression.mjs",
+        "required": true,
+        "description": "Advisory suppression loading and matching helpers"
+      },
       {
         "path": "scripts/setup_advisory_hook.mjs",
         "required": true,

skills/clawtributor/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.0.7] - 2026-06-10
+
+### Changed
+
+- Re-released skill package with updated marketplace grouping and signed release trust artifacts for Vercel-compatible skill installation.
+- Marked Clawtributor as a harness-neutral global skill for OpenClaw, NanoClaw, Hermes, and Picoclaw installer grouping.
+- Removed OpenClaw CLI as a declared runtime requirement because reporting is manual, approval-gated, and not tied to an OpenClaw command path.
+- Documented Vercel skills installer usage alongside the OpenClaw/ClawHub install path.
+- Moved local report/state guidance to `~/.clawsec/clawtributor/`.
+
 ## [0.0.6] - 2026-05-14
 
 ### Security

skills/clawtributor/README.md

@@ -2,6 +2,20 @@
 
 Community incident reporting for AI agents.
 
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill clawtributor -a openclaw -y
+```
+
+Codex install is also supported:
+
+```bash
+npx skills add prompt-security/clawsec --skill clawtributor -a codex -y
+```
+
 ## Operational Notes
 
 - Reporting is opt-in for every submission
@@ -17,6 +31,14 @@ Community incident reporting for AI agents.
 
 ## Quick Install
 
+Vercel skills installer:
+
+```bash
+npx skills add prompt-security/clawsec --skill clawtributor -a codex -y
+```
+
+OpenClaw/ClawHub:
+
 ```bash
 npx clawhub@latest install clawtributor
 ```

skills/clawtributor/SKILL.md

@@ -1,23 +1,44 @@
 ---
 name: clawtributor
-version: 0.0.6
-description: Community incident reporting for AI agents. Contribute to collective security by reporting threats.
+version: 0.0.7
+description: Harness-neutral community incident reporting for AI agents. Contribute to collective security by reporting threats.
 homepage: https://clawsec.prompt.security
-metadata: {"openclaw":{"emoji":"🤝","category":"security"}}
+platforms:
+  - openclaw
+  - nanoclaw
+  - hermes
+  - picoclaw
+metadata:
+  global: true
+  openclaw:
+    emoji: "🤝"
+    category: "security"
 clawdis:
   emoji: "🤝"
-  requires:
-    bins: [openclaw]
 ---
 
 # Clawtributor 🤝
 
 Community incident reporting for AI agents. Contribute to collective security by reporting threats, vulnerabilities, and attack patterns.
 
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill clawtributor -a openclaw -y
+```
+
+Codex install is also supported:
+
+```bash
+npx skills add prompt-security/clawsec --skill clawtributor -a codex -y
+```
+
 ## Operational Notes
 
-- Recommended install path: ClawHub registry (`npx clawhub@latest install clawtributor`)
-- Side effects: creates local report/state files under `~/.openclaw/`
+- Recommended install path: harness-native skills installer; use ClawHub for OpenClaw/ClawHub environments (`npx clawhub@latest install clawtributor`)
+- Side effects: creates local report/state files under `~/.clawsec/clawtributor/`
 - Network behavior: none unless the user explicitly approves manual submission
 - Trust model: reporting is opt-in for every submission; sanitize evidence before it leaves the host
 
@@ -27,7 +48,13 @@ Community incident reporting for AI agents. Contribute to collective security by
 
 ## Installation
 
-Install from the registry:
+Install with your harness-native skills installer. For the Vercel skills installer:
+
+```bash
+npx skills add prompt-security/clawsec --skill clawtributor -a codex -y
+```
+
+For OpenClaw/ClawHub environments, install from the registry:
 
 ```bash
 npx clawhub@latest install clawtributor
@@ -44,7 +71,6 @@ I will keep reports local unless you explicitly approve submission.
 
 ---
 
-
 ## Release Artifact Verification
 
 For standalone installs, verify the signed release manifest before trusting `SKILL.md`, `skill.json`, or the archive. The `skill.json` file is the package metadata/SBOM source, and the release pipeline signs `checksums.json` with the ClawSec release key.
@@ -53,7 +79,7 @@ For standalone installs, verify the signed release manifest before trusting `SKI
 set -euo pipefail
 
 SKILL_NAME="clawtributor"
-VERSION="0.0.6"
+VERSION="0.0.7"
 REPO="prompt-security/clawsec"
 TAG="${SKILL_NAME}-v${VERSION}"
 BASE="https://github.com/${REPO}/releases/download/${TAG}"
@@ -233,7 +259,7 @@ See [reporting.md](./reporting.md) for the full report format and submission gui
 
 ### Step 1: Prepare report locally
 
-- Save the report JSON under `~/.openclaw/clawtributor-reports/`
+- Save the report JSON under `~/.clawsec/clawtributor/reports/`
 - Keep file permissions private (`chmod 600`)
 - Confirm the report is sanitized before sharing
 
@@ -284,7 +310,7 @@ DO NOT include:
 
 ## State Tracking
 
-Track submitted reports in `~/.openclaw/clawtributor-state.json`.
+Track submitted reports in `~/.clawsec/clawtributor/state.json`.
 
 Example:
 

skills/clawtributor/skill.json

@@ -1,16 +1,24 @@
 {
   "name": "clawtributor",
-  "version": "0.0.6",
-  "description": "Community incident reporting for AI agents. Contribute to collective security by reporting threats.",
+  "version": "0.0.7",
+  "description": "Harness-neutral community incident reporting for AI agents. Contribute to collective security by reporting threats.",
   "author": "prompt-security",
   "license": "AGPL-3.0-or-later",
   "homepage": "https://clawsec.prompt.security",
+  "platforms": [
+    "openclaw",
+    "nanoclaw",
+    "hermes",
+    "picoclaw"
+  ],
   "keywords": [
     "security",
     "reporting",
     "community",
     "agents",
     "ai",
+    "global",
+    "harness-neutral",
     "vulnerability",
     "contribution"
   ],
@@ -36,11 +44,6 @@
   "openclaw": {
     "emoji": "🤝",
     "category": "security",
-    "requires": {
-      "bins": [
-        "openclaw"
-      ]
-    },
     "execution": {
       "always": false,
       "persistence": "Stores local report/state files only; no recurring automation is created by default.",

skills/hermes-attestation-guardian/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.1.4] - 2026-06-10
+
+### Changed
+
+- Re-released skill package with updated marketplace grouping and signed release trust artifacts for Vercel-compatible skill installation.
+
+## [0.1.3] - 2026-05-24
+
+### Changed
+- Documented that the default signed advisory feed is consolidated and may include NVD CVEs, approved community advisories, and provisional GHSA-without-CVE records while Hermes matching remains package-scoped.
+
+## [0.1.2] - 2026-05-15
+
+### Fixed
+- Included `lib/semver.mjs` and `lib/cron.mjs` in the release SBOM so signed archives contain every runtime library imported by shipped scripts.
+
 ## [0.1.1] - 2026-05-13
 
 ### Security

skills/hermes-attestation-guardian/README.md

@@ -4,6 +4,14 @@ Hermes-only attestation, advisory verification, and guarded verification workflo
 
 Status: implemented (v0.1.0), Hermes-only.
 
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill hermes-attestation-guardian -a hermes-agent -y
+```
+
 ## Capabilities
 
 This skill now covers the full Hermes-side capability set expected from the clawsec-suite parity workstream:

skills/hermes-attestation-guardian/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: hermes-attestation-guardian
-version: 0.1.1
+version: 0.1.4
 description: Hermes-only runtime security attestation and drift detection skill for operator-managed Hermes infrastructure.
 homepage: https://clawsec.prompt.security
 hermes:
@@ -15,6 +15,13 @@ IMPORTANT SCOPE:
 - This skill targets Hermes infrastructure only (CLI/Gateway/profile-managed deployments).
 - This skill is not an OpenClaw runtime hook package.
 
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill hermes-attestation-guardian -a hermes-agent -y
+```
 
 ## Release Artifact Verification
 
@@ -24,7 +31,7 @@ For standalone installs, verify the signed release manifest before trusting `SKI
 set -euo pipefail
 
 SKILL_NAME="hermes-attestation-guardian"
-VERSION="0.1.1"
+VERSION="0.1.4"
 REPO="prompt-security/clawsec"
 TAG="${SKILL_NAME}-v${VERSION}"
 BASE="https://github.com/${REPO}/releases/download/${TAG}"
@@ -207,6 +214,8 @@ Severity messages are emitted as INFO / WARNING / CRITICAL style lines.
 
 ## Advisory feed override knobs
 
+The default signed advisory feed is consolidated: it can contain NVD CVEs, approved community advisories, and provisional GHSA-without-CVE records. Hermes matching still gates on affected package names and supported version ranges.
+
 - Source selection: `HERMES_ADVISORY_FEED_SOURCE=auto|remote|local`
 - Remote artifacts: `HERMES_ADVISORY_FEED_URL`, `HERMES_ADVISORY_FEED_SIG_URL`, `HERMES_ADVISORY_FEED_CHECKSUMS_URL`, `HERMES_ADVISORY_FEED_CHECKSUMS_SIG_URL`
 - Local artifacts: `HERMES_LOCAL_ADVISORY_FEED`, `HERMES_LOCAL_ADVISORY_FEED_SIG`, `HERMES_LOCAL_ADVISORY_FEED_CHECKSUMS`, `HERMES_LOCAL_ADVISORY_FEED_CHECKSUMS_SIG`

skills/hermes-attestation-guardian/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-attestation-guardian",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "description": "Hermes-only runtime security attestation and drift detection skill. Generates deterministic posture artifacts, verifies integrity fail-closed, and classifies baseline drift severity.",
   "author": "prompt-security",
   "license": "AGPL-3.0-or-later",
@@ -46,6 +46,16 @@
         "required": true,
         "description": "Hermes-native advisory feed verification and state helpers"
       },
+      {
+        "path": "lib/semver.mjs",
+        "required": true,
+        "description": "Advisory version-range parsing and matching helpers"
+      },
+      {
+        "path": "lib/cron.mjs",
+        "required": true,
+        "description": "Shared managed cron block and cadence helpers"
+      },
       {
         "path": "scripts/generate_attestation.mjs",
         "required": true,

skills/hermes-traffic-guardian/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.0.1-beta3] - 2026-06-10
+
+### Changed
+
+- Re-released skill package with updated marketplace grouping and signed release trust artifacts for Vercel-compatible skill installation.
+
 ## [0.0.1-beta2] - 2026-05-13
 
 ### Security

skills/hermes-traffic-guardian/README.md

@@ -4,6 +4,14 @@ Baseline skill for Hermes runtime traffic monitoring.
 
 This package is intentionally a spec scaffold. Builders should add the Hermes-specific monitor implementation here while preserving the safety contract in `SKILL.md` and `SPEC.md`.
 
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill hermes-traffic-guardian -a hermes-agent -y
+```
+
 ## Intended Capability
 
 - detect outbound secret exfiltration in Hermes HTTP/HTTPS traffic
@@ -15,4 +23,3 @@ This package is intentionally a spec scaffold. Builders should add the Hermes-sp
 ## Builder Notes
 
 Keep runtime ownership in this skill. `hermes-attestation-guardian` should only attest this skill's state, config, and output fingerprints.
-

skills/hermes-traffic-guardian/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: hermes-traffic-guardian
-version: 0.0.1-beta2
+version: 0.0.1-beta3
 description: Hermes runtime traffic monitoring baseline for opt-in proxy inspection, egress detection, and attestation-aware traffic posture.
 homepage: https://clawsec.prompt.security
 author: prompt-security
@@ -15,6 +15,13 @@ hermes:
 
 This is a baseline specification skill. It intentionally does not ship a proxy or runtime implementation yet.
 
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill hermes-traffic-guardian -a hermes-agent -y
+```
 
 ## Release Artifact Verification
 
@@ -24,7 +31,7 @@ For standalone installs, verify the signed release manifest before trusting `SKI
 set -euo pipefail
 
 SKILL_NAME="hermes-traffic-guardian"
-VERSION="0.0.1-beta2"
+VERSION="0.0.1-beta3"
 REPO="prompt-security/clawsec"
 TAG="${SKILL_NAME}-v${VERSION}"
 BASE="https://github.com/${REPO}/releases/download/${TAG}"
@@ -145,4 +152,3 @@ Read `SPEC.md` before implementing. Use the placeholder folders as follows:
 - default blocking
 - sending traffic to external services
 - collecting full request/response bodies
-

skills/hermes-traffic-guardian/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-traffic-guardian",
-  "version": "0.0.1-beta2",
+  "version": "0.0.1-beta3",
   "description": "Hermes runtime traffic monitoring baseline for opt-in proxy inspection, egress detection, and attestation-aware traffic posture.",
   "author": "prompt-security",
   "license": "AGPL-3.0-or-later",

skills/nanoclaw-traffic-guardian/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [0.0.1-beta3] - 2026-06-10
+
+### Changed
+
+- Re-released skill package with updated marketplace grouping and signed release trust artifacts for Vercel-compatible skill installation.
+
 ## [0.0.1-beta2] - 2026-05-13
 
 ### Security

skills/nanoclaw-traffic-guardian/README.md

@@ -4,6 +4,14 @@ Baseline skill for NanoClaw runtime traffic monitoring.
 
 This package is intentionally a spec scaffold. Builders should add the NanoClaw-specific host-service, IPC, and MCP implementation here while preserving the safety contract in `SKILL.md` and `SPEC.md`.
 
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill nanoclaw-traffic-guardian -a openclaw -y
+```
+
 ## Intended Capability
 
 - detect outbound secret exfiltration in NanoClaw host-managed traffic
@@ -15,4 +23,3 @@ This package is intentionally a spec scaffold. Builders should add the NanoClaw-
 ## Builder Notes
 
 Follow the existing `clawsec-nanoclaw` pattern: host services own privileged operations, while MCP tools expose bounded requests and redacted responses.
-

skills/nanoclaw-traffic-guardian/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: nanoclaw-traffic-guardian
-version: 0.0.1-beta2
+version: 0.0.1-beta3
 description: NanoClaw runtime traffic monitoring baseline for host-side proxy inspection with container-safe MCP and IPC status surfaces.
 homepage: https://clawsec.prompt.security
 author: prompt-security
@@ -14,6 +14,13 @@ nanoclaw:
 
 This is a baseline specification skill. It intentionally does not ship a proxy or runtime implementation yet.
 
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill nanoclaw-traffic-guardian -a openclaw -y
+```
 
 ## Release Artifact Verification
 
@@ -23,7 +30,7 @@ For standalone installs, verify the signed release manifest before trusting `SKI
 set -euo pipefail
 
 SKILL_NAME="nanoclaw-traffic-guardian"
-VERSION="0.0.1-beta2"
+VERSION="0.0.1-beta3"
 REPO="prompt-security/clawsec"
 TAG="${SKILL_NAME}-v${VERSION}"
 BASE="https://github.com/${REPO}/releases/download/${TAG}"
@@ -146,4 +153,3 @@ Read `SPEC.md` before implementing. Use the placeholder folders as follows:
 - default blocking
 - sending traffic to external services
 - exposing raw request/response bodies to the container
-

skills/nanoclaw-traffic-guardian/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "nanoclaw-traffic-guardian",
-  "version": "0.0.1-beta2",
+  "version": "0.0.1-beta3",
   "description": "NanoClaw runtime traffic monitoring baseline for host-side proxy inspection with container-safe MCP and IPC status surfaces.",
   "author": "prompt-security",
   "license": "AGPL-3.0-or-later",

skills/openclaw-audit-watchdog/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.1.7] - 2026-06-10
+
+### Changed
+
+- Re-released skill package with updated marketplace grouping and signed release trust artifacts for Vercel-compatible skill installation.
+
+## [0.1.6] - 2026-05-16
+
+### Fixed
+- Added `scripts/load_suppression_config.mjs` to `skill.json` SBOM metadata so release archives include the helper imported by `scripts/render_report.mjs`.
+
 ## [0.1.5] - 2026-05-14
 
 ### Security

skills/openclaw-audit-watchdog/README.md

@@ -2,6 +2,14 @@
 
 Automated daily security audits for OpenClaw agents with DM delivery and optional email reporting.
 
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill openclaw-audit-watchdog -a openclaw -y
+```
+
 ## Overview
 
 The Audit Watchdog provides automated security monitoring for your OpenClaw agent deployments:

skills/openclaw-audit-watchdog/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: openclaw-audit-watchdog
-version: 0.1.5
+version: 0.1.7
 description: Automated daily security audits for OpenClaw agents with DM delivery and optional email reporting. Runs deep audits, creates or updates a recurring cron job, and sends formatted reports to configured recipients.
 homepage: https://clawsec.prompt.security
 metadata:
@@ -29,6 +29,14 @@ clawdis:
 
 # Prompt Security Audit (openclaw)
 
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill openclaw-audit-watchdog -a openclaw -y
+```
+
 ## Installation Options
 
 You can get openclaw-audit-watchdog in two ways:
@@ -65,7 +73,6 @@ Continue below for standalone installation instructions.
 
 ---
 
-
 ## Release Artifact Verification
 
 For standalone installs, verify the signed release manifest before trusting `SKILL.md`, `skill.json`, or the archive. The `skill.json` file is the package metadata/SBOM source, and the release pipeline signs `checksums.json` with the ClawSec release key.
@@ -74,7 +81,7 @@ For standalone installs, verify the signed release manifest before trusting `SKI
 set -euo pipefail
 
 SKILL_NAME="openclaw-audit-watchdog"
-VERSION="0.1.5"
+VERSION="0.1.7"
 REPO="prompt-security/clawsec"
 TAG="${SKILL_NAME}-v${VERSION}"
 BASE="https://github.com/${REPO}/releases/download/${TAG}"

skills/openclaw-audit-watchdog/skill.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-audit-watchdog",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Automated daily security audits for OpenClaw agents with DM delivery and optional email reporting. Creates or updates an unattended cron job and sends formatted reports to configured recipients.",
   "author": "prompt-security",
   "license": "AGPL-3.0-or-later",
@@ -52,6 +52,11 @@
         "required": false,
         "description": "SMTP delivery (Node.js)"
       },
+      {
+        "path": "scripts/load_suppression_config.mjs",
+        "required": false,
+        "description": "Suppression configuration loading and path normalization used by report rendering"
+      },
       {
         "path": "scripts/setup_cron.mjs",
         "required": false,

skills/openclaw-traffic-guardian/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.0.1-beta3] - 2026-06-10
+
+### Security
+- Added the `POLICY_REVIEW` scope for approval-sensitive social-account mutation requests, contributed by @kriptoburak.
+- Defined required JSONL metadata for social-account mutation findings, including source type, mutation category, approval-marker presence, and execution context.
+
+### Changed
+- Clarified that persistent social monitor and webhook configuration changes are review findings, while read-only social research should remain covered by no-false-positive tests.
+- Re-released skill package with updated marketplace grouping and signed release trust artifacts for Vercel-compatible skill installation.
+
 ## [0.0.1-beta2] - 2026-05-13
 
 ### Security

skills/openclaw-traffic-guardian/README.md

@@ -4,10 +4,19 @@ Baseline skill for OpenClaw runtime traffic monitoring.
 
 This package is intentionally a spec scaffold. Builders should add the OpenClaw-specific monitor implementation here while preserving the safety contract in `SKILL.md` and `SPEC.md`.
 
+## Vercel Skills Installation
+
+Install with the Vercel Skills CLI for this harness:
+
+```bash
+npx skills add prompt-security/clawsec --skill openclaw-traffic-guardian -a openclaw -y
+```
+
 ## Intended Capability
 
 - detect outbound secret exfiltration in agent HTTP/HTTPS traffic
 - detect inbound command-injection and tool-abuse payloads
+- record operator-review findings for approval-sensitive social-account mutations
 - write redacted local JSONL findings
 - provide explicit start, stop, status, and log-query commands
 - integrate with `clawsec-suite` as an optional add-on
@@ -15,4 +24,3 @@ This package is intentionally a spec scaffold. Builders should add the OpenClaw-
 ## Builder Notes
 
 Use `SPEC.md` as the implementation contract. Keep runtime changes opt-in and scoped to the OpenClaw process being monitored.
-