Defame1297
db5a426416
The routing-target check understood only a single-arrow clause naming a bare skill, so most real boundary prose was silently skipped rather than verified. Two of those silences were fail-open: an unrecognised token following a target dropped that target from the check entirely, and a skill directory with no SKILL.md still resolved as a valid routing target, so a broken route passed. Multi-target arrow clauses now draw a SUGGESTION instead of being ignored, hand-invocation phrasing is carved out so it is not read as a route, and a dotted filename parses into a new `unparsed` status rather than disappearing. Three test fixtures had been relying on the SKILL.md-less directory resolving as a target; they are corrected alongside the check. Addresses #107, #108, #110.
746 lines
30 KiB
Bash
Executable File
746 lines
30 KiB
Bash
Executable File
#!/usr/bin/env bats
|
|
|
|
setup() {
|
|
REPO_ROOT="$(cd "$BATS_TEST_DIRNAME/../../../../../../" && pwd)"
|
|
load "$REPO_ROOT/tests/test_helper/bats-support/load"
|
|
load "$REPO_ROOT/tests/test_helper/bats-assert/load"
|
|
|
|
SCRIPT="$(cd "$BATS_TEST_DIRNAME/../scripts" && pwd)/validate.sh"
|
|
TMPDIR="$(mktemp -d)"
|
|
|
|
# Helper: create a minimal valid skill directory.
|
|
#
|
|
# The description carries a boundary clause deliberately. ADR-0020's
|
|
# missing-boundary-clause SUGGESTION fires on any description without one, so
|
|
# a fixture that omits it is never "otherwise clean" — every test asserting
|
|
# SUGGESTION-freedom would be asserting the boundary check's absence instead
|
|
# of the thing it names. "anything else" is not hyphenated, so the clause adds
|
|
# a boundary marker without adding a routing target to resolve.
|
|
make_valid_skill() {
|
|
local dir="$1"
|
|
local name
|
|
name="$(basename "$dir")"
|
|
mkdir -p "$dir/scripts"
|
|
cat > "$dir/SKILL.md" <<EOF
|
|
---
|
|
name: $name
|
|
description: A valid skill description that is well within the limit. Do not use for anything else.
|
|
---
|
|
|
|
## Step 1
|
|
|
|
Do the thing.
|
|
EOF
|
|
}
|
|
|
|
# Helper: a description of EXACTLY <n> characters that carries a boundary
|
|
# clause and names no routing target. The tests below measure the description
|
|
# LENGTH, so the clause has to be paid for out of the same budget rather than
|
|
# appended to it — hence the padding arithmetic instead of a fixed suffix.
|
|
desc_of_length() {
|
|
python3 - "$1" <<'PY'
|
|
import sys
|
|
n = int(sys.argv[1])
|
|
prefix = 'Use when doing the thing. Do not use for anything else. '
|
|
assert n >= len(prefix), 'requested description shorter than the boundary clause'
|
|
print(prefix + 'x' * (n - len(prefix)))
|
|
PY
|
|
}
|
|
|
|
# Helper: create a skill directory with an exact description length and an
|
|
# exact body word count. <desc> is used verbatim; <body_words> "word"
|
|
# tokens follow the frontmatter. Used by the ADR-0020 boundary tests.
|
|
make_sized_skill() {
|
|
local dir="$1" desc="$2" body_words="$3"
|
|
local name
|
|
name="$(basename "$dir")"
|
|
mkdir -p "$dir"
|
|
{
|
|
echo "---"
|
|
echo "name: $name"
|
|
echo "description: $desc"
|
|
echo "---"
|
|
echo ""
|
|
python3 -c "print(' '.join(['word'] * $body_words))"
|
|
} > "$dir/SKILL.md"
|
|
}
|
|
|
|
# Helper: build a self-contained fixture plugin tree so the boundary-target
|
|
# resolver has a real authoring source to resolve against, independent of
|
|
# this repo's live skills. Echoes the subject skill's directory.
|
|
#
|
|
# <root>/plugins/fixture-plugin/.apm/skills/<subject>/SKILL.md
|
|
# <root>/plugins/fixture-plugin/.apm/skills/fixture-sibling-skill/SKILL.md
|
|
# <root>/plugins/fixture-plugin/.apm/agents/fixture-sibling-agent.agent.md
|
|
#
|
|
# The sibling gets a real SKILL.md, and that is load-bearing rather than
|
|
# tidiness: a directory under skills/ is a resolvable name only when it
|
|
# HOLDS one. An empty leftover directory is untracked by git, so counting
|
|
# one made a target resolve on the machine that made it and dangle in a
|
|
# fresh clone. This helper used to mkdir the sibling and write nothing into
|
|
# it, so the corroborator every blocking-tier test depends on silently
|
|
# stopped resolving the moment that rule was enforced.
|
|
make_fixture_tree() {
|
|
local root="$1" subject="$2"
|
|
local apm="$root/plugins/fixture-plugin/.apm"
|
|
mkdir -p "$apm/skills/$subject" "$apm/skills/fixture-sibling-skill" "$apm/agents"
|
|
touch "$apm/agents/fixture-sibling-agent.agent.md"
|
|
make_sized_skill "$apm/skills/fixture-sibling-skill" \
|
|
"Use when doing the other thing. Do not use for anything else." 10
|
|
echo "$apm/skills/$subject"
|
|
}
|
|
}
|
|
|
|
teardown() {
|
|
rm -rf "$TMPDIR"
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Passing cases
|
|
# ---------------------------------------------------------------------------
|
|
|
|
@test "passes on a valid minimal skill" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_valid_skill "$skill"
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
}
|
|
|
|
@test "--help exits 0" {
|
|
run bash "$SCRIPT" --help
|
|
assert_success
|
|
assert_output --partial "Usage:"
|
|
}
|
|
|
|
@test "passes when scripts/ directory is absent" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_valid_skill "$skill"
|
|
rmdir "$skill/scripts"
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
}
|
|
|
|
@test "FILL IN: inside backticks does not fail" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_valid_skill "$skill"
|
|
echo "Use \`FILL IN: value\` as an example." >> "$skill/SKILL.md"
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
}
|
|
|
|
@test "the 1024-char agentskills.io spec backstop is unchanged and separate from the ADR-0020 ceiling" {
|
|
local skill="$TMPDIR/my-skill"
|
|
local name
|
|
name="$(basename "$skill")"
|
|
mkdir -p "$skill"
|
|
local desc
|
|
desc="$(python3 -c "print('x' * 1024)")"
|
|
cat > "$skill/SKILL.md" <<EOF
|
|
---
|
|
name: $name
|
|
description: $desc
|
|
---
|
|
|
|
## Step 1
|
|
|
|
Do the thing.
|
|
EOF
|
|
run bash "$SCRIPT" "$skill"
|
|
# Two independent gates on one value: the spec limit still PASSES at
|
|
# exactly 1024 (its own boundary is unmoved), while ADR-0020's 400-char
|
|
# ceiling FAILs. The run fails on the second, not the first.
|
|
assert_output --partial "description length 1024 chars (agentskills.io spec limit: 1024)"
|
|
assert_output --partial "400-character ADR-0020 ceiling"
|
|
assert_failure
|
|
}
|
|
|
|
@test "passes at exactly 500 lines" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_valid_skill "$skill"
|
|
local current
|
|
current="$(wc -l < "$skill/SKILL.md")"
|
|
local needed=$(( 500 - current ))
|
|
python3 -c "print('\n' * $needed, end='')" >> "$skill/SKILL.md"
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Failing cases
|
|
# ---------------------------------------------------------------------------
|
|
|
|
@test "fails when SKILL.md is missing" {
|
|
local skill="$TMPDIR/my-skill"
|
|
mkdir -p "$skill"
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
}
|
|
|
|
@test "fails when name does not match directory" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_valid_skill "$skill"
|
|
sed -i 's/^name: .*/name: wrong-name/' "$skill/SKILL.md"
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
}
|
|
|
|
@test "fails when description exceeds 1024 chars" {
|
|
local skill="$TMPDIR/my-skill"
|
|
local name
|
|
name="$(basename "$skill")"
|
|
mkdir -p "$skill"
|
|
local desc
|
|
desc="$(python3 -c "print('x' * 1025)")"
|
|
cat > "$skill/SKILL.md" <<EOF
|
|
---
|
|
name: $name
|
|
description: $desc
|
|
---
|
|
|
|
## Step 1
|
|
|
|
Do the thing.
|
|
EOF
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
}
|
|
|
|
@test "fails when SKILL.md exceeds 500 lines" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_valid_skill "$skill"
|
|
python3 -c "print('\n' * 500)" >> "$skill/SKILL.md"
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
}
|
|
|
|
@test "fails when body contains unfilled FILL IN: placeholder" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_valid_skill "$skill"
|
|
echo "FILL IN: replace this" >> "$skill/SKILL.md"
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
}
|
|
|
|
@test "fails when a script is not executable" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_valid_skill "$skill"
|
|
echo "#!/usr/bin/env bash" > "$skill/scripts/helper.sh"
|
|
chmod -x "$skill/scripts/helper.sh"
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
}
|
|
|
|
@test "fails when a script has an interactive prompt" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_valid_skill "$skill"
|
|
printf '#!/usr/bin/env bash\nread -p "Enter value: " VAL\n' > "$skill/scripts/helper.sh"
|
|
chmod +x "$skill/scripts/helper.sh"
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
}
|
|
|
|
@test "fails when a script reads a variable with no redirect" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_valid_skill "$skill"
|
|
printf '#!/usr/bin/env bash\nread -r ANSWER\n' > "$skill/scripts/helper.sh"
|
|
chmod +x "$skill/scripts/helper.sh"
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
}
|
|
|
|
@test "fails when an interactive prompt string contains an angle bracket" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_valid_skill "$skill"
|
|
printf '#!/usr/bin/env bash\nread -p "enter <name>: " NAME\n' > "$skill/scripts/helper.sh"
|
|
chmod +x "$skill/scripts/helper.sh"
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
}
|
|
|
|
@test "passes when a script reads from a here-string" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_valid_skill "$skill"
|
|
printf '#!/usr/bin/env bash\nLINE="a b"\nread -r X Y <<< "$LINE"\n' \
|
|
> "$skill/scripts/helper.sh"
|
|
chmod +x "$skill/scripts/helper.sh"
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
}
|
|
|
|
@test "passes when a script reads from a here-doc" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_valid_skill "$skill"
|
|
printf '#!/usr/bin/env bash\nread -r X <<EOF\nvalue\nEOF\n' > "$skill/scripts/helper.sh"
|
|
chmod +x "$skill/scripts/helper.sh"
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
}
|
|
|
|
@test "passes when a script reads from a file redirect" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_valid_skill "$skill"
|
|
printf '#!/usr/bin/env bash\nread -r LINE < "$1"\n' > "$skill/scripts/helper.sh"
|
|
chmod +x "$skill/scripts/helper.sh"
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
}
|
|
|
|
@test "passes when a script reads from a pipe continued onto the next line" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_valid_skill "$skill"
|
|
printf '#!/usr/bin/env bash\nprintf %%s "$1" |\n read -r X\n' > "$skill/scripts/helper.sh"
|
|
chmod +x "$skill/scripts/helper.sh"
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
}
|
|
|
|
@test "fails when name contains consecutive hyphens" {
|
|
local skill="$TMPDIR/my--skill"
|
|
make_valid_skill "$skill"
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
}
|
|
|
|
@test "fails when name has a leading hyphen" {
|
|
local skill="$TMPDIR/-my-skill"
|
|
make_valid_skill "$skill"
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
}
|
|
|
|
@test "fails when no frontmatter block is present" {
|
|
local skill="$TMPDIR/my-skill"
|
|
mkdir -p "$skill"
|
|
echo "Just some content with no frontmatter." > "$skill/SKILL.md"
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
}
|
|
|
|
@test "fails when no arguments are given" {
|
|
run bash "$SCRIPT"
|
|
assert_failure
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# ADR-0020 — description budget (250 SUGGESTION / 400 FAIL)
|
|
#
|
|
# These sit UNDER the agentskills.io 1024-character spec backstop above, which
|
|
# is unchanged. Both ceilings are inclusive: exactly at the number passes that
|
|
# tier, one past it trips.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
@test "ADR-0020: description of exactly 250 chars raises no suggestion" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_sized_skill "$skill" "$(desc_of_length 250)" 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
refute_output --partial "SUGGESTION"
|
|
}
|
|
|
|
@test "ADR-0020: description of 251 chars raises a SUGGESTION and still exits 0" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_sized_skill "$skill" "$(desc_of_length 251)" 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
assert_output --partial "SUGGESTION"
|
|
assert_output --partial "description is 251 chars"
|
|
assert_output --partial "All checks passed (1 suggestion(s))."
|
|
}
|
|
|
|
@test "ADR-0020: description of exactly 400 chars is a SUGGESTION, not a FAIL" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_sized_skill "$skill" "$(desc_of_length 400)" 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
assert_output --partial "SUGGESTION"
|
|
}
|
|
|
|
@test "ADR-0020: description of 401 chars FAILs and exits non-zero" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_sized_skill "$skill" "$(desc_of_length 401)" 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
assert_output --partial "description is 401 chars"
|
|
assert_output --partial "400-character ADR-0020 ceiling"
|
|
}
|
|
|
|
@test "ADR-0020: description length is measured after YAML folding is resolved" {
|
|
local skill="$TMPDIR/my-skill"
|
|
mkdir -p "$skill"
|
|
# A >-folded block scalar: 11 lines of 40 chars folded with 10 joining
|
|
# spaces = 450 characters. Measured off its raw `description: >` line it is
|
|
# 1 character and passes; measured as the folded VALUE it must FAIL. This
|
|
# is exactly the case a line-wise regex gets wrong.
|
|
{
|
|
echo "---"
|
|
echo "name: my-skill"
|
|
echo "description: >"
|
|
python3 -c "print('\n'.join([' ' + 'x' * 40] * 11))"
|
|
echo "---"
|
|
echo ""
|
|
echo "Do the thing."
|
|
} > "$skill/SKILL.md"
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
assert_output --partial "description is 450 chars"
|
|
assert_output --partial "400-character ADR-0020 ceiling"
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# ADR-0020 — body budget (600 SUGGESTION / 900 FAIL), body ONLY
|
|
#
|
|
# Distinct from the 2,770-word whole-file spec ceiling above, which counts
|
|
# frontmatter too and is unchanged. Do not unify them.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
@test "ADR-0020: body of exactly 600 words raises no suggestion" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_sized_skill "$skill" "A short valid description. Do not use for anything else." 600
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
refute_output --partial "SUGGESTION"
|
|
}
|
|
|
|
@test "ADR-0020: body of 601 words raises a SUGGESTION and still exits 0" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_sized_skill "$skill" "A short valid description. Do not use for anything else." 601
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
assert_output --partial "body is 601 words"
|
|
assert_output --partial "All checks passed (1 suggestion(s))."
|
|
}
|
|
|
|
@test "ADR-0020: body of exactly 900 words is a SUGGESTION, not a FAIL" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_sized_skill "$skill" "A short valid description. Do not use for anything else." 900
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
assert_output --partial "body is 900 words"
|
|
}
|
|
|
|
@test "ADR-0020: body of 901 words FAILs and exits non-zero" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_sized_skill "$skill" "A short valid description. Do not use for anything else." 901
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
assert_output --partial "body is 901 words"
|
|
assert_output --partial "900-word ADR-0020 ceiling"
|
|
}
|
|
|
|
@test "ADR-0020: the body gate counts the body only — frontmatter words do not count toward it" {
|
|
local skill="$TMPDIR/my-skill"
|
|
# 895 body words plus a description long enough that the WHOLE FILE is well
|
|
# over 900 words. The body gate must stay silent; the 2,770-word whole-file
|
|
# ceiling is a separate measurement and is nowhere near tripping.
|
|
make_sized_skill "$skill" "$(python3 -c "print(' '.join(['w'] * 100))")" 895
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
refute_output --partial "900-word ADR-0020 ceiling"
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# ADR-0020 — resolvable boundary targets
|
|
#
|
|
# Resolved against the AUTHORING SOURCE (plugins/*/.apm/skills/ and
|
|
# plugins/*/.apm/agents/), never .claude/skills/, so the check works offline and
|
|
# before an apm install. Every fixture below builds its own plugin tree rather
|
|
# than leaning on this repo's live skills.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
@test "ADR-0020: a boundary target naming an existing sibling skill resolves" {
|
|
local skill
|
|
skill="$(make_fixture_tree "$TMPDIR/tree" "my-skill")"
|
|
make_sized_skill "$skill" "Use when doing the thing. Do not use for the other thing — use fixture-sibling-skill instead." 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
assert_output --partial "boundary target(s) resolve"
|
|
}
|
|
|
|
@test "ADR-0020: a boundary target naming a non-existent skill FAILs when its sentence names one that resolves" {
|
|
local skill
|
|
skill="$(make_fixture_tree "$TMPDIR/tree" "my-skill")"
|
|
# `fixture-sibling-skill` is the corroborator: a prose-form target only earns
|
|
# a FAIL when its own sentence proves it is a routing sentence. See the
|
|
# shared resolver's CORROBORATION note, and the uncorroborated case below.
|
|
make_sized_skill "$skill" "Use when doing the thing. Do not use for the other thing — use fixture-sibling-skill or fixture-missing-skill instead." 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
assert_output --partial "routes to 'fixture-missing-skill'"
|
|
}
|
|
|
|
@test "ADR-0020: a LONE boundary target naming a non-existent skill is a SUGGESTION, not a FAIL" {
|
|
local skill
|
|
skill="$(make_fixture_tree "$TMPDIR/tree" "my-skill")"
|
|
# Same grammar as the case above and as "run \`pre-commit\` instead" — a
|
|
# route verb, a hyphenated name, terminal position. Nothing local separates a
|
|
# broken route from a tool name, so the target is named on every run but does
|
|
# not block: this gate ships with no baseline and no suppression mechanism.
|
|
make_sized_skill "$skill" "Use when doing the thing. Do not use for the other thing — use fixture-missing-skill instead." 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
assert_output --partial "SUGGESTION"
|
|
assert_output --partial "routes to 'fixture-missing-skill'"
|
|
refute_output --partial "FAIL description routes to"
|
|
}
|
|
|
|
@test "ADR-0020: a boundary target naming an AGENT file resolves (agents are valid routing targets)" {
|
|
local skill
|
|
skill="$(make_fixture_tree "$TMPDIR/tree" "my-skill")"
|
|
make_sized_skill "$skill" "Use when doing the thing. Do not use when the caller is an agent — invoke fixture-sibling-agent instead." 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
assert_output --partial "boundary target(s) resolve"
|
|
}
|
|
|
|
@test "ADR-0020: a /slash-command boundary target that does not resolve FAILs" {
|
|
local skill
|
|
skill="$(make_fixture_tree "$TMPDIR/tree" "my-skill")"
|
|
make_sized_skill "$skill" "Use when doing the thing. Do not use when improvements are wanted — use /fixture-missing-improve instead." 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
assert_output --partial "routes to 'fixture-missing-improve'"
|
|
}
|
|
|
|
@test "ADR-0020: a backticked name that does not resolve FAILs when its sentence names one that resolves" {
|
|
local skill
|
|
skill="$(make_fixture_tree "$TMPDIR/tree" "my-skill")"
|
|
make_sized_skill "$skill" "Use when doing the thing. Composes \`fixture-sibling-skill\` and \`fixture-missing-helper\` for the shared part." 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
assert_output --partial "routes to 'fixture-missing-helper'"
|
|
}
|
|
|
|
@test "ADR-0020: a /slash-command target is route NOTATION and FAILs on its own, uncorroborated" {
|
|
local skill
|
|
skill="$(make_fixture_tree "$TMPDIR/tree" "my-skill")"
|
|
# The escape hatch from the SUGGESTION tier: `/name` and `-> name` are never
|
|
# how prose cites a tool, so they are exempt from corroboration. An author
|
|
# who wants a route checked unconditionally writes one of those two forms.
|
|
make_sized_skill "$skill" "Use when doing the thing. Do not use for the other thing — use /fixture-missing-notation instead." 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
assert_output --partial "routes to 'fixture-missing-notation'"
|
|
}
|
|
|
|
@test "ADR-0020: a bare hyphenated word outside a boundary sentence is not read as a routing target" {
|
|
local skill
|
|
skill="$(make_fixture_tree "$TMPDIR/tree" "my-skill")"
|
|
# "run pre-commit hooks" is pc-run's real phrasing. A naive extractor reads
|
|
# it as a route to a non-existent `pre-commit` skill.
|
|
make_sized_skill "$skill" "Use when the user wants to run pre-commit hooks or install git hooks." 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
refute_output --partial "pre-commit"
|
|
}
|
|
|
|
@test "ADR-0020: an arrow chain outside a boundary clause is not read as a routing target" {
|
|
local skill
|
|
skill="$(make_fixture_tree "$TMPDIR/tree" "my-skill")"
|
|
# diagnose's real process chain. Only ADR-0020's `Not <thing> -> <skill>`
|
|
# form makes a bare arrow target a route.
|
|
make_sized_skill "$skill" "Reproduce → minimise → instrument → fix → regression-test. Use when a bug is reported." 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
refute_output --partial "regression-test"
|
|
}
|
|
|
|
@test "ADR-0020: MCP tool names and capitalised tool names are not read as routing targets" {
|
|
local skill
|
|
skill="$(make_fixture_tree "$TMPDIR/tree" "my-skill")"
|
|
make_sized_skill "$skill" "Use when writing issues. Do not use for local files (use Read/Write/Edit) — that write goes through \`issue_write\`/\`pull_request_write\` instead." 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
refute_output --partial "routes to"
|
|
}
|
|
|
|
@test "ADR-0020: ADR's compressed boundary form (Not <thing> -> <skill>) is checked" {
|
|
local skill
|
|
skill="$(make_fixture_tree "$TMPDIR/tree" "my-skill")"
|
|
make_sized_skill "$skill" "Use when doing the thing. Not the other thing → fixture-missing-target." 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
assert_output --partial "routes to 'fixture-missing-target'"
|
|
}
|
|
|
|
@test "ADR-0020: the boundary check declines rather than false-FAILs when no authoring source is found" {
|
|
# Deliberately NOT built with make_fixture_tree: this skill sits in a bare
|
|
# temp directory with no plugins/*/.apm/ above it and no .git, so the resolver
|
|
# legitimately has no universe. That is a real path (a skill being drafted
|
|
# outside any repo), and the required behaviour is to DECLINE OUT LOUD rather
|
|
# than either false-FAIL or pass in silence — silence is what let a whole gate
|
|
# family go missing unnoticed. So the INFO text and the named unchecked target
|
|
# are both asserted, not just the absence of a failure.
|
|
local skill="$TMPDIR/orphan/my-skill"
|
|
make_sized_skill "$skill" "Use when doing the thing. Do not use for the other thing — use some-other-skill instead." 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
refute_output --partial "routes to"
|
|
assert_output --partial "boundary-target resolution DID NOT RUN"
|
|
assert_output --partial "Unchecked target(s): some-other-skill"
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# ADR-0020 — the hand-invocation carve-out (issue #108)
|
|
#
|
|
# A skill carrying `disable-model-invocation: true` is absent from the
|
|
# model-visible listing entirely: not preloaded, and the Skill tool refuses to
|
|
# call it. Its description is never matched against user intent, so
|
|
# references/description-quality.md Step 0 gives it ONE plain human-facing
|
|
# sentence — no trigger list, no boundary clause — and calls a
|
|
# missing-boundary-clause finding on such a skill "a wrong finding, not a strict
|
|
# one". Until this ran, nothing here knew the field existed, so the audit
|
|
# reported exactly the shape its own rubric mandates, with advice naming a
|
|
# router that cannot see the skill.
|
|
#
|
|
# The carve-out is narrow. Both size gates are unaffected and both are pinned
|
|
# below: the body is loaded on invocation like any other body, and the
|
|
# 400-character ceiling is an outlier stop rather than a routing budget.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
# Helper: a skill directory carrying `disable-model-invocation: true`.
|
|
make_hand_invoked_skill() {
|
|
local dir="$1" desc="$2" body_words="$3"
|
|
local name
|
|
name="$(basename "$dir")"
|
|
mkdir -p "$dir"
|
|
{
|
|
echo "---"
|
|
echo "name: $name"
|
|
echo "description: $desc"
|
|
echo "disable-model-invocation: true"
|
|
echo "---"
|
|
echo ""
|
|
python3 -c "print(' '.join(['word'] * $body_words))"
|
|
} > "$dir/SKILL.md"
|
|
}
|
|
|
|
@test "ADR-0020: a hand-invoked skill is not asked for a boundary clause" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_hand_invoked_skill "$skill" \
|
|
"Tell the agent to zoom out and give broader context or a higher level perspective." 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
refute_output --partial "has no boundary clause"
|
|
assert_output --partial "hand-invoked"
|
|
}
|
|
|
|
@test "ADR-0020: the SAME description without the flag IS asked for a boundary clause" {
|
|
# The control. Without it the case above is satisfied by an audit that
|
|
# stopped checking boundary clauses altogether.
|
|
local skill="$TMPDIR/my-skill"
|
|
make_sized_skill "$skill" \
|
|
"Tell the agent to zoom out and give broader context or a higher level perspective." 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
assert_output --partial "has no boundary clause"
|
|
}
|
|
|
|
@test "ADR-0020: a hand-invoked skill is exempt from the 250-character description target" {
|
|
local skill="$TMPDIR/my-skill"
|
|
make_hand_invoked_skill "$skill" \
|
|
"$(python3 -c "print('Tell the agent to zoom out. ' + 'x' * 273)")" 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
refute_output --partial "over the 250-character"
|
|
}
|
|
|
|
@test "ADR-0020: a hand-invoked description over 400 chars still FAILS" {
|
|
# The half the carve-out does NOT lift. 400 is an outlier stop, not a
|
|
# routing-quality target: a hand-invoked description is still the one line
|
|
# the user reads when choosing from the `/` menu.
|
|
local skill="$TMPDIR/my-skill"
|
|
make_hand_invoked_skill "$skill" \
|
|
"$(python3 -c "print('Tell the agent to zoom out. ' + 'x' * 374)")" 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
assert_output --partial "400-character"
|
|
}
|
|
|
|
@test "ADR-0020: a hand-invoked body over 900 words still FAILS" {
|
|
# The body is loaded on invocation exactly like any other body and competes
|
|
# with the caller's live conversation the same way, so no body tier moves.
|
|
local skill="$TMPDIR/my-skill"
|
|
make_hand_invoked_skill "$skill" "Tell the agent to zoom out." 901
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
assert_output --partial "900-word"
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# ADR-0020 — one arrow, one target (issue #107)
|
|
#
|
|
# Only the FIRST target after an arrow was resolved: the conjunction
|
|
# continuation is wired to the prose route verbs and never to arrows. So this
|
|
# script printed "1 of 1 boundary target(s) resolve" on a clause naming two,
|
|
# and the second was resolved by nothing and reported by nothing. A typo in it
|
|
# shipped through a green gate. The shape is now rejected rather than the
|
|
# extractor widened.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
@test "ADR-0020: an arrow clause naming two targets is reported, not silently half-checked" {
|
|
local skill
|
|
skill="$(make_fixture_tree "$TMPDIR/tree" "my-skill")"
|
|
# A bare `Not ... ->` sentence carries no BOUNDARY_MARKER, so the backtick
|
|
# sweep does not run and the second target is invisible to every other rule
|
|
# in the resolver — this is the exact shape #107 measured.
|
|
make_sized_skill "$skill" "Use when doing the thing. Not the other thing -> \`fixture-sibling-skill\` or \`fixture-missing-second\`." 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
assert_output --partial "names more than one target"
|
|
}
|
|
|
|
@test "ADR-0020: one arrow per target — the convention the suggestion asks for — is silent" {
|
|
local skill
|
|
skill="$(make_fixture_tree "$TMPDIR/tree" "my-skill")"
|
|
make_sized_skill "$skill" "Use when doing the thing. Not the other thing -> \`fixture-sibling-skill\`." 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
refute_output --partial "names more than one target"
|
|
}
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# ADR-0020 — a dotted filename in a boundary clause (issue #110)
|
|
#
|
|
# `[^.;]` could not cross the `.` in `AGENTS.md`, so a clause naming a dotted
|
|
# file between "Not" and the arrow was invisible. With a backticked target that
|
|
# was a MISDIAGNOSIS — "no boundary clause" reported on a clause that was
|
|
# present and working. With a BARE target it was worse: the target was never
|
|
# extracted, so the dangling check silently did not run on it.
|
|
# ---------------------------------------------------------------------------
|
|
|
|
@test "ADR-0020: a boundary clause naming a dotted filename is not reported as missing" {
|
|
local skill
|
|
skill="$(make_fixture_tree "$TMPDIR/tree" "my-skill")"
|
|
make_sized_skill "$skill" "Use when doing the thing. Not AGENTS.md -> \`fixture-sibling-skill\`." 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
refute_output --partial "has no boundary clause"
|
|
assert_output --partial "description has a boundary clause"
|
|
}
|
|
|
|
@test "ADR-0020: a BARE target after a dotted filename is extracted and checked" {
|
|
local skill
|
|
skill="$(make_fixture_tree "$TMPDIR/tree" "my-skill")"
|
|
# The silent half of #110: this clause produced no target at all, so it was
|
|
# neither resolved nor reported — a route to a non-existent skill shipping
|
|
# through a green gate with no finding of any kind.
|
|
make_sized_skill "$skill" "Use when doing the thing. Not AGENTS.md -> fixture-missing-dotted." 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_failure
|
|
assert_output --partial "routes to 'fixture-missing-dotted'"
|
|
}
|
|
|
|
@test "ADR-0020: an arrow clause yielding no target is reported as unparsed, not as missing" {
|
|
local skill
|
|
skill="$(make_fixture_tree "$TMPDIR/tree" "my-skill")"
|
|
# A single-word target is deliberately not matchable bare, because
|
|
# `research`, `triage` and `forge` are all skill names AND ordinary English.
|
|
# The clause is present; saying it is missing sends the author to add a
|
|
# second copy of a clause that is already there.
|
|
make_sized_skill "$skill" "Use when doing the thing. Not the other thing -> forge." 10
|
|
run bash "$SCRIPT" "$skill"
|
|
assert_success
|
|
refute_output --partial "has no boundary clause"
|
|
assert_output --partial "no target could be read"
|
|
}
|