@ccoalm/ccl-skills 0.7.0 → 0.9.0

package/dist/assets/marketplace/plugins/ccl-skills/skills/skill-extraction-workflow/references/source-to-skill-extraction.md

@@ -251,6 +251,14 @@ Rules:
 - Do not count source-register or source-map text as the skill itself. Provenance proves where a rule came from; the owning skill/reference must still tell a future user how to apply, implement, test, or reject the rule without reading the provenance trail.
 - **Reconcile the map against every upstream disposition surface before closeout — the map is a transcription, and transcriptions drop rows.** Walk every disposition surface still valid for the current scope — whichever round or session produced it (per-axis lesson tables, candidate ledger, a refined or replay-produced map; a cross-session resume inherits the prior round's surfaces, it does not reset them) — and list the surfaces actually reconciled: every row whose disposition carries a forward obligation — `routed`, `landed`, `updated`, `pending`, or any status naming an owner/output — must resolve to a map row (`updated`/`unchanged`/`routed`/`pending` with owner — a `pending` map row preserves the blocker per the existing pending rule instead of forcing a fake terminal status) or carry a superseded note that names the successor map row covering the same mechanism; derive the surface list from the round's own records (charter, source register, produced-artifact rows), not from memory — a disposition surface named in those records but absent from the reconciled list keeps the claim `interim` (wholesale omission of the records themselves is fabrication, out of scope for this gate and covered by the never-fabricate red line); only evidenced terminal rows (`discarded`/`no-new-lesson`/`not-applicable` with reason) need no map row, and a superseded note with no successor is `downgraded`/`pending`, not closure. A dispositioned row silently absent from the map blocks the complete claim — "diff matches map" then passes while the lesson is lost, which is the exact hole this check closes (observed shape: an axis table routed a craft lesson to two owners; the refined map omitted the row; the landing round verified diff-vs-map clean and shipped without it, caught only by user challenge).
 
+## Member-Join Inheritance
+
+The SKILL.md class-wide COMPLETE-set rule (example of a class-wide change: "every stack `*-dev`/`*-architecture` should advertise a localized-refactor trigger"; example of a member-pair landing: Python+Go) fires on change-side sweeps. This section is its join-side dual.
+
+- When a NEW skill joins an already-swept class (e.g. a new stack `*-dev` joining the stack-implementation-owner class), enumerate the class-wide obligations its siblings already carry — advertised triggers, skip-leg reciprocity on routing counterparties, pinned pointer-integrity anchors, and bank fixtures — and inherit each, or record a per-obligation `not-applicable` reason, before the member lands.
+- A sibling-generalization map that only answers the copied-content question ("does the new skill duplicate sibling text?") must not be counted as obligation-inheritance coverage; the two questions are independent, and the join-side miss survives a clean copied-content map.
+- Validation: the closeout map lists each inherited obligation with a status, exactly as the change-side sweep lists each member. Failure shape: a new stack implementation owner landed with "siblings unchanged because the new skill routes to their existing contracts" while lacking the CLI carve-out reciprocity and the localized-refactor trigger pair its siblings carry; only independent review caught it.
+
 ## Capability Naming And Provenance
 
 Use this when naming a new skill, naming a reference file, renaming an extracted artifact, or turning a source-specific pattern into reusable guidance.
@@ -669,3 +677,15 @@ Use these checks before treating a source-derived skill as ready:
 - New skill: create only when the future user would naturally ask for a different task type.
 - Reference file: use for detailed checklists, variants, examples, and source-derived heuristics.
 - Script: use for repeatable validation, scanning, generation, or formatting that should be deterministic.
+
+## Benchmark Verdict Discipline
+
+For an external-pack / sibling-repo benchmark round (the `SKILL.md` benchmark Core Rule owns when this fires), the per-mechanism verdict table replaces impressionistic gap lists. Each source mechanism gets one row:
+
+- **Verdict, four values**: `P` (we cover it correctly — requires a decision point, not just the concept named), `I` (covered but incomplete — name the missing branch), `M` (missing — but see the functional-equivalent check), `W` (we state it wrong — quote both sides with file:line and propose the fix).
+- **Grep-anchored evidence**: every row carries the grep terms used against our tree; an `M` verdict requires the zero-hit grep recorded as replayable evidence — terms plus the exact command/mode, path scope, and baseline revision (`NO_HITS: <terms> @ <rev>`), because once the borrow lands, a replay against HEAD hits the landed rule itself; replay runs against the recorded baseline.
+- **Functional-equivalent check before any `M` borrow**: a missing *name* is not a missing *capability* — search for what our tree does in that situation under other vocabulary; when an equivalent exists, the verdict is `P(功能等价)` or `I`, and the borrow shrinks to naming/linking value (usually low). This is the mechanical guard against borrowing-for-the-sake-of-alignment.
+- **Borrowing degree** per `M`/`I`: high / medium / low, scored on one axis only — how much the mechanism changes an agent's actual decisions — never on how impressive the source text reads.
+- **Disposition vocabulary**: beyond keep/merge/discard/route, two middle states are legitimate and prevent binary misjudgment — `待实验` (hypothesis worth testing: record the hypothesis, the experiment, and pass/fail criteria; do not land prose) and `条件化采纳` (adopt with explicit applicability conditions, disable conditions, and a fallback path recorded next to the rule).
+- **Conflict synthesis, three shapes before choosing sides**: when the source contradicts our rule, first test whether the conflict is (a) a missing tier — both are right in different regimes, so merge by adding the regime split; (b) a missing ordering — both rules survive with an explicit precedence; (c) conflated authority — one side owns proposing and the other owns deciding, so split the powers. Only when none fits is it a genuine pick-one decision (keep the stricter per Conflict Resolution).
+- **W-type internal-consistency sweep**: a mature skill tree's highest-yield audit is internal drift, not external comparison. The recurring W classes to grep for: an absolutized single-case rule (one scenario promoted to an unconditional "always/never"), same-name-different-meaning across files, translation/paraphrase drift between sibling-language files, a template violating its own stated hard rule, stale-era residue (rules about tools/versions no longer in the stack), a hard-coded value where a policy/parameter reference should be, and version-lagged claims about fast-moving vendors. Route wording-level dedup to `tighten-doc`; land each confirmed W as a fix with both sides cited.

package/dist/assets/marketplace/plugins/ccl-skills/skills/skill-extraction-workflow/references/uiux-judgment-extraction.md

@@ -86,7 +86,7 @@ Use source-specific judgment, but verify with concrete proxies:
 - One primary visual focus per task state; secondary controls should not compete with the main artifact or decision.
 - Use stable spacing rhythm such as 4/8px increments unless the source system clearly uses another rhythm.
 - Record token provenance before extracting visual rules: the source of typography, primary color, neutral/background scale, radius, shadow/elevation, and component density. If the source has multiple plausible visual directions or the implementation code hardcodes page-level colors, treat that as extraction evidence and decide whether the reusable rule should require a visual direction comparison, token cleanup, or both.
-- Touch targets should meet platform norms: at least 44pt on iOS and 48dp on Android where touch is required.
+- Touch targets should follow current first-party platform guidance. For buttons, preserve Apple HIG's general-rule hit region of at least 44×44pt (60×60pt on visionOS) and Android's at-least-48×48dp touch/focusable guidance as platform-scoped inputs, not universal constants; measure the actual hit region separately from the glyph.
 - Text contrast should meet WCAG expectations for normal and small text; do not rely on brand color alone for state.
 - Dense work surfaces should keep stable row/card height, fixed context when identity would be lost, and local overflow affordance instead of decorative whitespace.
 - Modal, drawer, overlay, and floating tool visual weight should match consequence: lightweight details should not look as severe as destructive confirmation.
@@ -106,12 +106,12 @@ For each flow, inspect and record:
 
 ## Behavioral And Psychology Anchors
 
-Each behavioral or psychology rule needs at least one falsifiable anchor:
+Each behavioral or psychology rule needs an observable risk, a falsifiable hypothesis, and a named evidence boundary. A theory name is retrieval shorthand, not a universal design instruction; classify and source theory claims through `product-ui-ux-design/references/external-ui-ux-quality-benchmarks.md`.
 
-- Hick: reduce active choices while the user is deciding; reveal controls when inspecting or correcting.
-- Fitts: repeated or high-risk controls need stable placement and adequate hit area.
-- Miller/cognitive load: chunk dense information; do not force users to hold hidden context across modal or route changes.
-- Doherty/feedback timing: show feedback quickly for user actions; use visible pending/final states for long work.
+- Choice search: when competing options slow or confuse the representative task, reduce simultaneous choices or progressively disclose secondary controls; verify the task outcome instead of invoking a named law as proof.
+- Target acquisition: repeated controls need stable placement, and interactive targets need a hit area appropriate to the current platform, input mode, task frequency, and consequence. Do not derive high-risk confirmation or an exact size from Fitts's law.
+- Hidden-context burden: chunk dense information and preserve task context across modal or route changes; verify recall, comparison, and recovery in representative tasks rather than asserting a fixed working-memory limit.
+- State uncertainty: acknowledge actions and expose pending, success, failure, and recovery states at a pace appropriate to the operation. An arbitrary response-time threshold is not acceptance evidence.
 - Error prevention: prevent invalid input before submit when possible; when not possible, show local repair guidance.
 - User control: provide cancel, undo, retry, edit, restore, or explicit irreversible confirmation depending on consequence.
 - Trust: show source, scope, permission, timestamp, automation caveat, and consequence near the affected decision.

package/dist/assets/marketplace/plugins/ccl-skills/skills/skill-extraction-workflow/references/validation-and-landing.md

@@ -128,14 +128,14 @@ Before commit, for any rule that appears in more than one authored file (`SKILL.
 
 ## Bounded Independent Review Packet
 
-Use this when an independent review is required but a broad reviewer prompt hangs, returns no output, or starts expanding beyond the intended review scope. The gate-valid path is the provider-neutral `code-review` gate (`review_gate.sh`) with its frozen packet, family exclusion, structured validation, and client-specific recovery; raw provider CLI packets are debugging/advisory only and must not be recorded as passing review evidence.
+Use this when an independent review is required but a broad reviewer prompt hangs, returns no output, or starts expanding beyond the intended review scope. For non-wording extraction work, the gate-valid path is `scripts/extraction_review_gate.sh`, which owns the fixed autonomous budget while delegating transport to the provider-neutral `code-review` controller. A strictly proven wording-only change uses the proof-bound generic single-review recipe in `code-review/references/staged-review-contract.md`; its controller-derived wording scope and independent `wording_only_boundary` result replace neither one another nor a failed semantic check. Both paths preserve the frozen packet, family exclusion, structured validation and client-specific recovery; raw provider CLI packets are debugging/advisory only and must not be recorded as passing review evidence.
 
 Required flow:
 
-1. Prove the reviewer gate is available. Run `skills/code-review/scripts/review_gate.sh --help` or the repo-local equivalent and confirm it prints usage. This local availability check does not invoke a model and is not review evidence. Do not use a raw provider "ping" as gate evidence. If the gate cannot run after documented remediation, record the lane as unavailable/inconclusive with command evidence.
+1. Prove the applicable owner gate is available. For non-wording work, run `skills/skill-extraction-workflow/scripts/extraction_review_gate.sh --help`; for a strictly proven wording-only change, use the generic `code-review` help recipe. This local availability check does not invoke a model and is not review evidence. Do not use a raw provider "ping" as gate evidence. If the gate cannot run after documented remediation, record the lane as unavailable/inconclusive with command evidence.
 2. Stop the stuck review process before retrying. Do not leave background reviewer sessions running and do not count a no-output process as a completed review.
 3. Build a bounded packet from the exact changed files or excerpts being claimed. Prefer `git diff -- <files>` for local changes.
-4. Feed the packet through `review_gate.sh` with the actual implementer family, required `--review-plan-file`, stage, exact base/paths or frozen diff file, and explicit non-Claude egress approval when applicable. The plan binds the target, acceptance criteria, self-review, and evidence before the independent run. The gate preserves tool posture, timeout, attribution, and output parsing while following the user's local client order. A raw Claude packet may be used only to debug a wrapper failure and remains advisory:
+4. Feed a non-wording packet through `scripts/extraction_review_gate.sh`; feed a strictly proven wording-only packet through the proof-bound generic single-review recipe. The wording-only path uses its exact canonical full-context diff and proof file, stays untracked, and does not run `complete`; a custom/context-augmented packet or missing `wording_only_boundary` result re-arms challenge. In either case supply the actual implementer family, required `--review-plan-file`, stage, exact candidate, and explicit non-Claude egress approval when applicable. The plan binds the target, acceptance criteria, self-review and evidence before the independent run. The gate preserves tool posture, timeout, attribution and output parsing while following the user's local client order. A raw Claude packet may be used only to debug a wrapper failure and remains advisory:
 
 ```sh
 git -C <repo> diff -- <files...> \
@@ -151,6 +151,7 @@ Review only stdin. Do not use tools. Do not request more context. Return finding
 5. Apply or explicitly reject actionable findings.
 6. Rerun the owning skill validators and `git diff --check`.
 7. Record the result as `findings applied`, `no blocking findings`, or `review unavailable after remediation` only when the wrapper or approved alternate produced valid structured evidence. Raw packet output is recorded separately as debugging/advisory and cannot close the gate.
+8. At a non-wording terminal checkpoint, build the receipt-bound ledger and run `scripts/validate_extraction_review_state.py <closeout.json>`. A wording-only review records its single independent-review row and does not invent a multi-round ledger.
 
 Do not count as completed review:
 

package/dist/assets/marketplace/plugins/ccl-skills/skills/skill-extraction-workflow/scripts/check-ccl-skills.sh

@@ -280,8 +280,11 @@ end
 # Maintain by RETIREMENT, not by growth: when a term no longer proxies anything
 # live, delete it (quantify current hits first, and keep a retained-term control
 # so the scan is proven still able to fail). Do not add generic technical words.
-# Both directions are pinned by test_entrypoint_domain_scan_terms.sh.
-if leak_output="$(rg -n 'code\.[[:alnum:].-]+|figma\.com/files|[0-9]{8,}|\x{6559}\x{5e08}|\x{5b66}\x{751f}|\x{8003}\x{8bd5}|\x{5b66}\x{6821}|\x{9605}\x{5377}|\x{51fa}\x{5377}|\x{5b66}\x{60c5}' "$root"/skills/*/SKILL.md "$root"/skills/*/references/*.md 2>/dev/null)"; then
+# Both directions are pinned by test_entrypoint_domain_scan_terms.sh. Long digit
+# runs are scanned separately so canonical public DOI/W3C identifiers are not
+# mistaken for private object IDs while an unrelated ID on the same line still
+# fails closed.
+if leak_output="$(rg -n 'code\.[[:alnum:].-]+|figma\.com/files|\x{6559}\x{5e08}|\x{5b66}\x{751f}|\x{8003}\x{8bd5}|\x{5b66}\x{6821}|\x{9605}\x{5377}|\x{51fa}\x{5377}|\x{5b66}\x{60c5}' "$root"/skills/*/SKILL.md "$root"/skills/*/references/*.md 2>/dev/null)"; then
   echo "$leak_output"
   echo "entrypoint_or_reference_domain_scan_failed" >&2
   exit 1
@@ -292,6 +295,70 @@ else
     exit 1
   fi
 fi
+
+if ! long_digit_output="$(ruby -e '
+  allowed_url = %r{https://(?:
+    doi\.org/10\.[0-9]{4,9}/(?<doipayload>[A-Za-z0-9._;()/:+\-]+)
+    |
+    www\.w3\.org/community/reports/[a-z0-9-]+/CG-FINAL-[A-Za-z0-9._-]*(?<w3cdate>[0-9]{8})/?
+  )}ix
+  ARGV.each do |path|
+    next unless File.file?(path)
+    File.foreach(path).with_index(1) do |line, line_number|
+      allowed_spans = []
+      line.to_enum(:scan, allowed_url).each do
+        match = Regexp.last_match
+        url = match[0]
+        next if url.include?("?") || url.include?("#")
+        # The allowlist is shape-only (no registrant validation), so a
+        # fabricated DOI-shaped wrapper could otherwise launder any private
+        # numeric ID. A span grants exemption only when its identifier
+        # payload (the DOI suffix after the registrant slash, or the W3C
+        # report date) carries no merged digit run above 9 digits, where a
+        # merged run joins digit groups across one or MORE consecutive
+        # punctuation separators — every punctuation char the DOI payload
+        # charset accepts, so no accepted punctuation can split an ID into
+        # exempt halves. Letters stay run boundaries because real DOI
+        # suffixes legitimately interleave them (s15516709cog1202_4). This
+        # keeps real citations green (10.1038/35057062 has an 8-digit
+        # payload; the registrant prefix is bounded to 9 digits by shape)
+        # while a split or padded identifier such as 123456789-123456789,
+        # 20260830--123456, or 123456789+123456789 voids its span entirely.
+        payload_name = match[:doipayload] ? :doipayload : :w3cdate
+        payload = line[match.begin(payload_name)...match.end(payload_name)]
+        payload_ok = payload.scan(/[0-9]+(?:[-._\/;():+]+[0-9]+)*/).all? do |run|
+          run.delete("^0-9").length <= 9
+        end
+        next unless payload_ok
+        # The exempt span is the identifier payload, not the whole URL: a
+        # W3C report NAME has no business carrying a long digit run, so only
+        # the trailing date is exempt there; a DOI suffix is the identifier
+        # itself, so its whole payload is exempt once it passes the cap.
+        allowed_spans << (match.begin(payload_name)...match.end(payload_name))
+      end
+
+      leaked = line.to_enum(:scan, /[0-9]{8,}/).any? do
+        match = Regexp.last_match
+        # Per-match cap: even inside a payload-clean span, a single raw run
+        # above 9 digits (timestamp/snowflake scale) is never exempt.
+        exempt = match[0].length <= 9 && allowed_spans.any? do |span|
+          span.begin <= match.begin(0) && match.end(0) <= span.end
+        end
+        !exempt
+      end
+      puts "#{path}:#{line_number}:#{line.chomp}" if leaked
+    end
+  end
+' "$root"/skills/*/SKILL.md "$root"/skills/*/references/*.md 2>&1)"; then
+  echo "$long_digit_output" >&2
+  echo "entrypoint_long_digit_scan_error" >&2
+  exit 1
+fi
+if [[ -n "$long_digit_output" ]]; then
+  echo "$long_digit_output"
+  echo "entrypoint_or_reference_domain_scan_failed" >&2
+  exit 1
+fi
 echo "entrypoint_and_reference_domain_scan_ok"
 
 # Recurring anti-pattern scan: a TARGETED mechanical backstop (NOT a comprehensive

package/dist/assets/marketplace/plugins/ccl-skills/skills/skill-extraction-workflow/scripts/extraction_review_gate.sh

@@ -0,0 +1,22 @@
+#!/usr/bin/env bash
+# Extraction-owned autonomous review wrapper: one review plus two challenges.
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd -P)"
+CONTROLLER="$SCRIPT_DIR/../../code-review/scripts/review_gate.sh"
+
+for arg in "$@"; do
+  case "$arg" in
+    --challenge-b*)
+      echo "extraction_review_gate_error: challenge budget is fixed at 2" >&2
+      exit 2
+      ;;
+  esac
+done
+
+if [[ ! -x "$CONTROLLER" ]]; then
+  echo "extraction_review_gate_error: code-review controller is unavailable" >&2
+  exit 2
+fi
+
+exec bash "$CONTROLLER" --challenge-budget 2 "$@"

package/dist/assets/marketplace/plugins/ccl-skills/skills/skill-extraction-workflow/scripts/impact-chain-gate.rb

@@ -132,6 +132,7 @@ upstream_owner_skills = %w[
   llm-inference-integration
   multi-agent-delegation
   multi-perspective-research
+  nodejs-service-dev
   platform-observability
   platform-release-engineering
   platform-service-connectivity
@@ -292,8 +293,10 @@ upstream = upstream.reject do |path|
   rename_excused[path] = true if excused
   excused
 end
-# The block runs when a selected owner changed (there is something to demand) OR
-# when the ledger itself changed (there is something to validate). It used to
+# The block runs when a selected owner changed (there is something to demand),
+# when any skill entrypoint changed (its description may owe routing-bank
+# evidence), OR when the ledger itself changed (there is something to validate).
+# It used to
 # gate on `upstream.any?` alone, which is the demand side only — and that is the
 # other half of the restored-owner hole: revert the owner and the range has no
 # changed owner at all, so the entire row evaluation was skipped and the
@@ -303,7 +306,10 @@ end
 # `eval/routing-tasks.jsonl` changes no owner package and need not touch the
 # ledger, so without this the whole block — including the bank-evidence
 # obligation written for exactly that change — was never entered.
-if upstream.any? || changed_paths.include?(LEDGER_PATH) || changed_paths.include?("eval/routing-tasks.jsonl")
+routing_entrypoint_changed = changed_paths.any? do |path|
+  path.match?(%r{\Askills/[^/]+/SKILL\.md\z})
+end
+if upstream.any? || routing_entrypoint_changed || changed_paths.include?(LEDGER_PATH) || changed_paths.include?("eval/routing-tasks.jsonl")
   # Rows are collected PER ROUND and carry the scope they were authored against,
   # so the classifiers below judge a row against its own round's diff. Reading the
   # cumulative register diff instead would re-judge every earlier round's rows
@@ -1564,6 +1570,13 @@ if upstream.any? || changed_paths.include?(LEDGER_PATH) || changed_paths.include
   round_bounds.each do |span_base, span_head|
     scope = scope_at.call(span_base, span_head)
     scope_rows = rows.select { |row| row[:scope].head == span_head }
+    # Routing-bank evidence applies to every skill description, not only to the
+    # curated impact-chain owners. Keep a separate vocabulary for this one
+    # obligation so broadening bank coverage cannot broaden the impact-chain
+    # subject set or its row refusals.
+    bank_owner_names = (
+      owner_names_at.call(scope.base) + owner_names_at.call(scope.head)
+    ).uniq
     # Same head-declared-grammar rule as `result-class` above, and for the same
     # reason: the paragraph that defines `bank-evidence` also dates it.
     next unless grammar_declared_at.call(scope.head)
@@ -1578,6 +1591,13 @@ if upstream.any? || changed_paths.include?(LEDGER_PATH) || changed_paths.include
     # being silently outside the trigger because of how the owner set is built.
     created_surfaces = scope.changed_paths.filter_map do |relative|
       next unless relative.start_with?("skills/") && relative.end_with?("/SKILL.md")
+      # This pickup covers both a brand-new entrypoint and an EXISTING
+      # non-curated skill editing its description — both move the routing
+      # surface. An earlier round bounded it to base-absent entrypoints
+      # because non-curated obligations were undischargeable then; the
+      # bank-only resolver below now binds rows over base+head skill names,
+      # so the obligation is dischargeable and the bound would only reopen
+      # the evidence-free description-edit hole.
       path = relative.sub(%r{\Askills/}, "")
       next if triggered_owners.include?(path)
       next unless description_touched.call(scope, path)
@@ -1623,7 +1643,31 @@ if upstream.any? || changed_paths.include?(LEDGER_PATH) || changed_paths.include
     end
     triggered_owners.each do |path|
       owner = path.sub(%r{/SKILL\.md\z}, "")
-      owner_scope_rows = rows_by_upstream_path[path].select { |row| row[:scope].head == scope.head }
+      owner_scope_rows =
+        if upstream_set[path] || lineage_extra[path]
+          # Preserve the existing selected-owner resolver byte-for-byte: bank
+          # coverage must not weaken or widen impact-chain attribution.
+          rows_by_upstream_path[path].select { |row| row[:scope].head == scope.head }
+        else
+          # Mirror that resolver for bank-only owners. Declaring rows use the
+          # owner-package prefix convention; non-declaring rows keep the prior
+          # exact `<owner>/SKILL.md` convention. A row naming more than one owner
+          # satisfies none of them, so one locator cannot discharge two routing
+          # surfaces.
+          scope_rows.select do |row|
+            declares_impact_chain = row[:behavior].split(";").any? do |fragment|
+              fragment.match?(/\A\s*behavioral-evidence:/i)
+            end
+            candidate_names =
+              if declares_impact_chain
+                bank_owner_names.select { |name| owner_mentioned.call(row[:evidence], name) }
+              else
+                row[:evidence].scan(owner_skill_md_path).flatten.uniq
+                   .select { |name| bank_owner_names.include?(name) }
+              end
+            candidate_names == [owner]
+          end
+        end
       bank_evidence_failures << path unless owner_scope_rows.any? { |row| row_satisfies.call(row, owner) }
     end
     if bank_changed
@@ -1637,6 +1681,7 @@ if upstream.any? || changed_paths.include?(LEDGER_PATH) || changed_paths.include
     warn "impact_chain_bank_evidence_missing: a round that changed the routing surface carries no bank evidence for that owner"
     warn "  note: the routing surface is the SKILL.md frontmatter `description` entry and `#{bank_relative}`. The measurement protocol says it is mandatory, but nothing produced or consumed it, so not running it left no absence to detect — the reviewer saw a candidate, not a gap"
     warn "  fix: add `bank-evidence: command:<changed executable>` or `bank-evidence: file:<changed markdown>#<unique anchor>` to that owner's row; to skip the run deliberately use `bank-evidence: downscoped:<token>` and record the same token in this round's spec, so the downscope is itself an artifact"
+    warn "  note: a row without a `behavioral-evidence:` fragment attributes to its owner only via a bare `<owner>/SKILL.md` citation in the evidence cell — the full `skills/<owner>/SKILL.md` spelling is reserved for locators and does NOT attribute, so a row that looks like valid evidence but cites only the full path never reaches the owner"
     bank_evidence_failures.each { |path| warn "  owes bank evidence: #{path}" }
     exit 1
   end