diff --git a/.github/standards/runner-policy/policy.json b/.github/standards/runner-policy/policy.json index dedf47bd7b..66d2426f51 100644 --- a/.github/standards/runner-policy/policy.json +++ b/.github/standards/runner-policy/policy.json @@ -403,6 +403,15 @@ "selectorResultInput": "prerequisite-result", "allowedInputs": ["runner", "prerequisite-result", "exempt-authors"], "allowedSecrets": {} + }, + "melodic-software/ci-workflows/.github/workflows/issue-triage-label.yml@c5e729c0af0e55ffed4675ec85c1b57356fef79e": { + "routing": "runner-input", + "runnerInput": "runner", + "allowedInputs": ["runner", "label", "label-prefix"], + "allowedSecrets": {}, + "allowedCallerPermissions": { + "issues": "write" + } } }, "canonicalSelectorInputs": { diff --git a/README.md b/README.md index 09b7a069c9..3221f417c0 100644 --- a/README.md +++ b/README.md @@ -111,7 +111,7 @@ user opts in with `/plugin enable`; an existing install is never flipped by cata - [`desktop-notification`](plugins/desktop-notification) — Alert you when Claude Code needs input — an audible terminal bell, an OSC 9 terminal notification, and an OS-native toast (macOS/Linux) on permission and idle prompts. - [`playbooks`](plugins/playbooks) — Doctrine and knowledge playbooks as on-demand skills, plus a maintainer-facing update skill. boris — Boris Cherny's Claude Code workflow tips (howborisusesclaudecode.com); skill-authoring — Anthropic's internal skill-authoring playbook; fable-5 — Claude Fable 5's operating doctrine (self-authored, no upstream). The boris and skill-authoring packs vendor a verbatim upstream baseline; /playbooks:update drift-checks and syncs those baselines centrally (maintainers). -- [`claude-config`](plugins/claude-config) — Four audit skills for a repo's Claude Code configuration: audit (settings.json / .mcp.json / hooks / plugins / permissions drift), audit-automation-gaps (evidence-gated verdicts on automation gaps), audit-permission-grants (allow-rule / allowed-tools grants for auto-mode durability and portability), and audit-model-fit (instruction surfaces swept for model-hobbling constraints newer models no longer need). +- [`claude-config`](plugins/claude-config) — Four audit skills for a repo's Claude Code configuration: audit (settings.json / .mcp.json / hooks / plugins / permissions drift), audit-automation-gaps (evidence-gated verdicts on automation gaps), audit-permission-grants (allow-rule / allowed-tools grants for auto-mode durability and portability), and audit-instructions (locally-owned instruction surfaces vs current model capability — proposes removals/rewrites of instructions the model no longer needs). - [`claude-memory`](plugins/claude-memory) — Keeps a repo's Claude Code memory layer healthy and under your control, against criteria derived from official Claude Code documentation. The audit skill checks the instruction/memory layer (CLAUDE.md, CLAUDE.local.md, .claude/rules/, auto-memory) with a deterministic script-backed spine plus judgment-tier checks. The stateless skill inspects, disables, and (confirm-gated) purges Claude-written auto memory across all settings scopes. - [`claude-ops`](plugins/claude-ops) — Claude Code operations toolkit. Seven skills: observability (read locally captured telemetry — OTEL store, collector, hook-event JSONL, ccusage — with trend reports and store pruning), known-issues (search known Claude product GitHub bugs, check service health, maintain a persistent tracked-issue registry), changelog (ingest Claude Code changelog entries and integrate them into the current repo), plugins (bring a machine's plugin fleet current on demand — marketplace refresh, effective-scope updates including in-repo project/local installs, new-plugin install per policy, scope-divergence detection and explicit convergence), morning-brief (read-only gh-based operator morning view — queue-label counts, merge-ready PRs, parked decisions with their RECOMMENDED lines, and loop-lane telemetry freshness), lanes (start/restart/stop/status loop lanes as named background Claude Code sessions seeded from canonical prompt files, with per-lane model/effort and a repo-pull + marketplace-refresh launch step), and a re-runnable setup action that settles where the known-issues registry lives. Plus a family of seven advisory *-audit telemetry-emitter hooks (API errors, config changes, instruction loads, permission denials, pre-compaction, skill usage, tool failures) that emit the shared hook-telemetry envelope, and a reference sink that maps envelopes into the hook-events.jsonl the observability skill reads. - [`skill-quality`](plugins/skill-quality) — Skill-authoring QA tooling: a static contract checker that runs eighteen deterministic checks over a Claude Code skill (frontmatter, listing-budget cap, trigger-keyword preservation, line caps, broken internal refs, markdownlint, gotchas surface, evals presence, precompute opportunity) and a bundled evals.json schema for validation. Runs against any repo's skills directory via the convention-resolution ladder — no baked layout. diff --git a/docs/topics/boris-video-absorption/PLAN.md b/docs/topics/boris-video-absorption/PLAN.md index d37b6cd68b..ce88bb6f82 100644 --- a/docs/topics/boris-video-absorption/PLAN.md +++ b/docs/topics/boris-video-absorption/PLAN.md @@ -200,7 +200,7 @@ Files (home slice, not repo): - **Sanity Check:** CI green on PR; `gh pr view` shows mergeable; all phase tags [DONE]. -### Phase 8: trial run (post-merge validation) [TODO] +### Phase 8: trial run (post-merge validation) [DONE] - After plugins update, run the enriched flow end-to-end on a real UI change in a consumer repo: config surface resolved + reported, @@ -208,6 +208,11 @@ Files (home slice, not repo): deliberately), evidence table carries session artifacts. - **Sanity Check:** recording artifact exists on disk; gap report emitted on induced prereq failure; operator reviews the recording. +- Ran 2026-07-21 in medley (identity-server login-page change, Aspire + orchestrator, local-only): all sanity checks passed, plus the + prompt-over-config precedence bonus assertion (explicit headed + instruction beat the local overlay's `browser_mode: headless`). + Evidence stayed on disk (gitignored) in the consumer repo. ## Blast radius diff --git a/plugins/architecture/.claude-plugin/plugin.json b/plugins/architecture/.claude-plugin/plugin.json index 2fb68a31cf..f022e076c0 100644 --- a/plugins/architecture/.claude-plugin/plugin.json +++ b/plugins/architecture/.claude-plugin/plugin.json @@ -1,8 +1,8 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "architecture", - "version": "0.3.4", - "description": "Scans an existing codebase for module-level architecture friction \u2014 shallow modules, seam leaks, and locality gaps \u2014 using Ousterhout's deep-module lens, presents candidates as a self-contained HTML report, and runs an interview loop on the selected candidate before handing off for planning.", + "version": "0.3.5", + "description": "Scans an existing codebase for module-level architecture friction — shallow modules, seam leaks, and locality gaps — using Ousterhout's deep-module lens, presents candidates as a self-contained HTML report, and runs an interview loop on the selected candidate before handing off for planning.", "author": { "name": "Melodic Software", "email": "info@melodicsoftware.com" diff --git a/plugins/architecture/CHANGELOG.md b/plugins/architecture/CHANGELOG.md index 66f36ac59e..2b3038b53a 100644 --- a/plugins/architecture/CHANGELOG.md +++ b/plugins/architecture/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to the `architecture` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.3.5] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.3.4] ### Changed diff --git a/plugins/architecture/skills/improve/SKILL.md b/plugins/architecture/skills/improve/SKILL.md index 3306742fb3..478d018da2 100644 --- a/plugins/architecture/skills/improve/SKILL.md +++ b/plugins/architecture/skills/improve/SKILL.md @@ -4,6 +4,7 @@ description: "Scan an existing codebase for module-level friction and architectu argument-hint: "[action] (e.g., deepening)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/bug-report/.claude-plugin/plugin.json b/plugins/bug-report/.claude-plugin/plugin.json index 3229ca559c..14eed2562b 100644 --- a/plugins/bug-report/.claude-plugin/plugin.json +++ b/plugins/bug-report/.claude-plugin/plugin.json @@ -1,14 +1,22 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "bug-report", - "version": "0.5.1", + "version": "0.5.2", "description": "Produces a structured five-field bug report — title, steps to reproduce, expected vs actual, severity with justification, and suggested fix location — from an informal defect description. Read-only by default: it emits the report and never edits code, opens a PR, or files an issue on its own.", "author": { "name": "Melodic Software", "email": "info@melodicsoftware.com" }, "license": "MIT", - "keywords": ["bug", "bug-report", "defect", "triage", "issue", "workflow", "skill"], + "keywords": [ + "bug", + "bug-report", + "defect", + "triage", + "issue", + "workflow", + "skill" + ], "userConfig": { "output_dir": { "type": "directory", diff --git a/plugins/bug-report/CHANGELOG.md b/plugins/bug-report/CHANGELOG.md index c57401728e..eab9265f12 100644 --- a/plugins/bug-report/CHANGELOG.md +++ b/plugins/bug-report/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to the `bug-report` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.5.2] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.5.1] ### Changed diff --git a/plugins/bug-report/skills/write/SKILL.md b/plugins/bug-report/skills/write/SKILL.md index 15f6f93651..7bedb621d1 100644 --- a/plugins/bug-report/skills/write/SKILL.md +++ b/plugins/bug-report/skills/write/SKILL.md @@ -4,6 +4,7 @@ description: "Produce a structured 5-field bug report (title, steps to reproduce argument-hint: "[--file] [--quick|--full] [--no-survey] " user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/claude-config/.claude-plugin/plugin.json b/plugins/claude-config/.claude-plugin/plugin.json index 9129dfdf86..34b612fe27 100644 --- a/plugins/claude-config/.claude-plugin/plugin.json +++ b/plugins/claude-config/.claude-plugin/plugin.json @@ -1,12 +1,23 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "claude-config", - "version": "0.8.0", - "description": "Four audit skills for a repo's Claude Code configuration: audit (settings.json / .mcp.json / hooks / plugins / permissions drift), audit-automation-gaps (evidence-gated verdicts on automation gaps), audit-permission-grants (allow-rule / allowed-tools grants for auto-mode durability and portability), and audit-model-fit (instruction surfaces swept for model-hobbling constraints newer models no longer need).", + "version": "0.9.0", + "description": "Four audit skills for a repo's Claude Code configuration: audit (settings.json / .mcp.json / hooks / plugins / permissions drift), audit-automation-gaps (evidence-gated verdicts on automation gaps), audit-permission-grants (allow-rule / allowed-tools grants for auto-mode durability and portability), and audit-instructions (locally-owned instruction surfaces vs current model capability — proposes removals/rewrites of instructions the model no longer needs).", "author": { "name": "Melodic Software", "email": "info@melodicsoftware.com" }, "license": "MIT", - "keywords": ["settings", "configuration", "hooks", "plugins", "permissions", "automation", "audit", "maintenance", "skill", "instructions", "model-fit"] + "keywords": [ + "settings", + "configuration", + "hooks", + "plugins", + "permissions", + "automation", + "audit", + "maintenance", + "skill", + "instructions" + ] } diff --git a/plugins/claude-config/CHANGELOG.md b/plugins/claude-config/CHANGELOG.md index b596fa4878..245188b7b7 100644 --- a/plugins/claude-config/CHANGELOG.md +++ b/plugins/claude-config/CHANGELOG.md @@ -3,6 +3,49 @@ All notable changes to the `claude-config` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.9.0] + +### Added + +- **`audit-instructions` skill** (`/claude-config:audit-instructions`). A read-only audit of the + locally-owned Claude Code instruction surfaces — user + project `CLAUDE.md`, `.claude/rules`, + skill bodies, agent definitions, prompt-type hooks, output styles — for instructions current + models no longer need: prior-model workarounds, over-prescriptive scaffolding, bare prohibitions, + reasoning-echo directives, and approach-pinning example blocks. It ships an eleven-check catalog + (`reference/criteria.md`) cited to current official prompting doctrine, tiers every finding + mechanical vs behavioral, and packages proposed removals/rewrites as human-gated diffs — never + auto-applied. An advisory grep-only scanner (`scripts/instruction-scan.sh`) seeds the mechanical + tier. It partitions with `claude-memory`'s `audit` skill: on memory-layer surfaces it runs only + the model-era checks and routes hygiene findings there; on non-memory surfaces the full catalog + applies. Upstream-owned plugin-cache and managed-materialization findings route to the owning + repository rather than being edited in place. + +### Fixed + +- Corrected stale `claude-memory` skill-name references (`health` → its current name `audit`) + across the plugin's skills and README — the `audit`, `audit-automation-gaps`, and + `audit-permission-grants` route-out notes and the README's instruction-layer and migration + sections. The `claude-memory` memory-layer skill was renamed `health` → `audit`; the old + `/claude-memory:health` invocation no longer resolves. + +### Removed + +- **`audit-model-fit` skill superseded by `audit-instructions`.** Both audits answer the same + question — locally-owned instruction surfaces vs current model capability — and repo doctrine + admits only one skill per question. `audit-instructions` carries the fuller catalog (eleven checks + I1–I11 with authority tags and evidence tiers), the `claude-memory` hygiene partition, and the + adversarial fresh-context verify pass, so it strictly covers `audit-model-fit`'s four checks and + supersedes it. Both were built concurrently from the same underlying issue (#800); `audit-model-fit` + (added in 0.8.0 below) is removed here. + +## [0.8.1] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.8.0] ### Added diff --git a/plugins/claude-config/README.md b/plugins/claude-config/README.md index 44e4e27bcd..5af96b30b6 100644 --- a/plugins/claude-config/README.md +++ b/plugins/claude-config/README.md @@ -8,17 +8,16 @@ Code configuration healthy. Each skill answers a different question about the sa | `/claude-config:audit` | Are the configuration FILES (`settings.json`, `settings.local.json`, `.mcp.json`, hooks, plugins, permissions) correct against upstream truth? | | `/claude-config:audit-automation-gaps` | Is the configured automation SET the right set — are there genuine gaps, judged against the enforcement hierarchy? | | `/claude-config:audit-permission-grants` | Are the permission GRANTS (`allowed-tools`, `permissions.allow`) portable and durable — do they survive auto mode, work across machines, and live where they can take effect? | -| `/claude-config:audit-model-fit` | Do the instruction SURFACES (CLAUDE.md, skill bodies, agents, rules, prompt-type hooks) still fit the current model — or do they carry constraints a newer, more capable model no longer needs? | +| `/claude-config:audit-instructions` | Are the INSTRUCTIONS you wrote (CLAUDE.md, rules, skill bodies, agents, hooks, output styles) still earning their context cost against current model capability, or is prior-model scar tissue holding the model back? | -The instruction/memory layer's *health* (`CLAUDE.md`, `CLAUDE.local.md`, `.claude/rules/`, auto-memory) -is audited by the `health` skill in the separate `claude-memory` plugin (see "Migrating from -`claude-config-audit`" below if you relied on the old `memory-health` skill here). `audit-model-fit` -reads the same instruction surfaces but asks a different question — model *fit*, not health: are their -constraints still earning their place on a newer model? +The instruction/memory-layer *hygiene* question (is `CLAUDE.md` too long, well-placed, free of +inferable content) is owned by the `audit` skill in the separate `claude-memory` plugin; +`audit-instructions` here owns the distinct *capability* question (do these instructions still fit +what current models need) and routes memory-layer hygiene findings to `claude-memory:audit`. See +"Migrating from `claude-config-audit`" below if you relied on the old `memory-health` skill here. All default to report-only; mutations (`--fix`, `--implement`) require explicit opt-in and per-item -user approval. `audit-permission-grants` and `audit-model-fit` are report-only (the former's remediation -is operator-manual; the latter is human-gated by design — it proposes diffs, never applies them). +user approval. `audit-permission-grants` is report-only (its correct remediation is operator-manual). ## What each skill does @@ -67,23 +66,23 @@ Report-only. /claude-config:audit-permission-grants settings # permissions.allow only ``` -### audit-model-fit +### audit-instructions -Sweeps the local instruction surfaces (user + project `CLAUDE.md`, skill `SKILL.md` bodies + context -files, agent definitions, `.claude/rules/**`, prompt-type hooks and output styles) for deterministic -constraints that hobble newer, more capable models: bare prohibitions with no rationale, -over-prescriptive step lists, over-constraining example blocks (kept to 3–5, not banned), and stale -model-era workarounds. Each candidate is measured against "would removing this cause Claude to make -mistakes?" A deterministic scan flags the grep-able smells; the judgment stays in the skill body. -Report-only and human-gated — it proposes diffs, never applies them. Findings inside -`melodic-software/standards`-managed materializations route upstream rather than being edited in place. -Distinct from `skill-quality:check` (structure), `docs-hygiene:compress` (token brevity), and `audit` -(config-file correctness). +Audits instruction *content* against current model capability — a different question from the +sibling audits (config-file correctness) and from `skill-quality:check` (structural lint) or +`docs-hygiene:compress` (token brevity). It sweeps the locally-owned surfaces (user + project +`CLAUDE.md`, `.claude/rules`, skill bodies, agent definitions, prompt-type hooks, output styles) +against an eleven-check catalog cited to current official prompting doctrine, running a fresh +read-only subagent per surface, then a fresh-context verify pass that re-judges every removal +proposal before it is surfaced. Findings are tiered mechanical vs behavioral and delivered as a +report plus proposed diffs — report-only, never auto-applied. On memory-layer surfaces it runs only +the model-era checks and routes hygiene findings to the `claude-memory` plugin's `audit` skill (with +a documented fallback when it is not installed); upstream-owned plugin-cache and managed-file +findings route to the owning repository rather than being edited in place. ```shell -/claude-config:audit-model-fit # sweep all instruction surfaces -/claude-config:audit-model-fit claude-md # CLAUDE.md only -/claude-config:audit-model-fit skills # skill bodies + context files only +/claude-config:audit-instructions # audit every locally-owned surface +/claude-config:audit-instructions skills # one surface (claude-md|rules|skills|agents|hooks|output-styles) ``` ## Consumer conventions @@ -106,7 +105,7 @@ automatically at your next session — no action needed for `audit`, `audit-auto `audit-permission-grants`. The `memory-health` skill did **not** move to `claude-config` — it was extracted into the new, -separate `claude-memory` plugin (as `health`). The rename only rewrites the `claude-config-audit` +separate `claude-memory` plugin (now its `audit` skill). The rename only rewrites the `claude-config-audit` plugin key; it does not enable additional plugins, so `claude-memory` is not installed for you automatically. If you used `/claude-config-audit:memory-health`, install it explicitly: diff --git a/plugins/claude-config/skills/audit-automation-gaps/SKILL.md b/plugins/claude-config/skills/audit-automation-gaps/SKILL.md index 2ad89a4c3c..b4f4c3d57b 100644 --- a/plugins/claude-config/skills/audit-automation-gaps/SKILL.md +++ b/plugins/claude-config/skills/audit-automation-gaps/SKILL.md @@ -4,6 +4,7 @@ description: "Audit a repo's Claude Code automation landscape (hooks, MCP server argument-hint: "[--recommend-only] [--implement] [category] — category: hooks|mcp|skills|subagents|scheduled|all (default: all)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context @@ -31,7 +32,7 @@ This skill is self-contained. Where a phase names an adjacent capability — a r implementation-planning skill, a work-item tracker, an outcome verifier — treat it as optional: if your setup provides an equivalent, use it; otherwise follow the inline guidance, which stands on its own. Adjacent skills cover neighboring questions: the sibling `audit` skill (are the config FILES -correct?) and the `health` skill in the `claude-memory` plugin (is the instruction layer healthy?). +correct?) and the `audit` skill in the `claude-memory` plugin (is the instruction layer healthy?). ## Arguments diff --git a/plugins/claude-config/skills/audit-instructions/SKILL.md b/plugins/claude-config/skills/audit-instructions/SKILL.md new file mode 100644 index 0000000000..1e75053d14 --- /dev/null +++ b/plugins/claude-config/skills/audit-instructions/SKILL.md @@ -0,0 +1,161 @@ +--- +name: audit-instructions +description: "Audit locally-owned Claude Code instruction surfaces — user + project CLAUDE.md, .claude/rules, skill bodies, agent definitions, prompt-type hooks, output styles — for instructions current models no longer need: prior-model workarounds, over-prescriptive scaffolding, bare prohibitions, reasoning-echo directives, stale examples. Report-only: emits a findings report with proposed diffs, gated to the human, never auto-applied. Use when: 'after a model upgrade', 'are my instructions holding the model back', 'instructions the model no longer needs', 'too prescriptive', 'audit instructions', 'instruction audit'. Not a brevity pass and not memory-layer hygiene." +argument-hint: "[scope] — scope: claude-md|rules|skills|agents|hooks|output-styles|all (default: all)" +user-invocable: true +disable-model-invocation: false +--- + +## Purpose + +Audit whether the instructions you have written for Claude Code are still earning their context +cost against **current** model capability. As models improve, prior-model-era scar tissue +accretes: workarounds for mistakes the model no longer makes, prescriptive step lists that now +constrain more than they help, bare prohibitions, and show-your-thinking directives. This skill +sweeps the locally-owned instruction surfaces, cites each finding to current official prompting +doctrine, tiers it by how confident the evidence can be, and packages proposed removals or +rewrites as a human-gated diff — so instruction surfaces shrink as models get better instead of +only ever growing. + +The check catalog — the eleven checks I1–I11, their evidence tier, authority tag, severity, and +per-surface applicability — lives in [reference/criteria.md](reference/criteria.md). The +deterministic pre-scan is +`${CLAUDE_PLUGIN_ROOT}/skills/audit-instructions/scripts/instruction-scan.sh`. + +## Read-only contract + +This skill is report-only. There is no `--fix`: instruction files are the operator's voice — +every change is applied by the human (or explicitly delegated afterward), never by this skill. +Diffs are proposed artifacts. A clean audit is a valid outcome. + +## Scope boundary (route out) + +This skill owns instruction **content vs current model capability**. It does not own the adjacent +concerns its siblings already cover — route rather than re-answer: + +- Structural skill lint (frontmatter, line caps, broken refs) is `skill-quality:check`. +- Token brevity for its own sake is `docs-hygiene:compress`. +- Config-file mechanics (settings.json, .mcp.json, hooks wiring) is `claude-config:audit`; grant + portability is `claude-config:audit-permission-grants`. + +On **memory-layer surfaces** (CLAUDE.md, CLAUDE.local.md, `.claude/rules/`, `~/.claude/rules/`), +this skill runs only the model-era checks I6–I11. It never runs or reports the hygiene checks +I1–I5 (line-necessity, length, placement, inferable content, rule-to-hook) on these surfaces — +that instruction-memory hygiene layer belongs to the `claude-memory` plugin. When that plugin is +installed, route memory-layer hygiene to its `audit` skill; when it is not installed, emit a single +one-line pointer to the official CLAUDE.md include/exclude guidance (recorded with I1–I5 in +[reference/criteria.md](reference/criteria.md)) so the operator knows where that audit lives — this +skill still does not perform it. Either way, no I1–I5 hygiene finding is ever produced here. On +**non-memory surfaces** (skill bodies, agent definitions, prompt-type hooks, output styles) the +full catalog I1–I11 applies — no incumbent auditor covers instruction content there. + +**Upstream-owned surfaces are excluded from the editable set.** Installed plugin-cache content is +owned by the publishing repository, and a managed materialization is owned by whatever upstream +the consuming repo's own distribution seam names (a `managed` versus `locally-owned` split in the +sync manifest that repo documents, when it documents one). Findings on these become routing +recommendations to the owning repository's tracker, never in-place edits. Absent such a +declaration in the consuming repo, no managed-file exclusion applies. + +## Arguments + +Parse `$ARGUMENTS` for an optional scope filter that narrows which surfaces the inventory collects: + +- `claude-md` — user + project CLAUDE.md and CLAUDE.local.md only +- `rules` — `.claude/rules/` and `~/.claude/rules/` only +- `skills` — skill bodies and their context/reference files only +- `agents` — agent definition markdown only +- `hooks` — prompt-type hook text only +- `output-styles` — output-style markdown only +- `all` — every locally-owned surface (default) + +## Phase A — Inventory + +Enumerate the locally-owned instruction surfaces in scope. All paths below are current per the +official memory and `.claude`-directory docs (cited in the report's Sources line): + +- User — resolve the root as `${CLAUDE_CONFIG_DIR:-~/.claude}` (setting `CLAUDE_CONFIG_DIR` + relocates the whole `~/.claude` tree, so never hardcode `~/.claude`), then: `CLAUDE.md`, + `rules/`, `skills/`, `agents/`, `output-styles/` under that root. +- Project: `./CLAUDE.md` or `./.claude/CLAUDE.md`, `./CLAUDE.local.md`, and every nested + `CLAUDE.md` / `CLAUDE.local.md` in subdirectories of the project tree (Claude loads these on + demand when it reads files in those directories, so walk the tree — do not stop at the root); + `.claude/rules/`, `.claude/skills/`, `.claude/agents/`, `.claude/output-styles/`. +- Prompt-type hook text configured in the project or user `settings.json`. + +Exclude, and hold for the routing subsection instead of the editable set: auto-memory +(`~/.claude/projects//memory/`, owned by `claude-memory`), org-managed policy CLAUDE.md, +installed plugin-cache content, and any managed materialization per the Scope boundary. Record +each surface found and each surface skipped, so the report's tier-transparency line can name both. + +## Phase B — Per-surface lanes + +Run one **fresh read-only subagent per surface**, each sharing +[reference/criteria.md](reference/criteria.md) and applying the per-surface check partition from +the Scope boundary. Seed each lane's mechanical tier with the deterministic pre-scan over that +surface's files: + +```shell +bash "${CLAUDE_PLUGIN_ROOT}/skills/audit-instructions/scripts/instruction-scan.sh" ... +``` + +It emits `file:line:check-id` candidate rows for I6 (bare prohibitions lacking a rationale marker) +and I10 (reasoning-echo directives); `--count` prints the row count. It is advisory and a grep +cannot judge whether a rationale is genuinely present, so the lane refines every candidate rather +than reporting it verbatim. + +Bound concurrency to 3–5 lanes at a time. The skills surface fans out one lane per skill. Before +the total dispatch count (lanes plus the Phase C verifiers) would exceed ~20, confirm with the +user first. + +## Phase C — Verify pass + +Every removal or rewrite proposal is re-judged before it reaches the report. Dispatch **fresh-context, +non-fork** subagents — this is a self-grade of the audit's own proposals, so a fork that inherits the +producing context would not be independent — prompted to refute: "would removing this instruction +cause Claude to make mistakes? Argue that it is still load-bearing." Batch one verifier per surface +(not one per finding), counted under the same ~20-dispatch gate. A proposal the verifier defends is +demoted to `info` or dropped, never surfaced as a confident removal. + +## Phase D — Report + +Persist the report to `${CLAUDE_PLUGIN_DATA}/audit-instructions/last-audit.md` and summarize it in +chat. Present findings as a table: + +| # | Check | Surface:Line | Severity | Tier | Authority | Finding | Proposed change | +|---|-------|--------------|----------|------|-----------|---------|-----------------| + +For each finding, give the proposed removal or rewrite as a fenced diff block. Tier is `mechanical` +(pattern-detectable) or `behavioral` (its ground truth is observed behavior); authority is the +check's tag from the catalog. End with a **Routing** subsection listing every excluded upstream-owned +or memory-layer surface and where its findings should go, and a **Recommended follow-through** +subsection: apply an accepted change, then observe whether Claude's behavior actually shifts; +re-add on the next mistake as the compounding safety net; for example blocks, A/B against the +no-example default. That loop is prose guidance — this skill ships no eval tooling. + +Open the Sources line with the two official pages the paths and doctrine derive from +(code.claude.com memory + `.claude`-directory docs; the prompting pages cited per check in the +catalog). + +## Gotchas + +- **Examples are not scaffolding.** Keep the 3–5 format/tone/structure-steering examples the docs + recommend; flag an example block only when it pins the model's *approach* to a task (behavioral + scaffolding), never when it steers output format. +- **Bare-prohibition rewrites go positive first.** The primary remediation is "say what to do + instead of what not to do"; adding a rationale is the fallback where a genuine hard "never" + survives. Do not mechanically delete every prohibition the pre-scan flags. +- **Behavioral findings ship as proposals, not confident cuts.** A narrow eval can miss a small + regression from an over-aggressive trim — that is why the verify pass and the delete-and-watch + loop exist. Never present a behavioral removal as certain. +- **Windows shell.** The pre-scan is bash; on native Windows run it through Git Bash. + +## What this skill does NOT do + +- Never edits an instruction file and never auto-files a tracker item — output is a report plus + proposed diffs the human applies. +- Not a token-brevity pass (`docs-hygiene:compress`) and not structural skill lint + (`skill-quality:check`). +- Not memory-layer hygiene — checks I1–I5 on CLAUDE.md/rules route to `claude-memory`'s `audit` + skill when installed. +- Does not edit upstream-owned plugin-cache or managed materializations — those findings route to + the owning repository. diff --git a/plugins/claude-config/skills/audit-instructions/evals/evals.json b/plugins/claude-config/skills/audit-instructions/evals/evals.json new file mode 100644 index 0000000000..6b188973d4 --- /dev/null +++ b/plugins/claude-config/skills/audit-instructions/evals/evals.json @@ -0,0 +1,65 @@ +{ + "skill_name": "audit-instructions", + "evals": [ + { + "id": 1, + "name": "bare-invocation-stays-read-only", + "prompt": "/claude-config:audit-instructions", + "expected_output": "Runs the read-only sweep of the locally-owned instruction surfaces and produces a findings report plus proposed diffs, persisted to CLAUDE_PLUGIN_DATA and summarized in chat. It never edits an audited instruction file: there is no --fix, diffs are proposed artifacts the human applies, and a clean audit is a valid outcome.", + "files": [], + "expectations": [ + "Produces a findings report with proposed diffs and does not Edit or Write any audited instruction file", + "Treats the proposed diffs as artifacts the human applies (no --fix), never applying a change itself", + "Treats a clean audit as a valid outcome rather than manufacturing findings" + ] + }, + { + "id": 2, + "name": "scope-boundary-routes-out", + "prompt": "/claude-config:audit-instructions is my CLAUDE.md too long, and can you prune the always-loaded hygiene lines out of it?", + "expected_output": "Recognizes memory-layer hygiene — line budget, whether CLAUDE.md is too long, pruning always-loaded content — as the claude-memory plugin's audit skill's concern. On memory-layer surfaces (CLAUDE.md, CLAUDE.local.md, .claude/rules) this skill runs only the model-era checks I6-I11 and routes the I1-I5 hygiene findings to claude-memory:audit when that plugin is installed, falling back to the official CLAUDE.md include/exclude guidance pointer when it is not, rather than answering the hygiene question itself.", + "files": [], + "expectations": [ + "Routes memory-layer hygiene (line budget, 'CLAUDE.md too long', pruning) to the claude-memory plugin's audit skill when installed", + "On memory-layer surfaces runs only the model-era checks I6-I11, not the I1-I5 hygiene checks", + "Falls back to the official CLAUDE.md include/exclude guidance pointer when claude-memory is not installed instead of silently skipping" + ] + }, + { + "id": 3, + "name": "plugin-cache-finding-routed-not-edited", + "prompt": "/claude-config:audit-instructions also audit the instruction files inside my installed plugins' cache and fix anything stale there.", + "expected_output": "Excludes installed plugin-cache content from the editable set because it is owned by the publishing repository. Any finding on plugin-cache instructions is emitted as a routing recommendation to the owning repository's tracker, never applied as an in-place edit to the cache.", + "files": [], + "expectations": [ + "Excludes installed plugin-cache content from the editable set as upstream-owned by the publishing repository", + "Emits any plugin-cache finding as a routing recommendation to the owning repository's tracker", + "Does not edit files under the plugin cache in place" + ] + }, + { + "id": 4, + "name": "example-block-nuance", + "prompt": "/claude-config:audit-instructions one of my skills includes three short examples showing the exact output format and tone I want — flag those as bloat to cut.", + "expected_output": "Does not flag format/tone/structure-steering example blocks: check I9 keeps 3-5 such examples as officially recommended. It flags an example block only when it pins the model's approach to a task (behavioral scaffolding), and does not treat the mere presence of examples as a finding.", + "files": [], + "expectations": [ + "Does not flag example blocks that steer output format, tone, or structure (I9 keeps 3-5 such examples)", + "Flags an example block only when it pins the model's approach to a task (behavioral scaffolding)", + "Does not treat the presence of examples as itself a finding" + ] + }, + { + "id": 5, + "name": "verify-pass-demotion", + "prompt": "/claude-config:audit-instructions you proposed removing a prior-model instruction, but the verify pass argued it is still load-bearing — how does that show up in the report?", + "expected_output": "Every removal or rewrite proposal passes a fresh-context, non-fork verify pass before it reaches the report. A proposal the verifier successfully defends is demoted to info or dropped, not surfaced as a confident removal, and a refuted or behavioral-tier removal is never presented as an error or an applied change.", + "files": [], + "expectations": [ + "Runs each removal proposal through a fresh-context, non-fork verify pass before surfacing it", + "Demotes a proposal the verifier defends to info or drops it, rather than presenting it as a confident removal", + "Does not present a refuted or behavioral-tier removal as an error or an applied change" + ] + } + ] +} diff --git a/plugins/claude-config/skills/audit-instructions/reference/criteria.md b/plugins/claude-config/skills/audit-instructions/reference/criteria.md new file mode 100644 index 0000000000..804aff19cb --- /dev/null +++ b/plugins/claude-config/skills/audit-instructions/reference/criteria.md @@ -0,0 +1,172 @@ +# Instruction-Audit Criteria + +Version: 1.0.0 +Last updated: 2026-07-21 + +The checks the `audit-instructions` skill runs, seeded from current official prompting doctrine. +Each check carries an evidence tier, an authority tag, a default severity, its surface +applicability, and one decisive source line (point-don't-copy — the full doctrine lives at the +cited URL, not restated here). + +**Recheck triggers** — treat these as staleness signals and re-verify the catalog against live +docs when any fires: a new frontier model release; any change to the two prompting-best-practices +pages; a change to the Claude Code best-practices page. Model-specific pages (the Fable 5 guide) +are superseded on each model generation. + +**Axes.** Three orthogonal axes, never conflated: + +- **Evidence tier** — `mechanical` (pattern-detectable by static reading) or `behavioral` (ground + truth is observed model behavior, so findings ship as proposals verified by the delete-and-watch + loop, never confident removals). +- **Authority** — `ANTHROPIC-DOCS` (official documentation), `TALK` (a recorded talk), `OPINION` + (a practitioner's stated practice). All eleven seeds are `ANTHROPIC-DOCS`. +- **Severity** — `error` / `warning` / `info`. + +**Surface partition.** Checks I1–I5 are the instruction-memory hygiene layer: they apply on +non-memory surfaces (skill bodies, agent definitions, prompt-type hooks, output styles); on +memory-layer surfaces (CLAUDE.md, CLAUDE.local.md, `.claude/rules/`, `~/.claude/rules/`) their +findings route to the `claude-memory` plugin's `audit` skill when it is installed, and fall back +to the official include/exclude guidance (I1–I5 source below) when it is not. Checks I6–I11 apply +to all surfaces. + +## Sources + +- Claude Code best practices — +- Prompting best practices — + +- Prompting Claude Fable 5 — + +- Memory (CLAUDE.md, rules, auto memory) — +- The `.claude` directory — +- Refusals and fallback (`reasoning_extraction`) — + + +--- + +### I1: Line-necessity bar + +Tier `mechanical` · Authority `ANTHROPIC-DOCS` · Severity `warning` · Surfaces: I1–I5 partition. + +- **Detect:** a line whose removal would not change behavior — restates a default, a truism, or + something the model already does correctly. +- **Remediate:** cut it, or (if it enforces something) convert per I5. +- **Source:** best-practices — "For each line, ask: *Would removing this cause Claude to make + mistakes?* If not, cut it." + +### I2: Length and skimmability + +Tier `behavioral` · Authority `ANTHROPIC-DOCS` · Severity `warning` · Surfaces: I1–I5 partition. + +- **Detect:** a surface long or dense enough that its own rules start getting ignored; the tell is + the model breaking a rule the file contains. +- **Remediate:** prune, split into path-scoped rules or skills, tighten structure. +- **Source:** best-practices — "Bloated CLAUDE.md files cause Claude to ignore your actual + instructions." + +### I3: Broad-applicability placement + +Tier `mechanical` · Authority `ANTHROPIC-DOCS` · Severity `warning` · Surfaces: I1–I5 partition. + +- **Detect:** only-sometimes-relevant content (a workflow, domain knowledge, one subsystem's + quirks) living in an always-loaded surface. +- **Remediate:** move it to a skill or a path-scoped rule that loads on demand. +- **Source:** best-practices — "only include things that apply broadly. For domain knowledge or + workflows that are only relevant sometimes, use skills instead." + +### I4: Inferable or redundant content + +Tier `mechanical` · Authority `ANTHROPIC-DOCS` · Severity `warning` · Surfaces: I1–I5 partition. + +- **Detect:** content the model can derive from the code, standard language conventions it already + knows, inlined API docs that should be a link, or self-evident practices. +- **Remediate:** delete; link to the source of truth instead of inlining it. +- **Source:** best-practices include/exclude table — exclude "Anything Claude can figure out by + reading code" and "Standard language conventions Claude already knows." + +### I5: Rule-to-hook or delete + +Tier `mechanical` · Authority `ANTHROPIC-DOCS` · Severity `info` · Surfaces: I1–I5 partition. + +- **Detect:** a rule the model already follows without it, or one that must fire every time with + zero exceptions. +- **Remediate:** delete the already-followed rule; convert the must-always rule to a hook, which is + deterministic where an instruction is only advisory. +- **Source:** best-practices — "If Claude already does something correctly without the instruction, + delete it or convert it to a hook." + +### I6: Bare prohibition to positive reframing + +Tier `mechanical` · Authority `ANTHROPIC-DOCS` · Severity `warning` · Surfaces: all. + +- **Detect:** a bare "never / do not / don't" instruction. The deterministic pre-scan marks + candidate lines; a line already carrying a rationale marker is a weaker candidate. +- **Remediate:** reframe positively — state what to do instead — as the primary fix. Where a + genuine hard "never" survives, keep it but add its rationale (see I7) as the fallback. +- **Source:** prompting best-practices — "Tell Claude what to do instead of what not to do." + +### I7: Reason with the request + +Tier `behavioral` · Authority `ANTHROPIC-DOCS` · Severity `info` · Surfaces: all. + +- **Detect:** an instruction that states a request with no intent or motivation attached. +- **Remediate:** add the why — the model connects the task to relevant context instead of inferring + intent on its own. +- **Source:** Fable 5 guide, "Give the reason, not only the request" — "Claude Fable 5 tends to + perform better when it understands the intent behind a request." + +### I8: Model-era re-audit + +Tier `behavioral` · Authority `ANTHROPIC-DOCS` · Severity `warning` · Surfaces: all. + +- **Detect:** prior-model workarounds and over-prescriptive step lists — instructions enumerating + behaviors a current model handles from a brief instruction, or scaffolding that pins an approach. +- **Remediate:** propose removal or a briefer instruction; verify via the delete-and-watch loop + that default performance holds or improves. +- **Source:** Fable 5 guide — "Skills developed for prior models are often too prescriptive for + Claude Fable 5 and can degrade output quality." + +### I9: Example hygiene + +Tier `behavioral` · Authority `ANTHROPIC-DOCS` · Severity `info` · Surfaces: all. + +- **Detect:** an example block that pins the model's *approach* to a task (behavioral scaffolding). + Do not flag examples that steer output format, tone, or structure — those remain recommended. +- **Remediate:** keep 3–5 diverse format/tone/structure examples; propose trimming or reframing + only approach-pinning ones, A/B'd against the no-example default. +- **Source:** prompting best-practices, "Use examples effectively" — examples are "one of the most + reliable ways to steer Claude's output format, tone, and structure"; keep them diverse enough + "that Claude doesn't pick up unintended patterns." + +### I10: Reasoning-echo directives + +Tier `mechanical` · Authority `ANTHROPIC-DOCS` · Severity `error` · Surfaces: all. + +- **Detect:** instructions telling the model to show, echo, transcribe, or explain its internal + reasoning as response text. The deterministic pre-scan marks show-your-thinking phrasing. +- **Remediate:** remove them; read structured `thinking` blocks or use a send-to-user tool if + reasoning visibility is needed. +- **Source:** Fable 5 guide — such instructions "can trigger the `reasoning_extraction` refusal + category on Claude Fable 5, causing elevated fallbacks." + +### I11: CLI over MCP where equivalent + +Tier `mechanical` · Authority `ANTHROPIC-DOCS` · Severity `info` · Surfaces: all. + +- **Detect:** an instruction steering the model to an MCP tool where an equivalent CLI exists, when + the surface's concern is context cost rather than a capability the MCP server uniquely provides. +- **Remediate:** prefer the CLI for the equivalent operation; keep the MCP path where it adds + capability. +- **Source:** best-practices — "CLI tools are the most context-efficient way to interact with + external services." + +--- + +## Output format + +Findings are presented using the Phase D report table defined in the skill body +([SKILL.md](../SKILL.md)), one proposed diff per finding — the column set lives there and is not +restated here. + +A clean audit ("No instructions flagged.") is a valid outcome. Behavioral-tier proposals are +always presented as proposals paired with the delete-and-watch follow-through, never as confident +removals. diff --git a/plugins/claude-config/skills/audit-instructions/scripts/instruction-scan.sh b/plugins/claude-config/skills/audit-instructions/scripts/instruction-scan.sh new file mode 100755 index 0000000000..6ffac11470 --- /dev/null +++ b/plugins/claude-config/skills/audit-instructions/scripts/instruction-scan.sh @@ -0,0 +1,108 @@ +#!/usr/bin/env bash +# instruction-scan.sh — advisory deterministic pre-scan for the audit-instructions +# skill. Marks CANDIDATE lines for two of the catalog checks (reference/criteria.md) +# in the instruction files handed to it: +# +# I6 bare prohibition ("never", "do not", "don't", "must not", "should not") +# on a line that carries no rationale marker (because/since/so that/…). A +# grep cannot judge whether a rationale is genuinely present or whether the +# prohibition is a genuine hard "never", so these are candidates the model +# lane refines — not confirmed findings. +# I10 reasoning-echo directive (show/explain/reproduce your thinking or +# reasoning, "think out loud", reasoning_extraction). These tell the model +# to emit its internal reasoning as response text. +# +# Advisory: prints candidate rows, ALWAYS exits 0 (candidates never fail a run). +# Requires grep; exits 2 when grep is absent. +# +# Rows are `file:line:check-id` (grep -n convention). With no rationale on a line +# a prohibition surfaces as an I6 row; a line may surface once for I6 and once for +# I10. Nonexistent path arguments are skipped, not errors. +# +# Usage: +# instruction-scan.sh FILE... # one candidate row per line; exit 0 +# instruction-scan.sh --count FILE... # integer candidate count only; exit 0 +# instruction-scan.sh --help + +set -uo pipefail + +usage() { + cat <<'EOF' +instruction-scan.sh — mark I6/I10 instruction candidates in given files. + +Usage: instruction-scan.sh [--count|--help] FILE... + + FILE... print one candidate row (file:line:check-id) per match; exit 0 + --count print the integer candidate count only; exit 0 + --help this message + +Advisory — always exits 0 (candidates never fail the run). Requires grep +(exit 2 when absent). Seeds the mechanical tier of the audit-instructions +skill; the per-surface lane refines every candidate against reference/criteria.md. +EOF +} + +case "${1:-}" in + -h | --help) + usage + exit 0 + ;; + *) ;; +esac + +if ! command -v grep >/dev/null 2>&1; then + echo "ERROR: grep required" >&2 + exit 2 +fi + +mode="report" +if [[ "${1:-}" == "--count" ]]; then + mode="count" + shift +fi + +# --- Detection patterns (case-insensitive) ----------------------------------- +# I6 prohibition tokens. `do NOT` folds into `do not` under -i. +I6_ERE="\\bnever\\b|\\bdo not\\b|\\bdon'?t\\b|\\bmust ?not\\b|\\bmustn'?t\\b|\\bshould ?not\\b|\\bshouldn'?t\\b" +# Rationale markers — a prohibition line carrying one of these is not an I6 candidate. +RATIONALE_ERE="because|\\bsince\\b|\\bso that\\b|\\bso it\\b|\\bso the\\b|\\bto avoid\\b|\\botherwise\\b|\\bin order to\\b|\\brationale\\b|\\breason\\b" +# I10 reasoning-echo phrasing. +I10_ERE="(show|explain|reproduce|echo|transcribe|verbalize|narrate|share|describe) (your |the )?(thinking|reasoning|thought process|chain of thought)" +I10_ERE="${I10_ERE}|think out loud|walk (me|us) through your (thinking|reasoning)|reasoning_extraction|chain[- ]of[- ]thought" + +rows=() + +scan_file() { + local file="$1" hit lineno text + [[ -f "$file" ]] || return 0 + + while IFS= read -r hit; do + [[ -n "$hit" ]] || continue + lineno="${hit%%:*}" + text="${hit#*:}" + printf '%s\n' "$text" | grep -qiE "$RATIONALE_ERE" && continue + rows+=("$file:$lineno:I6") + done < <(grep -niE "$I6_ERE" "$file" 2>/dev/null) + + while IFS= read -r hit; do + [[ -n "$hit" ]] || continue + lineno="${hit%%:*}" + rows+=("$file:$lineno:I10") + done < <(grep -niE "$I10_ERE" "$file" 2>/dev/null) +} + +for file in "$@"; do + scan_file "$file" +done + +if [[ "$mode" == "count" ]]; then + printf '%s\n' "${#rows[@]}" + exit 0 +fi + +if [[ "${#rows[@]}" -eq 0 ]]; then + echo "No instruction candidates found." +else + printf '%s\n' "${rows[@]}" +fi +exit 0 diff --git a/plugins/claude-config/skills/audit-instructions/scripts/instruction-scan.test.sh b/plugins/claude-config/skills/audit-instructions/scripts/instruction-scan.test.sh new file mode 100755 index 0000000000..e01ee48bf5 --- /dev/null +++ b/plugins/claude-config/skills/audit-instructions/scripts/instruction-scan.test.sh @@ -0,0 +1,130 @@ +#!/usr/bin/env bash +# Regression tests for instruction-scan.sh (self-contained — ships with the plugin). +set -uo pipefail + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +SCRIPT="$SCRIPT_DIR/instruction-scan.sh" + +TEST_TMPDIR="$(mktemp -d)" +trap 'rm -rf "$TEST_TMPDIR"' EXIT + +FAILED=0 +CASE_NUM=0 + +pass() { + CASE_NUM=$((CASE_NUM + 1)) + printf 'PASS: %s\n' "$1" +} +fail() { + CASE_NUM=$((CASE_NUM + 1)) + FAILED=$((FAILED + 1)) + printf 'FAIL: %s\n detail: %s\n' "$1" "$2" >&2 +} +assert_eq() { + if [[ "$2" == "$3" ]]; then pass "$1"; else fail "$1" "expected: $2, actual: $3"; fi +} +assert_exit() { + if [[ "$2" == "$3" ]]; then pass "$1"; else fail "$1" "expected exit $2, got $3"; fi +} +assert_contains() { + case "$2" in + *"$3"*) pass "$1" ;; + *) fail "$1" "expected to contain: $3" ;; + esac +} +assert_not_contains() { + case "$2" in + *"$3"*) fail "$1" "unexpected substring: $3" ;; + *) pass "$1" ;; + esac +} + +if ! command -v grep >/dev/null 2>&1; then + echo "SKIP: grep not installed" >&2 + exit 0 +fi + +# --- Case 1: --help ---------------------------------------------------------- +rc=0 +OUT=$(bash "$SCRIPT" --help) || rc=$? +assert_exit "--help exits 0" 0 "$rc" +assert_contains "--help prints usage" "$OUT" "Usage:" + +# --- Case 2: I6 bare prohibitions flagged ----------------------------------- +I6F="$TEST_TMPDIR/i6.md" +cat >"$I6F" <<'EOF' +Never commit secrets to the repository. +Do not use bare Bash grants in auto mode. +Always run the tests before pushing. +EOF +rc=0 +OUT=$(bash "$SCRIPT" "$I6F") || rc=$? +assert_exit "I6 scan exits 0 (advisory)" 0 "$rc" +assert_contains "flags 'Never' prohibition on line 1" "$OUT" "$I6F:1:I6" +assert_contains "flags 'Do not' prohibition on line 2" "$OUT" "$I6F:2:I6" +assert_not_contains "positive 'Always' instruction not flagged" "$OUT" ":3:I6" +assert_eq "two I6 candidates" "2" "$(bash "$SCRIPT" --count "$I6F")" + +# --- Case 3: prohibition WITH rationale not flagged ------------------------- +I6R="$TEST_TMPDIR/i6-rationale.md" +cat >"$I6R" <<'EOF' +Never force-push to main because it rewrites shared history. +Do not skip the lint step, since CI will reject the PR otherwise. +EOF +assert_eq "rationale-bearing prohibitions not flagged" "0" "$(bash "$SCRIPT" --count "$I6R")" + +# --- Case 4: I10 reasoning-echo directives flagged -------------------------- +I10F="$TEST_TMPDIR/i10.md" +cat >"$I10F" <<'EOF' +Show your thinking before giving the final answer. +Explain your reasoning step by step in the response. +Think out loud as you work through the problem. +Summarize the changes in two bullet points. +EOF +OUT=$(bash "$SCRIPT" "$I10F") +assert_contains "flags 'Show your thinking'" "$OUT" "$I10F:1:I10" +assert_contains "flags 'Explain your reasoning'" "$OUT" "$I10F:2:I10" +assert_contains "flags 'Think out loud'" "$OUT" "$I10F:3:I10" +assert_not_contains "benign summarize instruction not flagged" "$OUT" ":4:I10" +assert_eq "three I10 candidates" "3" "$(bash "$SCRIPT" --count "$I10F")" + +# --- Case 5: clean file ------------------------------------------------------ +CLEAN="$TEST_TMPDIR/clean.md" +cat >"$CLEAN" <<'EOF' +Use ES modules syntax. +Run npm test before committing. +API handlers live in src/api/handlers/. +EOF +assert_contains "clean file message" "$(bash "$SCRIPT" "$CLEAN")" "No instruction candidates found." +assert_eq "clean file count is 0" "0" "$(bash "$SCRIPT" --count "$CLEAN")" + +# --- Case 6: multiple files aggregate --------------------------------------- +assert_eq "aggregate count across files" "5" "$(bash "$SCRIPT" --count "$I6F" "$I10F")" + +# --- Case 7: nonexistent path skipped, not an error ------------------------- +rc=0 +OUT=$(bash "$SCRIPT" "$TEST_TMPDIR/does-not-exist.md") || rc=$? +assert_exit "nonexistent path exits 0" 0 "$rc" +assert_contains "nonexistent path yields clean message" "$OUT" "No instruction candidates found." + +# --- Case 8: no file arguments ---------------------------------------------- +rc=0 +OUT=$(bash "$SCRIPT") || rc=$? +assert_exit "no-args exits 0" 0 "$rc" +assert_eq "no-args count is 0" "0" "$(bash "$SCRIPT" --count)" + +# --- Case 9: missing grep exits 2 ------------------------------------------- +real_bash=$(command -v bash) +empty_path_dir="$TEST_TMPDIR/empty-path" +mkdir -p "$empty_path_dir" +rc=0 +err_out=$(PATH="$empty_path_dir" "$real_bash" "$SCRIPT" "$CLEAN" 2>&1) || rc=$? +assert_exit "exit 2 when grep missing" 2 "$rc" +assert_contains "grep required message" "$err_out" "grep required" + +if [[ "$FAILED" -eq 0 ]]; then + printf '\nAll %d checks passed.\n' "$CASE_NUM" + exit 0 +fi +printf '\n%d/%d checks failed.\n' "$FAILED" "$CASE_NUM" >&2 +exit 1 diff --git a/plugins/claude-config/skills/audit-model-fit/SKILL.md b/plugins/claude-config/skills/audit-model-fit/SKILL.md deleted file mode 100644 index 1fd772c1dc..0000000000 --- a/plugins/claude-config/skills/audit-model-fit/SKILL.md +++ /dev/null @@ -1,110 +0,0 @@ ---- -name: audit-model-fit -description: "Audit local Claude Code instruction surfaces (user + project CLAUDE.md, skill SKILL.md bodies + context files, agent definitions, .claude/rules, prompt-type hooks and output styles) for deterministic constraints that hobble newer, more capable models — bare prohibitions with no rationale, over-prescriptive step lists, over-constraining example blocks, and stale model-era workarounds — and propose removals/rewrites against the bar 'would removing this cause Claude to make mistakes?'. Use when: 'audit model fit', 'unhobble my instructions', 'after a model upgrade', 'are my CLAUDE.md constraints still needed', 'prune stale prompt instructions', 'my skills are too prescriptive'. Report-only: proposes diffs, never auto-applies." -argument-hint: "[scope] — scope: claude-md|skills|agents|rules|hooks|all (default: all)" -user-invocable: true -disable-model-invocation: false ---- - -## Pre-computed context - -Instruction-surface inventory: !`bash "${CLAUDE_PLUGIN_ROOT}/skills/audit-model-fit/scripts/instruction-surface-scan.sh" 2>/dev/null || echo "scan unavailable"` - -## Purpose - -Upgrade-triggered (or on-demand) audit that sweeps the local Claude Code instruction surfaces and -proposes removals/rewrites of deterministic constraints that hobble newer models. Instructions written -to make a prior, weaker model behave — bare prohibitions, mechanical step lists, defensive -over-specification — become carrying cost and can *degrade* a capable model's output. This audit finds -them and proposes changes; a human applies them. - -The governing bar: **"Would removing this instruction cause Claude to make mistakes?"** If no, it is a -removal or loosening candidate. The full check catalog, treatments, sources, and output format live in -[reference/criteria.md](reference/criteria.md) — read it when running this audit. - -## Scope boundary (compose with — route out, do not restate their logic) - -This audit owns instruction **content fit** to the current model. Four adjacent skills own neighboring -questions; route findings that belong to them rather than handling them here: - -- `claude-memory:audit` — instruction-layer **health** against a codified checklist (is `CLAUDE.md` - well-formed, within length, are rules valid). It reads the same surfaces and shares the pruning bar, - but asks "is the instruction layer healthy?"; this audit asks "do its constraints still fit a newer - model?". Route structure/health/length findings there; keep model-fit loosening here. -- `skill-quality:check` — **structural** SKILL.md lint (frontmatter, line caps, broken refs). -- `docs-hygiene:compress` — **token brevity** (shorten prose without dropping meaning). This audit - removes now-unnecessary *constraints*, not just words. -- `claude-config:audit` — **config-file** hygiene (settings.json / .mcp.json / hooks / permissions). - -## Cross-repo routing (standards-managed materializations) - -A finding inside a file **synced from `melodic-software/standards`** (owned upstream per that repo's -`distribution/sync-manifest.yml`) is **never edited in place** — the next sync overwrites it. Route the -change upstream to the owning repo and say so in the report; propose no in-place diff for that file. If -the manifest is not reachable from the consuming repo, still apply the rule: flag any vendored/synced -file for upstream routing. Locally-owned surfaces get the normal human-gated proposed diff. - -## Arguments - -Parse `$ARGUMENTS` for an optional scope filter: - -- `claude-md` — user + project `CLAUDE.md` only -- `skills` — skill `SKILL.md` bodies + `context/`/`reference/` files only -- `agents` — agent definitions only -- `rules` — `.claude/rules/**/*.md` only -- `hooks` — prompt-type hook scripts + output styles only -- `all` — everything (default) - -This skill is **report-only**. There is no `--fix`: every change is human-gated. It proposes diffs; a -human (or a skill the human explicitly invokes) applies them. - -## Phase 1: Enumerate surfaces - -Run the deterministic scan (also injected above at load): - -```shell -bash "${CLAUDE_PLUGIN_ROOT}/skills/audit-model-fit/scripts/instruction-surface-scan.sh" -``` - -It reports the surface inventory and flags the two grep-able smells as **candidates** — bare -prohibitions (C1) and example-dense files (C3). `--candidates` lists each `file:line`; `--count` prints -the bare-prohibition count. Candidates are starting points, not verdicts. - -If a scope filter was given, read only the matching surfaces in Phase 2. - -## Phase 2: Classify against the check catalog - -Read [reference/criteria.md](reference/criteria.md) and read the in-scope surfaces. For each candidate, -and each instruction in the surfaces you read, apply the checks: - -- **C1 bare prohibition** → propose a **prohibition + rationale** rewrite, not deletion (the constraint - may still be needed; only the missing *why* is the defect). -- **C2 over-prescriptive step list** → cull to intent + hard constraints; keep steps that encode a real - ordering/safety/contract. -- **C3 example-dense** → trim toward 3–5 format-steering examples; **not** a blanket ban — a file at or - below the range is not a finding. -- **C4 stale model-era workaround** → verbose over-specification compensating for a prior model's - weakness; propose removal/loosening. - -Measure every candidate against the pruning bar. **No** (removal changes nothing) → removal/loosening -candidate. **Yes** → keep it (for a C1, still propose the rationale rewrite). A clean sweep is a valid -outcome — do not manufacture findings. - -## Phase 3: Report + proposed diffs (human-gated) - -Present findings as the table and proposed-diffs format in -[reference/criteria.md](reference/criteria.md) "Output format": one row per finding with its check, -surface, pruning-bar verdict, proposed change, and routing. For each locally-owned finding, give the -exact before/after rewrite. For a standards-managed finding, the routing reads -"upstream: melodic-software/standards" and **no** in-place diff is proposed. - -Then stop. Do **not** edit any `CLAUDE.md`, `SKILL.md`, agent definition, rule, hook, or output style. -Applying the diffs is a human action (or a separate skill the human explicitly invokes): - -> "Here are the proposed changes. Which would you like applied? I will not change any file without your go-ahead." - -## Consumer conventions - -A consuming repo may declare, in its own `CLAUDE.md` / `.claude/rules/`, prohibitions it deliberately -keeps bare, example sets it intends to hold above the 3–5 range, or surfaces exempt from this sweep. -Read those when present; this skill does not assume them. diff --git a/plugins/claude-config/skills/audit-model-fit/evals/evals.json b/plugins/claude-config/skills/audit-model-fit/evals/evals.json deleted file mode 100644 index 84f5c98710..0000000000 --- a/plugins/claude-config/skills/audit-model-fit/evals/evals.json +++ /dev/null @@ -1,113 +0,0 @@ -{ - "skill_name": "audit-model-fit", - "evals": [ - { - "id": 1, - "name": "sweep-happy-path", - "prompt": "I just upgraded my model. Audit my CLAUDE.md and skills for instructions that are hobbling it and tell me what to prune.", - "expected_output": "Runs the instruction-surface-scan to enumerate CLAUDE.md, skills, agents, rules, and hooks/output-styles, classifies candidates against the check catalog (bare prohibitions, over-prescriptive step lists, example-dense blocks, stale model-era workarounds), measures each against 'would removing this cause Claude to make mistakes?', and presents a findings report plus proposed diffs.", - "files": [], - "expectations": [ - "Output runs the instruction-surface-scan.sh scan rather than eyeballing the files", - "Output classifies findings against the check catalog and applies the 'would removing this cause mistakes?' pruning bar", - "Output presents findings plus proposed diffs rather than applying any change" - ] - }, - { - "id": 2, - "name": "bare-prohibition-rewrite-not-delete", - "prompt": "My CLAUDE.md says 'Never commit directly to main.' with no reason given. Is that a finding, and if so should I just delete it?", - "expected_output": "Flags it as a bare-prohibition (C1) smell but recommends a prohibition-plus-rationale REWRITE, not deletion — the constraint may still be needed; only the missing rationale is the defect. Deletion applies only if the pruning bar says removing it changes nothing.", - "files": [], - "expectations": [ - "Output identifies the bare prohibition as a C1 finding", - "Output recommends rewriting it to add a rationale, NOT deleting the prohibition", - "Output does not treat every 'never'/'do not' as a delete candidate" - ] - }, - { - "id": 3, - "name": "examples-not-blanket-flagged", - "prompt": "My skill has 4 example blocks steering the output format. Flag them as over-constraining and tell me to remove them.", - "expected_output": "Does NOT blanket-flag the examples: current guidance still recommends keeping 3-5 format-steering examples, so 4 is within range and not a finding. Only example volume well beyond that range is flagged as over-constraining (C3), and the treatment is trimming toward 3-5, never a blanket removal.", - "files": [], - "expectations": [ - "Output states that 3-5 format-steering examples are recommended to keep and 4 is within range", - "Output does NOT flag the 4 example blocks as a finding or recommend removing them", - "Output explains only example volume well beyond 3-5 is the C3 over-constraining smell" - ] - }, - { - "id": 4, - "name": "standards-managed-routes-upstream", - "prompt": "One of the over-prescriptive rule files I want pruned is a copy synced from melodic-software/standards. Just edit it in place to loosen it.", - "expected_output": "Explains a standards-managed materialization is owned upstream per the sync-manifest and the next sync overwrites a local edit, so it is never edited in place. Routes the change upstream to melodic-software/standards and proposes no in-place diff for that file.", - "files": [], - "expectations": [ - "Output explains the file is a standards-managed materialization that a sync would overwrite", - "Output routes the change upstream to melodic-software/standards instead of editing in place", - "Output does not propose an in-place diff for the standards-managed file" - ] - }, - { - "id": 5, - "name": "never-auto-applies", - "prompt": "Audit my instruction surfaces and just auto-apply every loosening you find so I don't have to review them.", - "expected_output": "The skill is report-only and human-gated: it runs the audit and presents findings plus proposed diffs, but does not edit any CLAUDE.md, SKILL.md, agent, rule, hook, or output style itself. There is no --fix; applying the diffs is a human action.", - "files": [], - "expectations": [ - "Output does not edit any instruction file itself", - "Output presents proposed diffs for human review rather than auto-applying them", - "Output states the skill is report-only / human-gated with no --fix" - ] - }, - { - "id": 6, - "name": "route-out-to-siblings", - "prompt": "While auditing model fit, also validate my SKILL.md frontmatter and line caps, shorten the verbose prose, and check my settings.json permissions for drift.", - "expected_output": "Audits only instruction content-fit and routes the adjacent concerns to their owning skills: structural frontmatter/line-cap lint to skill-quality:check, prose-length shortening to docs-hygiene:compress, and settings.json/permissions drift to claude-config:audit — without restating their logic.", - "files": [], - "expectations": [ - "Output audits only the content-fit question it owns", - "Output routes structural SKILL.md lint to skill-quality:check and config/permissions drift to claude-config:audit", - "Output routes prose shortening to docs-hygiene:compress and distinguishes removing constraints from shortening words" - ] - }, - { - "id": 7, - "name": "step-list-culled-not-preserved", - "prompt": "My skill spells out a 9-step numbered procedure for how to open a PR — 'run git status, then git add, then write the message, then...'. Should I keep all the steps for a capable model?", - "expected_output": "Flags the mechanical step list as a C2 over-prescriptive finding and recommends culling it to the intent plus the hard constraints (ordering that genuinely matters, safety gates, external contracts), removing the steps that only narrate a procedure a capable model already sequences correctly — not preserving all 9 steps verbatim.", - "files": [], - "expectations": [ - "Output identifies the numbered step list as a C2 over-prescriptive-step-list finding", - "Output recommends culling to intent + hard constraints, not keeping all steps verbatim", - "Output notes steps encoding a real ordering/safety/contract are kept" - ] - }, - { - "id": 8, - "name": "stale-workaround-removed", - "prompt": "My CLAUDE.md has a paragraph re-explaining what JSON is and a defensive 'if you are unsure how to format the output, just wrap it in a code block' note, added back when the old model kept getting it wrong. Keep them?", - "expected_output": "Flags both as C4 stale model-era workarounds — verbose over-specification and defensive scaffolding compensating for a prior model's weakness — and, applying the pruning bar (removing them would not cause the current model to make mistakes), proposes removal/loosening rather than retention.", - "files": [], - "expectations": [ - "Output identifies the re-explanation and defensive scaffolding as C4 stale model-era workarounds", - "Output applies the pruning bar and concludes removing them would not cause mistakes on the current model", - "Output proposes removing/loosening them rather than keeping them" - ] - }, - { - "id": 9, - "name": "clean-sweep-valid-outcome", - "prompt": "Run the model-fit audit on my repo — but I've already trimmed everything and every instruction earns its place.", - "expected_output": "Runs the sweep and, if every instruction passes the pruning bar, reports a clean result as a valid outcome rather than manufacturing findings to justify the audit.", - "files": [], - "expectations": [ - "Output runs the scan and applies the pruning bar", - "Output reports a clean sweep as a valid outcome when nothing fails the bar", - "Output does not manufacture findings to justify the audit" - ] - } - ] -} diff --git a/plugins/claude-config/skills/audit-model-fit/reference/criteria.md b/plugins/claude-config/skills/audit-model-fit/reference/criteria.md deleted file mode 100644 index a4be9a7f78..0000000000 --- a/plugins/claude-config/skills/audit-model-fit/reference/criteria.md +++ /dev/null @@ -1,148 +0,0 @@ -# Model-Fit Criteria - -Version: 1.0.0 -Last updated: 2026-07-21 - -This file defines the checks the `audit-model-fit` audit runs against local Claude Code instruction -surfaces. It sweeps for deterministic constraints that hobble newer, more capable models — instructions -that made a prior, weaker model behave but now only narrow a capable one — and proposes removals or -rewrites. It **never** applies them: output is a findings report plus proposed diffs, human-gated. - -The governing question — the pruning bar every finding is measured against — is from Anthropic's -guidance: **"Would removing this instruction cause Claude to make mistakes?"** If no, the instruction is -a removal or loosening candidate. - -Sources (verify against these; do not fabricate deep-link anchors): - -- [Prompting Claude Fable 5](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-fable-5) - — "re-evaluate which instructions, tools, and guardrails are still needed"; skills built for prior - models are "often too prescriptive… and can degrade output quality". -- [Claude prompting best practices](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/claude-prompting-best-practices) -- [Claude Code best practices](https://code.claude.com/docs/en/best-practices) — the pruning bar. - -## Surfaces - -The deterministic spine is -`bash "${CLAUDE_PLUGIN_ROOT}/skills/audit-model-fit/scripts/instruction-surface-scan.sh"`. It enumerates, -across the consuming repo (and the user-global `~/.claude/CLAUDE.md`): - -- user + project `CLAUDE.md` (`CLAUDE.md`, `.claude/CLAUDE.md`, `CLAUDE.local.md`, `~/.claude/CLAUDE.md`) -- skill `SKILL.md` bodies + their `context/` and `reference/` files -- agent definitions (`.claude/agents/*.md`) -- `.claude/rules/**/*.md` -- output styles (`.claude/output-styles/*.md`) and prompt-type hook scripts (`.claude/hooks`) - -It flags the two grep-able smells (C1 bare prohibitions, C3 example-dense files) as **candidates** and -is advisory (always exits 0). `--candidates` lists each `file:line`; `--count` prints the -bare-prohibition candidate count. The other checks are model judgment applied while reading the surfaces -— the script does not verdict them. - -Prose surfaces (CLAUDE.md, skill bodies + context, agents, rules, output styles) are grep-scanned for -the two candidate smells. **Hook scripts are enumerated (counted) but not grep-scanned** — a prompt-type -hook's instruction text is embedded in code, where a "never/do not" grep is noise; read the hook bodies -by hand in Phase 2 and apply the same checks. - -Findings are reported, never applied. There is no `--fix`. - ---- - -## C1: Bare prohibition — "never/do not X" with no stated why [rewrite, not delete] - -**What**: A prohibition (`never`, `do not`, `must not`, `shall not`) with no rationale attached. The -scan flags the prohibition lines; whether a rationale is present is the model's call. - -**Why it is a smell**: a capable model follows a reasoned constraint and generalizes it; a bare "never -X" it cannot reason about is both easier to misapply and a frequent relic of steering a weaker model. - -**Treatment**: rewrite to **prohibition + rationale**, not deletion. The constraint may still be needed -— only the missing *why* is the defect. Delete only if the pruning bar says removing it changes nothing. - -## C2: Over-prescriptive step list → cull to intent + constraints [rewrite] - -**What**: A mechanical, numbered step-by-step recipe for something a capable model already sequences -correctly on its own. - -**Why it is a smell**: prescriptive step lists built for prior models "can degrade output quality" — they -over-constrain the model's own planning. Keep the *goal* and the *hard constraints*; drop the mechanics. - -**Treatment**: rewrite to state the intent and the non-negotiable constraints, removing steps that only -narrate an obvious procedure. Keep any step that encodes a genuine hard constraint (an ordering that -matters, a safety gate, an external contract). - -## C3: Example-dense block — over-constraining format steering [rewrite; NOT a blanket ban] - -**What**: An instruction surface carrying far more format-steering example blocks than needed. The scan -flags files with **more than 5** fenced/`` blocks as candidates. - -**Why it is a smell — and its limit**: current guidance still recommends keeping **3–5** examples to -steer format; examples are not the enemy. Only volume **well beyond** that range starts pinning the -model to a rigid template. Do **not** blanket-flag example blocks. - -**Treatment**: trim toward the 3–5 that genuinely steer format; keep coverage of the distinct shapes, -drop near-duplicates. A file at or below the range is not a finding. - -## C4: Stale model-era workaround [remove/loosen] - -**What**: An instruction that reads as compensating for a prior, less-capable model's specific weakness — -verbose over-specification of things a capable model now gets right (belaboring output format it would -infer, re-explaining a concept it knows, defensive "if you are unsure, do X" scaffolding for a task it -now handles). - -**Why it is a smell**: it is pure carrying cost — tokens and rigidity spent to fix a model that is no -longer running. - -**Treatment**: apply the pruning bar. If removing it would not cause mistakes on the current model, -propose removal or loosening. - ---- - -## The pruning bar (applies to every finding) - -For each candidate, ask: **would removing this instruction cause Claude to make mistakes?** - -- **No** → removal/loosening candidate (report the proposed diff). -- **Yes** → keep it. If it is a bare prohibition (C1), still propose the rationale rewrite. - -A clean sweep — every instruction earns its place — is a valid outcome. Do not manufacture findings. - -## Compose with — distinct intents, route out (do not restate their logic) - -- `claude-memory:audit` — instruction-layer **health** (well-formed `CLAUDE.md`, length, valid rules) - against a codified checklist. Same surfaces, same pruning bar, different question: health/structure - vs. model-fit. Route health/length/structure findings there; keep constraint-loosening here. -- `skill-quality:check` — **structural** lint of a SKILL.md (frontmatter, line caps, broken refs). This - audit is content/fit, not structure. Structural defects route there. -- `docs-hygiene:compress` — **token brevity** (shorten prose without semantic loss). This audit removes - now-unnecessary *constraints*, not just words. A prohibition that should stay but read tighter is a - compress job; a prohibition that should loosen is this audit. -- `claude-config:audit` — **config-file** hygiene (settings.json / .mcp.json / hooks / permissions). This - audit reads instruction *content*, not config correctness. - -## Cross-repo routing — standards-managed materializations - -A finding inside a file that is a **materialization synced from `melodic-software/standards`** (owned -upstream per that repo's `distribution/sync-manifest.yml`) is **never edited in place** — the local copy -would be overwritten on the next sync and the change lost. Route such a finding upstream to -`melodic-software/standards` (or the owning source repo the manifest names) as the change target, and -say so in the report. Locally-owned surfaces are edited via the normal human-gated proposed diff. When -the manifest is not reachable from the consuming repo, still apply the rule: flag any file that looks -vendored/synced and note it needs upstream routing rather than an in-place edit. - -## Output format - -```text -## Model-Fit Report — {date} - -### Surfaces scanned -(inventory from instruction-surface-scan.sh) - -### Findings -| # | Check | Surface | Finding | Pruning-bar verdict | Proposed change | Routing | -|---|-------|---------|---------|---------------------|-----------------|---------| - -### Proposed diffs -(per finding: the exact before/after rewrite — human applies, never auto-applied) -``` - -For a standards-managed finding, the Routing column reads "upstream: melodic-software/standards" and no -in-place diff is proposed for that file. diff --git a/plugins/claude-config/skills/audit-model-fit/scripts/instruction-surface-scan.sh b/plugins/claude-config/skills/audit-model-fit/scripts/instruction-surface-scan.sh deleted file mode 100755 index cc80f6c7ef..0000000000 --- a/plugins/claude-config/skills/audit-model-fit/scripts/instruction-surface-scan.sh +++ /dev/null @@ -1,170 +0,0 @@ -#!/usr/bin/env bash -# Enumerate local Claude Code instruction surfaces and surface the grep-able -# model-fit smells for the audit-model-fit skill. -# -# Scans project + user CLAUDE.md, skill SKILL.md bodies (+ context files), -# agent definitions, .claude/rules/**/*.md, output styles, and hook scripts. -# Flags the two deterministically-detectable smells as CANDIDATES only — -# bare prohibitions (never/do not/must not) and oversized example-block files. -# The judgment (is a rationale present? is a step list over-prescriptive? does -# removing this cause mistakes?) stays in the skill body, never here. -# -# Modes: (default) compact inventory + smell summary -# --candidates list each flagged file:line -# --count print total candidate-line count only -# Exit: always 0 (advisory). -set -u - -usage() { - cat <<'EOF' -instruction-surface-scan.sh — enumerate Claude Code instruction surfaces and -flag the grep-able model-fit smells (bare prohibitions, oversized example blocks). - -Usage: - instruction-surface-scan.sh [--candidates | --count | --help] - -Modes: - (default) compact surface inventory + smell summary - --candidates list each flagged file:line (bounded to 200 lines) - --count print the total bare-prohibition candidate-line count only - -Exit: always 0 (advisory — candidates require model judgment, not a verdict). -EOF -} - -MODE="summary" -case "${1:-}" in --h | --help) - usage - exit 0 - ;; ---candidates) MODE="candidates" ;; ---count) MODE="count" ;; -"") ;; -*) - usage >&2 - exit 0 - ;; -esac - -repo_root="$(git rev-parse --show-toplevel 2>/dev/null | tr -d '\r')" -[[ -n "$repo_root" ]] && cd "$repo_root" || true - -# Word-boundary bare-prohibition pattern (case-insensitive). A prohibition is -# only a smell when NO rationale accompanies it — that call is the model's; the -# script just locates the prohibitions. -PROHIBITION='(^|[^[:alnum:]])(never|do not|don'\''t|must not|shall not)([^[:alnum:]]|$)' -EXAMPLE_BLOCK_THRESHOLD=5 - -# Collect the prose surface files (NUL-safe) into an array to grep for smells. -surfaces=() - -# CLAUDE_CONFIG_DIR relocates the whole ~/.claude tree; honor it so the scan -# reads the user-global CLAUDE.md actually loaded into the session. -user_config_dir="${CLAUDE_CONFIG_DIR:-$HOME/.claude}" -claude_md_count=0 -for f in CLAUDE.md .claude/CLAUDE.md CLAUDE.local.md "$user_config_dir/CLAUDE.md"; do - if [[ -f "$f" ]]; then - surfaces+=("$f") - claude_md_count=$((claude_md_count + 1)) - fi -done - -skill_count=0 -context_count=0 -if [[ -d .claude/skills ]]; then - while IFS= read -r -d '' f; do - surfaces+=("$f") - skill_count=$((skill_count + 1)) - done < <(find .claude/skills -name 'SKILL.md' -print0 2>/dev/null) - while IFS= read -r -d '' f; do - surfaces+=("$f") - context_count=$((context_count + 1)) - done < <(find .claude/skills \( -path '*/context/*' -o -path '*/reference/*' \) -name '*.md' -print0 2>/dev/null) -fi - -agent_count=0 -while IFS= read -r -d '' f; do - surfaces+=("$f") - agent_count=$((agent_count + 1)) -done < <(find .claude/agents -maxdepth 1 -name '*.md' -print0 2>/dev/null) - -rule_count=0 -while IFS= read -r -d '' f; do - surfaces+=("$f") - rule_count=$((rule_count + 1)) -done < <(find .claude/rules -name '*.md' -print0 2>/dev/null) - -style_count=0 -while IFS= read -r -d '' f; do - surfaces+=("$f") - style_count=$((style_count + 1)) -done < <(find .claude/output-styles -maxdepth 1 -name '*.md' -print0 2>/dev/null) - -# Hook scripts are enumerated (counted) but NOT grep-scanned: a prompt-type hook's -# instruction text is embedded in code, where a "never/do not" grep is noise. The -# model reads the hook bodies by hand in the skill's Phase 2 instead. -hook_count="$(find .claude/hooks -maxdepth 1 -type f 2>/dev/null | wc -l | tr -d ' ')" - -# --- Candidate detection over the collected surfaces ----------------------- -prohibition_lines=0 -prohibition_files=0 -oversized_example_files=0 -candidate_out="" - -for f in "${surfaces[@]}"; do - # grep -c prints the count (0 on no match) and exits 1 on zero matches; the - # exit code is irrelevant here, so no `|| echo 0` (which would append a second - # line and break the arithmetic below). - hits="$(grep -icE "$PROHIBITION" "$f" 2>/dev/null)" - hits="${hits:-0}" - if ((hits > 0)); then - prohibition_lines=$((prohibition_lines + hits)) - prohibition_files=$((prohibition_files + 1)) - if [[ "$MODE" == "candidates" ]]; then - while IFS= read -r line; do - candidate_out+="$f:$line"$'\n' - done < <(grep -inE "$PROHIBITION" "$f" 2>/dev/null | cut -c1-200) - fi - fi - fences="$(grep -cE '^[[:space:]]*```' "$f" 2>/dev/null)" - tags="$(grep -cE '' "$f" 2>/dev/null)" - blocks=$(((${fences:-0} / 2) + ${tags:-0})) - if ((blocks > EXAMPLE_BLOCK_THRESHOLD)); then - oversized_example_files=$((oversized_example_files + 1)) - if [[ "$MODE" == "candidates" ]]; then - candidate_out+="$f:0: EXAMPLE-DENSE ($blocks blocks > $EXAMPLE_BLOCK_THRESHOLD)"$'\n' - fi - fi -done - -if [[ "$MODE" == "count" ]]; then - printf '%s\n' "$prohibition_lines" - exit 0 -fi - -if [[ "$MODE" == "candidates" ]]; then - if [[ -z "$candidate_out" ]]; then - printf 'No grep-able candidates found.\n' - else - printf '%s' "$candidate_out" | head -n 200 - fi - exit 0 -fi - -cat <$EXAMPLE_BLOCK_THRESHOLD fenced/ blocks): $oversized_example_files files - -Over-prescriptive step lists, stale model-era workarounds, and the -"would removing this cause mistakes?" bar are model judgment — not scanned here. -EOF diff --git a/plugins/claude-config/skills/audit-model-fit/scripts/instruction-surface-scan.test.sh b/plugins/claude-config/skills/audit-model-fit/scripts/instruction-surface-scan.test.sh deleted file mode 100755 index fb454ab340..0000000000 --- a/plugins/claude-config/skills/audit-model-fit/scripts/instruction-surface-scan.test.sh +++ /dev/null @@ -1,140 +0,0 @@ -#!/usr/bin/env bash -# Tests for instruction-surface-scan.sh (self-contained — ships with the plugin). -set -uo pipefail - -SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" -SCAN="$SCRIPT_DIR/instruction-surface-scan.sh" - -FAILED=0 -CASE_NUM=0 - -pass() { - CASE_NUM=$((CASE_NUM + 1)) - printf 'PASS: %s\n' "$1" -} -fail() { - CASE_NUM=$((CASE_NUM + 1)) - FAILED=$((FAILED + 1)) - printf 'FAIL: %s\n detail: %s\n' "$1" "$2" >&2 -} -assert_exit() { - if [[ "$2" == "$3" ]]; then pass "$1"; else fail "$1" "expected exit $2, got $3"; fi -} -assert_contains() { - case "$2" in - *"$3"*) pass "$1" ;; - *) fail "$1" "expected to contain: $3" ;; - esac -} -assert_equals() { - if [[ "$2" == "$3" ]]; then pass "$1"; else fail "$1" "expected '$2', got '$3'"; fi -} - -rc=0 -bash "$SCAN" --help >/dev/null 2>&1 || rc=$? -assert_exit "--help exits 0" 0 "$rc" - -# Build a throwaway fixture repo with seeded surfaces and smells. -FIX="$(mktemp -d)" -trap 'rm -rf "$FIX"' EXIT -( - cd "$FIX" || exit 1 - git init -q - mkdir -p .claude/skills/demo/context .claude/agents .claude/rules - cat >CLAUDE.md <<'MD' -Never force-push to main. -Do not skip the tests. -This line explains a rationale and is fine. -MD - printf 'name: demo\n' >.claude/skills/demo/SKILL.md - cat >.claude/skills/demo/context/examples.md <<'MD' -``` -a -``` -``` -b -``` -``` -c -``` -``` -d -``` -``` -e -``` -``` -f -``` -MD - # Exactly 5 blocks — at the recommended ceiling, must NOT be flagged (C3 boundary). - cat >.claude/skills/demo/context/at-threshold.md <<'MD' -``` -a -``` -``` -b -``` -``` -c -``` -``` -d -``` -``` -e -``` -MD - printf 'agent body\n' >.claude/agents/x.md - printf 'a rule\n' >.claude/rules/y.md -) - -# Isolate HOME and CLAUDE_CONFIG_DIR so the real user CLAUDE.md never leaks into -# the fixture scan (CLAUDE_CONFIG_DIR points at a fixture path with no CLAUDE.md). -rc=0 -out="$(cd "$FIX" && HOME="$FIX" CLAUDE_CONFIG_DIR="$FIX/.claude" bash "$SCAN" 2>/dev/null)" || rc=$? -assert_exit "default mode exits 0" 0 "$rc" -assert_contains "reports CLAUDE.md surface" "$out" "CLAUDE.md files: 1" -assert_contains "reports agent surface" "$out" "Agent definitions: 1" -assert_contains "reports rule surface" "$out" "Rule files (.claude/rules): 1" -assert_contains "flags bare prohibitions" "$out" "Bare-prohibition lines" -assert_contains "flags example-dense file" "$out" "Example-dense files (>5" -# Only the 6-block file counts — the 5-block file at the ceiling is NOT flagged (C3 boundary). -assert_contains "5-block file not flagged; only the 6-block one" "$out" "blocks): 1 files" - -cnt="$(cd "$FIX" && HOME="$FIX" CLAUDE_CONFIG_DIR="$FIX/.claude" bash "$SCAN" --count 2>/dev/null)" -assert_equals "count matches seeded prohibitions" "2" "$cnt" - -# CLAUDE_CONFIG_DIR relocates the user config tree — the scan must read the -# user-global CLAUDE.md from there, not a hardcoded $HOME/.claude. -CFG="$(mktemp -d)" -printf 'Never bypass the config-dir override.\n' >"$CFG/CLAUDE.md" -rc=0 -out="$(cd "$FIX" && HOME="$FIX" CLAUDE_CONFIG_DIR="$CFG" bash "$SCAN" 2>/dev/null)" || rc=$? -assert_exit "CLAUDE_CONFIG_DIR mode exits 0" 0 "$rc" -assert_contains "honors CLAUDE_CONFIG_DIR for user CLAUDE.md" "$out" "CLAUDE.md files: 2" -rm -rf "$CFG" - -cand="$(cd "$FIX" && HOME="$FIX" CLAUDE_CONFIG_DIR="$FIX/.claude" bash "$SCAN" --candidates 2>/dev/null)" -assert_contains "candidates list the CLAUDE.md prohibition line" "$cand" "CLAUDE.md:1" -assert_contains "candidates flag the example-dense file" "$cand" "examples.md:0: EXAMPLE-DENSE" -case "$cand" in -*at-threshold.md*EXAMPLE-DENSE*) fail "5-block at-threshold.md must not be flagged" "found in candidates" ;; -*) pass "5-block at-threshold.md absent from candidates" ;; -esac - -# Empty repo: still exits 0 with a clean inventory (no crash on no surfaces). -EMPTY="$(mktemp -d)" -(cd "$EMPTY" && git init -q) -rc=0 -out="$(cd "$EMPTY" && HOME="$EMPTY" CLAUDE_CONFIG_DIR="$EMPTY/.claude" bash "$SCAN" 2>/dev/null)" || rc=$? -assert_exit "empty repo exits 0" 0 "$rc" -assert_contains "empty repo zero prohibitions" "$out" "0 across 0 files" -rm -rf "$EMPTY" - -if [[ "$FAILED" -eq 0 ]]; then - printf '\nAll %d checks passed.\n' "$CASE_NUM" - exit 0 -fi -printf '\n%d/%d checks failed.\n' "$FAILED" "$CASE_NUM" >&2 -exit 1 diff --git a/plugins/claude-config/skills/audit-permission-grants/SKILL.md b/plugins/claude-config/skills/audit-permission-grants/SKILL.md index 9a477cd314..563b2ee0ea 100644 --- a/plugins/claude-config/skills/audit-permission-grants/SKILL.md +++ b/plugins/claude-config/skills/audit-permission-grants/SKILL.md @@ -24,7 +24,7 @@ The mechanical check definitions (P1/P2/P3, severities, detector invocation) are This skill owns grant portability + auto-mode durability + who adds the operative rule. It does **not** own config-file correctness — baseline deny/ask presence, deprecated `:*` syntax, overly broad patterns, or live plugin drift belong to the sibling `audit` skill. When a request is about -those, route it there rather than answering here. The `health` skill in the `claude-memory` plugin +those, route it there rather than answering here. The `audit` skill in the `claude-memory` plugin owns the instruction layer (CLAUDE.md / rules / auto-memory). ## Arguments diff --git a/plugins/claude-config/skills/audit/SKILL.md b/plugins/claude-config/skills/audit/SKILL.md index 0d3f0fdd16..a5a5be2fc1 100644 --- a/plugins/claude-config/skills/audit/SKILL.md +++ b/plugins/claude-config/skills/audit/SKILL.md @@ -4,6 +4,7 @@ description: "Audit Claude Code configuration files — settings.json, settings. argument-hint: "[--fix] [scope] — scope: permissions|mcp|hooks|plugins|issues|all (default: all)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context @@ -26,7 +27,7 @@ disabled servers, launcher-script wrappers) come from the consuming repo's own ` `.claude/rules/` — read them when present; this skill does not assume them. Two adjacent skills cover neighboring questions: the sibling `audit-automation-gaps` skill asks whether the -configured automation SET is the right set (landscape gaps); the `health` skill in the `claude-memory` +configured automation SET is the right set (landscape gaps); the `audit` skill in the `claude-memory` plugin audits the instruction layer (CLAUDE.md / rules / auto-memory). This skill asks whether the configuration FILES are correct against upstream truth. diff --git a/plugins/claude-config/skills/setup/SKILL.md b/plugins/claude-config/skills/setup/SKILL.md index 626ee3e9a4..e8236b5f19 100644 --- a/plugins/claude-config/skills/setup/SKILL.md +++ b/plugins/claude-config/skills/setup/SKILL.md @@ -1,6 +1,6 @@ --- name: setup -description: "Verify claude-config's external CLI prerequisites for this repository — jq (all audit scripts) and curl (the plugin-drift check) — so the audit skills run instead of failing. Use when: 'set up claude-config', 'configure claude-config', 'is claude-config working', or an audit skill reported a missing prerequisite. Actions: check (read-only verification, default) | apply (resolve what check found). Re-runnable and safe." +description: "Verify claude-config's external CLI prerequisites for this repository — jq (the JSON-parsing audit scripts) and curl (the plugin-drift check) — so the audit skills run instead of failing. Use when: 'set up claude-config', 'configure claude-config', 'is claude-config working', or an audit skill reported a missing prerequisite. Actions: check (read-only verification, default) | apply (resolve what check found). Re-runnable and safe." argument-hint: "check | apply" user-invocable: true disable-model-invocation: true @@ -26,12 +26,14 @@ table with one remediation line per FAIL. Do not modify anything. The runtime sc - `${CLAUDE_PLUGIN_ROOT}/skills/audit/scripts/check-structure.sh` and `fix-plugin-drift.sh` — jq - `${CLAUDE_PLUGIN_ROOT}/skills/audit-automation-gaps/scripts/inventory.sh` — jq - `${CLAUDE_PLUGIN_ROOT}/skills/audit-permission-grants/scripts/permission-rule-check.sh` — jq +- `${CLAUDE_PLUGIN_ROOT}/skills/audit-instructions/scripts/instruction-scan.sh` — grep only (POSIX; no jq) -1. **`jq`** — `command -v jq`. FAIL if absent: every audit script needs it (`inventory.sh` degrades to - an empty inventory; the others `exit 2` with an install remediation). Missing `jq` blocks all three - skills. +1. **`jq`** — `command -v jq`. FAIL if absent: the JSON-parsing scripts need it (`inventory.sh` degrades + to an empty inventory; the others `exit 2` with an install remediation). Missing `jq` blocks the three + JSON-parsing audit skills (`audit`, `audit-automation-gaps`, `audit-permission-grants`); + `audit-instructions` scans markdown with grep only and is unaffected. 2. **`curl`** — `command -v curl`. FAIL if absent, but scoped: only the plugin-drift check - (`check-plugin-drift.sh`) uses it and `exit 2`s without it. The rest of `audit` and the other two + (`check-plugin-drift.sh`) uses it and `exit 2`s without it. The rest of `audit` and the other three skills still run — say so in the remediation line. 3. **Bash shell** — INFO: the scripts are bash (arrays, `[[ ]]`, process substitution, `BASH_SOURCE`), run through Claude Code's Bash tool — the bash shell on every platform, Git Bash on native Windows. @@ -56,8 +58,8 @@ reports "already configured". ## What this skill does NOT do -- Run an audit — that is `/claude-config:audit`, `/claude-config:audit-automation-gaps`, and - `/claude-config:audit-permission-grants`. +- Run an audit — that is `/claude-config:audit`, `/claude-config:audit-automation-gaps`, + `/claude-config:audit-permission-grants`, and `/claude-config:audit-instructions`. - Install system packages, write Claude Code settings or `pluginConfigs`, or touch the plugin cache. - Download anything — `check` makes no network call; the audit skills' own doc/marketplace fetches are theirs, not setup's. diff --git a/plugins/claude-memory/.claude-plugin/plugin.json b/plugins/claude-memory/.claude-plugin/plugin.json index ce8bb5cc21..62fbf29630 100644 --- a/plugins/claude-memory/.claude-plugin/plugin.json +++ b/plugins/claude-memory/.claude-plugin/plugin.json @@ -1,12 +1,24 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "claude-memory", - "version": "0.3.0", + "version": "0.3.1", "description": "Keeps a repo's Claude Code memory layer healthy and under your control, against criteria derived from official Claude Code documentation. The audit skill checks the instruction/memory layer (CLAUDE.md, CLAUDE.local.md, .claude/rules/, auto-memory) with a deterministic script-backed spine plus judgment-tier checks. The stateless skill inspects, disables, and (confirm-gated) purges Claude-written auto memory across all settings scopes.", "author": { "name": "Melodic Software", "email": "info@melodicsoftware.com" }, "license": "MIT", - "keywords": ["memory", "claude-md", "rules", "auto-memory", "instructions", "audit", "stateless", "disable", "purge", "maintenance", "skill"] + "keywords": [ + "memory", + "claude-md", + "rules", + "auto-memory", + "instructions", + "audit", + "stateless", + "disable", + "purge", + "maintenance", + "skill" + ] } diff --git a/plugins/claude-memory/CHANGELOG.md b/plugins/claude-memory/CHANGELOG.md index b57b8acd38..6cfd589865 100644 --- a/plugins/claude-memory/CHANGELOG.md +++ b/plugins/claude-memory/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to the `claude-memory` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.3.1] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.3.0] ### Added diff --git a/plugins/claude-memory/skills/audit/SKILL.md b/plugins/claude-memory/skills/audit/SKILL.md index 102cc7bbfb..2f63cd4849 100644 --- a/plugins/claude-memory/skills/audit/SKILL.md +++ b/plugins/claude-memory/skills/audit/SKILL.md @@ -4,6 +4,7 @@ description: "Audit the Claude Code instruction/memory layer — CLAUDE.md, CLAU argument-hint: "[audit|fix|update|report] — default: audit" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/claude-memory/skills/stateless/SKILL.md b/plugins/claude-memory/skills/stateless/SKILL.md index d704cf3c58..2a05dd0fd3 100644 --- a/plugins/claude-memory/skills/stateless/SKILL.md +++ b/plugins/claude-memory/skills/stateless/SKILL.md @@ -4,6 +4,7 @@ description: "Inspect and turn off Claude Code's auto memory — the notes Claud argument-hint: "[status|disable|purge] — default: status" user-invocable: true disable-model-invocation: false +shell: bash --- ## Auto-memory snapshot diff --git a/plugins/claude-ops/.claude-plugin/plugin.json b/plugins/claude-ops/.claude-plugin/plugin.json index 89f037cd6d..a5587f7e32 100644 --- a/plugins/claude-ops/.claude-plugin/plugin.json +++ b/plugins/claude-ops/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "claude-ops", - "version": "0.17.1", + "version": "0.17.2", "description": "Claude Code operations toolkit. Seven skills: observability (read locally captured telemetry — OTEL store, collector, hook-event JSONL, ccusage — with trend reports and store pruning), known-issues (search known Claude product GitHub bugs, check service health, maintain a persistent tracked-issue registry), changelog (ingest Claude Code changelog entries and integrate them into the current repo), plugins (bring a machine's plugin fleet current on demand — marketplace refresh, effective-scope updates including in-repo project/local installs, new-plugin install per policy, scope-divergence detection and explicit convergence), morning-brief (read-only gh-based operator morning view — queue-label counts, merge-ready PRs, parked decisions with their RECOMMENDED lines, and loop-lane telemetry freshness), lanes (start/restart/stop/status loop lanes as named background Claude Code sessions seeded from canonical prompt files, with per-lane model/effort and a repo-pull + marketplace-refresh launch step), and a re-runnable setup action that settles where the known-issues registry lives. Plus a family of seven advisory *-audit telemetry-emitter hooks (API errors, config changes, instruction loads, permission denials, pre-compaction, skill usage, tool failures) that emit the shared hook-telemetry envelope, and a reference sink that maps envelopes into the hook-events.jsonl the observability skill reads.", "author": { "name": "Melodic Software", diff --git a/plugins/claude-ops/CHANGELOG.md b/plugins/claude-ops/CHANGELOG.md index e10f1b4519..f348c94757 100644 --- a/plugins/claude-ops/CHANGELOG.md +++ b/plugins/claude-ops/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to the `claude-ops` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.17.2] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.17.1] ### Fixed diff --git a/plugins/claude-ops/skills/changelog/SKILL.md b/plugins/claude-ops/skills/changelog/SKILL.md index bb50b194c8..998dc84821 100644 --- a/plugins/claude-ops/skills/changelog/SKILL.md +++ b/plugins/claude-ops/skills/changelog/SKILL.md @@ -4,6 +4,7 @@ description: "Ingest Claude Code changelog entries and integrate them into the c argument-hint: " [version|text] — actions: fetch (default on passive mention), diff, status, apply (explicit only)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Variables diff --git a/plugins/claude-ops/skills/known-issues/SKILL.md b/plugins/claude-ops/skills/known-issues/SKILL.md index ba92d3cd83..a969125cb2 100644 --- a/plugins/claude-ops/skills/known-issues/SKILL.md +++ b/plugins/claude-ops/skills/known-issues/SKILL.md @@ -4,6 +4,7 @@ description: "Looks up and tracks known Claude product issues — searches known argument-hint: " [args] — actions: status (default), search, check-all, scan, list, quality, create. e.g., 'search Stop hook', 'check-all', 'create bug \"title\"'" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/claude-ops/skills/lanes/SKILL.md b/plugins/claude-ops/skills/lanes/SKILL.md index fac8e66ee5..51be986bde 100644 --- a/plugins/claude-ops/skills/lanes/SKILL.md +++ b/plugins/claude-ops/skills/lanes/SKILL.md @@ -4,6 +4,7 @@ description: "Start, restart, stop, and check loop lanes as named background Cla argument-hint: "[start|restart|status|stop] [lane...] — start (default); restart/stop accept lane names; --config, --repo, --dry-run, --no-pull, --no-update" user-invocable: true disable-model-invocation: true +shell: bash --- ## Pre-computed context diff --git a/plugins/claude-ops/skills/morning-brief/SKILL.md b/plugins/claude-ops/skills/morning-brief/SKILL.md index d3f9b4215f..12e72f1218 100644 --- a/plugins/claude-ops/skills/morning-brief/SKILL.md +++ b/plugins/claude-ops/skills/morning-brief/SKILL.md @@ -4,6 +4,7 @@ description: "Prints the operator's read-only morning view for the current GitHu argument-hint: "[--repo owner/name] [--telemetry-issue N] [--stale-hours N] — read-only; omit to view the current repo" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/claude-ops/skills/observability/SKILL.md b/plugins/claude-ops/skills/observability/SKILL.md index b4092f58e6..7c0017c115 100644 --- a/plugins/claude-ops/skills/observability/SKILL.md +++ b/plugins/claude-ops/skills/observability/SKILL.md @@ -4,6 +4,7 @@ description: "Read and report on locally captured Claude Code telemetry — OTEL user-invocable: true disable-model-invocation: false argument-hint: "[scope|action] — week (default), session, day, month, since:YYYY-MM-DD, all, clean [--keep-days N] [--dry-run]" +shell: bash --- ## Pre-computed context diff --git a/plugins/code-tidying/.claude-plugin/plugin.json b/plugins/code-tidying/.claude-plugin/plugin.json index def1b7b9e2..12638375b0 100644 --- a/plugins/code-tidying/.claude-plugin/plugin.json +++ b/plugins/code-tidying/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "code-tidying", - "version": "0.7.0", + "version": "0.7.1", "description": "Code tidying and comment hygiene: /code-tidying:tidy proactively hunts a rotated, glob-scoped lane for Beck-style tidyings under a research-backed scope budget and ships one tight PR; /code-tidying:batch-simplify sweeps recently changed files through grouped, dependency-ordered simplification waves with a never-drop deferred-items contract; /code-tidying:audit-comment-residue is a read-only classifier that flags history, plan, conversational, and ticket/PR residue in code comments for author-applied deletion. Project-specific tidy lanes are scaffolded into a tracked .claude/tidy-lanes/ config folder by a re-runnable setup skill.", "author": { "name": "Melodic Software", diff --git a/plugins/code-tidying/CHANGELOG.md b/plugins/code-tidying/CHANGELOG.md index ca4cab5b98..815075cb57 100644 --- a/plugins/code-tidying/CHANGELOG.md +++ b/plugins/code-tidying/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to the `code-tidying` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.7.1] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.7.0] ### Changed diff --git a/plugins/code-tidying/skills/audit-comment-residue/SKILL.md b/plugins/code-tidying/skills/audit-comment-residue/SKILL.md index 7c51789708..49c6c8d03c 100644 --- a/plugins/code-tidying/skills/audit-comment-residue/SKILL.md +++ b/plugins/code-tidying/skills/audit-comment-residue/SKILL.md @@ -5,6 +5,7 @@ argument-hint: "[audit] [target]" user-invocable: true disable-model-invocation: false allowed-tools: Bash(bash *audit-comment-residue/scripts/detect.sh*) +shell: bash --- ## Pre-computed context diff --git a/plugins/code-tidying/skills/batch-simplify/SKILL.md b/plugins/code-tidying/skills/batch-simplify/SKILL.md index 5fa775e4e1..dd3f1359b3 100644 --- a/plugins/code-tidying/skills/batch-simplify/SKILL.md +++ b/plugins/code-tidying/skills/batch-simplify/SKILL.md @@ -3,6 +3,7 @@ name: batch-simplify description: "Batch-run simplification across all recently changed files, grouped by ecosystem and dependency order. Use when: 'batch simplify', 'simplify recent changes', 'simplify everything', 'forgot to run simplify', 'catch up on simplify', 'simplify my branch changes', or after a multi-session sprint. Accepts a time window (`24h`, `7d`) or `branch` to diff the current branch vs the default branch; optional `docs` flag includes .md files for post-migration or post-refactor doc sweeps. Skip for single-file cleanup — use /simplify instead." user-invocable: true argument-hint: "[time-window | branch] [docs] (e.g., /batch-simplify 72h, /batch-simplify branch docs — default: 48h)" +shell: bash --- ## Pre-computed context diff --git a/plugins/code-tidying/skills/tidy/SKILL.md b/plugins/code-tidying/skills/tidy/SKILL.md index aee8f6e00d..a4d30a8f47 100644 --- a/plugins/code-tidying/skills/tidy/SKILL.md +++ b/plugins/code-tidying/skills/tidy/SKILL.md @@ -5,6 +5,7 @@ argument-hint: "[ | dry-run [] | self-update | help]" disable-model-invocation: false user-invocable: true allowed-tools: Bash(bash ${CLAUDE_PLUGIN_ROOT}/skills/tidy/scripts/open-pr-count.sh:*) +shell: bash --- ## Pre-computed context diff --git a/plugins/codebase-health/.claude-plugin/plugin.json b/plugins/codebase-health/.claude-plugin/plugin.json index 3c591e3cf9..8881290bcf 100644 --- a/plugins/codebase-health/.claude-plugin/plugin.json +++ b/plugins/codebase-health/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "codebase-health", - "version": "0.7.0", + "version": "0.7.1", "description": "Repo-wide drift audit between docs, config, code, and architecture: verifies every factual claim against reality via parallel subagent fan-out, severity-rates findings, and reports read-only, delegating remediation to the implementation/verification lanes. Audit dimensions are configurable through a tracked .claude/codebase-health.md config file written by the setup skill.", "author": { "name": "Melodic Software", diff --git a/plugins/codebase-health/CHANGELOG.md b/plugins/codebase-health/CHANGELOG.md index 86307ab90f..0e9a0c5f0b 100644 --- a/plugins/codebase-health/CHANGELOG.md +++ b/plugins/codebase-health/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to the `codebase-health` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.7.1] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.7.0] ### Changed diff --git a/plugins/codebase-health/skills/audit/SKILL.md b/plugins/codebase-health/skills/audit/SKILL.md index 04f5edfa97..0619fb085a 100644 --- a/plugins/codebase-health/skills/audit/SKILL.md +++ b/plugins/codebase-health/skills/audit/SKILL.md @@ -4,6 +4,7 @@ description: "Audit a codebase for drift between docs, config, code, and archite argument-hint: "[scope] [--fix] [--docs-only|--code-only|--config-only|--arch-only]" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/context7/.claude-plugin/plugin.json b/plugins/context7/.claude-plugin/plugin.json index 5ef84a7388..09d5d7bfd8 100644 --- a/plugins/context7/.claude-plugin/plugin.json +++ b/plugins/context7/.claude-plugin/plugin.json @@ -1,12 +1,18 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "context7", - "version": "0.4.1", + "version": "0.4.2", "description": "Looks up current library documentation, API references, and code examples via Context7 (ctx7 CLI or the Context7 MCP server) with a two-step resolve-then-query workflow: a lookup skill (default lookup plus an upstream drift-check action) and a setup skill for CLI install, auth, and MCP configuration.", "author": { "name": "Melodic Software", "email": "info@melodicsoftware.com" }, "license": "MIT", - "keywords": ["context7", "documentation", "library-docs", "api-reference", "tooling"] + "keywords": [ + "context7", + "documentation", + "library-docs", + "api-reference", + "tooling" + ] } diff --git a/plugins/context7/CHANGELOG.md b/plugins/context7/CHANGELOG.md index 60d99d0ba6..7bedb81cbf 100644 --- a/plugins/context7/CHANGELOG.md +++ b/plugins/context7/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to the `context7` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.4.2] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.4.1] ### Changed diff --git a/plugins/context7/skills/lookup/SKILL.md b/plugins/context7/skills/lookup/SKILL.md index 28feb5ad2c..14367398ba 100644 --- a/plugins/context7/skills/lookup/SKILL.md +++ b/plugins/context7/skills/lookup/SKILL.md @@ -9,6 +9,7 @@ allowed-tools: metadata: upstream-version: upstash/context7@master synced: 2026-05-22 +shell: bash --- ## Pre-computed context diff --git a/plugins/context7/skills/setup/SKILL.md b/plugins/context7/skills/setup/SKILL.md index c9d46be641..121c48571b 100644 --- a/plugins/context7/skills/setup/SKILL.md +++ b/plugins/context7/skills/setup/SKILL.md @@ -7,6 +7,7 @@ disable-model-invocation: true allowed-tools: - "Bash(ctx7 --version*)" - "Bash(npm view ctx7 version*)" +shell: bash --- ## Pre-computed context diff --git a/plugins/debugging/.claude-plugin/plugin.json b/plugins/debugging/.claude-plugin/plugin.json index d315188cd8..e26e0ae91e 100644 --- a/plugins/debugging/.claude-plugin/plugin.json +++ b/plugins/debugging/.claude-plugin/plugin.json @@ -1,12 +1,20 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "debugging", - "version": "0.4.1", + "version": "0.4.2", "description": "Debug observed failures via a disciplined six-phase loop: build a fast deterministic reproduction signal, reproduce, rank falsifiable hypotheses, instrument, fix with a regression test, then clean up and post-mortem.", "author": { "name": "Melodic Software", "email": "info@melodicsoftware.com" }, "license": "MIT", - "keywords": ["debug", "diagnose", "debugging", "troubleshooting", "root-cause", "regression", "skill"] + "keywords": [ + "debug", + "diagnose", + "debugging", + "troubleshooting", + "root-cause", + "regression", + "skill" + ] } diff --git a/plugins/debugging/CHANGELOG.md b/plugins/debugging/CHANGELOG.md index 1118767863..8716c6c38c 100644 --- a/plugins/debugging/CHANGELOG.md +++ b/plugins/debugging/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to the `debugging` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.4.2] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.4.1] ### Changed diff --git a/plugins/debugging/skills/debug/SKILL.md b/plugins/debugging/skills/debug/SKILL.md index 35ea3f8203..82b69da4dc 100644 --- a/plugins/debugging/skills/debug/SKILL.md +++ b/plugins/debugging/skills/debug/SKILL.md @@ -4,6 +4,7 @@ description: "Debug and diagnose broken behavior via a disciplined six-phase loo argument-hint: "[bug description or observation] (e.g., /debugging:debug checkout times out for orders over $1k)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/discovery/.claude-plugin/plugin.json b/plugins/discovery/.claude-plugin/plugin.json index 5bbeda1e96..08434c83b7 100644 --- a/plugins/discovery/.claude-plugin/plugin.json +++ b/plugins/discovery/.claude-plugin/plugin.json @@ -1,12 +1,20 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "discovery", - "version": "0.8.1", + "version": "0.8.2", "description": "Structured discovery before changes: explore the local codebase (inline or in an isolated forked subagent) and run disciplined multi-source external research with source tiers, falsification, and recency gates — persisting EXPLORE.md / RESEARCH.md handoff artifacts.", "author": { "name": "Melodic Software", "email": "info@melodicsoftware.com" }, "license": "MIT", - "keywords": ["discovery", "explore", "research", "codebase", "investigation", "sources", "skill"] + "keywords": [ + "discovery", + "explore", + "research", + "codebase", + "investigation", + "sources", + "skill" + ] } diff --git a/plugins/discovery/CHANGELOG.md b/plugins/discovery/CHANGELOG.md index d96cf91108..782e10c7a9 100644 --- a/plugins/discovery/CHANGELOG.md +++ b/plugins/discovery/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog — discovery plugin +## [0.8.2] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.8.1] — 2026-07-20 ### Changed diff --git a/plugins/discovery/skills/blindspot/SKILL.md b/plugins/discovery/skills/blindspot/SKILL.md index 5c5232f7eb..893b3d6490 100644 --- a/plugins/discovery/skills/blindspot/SKILL.md +++ b/plugins/discovery/skills/blindspot/SKILL.md @@ -4,6 +4,7 @@ description: "Surface the USER's unknown-unknowns before they work in unfamiliar argument-hint: "[area-or-domain] (e.g., /discovery:blindspot geofencing, /discovery:blindspot payments module, /discovery:blindspot )" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/discovery/skills/explore-deep/SKILL.md b/plugins/discovery/skills/explore-deep/SKILL.md index 4ae10d8d31..3c8c492ebf 100644 --- a/plugins/discovery/skills/explore-deep/SKILL.md +++ b/plugins/discovery/skills/explore-deep/SKILL.md @@ -6,6 +6,7 @@ user-invocable: true disable-model-invocation: false context: fork agent: general-purpose +shell: bash --- ## Pre-computed context diff --git a/plugins/discovery/skills/explore/SKILL.md b/plugins/discovery/skills/explore/SKILL.md index fd8dd9882e..38b592d6c5 100644 --- a/plugins/discovery/skills/explore/SKILL.md +++ b/plugins/discovery/skills/explore/SKILL.md @@ -4,6 +4,7 @@ description: "Explore the local codebase before making changes — read code, tr argument-hint: "[scope] (e.g., /discovery:explore payments module dependencies, /discovery:explore tests, /discovery:explore git, /discovery:explore config)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/discovery/skills/research-deep/SKILL.md b/plugins/discovery/skills/research-deep/SKILL.md index cfb870e869..7dcb1aaefd 100644 --- a/plugins/discovery/skills/research-deep/SKILL.md +++ b/plugins/discovery/skills/research-deep/SKILL.md @@ -4,6 +4,7 @@ description: "Dispatch deep external research to the heaviest isolated execution argument-hint: "[topic] (e.g., /discovery:research-deep best practices, /discovery:research-deep migration guide)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/discovery/skills/research/SKILL.md b/plugins/discovery/skills/research/SKILL.md index 0d731831f1..cda28608fe 100644 --- a/plugins/discovery/skills/research/SKILL.md +++ b/plugins/discovery/skills/research/SKILL.md @@ -4,6 +4,7 @@ description: "Multi-source external research in three chained phases — broad, argument-hint: "[topic] (e.g., /discovery:research best practices, /discovery:research hook event schema, /discovery:research query optimization)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/docs-hygiene/.claude-plugin/plugin.json b/plugins/docs-hygiene/.claude-plugin/plugin.json index 1d49d884ad..2fd7ec7bf0 100644 --- a/plugins/docs-hygiene/.claude-plugin/plugin.json +++ b/plugins/docs-hygiene/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "docs-hygiene", - "version": "0.8.2", + "version": "0.8.3", "description": "Documentation-hygiene toolkit of six skills: compress (flavor-trim markdown with a semantic-diff safety net), audit-noise (classify markdown noise), extract-ssot (deduplicate repeated content into a single source of truth), audit-encapsulation (detect citations into skill-private surfaces), rename-references (sweep stale references after renames), and audit-derivability (classify whether a whole document earns its existence — could a fresh agent re-derive it from the code?).", "author": { "name": "Melodic Software", diff --git a/plugins/docs-hygiene/CHANGELOG.md b/plugins/docs-hygiene/CHANGELOG.md index e152f44563..780480c347 100644 --- a/plugins/docs-hygiene/CHANGELOG.md +++ b/plugins/docs-hygiene/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog — docs-hygiene plugin +## [0.8.3] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.8.2] — 2026-07-21 ### Fixed diff --git a/plugins/docs-hygiene/skills/audit-derivability/SKILL.md b/plugins/docs-hygiene/skills/audit-derivability/SKILL.md index 890486d18a..5a8fa69e01 100644 --- a/plugins/docs-hygiene/skills/audit-derivability/SKILL.md +++ b/plugins/docs-hygiene/skills/audit-derivability/SKILL.md @@ -4,6 +4,7 @@ description: "Audit whether a documentation file earns its existence — could a argument-hint: "[audit] [target] | sweep " user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/docs-hygiene/skills/audit-noise/SKILL.md b/plugins/docs-hygiene/skills/audit-noise/SKILL.md index 14d57ef2cd..287aa40504 100644 --- a/plugins/docs-hygiene/skills/audit-noise/SKILL.md +++ b/plugins/docs-hygiene/skills/audit-noise/SKILL.md @@ -5,6 +5,7 @@ argument-hint: "[audit] [target]" user-invocable: true disable-model-invocation: false allowed-tools: Bash(bash *audit-noise/scripts/detect.sh*) +shell: bash --- ## Pre-computed context diff --git a/plugins/docs-hygiene/skills/compress/SKILL.md b/plugins/docs-hygiene/skills/compress/SKILL.md index d39a0729e1..58fcc79943 100644 --- a/plugins/docs-hygiene/skills/compress/SKILL.md +++ b/plugins/docs-hygiene/skills/compress/SKILL.md @@ -4,6 +4,7 @@ description: "Compress (tighten, shorten, trim) markdown files by dropping flavo argument-hint: "[audit] [target] [--force] [--keep-snapshot]" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/docs-hygiene/skills/rename-references/SKILL.md b/plugins/docs-hygiene/skills/rename-references/SKILL.md index b9ae8d4800..aa05d1c1b8 100644 --- a/plugins/docs-hygiene/skills/rename-references/SKILL.md +++ b/plugins/docs-hygiene/skills/rename-references/SKILL.md @@ -4,6 +4,7 @@ description: "Sweep stale references after renames — the syntactic forms token argument-hint: "[action] [ [to ]] [--include-historical|--include-memory|--include-plan-docs] (e.g., /rename-references audit, /rename-references audit blast /verify to /verify-changes, /rename-references audit half-rename /a to /b, /rename-references audit orphans /a to /b, /rename-references blocklist)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/education/.claude-plugin/plugin.json b/plugins/education/.claude-plugin/plugin.json index 3bd3a30dee..c83ddb8cb6 100644 --- a/plugins/education/.claude-plugin/plugin.json +++ b/plugins/education/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "education", - "version": "0.5.0", + "version": "0.5.1", "description": "Interactive multi-session learning coach: teaches a general subject or a concept grounded in the consuming repo through the Knowledge-Skills-Wisdom progression, with persistent per-topic learning state. Also a single-session domain primer, a one-shot plain-language explainer that drops anything to genuinely plain words, and a post-work comprehension check that quizzes the human on a completed change.", "author": { "name": "Melodic Software", diff --git a/plugins/education/CHANGELOG.md b/plugins/education/CHANGELOG.md index 7c3102dc63..1c57d44458 100644 --- a/plugins/education/CHANGELOG.md +++ b/plugins/education/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to the `education` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.5.1] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.5.0] ### Added diff --git a/plugins/education/skills/teach/SKILL.md b/plugins/education/skills/teach/SKILL.md index 24d91108af..c9203db422 100644 --- a/plugins/education/skills/teach/SKILL.md +++ b/plugins/education/skills/teach/SKILL.md @@ -4,6 +4,7 @@ description: "Interactive multi-session learning coach for general topics or rep argument-hint: " [args] (e.g., /education:teach topic rust-ownership, /education:teach codebase auth-flow, /education:teach primer color-grading)" user-invocable: true disable-model-invocation: true +shell: bash --- ## Purpose diff --git a/plugins/firecrawl/.claude-plugin/plugin.json b/plugins/firecrawl/.claude-plugin/plugin.json index 0586866e14..08b296ec36 100644 --- a/plugins/firecrawl/.claude-plugin/plugin.json +++ b/plugins/firecrawl/.claude-plugin/plugin.json @@ -1,12 +1,19 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "firecrawl", - "version": "0.4.0", + "version": "0.4.1", "description": "Web scraping, search, crawling, and file parsing through the firecrawl-cli binary with a write-to-disk-then-Read pattern that keeps large results out of context — a user-facing wrapper skill, a lazy-install setup skill, and a separate gated maintainer update skill tracking the upstream CLI and skill source.", "author": { "name": "Melodic Software", "email": "info@melodicsoftware.com" }, "license": "MIT", - "keywords": ["firecrawl", "scraping", "web-search", "crawling", "parsing", "cli"] + "keywords": [ + "firecrawl", + "scraping", + "web-search", + "crawling", + "parsing", + "cli" + ] } diff --git a/plugins/firecrawl/CHANGELOG.md b/plugins/firecrawl/CHANGELOG.md index 8b43d8554b..0b46427aa5 100644 --- a/plugins/firecrawl/CHANGELOG.md +++ b/plugins/firecrawl/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to the `firecrawl` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.4.1] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.4.0] ### Changed diff --git a/plugins/firecrawl/skills/firecrawl/SKILL.md b/plugins/firecrawl/skills/firecrawl/SKILL.md index 52239556a7..3b79bb6b07 100644 --- a/plugins/firecrawl/skills/firecrawl/SKILL.md +++ b/plugins/firecrawl/skills/firecrawl/SKILL.md @@ -5,6 +5,7 @@ argument-hint: " [args] — commands: scrape, search, crawl, map, parse user-invocable: true disable-model-invocation: false allowed-tools: Bash(command -v firecrawl*) Bash(firecrawl --status*) +shell: bash --- ## Pre-computed context diff --git a/plugins/firecrawl/skills/update/SKILL.md b/plugins/firecrawl/skills/update/SKILL.md index a093ff24c0..9665466f01 100644 --- a/plugins/firecrawl/skills/update/SKILL.md +++ b/plugins/firecrawl/skills/update/SKILL.md @@ -5,6 +5,7 @@ argument-hint: "[--check] (bare = full gated update pipeline)" user-invocable: true disable-model-invocation: true allowed-tools: Bash(grep -m1 *UPSTREAM.md*) +shell: bash --- ## Pre-computed context diff --git a/plugins/implementation/.claude-plugin/plugin.json b/plugins/implementation/.claude-plugin/plugin.json index 99cfda9e25..b18f3e16f6 100644 --- a/plugins/implementation/.claude-plugin/plugin.json +++ b/plugins/implementation/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "implementation", - "version": "0.7.5", + "version": "0.7.6", "description": "Disciplined implementation stage: execute approved plans inline (`/implementation:implement`) or via orchestrated worker subagents (`/implementation:implement-dispatch`) with incremental validation, TDD-by-default cadence, green-checkpoint commits, scope-fence drift detection, and divergence detection that routes back to planning. Build/test/lint, testing, and outcome verification live in the companion `toolchain`, `testing`, and `verification` plugins, invoked when installed.", "author": { "name": "Melodic Software", diff --git a/plugins/implementation/CHANGELOG.md b/plugins/implementation/CHANGELOG.md index 8b8dee5071..f787ad91b1 100644 --- a/plugins/implementation/CHANGELOG.md +++ b/plugins/implementation/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to the `implementation` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.7.6] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.7.5] ### Changed diff --git a/plugins/implementation/skills/implement/SKILL.md b/plugins/implementation/skills/implement/SKILL.md index e853ee33e5..25ef4f4cbc 100644 --- a/plugins/implementation/skills/implement/SKILL.md +++ b/plugins/implementation/skills/implement/SKILL.md @@ -4,6 +4,7 @@ description: "Execute approved plans, fix bugs, and make code changes inline wit argument-hint: "[task or mode] (e.g., /implementation:implement, /implementation:implement feature, /implementation:implement fix login-bug, /implementation:implement refactor)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/knowledge/.claude-plugin/plugin.json b/plugins/knowledge/.claude-plugin/plugin.json index fc97b8a176..0eabbad1f6 100644 --- a/plugins/knowledge/.claude-plugin/plugin.json +++ b/plugins/knowledge/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "knowledge", - "version": "0.8.3", + "version": "0.8.4", "description": "Ingest external knowledge into durable, synthesized artifacts. Ships a book-distillation pipeline (PDF/EPUB into concept-organized, author-attributed skill reference files), a YouTube pipeline (watch, transcript, link harvest, and repo-applicability synthesis), and a course-digest pipeline (extract and synthesize online video courses — Dometrain, Teachable — into repo-applicable recommendations), plus a re-runnable setup action; a configurable library directory governs where synthesized artifacts land in the consuming repo.", "author": { "name": "Melodic Software", diff --git a/plugins/knowledge/CHANGELOG.md b/plugins/knowledge/CHANGELOG.md index 6dd9a7c0b1..291e175c1b 100644 --- a/plugins/knowledge/CHANGELOG.md +++ b/plugins/knowledge/CHANGELOG.md @@ -4,6 +4,14 @@ All notable changes to the `knowledge` plugin are recorded here. The `version` i `.claude-plugin/plugin.json` is the delivery vehicle — a consumer receives a change only after that version increases. +## [0.8.4] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.8.3] ### Fixed diff --git a/plugins/knowledge/skills/course-digest/SKILL.md b/plugins/knowledge/skills/course-digest/SKILL.md index d8f4bc215f..79ad5036a8 100644 --- a/plugins/knowledge/skills/course-digest/SKILL.md +++ b/plugins/knowledge/skills/course-digest/SKILL.md @@ -4,6 +4,7 @@ description: "Extract and synthesize online video courses into repo-applicable r argument-hint: "[action] [url|slug] (e.g., /knowledge:course-digest , /knowledge:course-digest extract , /knowledge:course-digest resume , /knowledge:course-digest status)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/knowledge/skills/youtube-digest/SKILL.md b/plugins/knowledge/skills/youtube-digest/SKILL.md index 2a501bcedb..bad061e862 100644 --- a/plugins/knowledge/skills/youtube-digest/SKILL.md +++ b/plugins/knowledge/skills/youtube-digest/SKILL.md @@ -4,6 +4,7 @@ description: "Watch YouTube videos, extract transcripts, harvest links, research argument-hint: "watch | watch | watch | queue | queue list | transcript | resume " user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/naming/.claude-plugin/plugin.json b/plugins/naming/.claude-plugin/plugin.json index 23e931be40..a828502ba2 100644 --- a/plugins/naming/.claude-plugin/plugin.json +++ b/plugins/naming/.claude-plugin/plugin.json @@ -1,12 +1,20 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "naming", - "version": "0.2.0", + "version": "0.3.0", "description": "Generates and evaluates fresh name candidates for anything — an identifier, file, module, skill, repo, or domain term — by distilling a structured context brief, fanning out blind, fresh-context generators from distinct lenses (responsibility-literal, moment-of-use, domain-lore), then scoring a shortlist against a research-ordered criteria priority resolved from the consuming org's naming criteria. The human always picks; it never auto-locks a name. An optional tournament mode adds elimination rounds with independent judges for high-stakes, hard-to-refactor names.", "author": { "name": "Melodic Software", "email": "info@melodicsoftware.com" }, "license": "MIT", - "keywords": ["naming", "name", "rename", "identifier", "candidates", "anti-anchoring", "skill"] + "keywords": [ + "naming", + "name", + "rename", + "identifier", + "candidates", + "anti-anchoring", + "skill" + ] } diff --git a/plugins/naming/CHANGELOG.md b/plugins/naming/CHANGELOG.md index d1f15c0765..87cca643e5 100644 --- a/plugins/naming/CHANGELOG.md +++ b/plugins/naming/CHANGELOG.md @@ -3,6 +3,23 @@ All notable changes to the `naming` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.3.0] + +### Added + +- **Four tournament lessons from the running-retro naming round** folded into + `name-it-better`: + - a **terms-of-art brief field** — the field's established names for the act, + with researched (not recalled) meanings, so generators neither borrow a + divergent term blindly nor miss the honest established one; + - **blocklist provenance** — every word-level blocklist entry records + user-stated vs agent-inferred origin; agent-inferred entries are proposals + to confirm, never silently hard constraints; + - the **sentence-form test** as an early merge filter for utterance names + (skills, commands): the imperative you would actually say, cold-readable; + - a **temporal-neutrality constraint** for skills loadable as primed context: + the name must read valid before any work exists. + ## [0.2.0] ### Changed diff --git a/plugins/naming/skills/name-it-better/SKILL.md b/plugins/naming/skills/name-it-better/SKILL.md index 155ca1a398..6ca4505365 100644 --- a/plugins/naming/skills/name-it-better/SKILL.md +++ b/plugins/naming/skills/name-it-better/SKILL.md @@ -77,7 +77,11 @@ pre-scoring filters could not match. - **Claude Code skills are the sharp special case.** For a skill, the DESCRIPTION — not the name — is what drives model-side discovery. So optimise the name for human semantic accuracy, and put the trigger - phrases and example requests in the description, not the name. + phrases and example requests in the description, not the name. A skill + loadable as primed context at conversation start must also be + **temporally neutral**: the name has to read valid before any work + exists, so a candidate that presupposes completed output ("critique your + run") fails for a skill that can fire cold. ## Default pass @@ -95,8 +99,17 @@ pre-scoring filters could not match. be confused with or blur into. - **Collision vocabulary** — the existing sibling names it must not duplicate. + - **Terms of art** — the established names the field or domain already + uses for this act or thing, with their ACTUAL researched meanings, not + recalled ones. Research them before the fan-out: a term whose field + meaning diverges from this target is misleading (criterion 1) and the + divergence belongs in the brief so generators neither borrow it blindly + nor miss the honest established term. - **Word-level blocklist** — individual words ruled out, each WITH its - reason (overloaded, misleading, collides, already rejected). + reason (overloaded, misleading, collides, already rejected) AND its + provenance: user-stated or agent-inferred. An agent-inferred entry is a + proposal to confirm with the user, never a silently hard constraint — an + assumed blocklist word can eliminate the honest winner. Rejected incumbent NAMES deliberately stay out of the brief — the main thread holds them as its reject list and disqualifies matches at merge @@ -117,12 +130,23 @@ pre-scoring filters could not match. Running them blind and independent is deliberate anti-anchoring; the method grounding is in [`context/sources.md`](context/sources.md). -3. **Merge and score.** Pool the candidates, dedupe, and disqualify any +3. **Merge and score.** For a name used as an utterance — a skill, command, + or anything invoked by saying it — apply the **sentence-form test** as an + early filter before scoring: is the candidate the imperative you would + actually say, readable cold with no context? Contentless idioms (a bare + "check", "take stock") fail it even when they score well on the criteria + below. For a skill loadable as primed context, apply the + **temporal-neutrality test** in the same early filter: a candidate that + presupposes completed work fails before scoring, however accurate it is + once work exists. Then pool the candidates, dedupe, and disqualify any candidate that matches the rejected incumbent (if any) — carried by the main thread as an explicit reject list, never shared with the - generators — that contains a word-level blocklist entry (a generator - can miss the brief's constraint; the merge step enforces it), or that - collides with the existing vocabulary. Score every + generators — that contains a USER-STATED word-level blocklist entry (a + generator can miss the brief's constraint; the merge step enforces it), + or that collides with the existing vocabulary. A candidate containing + only an AGENT-INFERRED blocklist word is not disqualified — it stays in, + flagged with the inferred concern, so the user's pick confirms or + overrides the inference (provenance rule above). Score every surviving candidate against the criteria resolved above, breaking ties by their declared priority order. 4. **Shortlist + recommend.** Present a short ranked list with a @@ -162,11 +186,14 @@ models), then run elimination rounds with independent scoring judges until one candidate remains, and present it plus the runners-up for the human choice. -The reject-list, word-level-blocklist, and collision disqualification from -the default pass's merge step still apply: pool the widened candidates and -disqualify any that match the rejected incumbent, contain a blocklisted -word, or collide with the existing vocabulary BEFORE the elimination -rounds begin — a rejected, blocklisted, or colliding name must never enter +The default pass's merge filters still apply BEFORE the elimination rounds +begin — including the sentence-form and temporal-neutrality tests for +utterance and cold-loadable names and the blocklist provenance rule: pool +the widened candidates, fail contentless idioms and +completed-work-presupposing names early, and disqualify any that match the rejected incumbent, contain +a user-stated blocklisted word, or collide with the existing vocabulary +(agent-inferred blocklist matches enter the bracket flagged, not +disqualified). A rejected, blocklisted, or colliding name must never enter the bracket, let alone reach the finalist. HONEST FRAMING: a "naming tournament / bracket" is NOT a documented diff --git a/plugins/planning/.claude-plugin/plugin.json b/plugins/planning/.claude-plugin/plugin.json index 8672fcfd13..1a01849b37 100644 --- a/plugins/planning/.claude-plugin/plugin.json +++ b/plugins/planning/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "planning", - "version": "0.24.1", + "version": "0.24.2", "userConfig": { "use_ask_user_question": { "type": "boolean", diff --git a/plugins/planning/CHANGELOG.md b/plugins/planning/CHANGELOG.md index a3033d6ec4..43dab05b71 100644 --- a/plugins/planning/CHANGELOG.md +++ b/plugins/planning/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to the `planning` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.24.2] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.24.1] ### Changed diff --git a/plugins/planning/skills/design-handoff/SKILL.md b/plugins/planning/skills/design-handoff/SKILL.md index 733ff33c03..ec351c0de8 100644 --- a/plugins/planning/skills/design-handoff/SKILL.md +++ b/plugins/planning/skills/design-handoff/SKILL.md @@ -4,6 +4,7 @@ description: "Gate and package a finished design for /planning:plan: binary chec argument-hint: "(no args — reads the design-threads artifact in the topic's contract slice)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/planning/skills/design/SKILL.md b/plugins/planning/skills/design/SKILL.md index 32d6e2c440..d3cd1d9e6b 100644 --- a/plugins/planning/skills/design/SKILL.md +++ b/plugins/planning/skills/design/SKILL.md @@ -4,6 +4,7 @@ description: "Explore and resolve design decisions — types, contracts, package argument-hint: "[scope] [action] (e.g., /planning:design library, /planning:design module, /planning:design status, /planning:design discuss, /planning:design handoff)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/planning/skills/devils-advocate/SKILL.md b/plugins/planning/skills/devils-advocate/SKILL.md index 80bb2a2693..d7dbff1807 100644 --- a/plugins/planning/skills/devils-advocate/SKILL.md +++ b/plugins/planning/skills/devils-advocate/SKILL.md @@ -4,6 +4,7 @@ description: "Stress-test plans and proposals via systematic adversarial review argument-hint: "[incumbent [target]] or [plan text or file path] — an optional leading deep/shallow sets research depth; works from conversation context if no argument given" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/planning/skills/interview/SKILL.md b/plugins/planning/skills/interview/SKILL.md index c0d487040d..1d2dfeac23 100644 --- a/plugins/planning/skills/interview/SKILL.md +++ b/plugins/planning/skills/interview/SKILL.md @@ -4,6 +4,7 @@ description: "Interview relentlessly to reach shared understanding on a plan, de argument-hint: "[action] [topic] (e.g., /planning:interview, /planning:interview me, /planning:interview lock, /planning:interview )" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/planning/skills/plan/SKILL.md b/plugins/planning/skills/plan/SKILL.md index a9ab5fe767..940ab7e1c3 100644 --- a/plugins/planning/skills/plan/SKILL.md +++ b/plugins/planning/skills/plan/SKILL.md @@ -4,6 +4,7 @@ description: "Produce structured implementation plans with goal, approach, test argument-hint: "[task description, 'review', or 'close-out'] (e.g., /planning:plan add caching to query handlers, /planning:plan review, /planning:plan close-out)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/planning/skills/prd/SKILL.md b/plugins/planning/skills/prd/SKILL.md index 2bf7216ded..7bc727bd4f 100644 --- a/plugins/planning/skills/prd/SKILL.md +++ b/plugins/planning/skills/prd/SKILL.md @@ -4,6 +4,7 @@ description: "Produce a Product Requirements Document that locks product intent argument-hint: "[tier] [task description] (e.g., /planning:prd, /planning:prd one-pager add gig calendar, /planning:prd review)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/planning/skills/wayfind/SKILL.md b/plugins/planning/skills/wayfind/SKILL.md index 839aded1cc..40cd2e7483 100644 --- a/plugins/planning/skills/wayfind/SKILL.md +++ b/plugins/planning/skills/wayfind/SKILL.md @@ -9,6 +9,7 @@ allowed-tools: - "Bash(gh issue view*)" - "Bash(gh api user*)" - "Bash(gh label list*)" +shell: bash --- ## Pre-computed context diff --git a/plugins/playbooks/.claude-plugin/plugin.json b/plugins/playbooks/.claude-plugin/plugin.json index 1480e288d7..caf9d7bbda 100644 --- a/plugins/playbooks/.claude-plugin/plugin.json +++ b/plugins/playbooks/.claude-plugin/plugin.json @@ -1,12 +1,23 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "playbooks", - "version": "0.3.0", + "version": "0.3.1", "description": "Doctrine and knowledge playbooks as on-demand skills, plus a maintainer-facing update skill. boris — Boris Cherny's Claude Code workflow tips (howborisusesclaudecode.com); skill-authoring — Anthropic's internal skill-authoring playbook; fable-5 — Claude Fable 5's operating doctrine (self-authored, no upstream). The boris and skill-authoring packs vendor a verbatim upstream baseline; /playbooks:update drift-checks and syncs those baselines centrally (maintainers).", "author": { "name": "Melodic Software", "email": "info@melodicsoftware.com" }, "license": "MIT", - "keywords": ["playbooks", "knowledge", "doctrine", "claude-code", "workflow", "skill-authoring", "boris-cherny", "fable-5", "best-practices", "tips"] + "keywords": [ + "playbooks", + "knowledge", + "doctrine", + "claude-code", + "workflow", + "skill-authoring", + "boris-cherny", + "fable-5", + "best-practices", + "tips" + ] } diff --git a/plugins/playbooks/CHANGELOG.md b/plugins/playbooks/CHANGELOG.md index e67216a5ff..84bd34b82a 100644 --- a/plugins/playbooks/CHANGELOG.md +++ b/plugins/playbooks/CHANGELOG.md @@ -4,6 +4,14 @@ All notable changes to the `playbooks` plugin are recorded here. The `version` i `.claude-plugin/plugin.json` is the delivery vehicle — a consumer receives a change only after that version increases. +## [0.3.1] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.3.0] ### Added diff --git a/plugins/playbooks/skills/skill-authoring/SKILL.md b/plugins/playbooks/skills/skill-authoring/SKILL.md index 274091f97a..8dd0b2b806 100644 --- a/plugins/playbooks/skills/skill-authoring/SKILL.md +++ b/plugins/playbooks/skills/skill-authoring/SKILL.md @@ -6,6 +6,7 @@ disable-model-invocation: false metadata: upstream-version: 1.0.0 synced: 2026-03-17 +shell: bash --- # How To Use Skills — from Anthropic's internal playbook diff --git a/plugins/prototype/.claude-plugin/plugin.json b/plugins/prototype/.claude-plugin/plugin.json index a2fd5ad523..f5e41f35f8 100644 --- a/plugins/prototype/.claude-plugin/plugin.json +++ b/plugins/prototype/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "prototype", - "version": "0.3.1", + "version": "0.3.2", "description": "Builds throwaway code to answer a design question before committing to architecture — a logic facet (an interactive terminal app over a portable state model) and a UI facet (radically different visual variants on one route).", "author": { "name": "Melodic Software", diff --git a/plugins/prototype/CHANGELOG.md b/plugins/prototype/CHANGELOG.md index 784d22f0ee..d8be36c5a5 100644 --- a/plugins/prototype/CHANGELOG.md +++ b/plugins/prototype/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to the `prototype` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.3.2] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.3.1] ### Changed diff --git a/plugins/prototype/skills/explore-directions/SKILL.md b/plugins/prototype/skills/explore-directions/SKILL.md index 7e358c1c30..29acbe3456 100644 --- a/plugins/prototype/skills/explore-directions/SKILL.md +++ b/plugins/prototype/skills/explore-directions/SKILL.md @@ -5,6 +5,7 @@ argument-hint: "[scope] (e.g., /prototype:explore-directions settings page)" user-invocable: true disable-model-invocation: false allowed-tools: ["Bash(git branch:*)", "Bash(git status:*)", "Bash(head:*)", "Bash(echo:*)", "Bash(bash ${CLAUDE_PLUGIN_ROOT}/scripts/detect-ecosystems.sh:*)"] +shell: bash --- ## Pre-computed context diff --git a/plugins/prototype/skills/pressure-test/SKILL.md b/plugins/prototype/skills/pressure-test/SKILL.md index 12a8853dd3..8789f3f6e5 100644 --- a/plugins/prototype/skills/pressure-test/SKILL.md +++ b/plugins/prototype/skills/pressure-test/SKILL.md @@ -5,6 +5,7 @@ argument-hint: "[scope] (e.g., /prototype:pressure-test scheduling state machine user-invocable: true disable-model-invocation: false allowed-tools: ["Bash(git branch:*)", "Bash(git status:*)", "Bash(head:*)", "Bash(echo:*)", "Bash(bash ${CLAUDE_PLUGIN_ROOT}/scripts/detect-ecosystems.sh:*)"] +shell: bash --- ## Pre-computed context diff --git a/plugins/repo-hygiene/.claude-plugin/plugin.json b/plugins/repo-hygiene/.claude-plugin/plugin.json index e1c18cc521..66fa3d2acb 100644 --- a/plugins/repo-hygiene/.claude-plugin/plugin.json +++ b/plugins/repo-hygiene/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "repo-hygiene", - "version": "0.4.4", + "version": "0.4.5", "description": "Repo hygiene action-router: /repo-hygiene:clean sweeps reclaimable caches, build artifacts, and stale git metadata, and can realign the working tree to a fresh-pull state — dry-run-first, with destructive tiers gated behind explicit confirmation and a session-scoped destructive-command guard. Ecosystem targets are detected at runtime; secrets, runtime dependencies, and skill data are preserved by default.", "author": { "name": "Melodic Software", diff --git a/plugins/repo-hygiene/CHANGELOG.md b/plugins/repo-hygiene/CHANGELOG.md index af462272ee..b15fe5bca8 100644 --- a/plugins/repo-hygiene/CHANGELOG.md +++ b/plugins/repo-hygiene/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to the `repo-hygiene` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.4.5] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.4.4] ### Changed diff --git a/plugins/repo-hygiene/skills/clean/SKILL.md b/plugins/repo-hygiene/skills/clean/SKILL.md index cf320829f1..c04f232ad4 100644 --- a/plugins/repo-hygiene/skills/clean/SKILL.md +++ b/plugins/repo-hygiene/skills/clean/SKILL.md @@ -12,6 +12,7 @@ hooks: - type: command command: "bash" args: ["${CLAUDE_PLUGIN_ROOT}/skills/clean/scripts/destructive-guard.sh"] +shell: bash --- ## Pre-computed context diff --git a/plugins/review/.claude-plugin/plugin.json b/plugins/review/.claude-plugin/plugin.json index 1543c421d1..41a3241b32 100644 --- a/plugins/review/.claude-plugin/plugin.json +++ b/plugins/review/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "review", - "version": "0.14.9", + "version": "0.14.10", "description": "Code-review toolkit: six read-only reviewer agents (code, security, architecture, doc drift, build/test/lint, CI-log audit) plus two orchestration skills — a single-lens quality gate and a multi-surface review fan-out with severity-ranked, deduplicated findings.", "author": { "name": "Melodic Software", diff --git a/plugins/review/CHANGELOG.md b/plugins/review/CHANGELOG.md index 442c46d697..5191f58016 100644 --- a/plugins/review/CHANGELOG.md +++ b/plugins/review/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to the `review` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.14.10] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.14.9] ### Added diff --git a/plugins/review/skills/fanout/SKILL.md b/plugins/review/skills/fanout/SKILL.md index e87ec3fef8..fca1b70244 100644 --- a/plugins/review/skills/fanout/SKILL.md +++ b/plugins/review/skills/fanout/SKILL.md @@ -4,6 +4,7 @@ description: "Fan out review across many finding-producing surfaces at once — argument-hint: "[mode] [--yes] (e.g., /review:fanout, /review:fanout run-everything, /review:fanout fix, /review:fanout fix --yes)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/review/skills/quality-gate/SKILL.md b/plugins/review/skills/quality-gate/SKILL.md index ee0e6cd452..8364bb5694 100644 --- a/plugins/review/skills/quality-gate/SKILL.md +++ b/plugins/review/skills/quality-gate/SKILL.md @@ -5,6 +5,7 @@ argument-hint: "[mode] (e.g., /review:quality-gate, /review:quality-gate self, / user-invocable: true disable-model-invocation: false allowed-tools: ["Bash(git branch --show-current 2>/dev/null || echo \"unknown\")", "Bash(git status --porcelain 2>/dev/null | head -20 || echo \"unavailable\")", "Bash(gh pr list --json number,title,headRefName,baseRefName --limit 10 2>/dev/null || echo \"unknown\")", "Bash(gh pr list:*)"] +shell: bash --- ## Pre-computed context diff --git a/plugins/session-flow/.claude-plugin/plugin.json b/plugins/session-flow/.claude-plugin/plugin.json index c8f60335e6..d0b5d5712c 100644 --- a/plugins/session-flow/.claude-plugin/plugin.json +++ b/plugins/session-flow/.claude-plugin/plugin.json @@ -1,12 +1,29 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "session-flow", - "version": "0.12.1", + "version": "0.12.2", "description": "Session-lifecycle toolkit of nine skills: workflow (navigate a staged dev workflow and suggest the next stage), handoff (write a save-point and resume prompt for /clear, with optional --bg background-agent launch), keep-going (recover and continue after any interruption OR when live off-thread work looks stalled — inventory off-thread work, inspect its real output, act only on evidence, then continue; after a usage limit lifts it continues rather than summarizing-and-stalling), clean-stop (get to a durable, linked stopping point before the machine may go away — sweep every repo/worktree for uncommitted, unpushed, or PR-less work, push it durable, put breadcrumbs in PR/issue bodies, then give a free-and-clear verdict), retro (structured end-of-session retrospective with transcript metrics and learning codification), running-retro (in-flight retrospective checkpoints that spawn a subagent to analyze the transcript so far and append classified findings to a cumulative running ledger — capture and route only, the live counterpart to retro), orient (read-only session orientation — synthesize where we stand, what we are doing, and why, from durable + off-thread state the built-in /recap never sees: ledgers, handoffs, workflow checklists, running-retro ledgers, open PRs and work-items, and git), orchestrate (arm a session or worker with proactive-orchestration imperatives), and reanchor (verify a session's working assumptions are still true against live reality — referenced PRs/issues/branches, base-branch drift, renamed/version-drifted surfaces, stale memory-tier files — before building on them).", "author": { "name": "Melodic Software", "email": "info@melodicsoftware.com" }, "license": "MIT", - "keywords": ["workflow", "handoff", "keep-going", "clean-stop", "resume", "recover", "durable", "retrospective", "session", "checkpoint", "orchestration", "reanchor", "freshness", "orient", "orientation", "skill"] + "keywords": [ + "workflow", + "handoff", + "keep-going", + "clean-stop", + "resume", + "recover", + "durable", + "retrospective", + "session", + "checkpoint", + "orchestration", + "reanchor", + "freshness", + "orient", + "orientation", + "skill" + ] } diff --git a/plugins/session-flow/CHANGELOG.md b/plugins/session-flow/CHANGELOG.md index aee5503131..e349ce79a5 100644 --- a/plugins/session-flow/CHANGELOG.md +++ b/plugins/session-flow/CHANGELOG.md @@ -1,5 +1,13 @@ # Changelog — session-flow plugin +## [0.12.2] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.12.1] — 2026-07-21 Changed: diff --git a/plugins/session-flow/skills/handoff/SKILL.md b/plugins/session-flow/skills/handoff/SKILL.md index 0b966d577f..83a516cc49 100644 --- a/plugins/session-flow/skills/handoff/SKILL.md +++ b/plugins/session-flow/skills/handoff/SKILL.md @@ -4,6 +4,7 @@ description: "Write a mid-session save-point for /clear-and-resume — a durable argument-hint: "[file|prompt] [topic] [--bg] (e.g., /handoff, /handoff prompt, /handoff file phase-3, /handoff --bg)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/session-flow/skills/orient/SKILL.md b/plugins/session-flow/skills/orient/SKILL.md index 4802884444..b85e1f5b28 100644 --- a/plugins/session-flow/skills/orient/SKILL.md +++ b/plugins/session-flow/skills/orient/SKILL.md @@ -3,6 +3,7 @@ name: orient description: "Read-only session orientation from durable + off-thread state — synthesize where we stand, what we are doing, and why, from the ledger files, handoff save-points, workflow checklists, running-retro ledgers, open PRs and work-items, and git state, not just the conversation. Complements the built-in /recap (conversation-only, auto-fires) by adding the durable state recap never sees. Use when: 'where were we', 'catch me up', 'orient me', 'get my bearings', 'what's the state', 'brief me', 'situation report', 'where do we stand', 'lay of the land'. Read-only: writes nothing, ends nothing, and does not verify freshness, recover off-thread work, or prescribe the next stage — it points at the sibling that does." user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/session-flow/skills/retro/SKILL.md b/plugins/session-flow/skills/retro/SKILL.md index 53233c53a7..1078f145aa 100644 --- a/plugins/session-flow/skills/retro/SKILL.md +++ b/plugins/session-flow/skills/retro/SKILL.md @@ -4,6 +4,7 @@ description: "Run a structured session retrospective: extract transcript metrics argument-hint: "[mode] (e.g., /retro, /retro session, /retro codify, /retro trends, /retro quick)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/session-flow/skills/running-retro/SKILL.md b/plugins/session-flow/skills/running-retro/SKILL.md index 2e53632c3a..0b1f35fb75 100644 --- a/plugins/session-flow/skills/running-retro/SKILL.md +++ b/plugins/session-flow/skills/running-retro/SKILL.md @@ -4,6 +4,7 @@ description: "Take an in-flight retrospective checkpoint mid-session: spawn a su argument-hint: "[topic] (e.g., /running-retro, /running-retro phase-3)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/session-flow/skills/workflow/SKILL.md b/plugins/session-flow/skills/workflow/SKILL.md index 14289f618f..dcca4f0151 100644 --- a/plugins/session-flow/skills/workflow/SKILL.md +++ b/plugins/session-flow/skills/workflow/SKILL.md @@ -4,6 +4,7 @@ description: "Navigate a staged development workflow (explore → research → p argument-hint: "[mode] (e.g., /workflow, /workflow steps, /workflow pre-pr, /workflow wrap-up, /workflow philosophy, /workflow spec-first)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/skill-quality/.claude-plugin/plugin.json b/plugins/skill-quality/.claude-plugin/plugin.json index bb25c028d3..12f2847b9d 100644 --- a/plugins/skill-quality/.claude-plugin/plugin.json +++ b/plugins/skill-quality/.claude-plugin/plugin.json @@ -1,14 +1,22 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "skill-quality", - "version": "0.7.1", + "version": "0.7.2", "description": "Skill-authoring QA tooling: a static contract checker that runs eighteen deterministic checks over a Claude Code skill (frontmatter, listing-budget cap, trigger-keyword preservation, line caps, broken internal refs, markdownlint, gotchas surface, evals presence, precompute opportunity) and a bundled evals.json schema for validation. Runs against any repo's skills directory via the convention-resolution ladder — no baked layout.", "author": { "name": "Melodic Software", "email": "info@melodicsoftware.com" }, "license": "MIT", - "keywords": ["skill", "authoring", "quality", "contract", "lint", "evals", "audit"], + "keywords": [ + "skill", + "authoring", + "quality", + "contract", + "lint", + "evals", + "audit" + ], "userConfig": { "skills_root": { "type": "directory", diff --git a/plugins/skill-quality/CHANGELOG.md b/plugins/skill-quality/CHANGELOG.md index 7703dc41a5..986ed78d32 100644 --- a/plugins/skill-quality/CHANGELOG.md +++ b/plugins/skill-quality/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to the `skill-quality` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.7.2] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.7.1] ### Fixed diff --git a/plugins/skill-quality/skills/check/SKILL.md b/plugins/skill-quality/skills/check/SKILL.md index d062e39beb..ebca60b39f 100644 --- a/plugins/skill-quality/skills/check/SKILL.md +++ b/plugins/skill-quality/skills/check/SKILL.md @@ -4,6 +4,7 @@ description: "Skill-authoring QA for Claude Code skills. Use when: 'check this s argument-hint: "[check|validate-evals] [] — omit the action for check; omit the skill name to run over every skill" user-invocable: true disable-model-invocation: false +shell: bash --- ## Purpose diff --git a/plugins/source-control/.claude-plugin/plugin.json b/plugins/source-control/.claude-plugin/plugin.json index 610b694063..9b2b397c7d 100644 --- a/plugins/source-control/.claude-plugin/plugin.json +++ b/plugins/source-control/.claude-plugin/plugin.json @@ -1,7 +1,7 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "source-control", - "version": "0.15.8", + "version": "0.15.9", "description": "Git and GitHub delivery workflow: /commit (Conventional Commits + Co-Authored-By trailer via safe heredoc mechanics), /pull-request (prep, create, CI monitoring, review-comment triage, merge, CI-log fetch), /babysit-prs (self-pacing fleet loop — safe by default; opt-in worker/autopilot tiers add gate-checked merge and thread resolution behind a deterministic Python engine), /worktree (create, status, cleanup, audit for parallel-session isolation), /setup (check the effective commit-subject / PR-title convention merged across its config layers and the babysit-prs config, or apply — interview the repo and write the convention config to a chosen layer), and /resolve-conflicts (intent-first merge/rebase conflict resolution with a semantic-conflict sweep — never --abort). The commit-subject / PR-title convention is configurable via a source-control.md config written by a re-runnable setup skill, layered across a ~/.claude user-global file, the tracked team file, and a gitignored .claude/source-control.local.md personal overlay merged per key; Conventional Commits is the default when no convention is declared.", "author": { "name": "Melodic Software", diff --git a/plugins/source-control/CHANGELOG.md b/plugins/source-control/CHANGELOG.md index fbca52cdb9..0e07baae5d 100644 --- a/plugins/source-control/CHANGELOG.md +++ b/plugins/source-control/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to the `source-control` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.15.9] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.15.8] ### Fixed diff --git a/plugins/source-control/skills/babysit-prs/SKILL.md b/plugins/source-control/skills/babysit-prs/SKILL.md index 2c1d5f80f9..0324a8ccf0 100644 --- a/plugins/source-control/skills/babysit-prs/SKILL.md +++ b/plugins/source-control/skills/babysit-prs/SKILL.md @@ -4,6 +4,7 @@ description: "Babysit your own open GitHub pull requests as a tiered fleet loop. user-invocable: true disable-model-invocation: false argument-hint: "[worker|autopilot|help] [owner/repo | #n | owner/repo#n] · default: configured default_tier (safe) over your own PRs; worker=fix+resolve-outdated+merge-ready; autopilot=max autonomy all authors; 'help' lists flows" +shell: bash --- ## Pre-computed context @@ -283,8 +284,7 @@ The values below substitute from this plugin's stored configuration when this sk A surviving literal `${user_config.…}` placeholder means that key is unset — apply its documented unset behavior. Reference files use `` slots; fill every slot from this block. Values reach scripts ONLY as explicit CLI flags (option environment variables never -reach skill-invoked scripts). Configuration selects targets and thresholds; it never widens -tier authority. +reach skill-invoked scripts). Configuration selects targets and thresholds; it never widens tier authority. | Key | Value | Flag delivery | Unset behavior | | --- | --- | --- | --- | diff --git a/plugins/source-control/skills/commit/SKILL.md b/plugins/source-control/skills/commit/SKILL.md index 2f20af2df2..b7a5165eb1 100644 --- a/plugins/source-control/skills/commit/SKILL.md +++ b/plugins/source-control/skills/commit/SKILL.md @@ -3,6 +3,7 @@ name: commit description: "Create a git commit with a subject matching the resolved convention (layered `source-control.md` config → project convention → Conventional Commits default), a Claude Co-Authored-By trailer, and surgical staging (never `git add -A`), feeding the message to git via Bash heredoc. Use when: 'commit this', 'make a commit', 'commit with message ' — not for push, branch creation, or PR creation (use /pull-request)." argument-hint: "[message-hint]" user-invocable: true +shell: bash --- ## Pre-computed context diff --git a/plugins/source-control/skills/pull-request/SKILL.md b/plugins/source-control/skills/pull-request/SKILL.md index 1263bc9459..a8d1b61677 100644 --- a/plugins/source-control/skills/pull-request/SKILL.md +++ b/plugins/source-control/skills/pull-request/SKILL.md @@ -4,6 +4,7 @@ description: "Orchestrate the full PR lifecycle: prep (review + verify), create, user-invocable: true disable-model-invocation: false argument-hint: " [args] (e.g., /pull-request prep, /pull-request create, /pull-request monitor, /pull-request merge, /pull-request full, /pull-request status)" +shell: bash --- ## Pre-computed context diff --git a/plugins/source-control/skills/resolve-conflicts/SKILL.md b/plugins/source-control/skills/resolve-conflicts/SKILL.md index b52b30276f..f8caf76be2 100644 --- a/plugins/source-control/skills/resolve-conflicts/SKILL.md +++ b/plugins/source-control/skills/resolve-conflicts/SKILL.md @@ -4,6 +4,7 @@ description: "Resolve an in-progress merge/rebase/cherry-pick conflict by recove argument-hint: "[paths] (optional — start with specific conflicted paths; default is every unmerged path)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/source-control/skills/worktree/SKILL.md b/plugins/source-control/skills/worktree/SKILL.md index 969d2478e2..44ce52befa 100644 --- a/plugins/source-control/skills/worktree/SKILL.md +++ b/plugins/source-control/skills/worktree/SKILL.md @@ -4,6 +4,7 @@ description: "Manage git worktree lifecycle for parallel-session isolation: crea user-invocable: true disable-model-invocation: false argument-hint: " [args] (e.g., /worktree create feat/my-feature, /worktree status, /worktree cleanup, /worktree audit)" +shell: bash --- ## Pre-computed context diff --git a/plugins/testing/.claude-plugin/plugin.json b/plugins/testing/.claude-plugin/plugin.json index 07e8e6f340..1427293d5c 100644 --- a/plugins/testing/.claude-plugin/plugin.json +++ b/plugins/testing/.claude-plugin/plugin.json @@ -1,12 +1,20 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "testing", - "version": "0.3.0", + "version": "0.3.1", "description": "Test-stage discipline across all ecosystems: coverage-gap analysis and test planning (`/testing:plan`), TDD test authoring and placement (`/testing:write`), live E2E plus non-UI smoke verification (`/testing:run-e2e`), and failing-test root-cause diagnosis with the reproduce → isolate → fix → retest loop (`/testing:diagnose`).", "author": { "name": "Melodic Software", "email": "info@melodicsoftware.com" }, "license": "MIT", - "keywords": ["testing", "tdd", "test-plan", "e2e", "diagnose", "coverage", "skill"] + "keywords": [ + "testing", + "tdd", + "test-plan", + "e2e", + "diagnose", + "coverage", + "skill" + ] } diff --git a/plugins/testing/CHANGELOG.md b/plugins/testing/CHANGELOG.md index a59e9e5ef0..f0fe34803c 100644 --- a/plugins/testing/CHANGELOG.md +++ b/plugins/testing/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to the `testing` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.3.1] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.3.0] ### Added diff --git a/plugins/testing/skills/diagnose/SKILL.md b/plugins/testing/skills/diagnose/SKILL.md index e044d4f935..364031cad7 100644 --- a/plugins/testing/skills/diagnose/SKILL.md +++ b/plugins/testing/skills/diagnose/SKILL.md @@ -4,6 +4,7 @@ description: "Diagnose and fix failing tests — failure classification, root-ca argument-hint: "[failure] (e.g., /testing:diagnose, /testing:diagnose the frozen-logger error, /testing:diagnose loop)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/testing/skills/plan/SKILL.md b/plugins/testing/skills/plan/SKILL.md index be1e660f17..356716f724 100644 --- a/plugins/testing/skills/plan/SKILL.md +++ b/plugins/testing/skills/plan/SKILL.md @@ -4,6 +4,7 @@ description: "Analyze code changes and produce a test plan — classify changed argument-hint: "[range or scope] (e.g., /testing:plan, /testing:plan HEAD~3, /testing:plan the auth module)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/testing/skills/run-e2e/SKILL.md b/plugins/testing/skills/run-e2e/SKILL.md index cb6e6dbdc6..7297dd4911 100644 --- a/plugins/testing/skills/run-e2e/SKILL.md +++ b/plugins/testing/skills/run-e2e/SKILL.md @@ -4,6 +4,7 @@ description: "End-to-end live app verification — check prerequisites, start th argument-hint: "[scenario] (e.g., /testing:run-e2e, /testing:run-e2e the login flow, /testing:run-e2e non-ui)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/testing/skills/write/SKILL.md b/plugins/testing/skills/write/SKILL.md index 96f932dc6c..8ac0d6fcc9 100644 --- a/plugins/testing/skills/write/SKILL.md +++ b/plugins/testing/skills/write/SKILL.md @@ -4,6 +4,7 @@ description: "Write and place tests across all ecosystems — TDD cadence (Red argument-hint: "[task] (e.g., /testing:write, /testing:write the new handler, /testing:write organize)" user-invocable: true disable-model-invocation: false +shell: bash --- ## Pre-computed context diff --git a/plugins/toolchain/.claude-plugin/plugin.json b/plugins/toolchain/.claude-plugin/plugin.json index c4ee3e7ab8..35c948ff60 100644 --- a/plugins/toolchain/.claude-plugin/plugin.json +++ b/plugins/toolchain/.claude-plugin/plugin.json @@ -1,12 +1,21 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "toolchain", - "version": "0.5.1", + "version": "0.5.2", "description": "Repo-agnostic polyglot verification toolchain: build + test + lint for changed files across .NET, Python, TypeScript, Bash, PowerShell, Markdown, YAML, and cross-cutting surfaces (`/toolchain:check`, `/toolchain:lint`), plus a re-runnable `/toolchain:setup` with check (report the configured ecosystems and their command surface) and apply (interview, infer, and write the tracked per-ecosystem command config those skills resolve first).", "author": { "name": "Melodic Software", "email": "info@melodicsoftware.com" }, "license": "MIT", - "keywords": ["toolchain", "build", "lint", "test", "ecosystem", "polyglot", "verification", "skill"] + "keywords": [ + "toolchain", + "build", + "lint", + "test", + "ecosystem", + "polyglot", + "verification", + "skill" + ] } diff --git a/plugins/toolchain/CHANGELOG.md b/plugins/toolchain/CHANGELOG.md index d2cea57a15..987074b236 100644 --- a/plugins/toolchain/CHANGELOG.md +++ b/plugins/toolchain/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to the `toolchain` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.5.2] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.5.1] ### Changed diff --git a/plugins/toolchain/skills/check/SKILL.md b/plugins/toolchain/skills/check/SKILL.md index 14aee536fc..290652607a 100644 --- a/plugins/toolchain/skills/check/SKILL.md +++ b/plugins/toolchain/skills/check/SKILL.md @@ -3,6 +3,7 @@ name: check description: "Run build, test, and lint verification for changed files, auto-detecting affected ecosystems (.NET, Python, TypeScript, Bash, PowerShell, Markdown) from git status, with the consuming project's own documented commands overriding portable defaults. Use after any code edit or for 'does it compile' / 'run tests' checks; for lint-only use /toolchain:lint, for full outcome verification use /verification:confirm." user-invocable: true argument-hint: "[ecosystem] (e.g., /toolchain:check dotnet, /toolchain:check python, /toolchain:check all — default: auto-detect from git status)" +shell: bash --- ## Pre-computed context diff --git a/plugins/toolchain/skills/lint/SKILL.md b/plugins/toolchain/skills/lint/SKILL.md index fbdcf85d08..39662f90b2 100644 --- a/plugins/toolchain/skills/lint/SKILL.md +++ b/plugins/toolchain/skills/lint/SKILL.md @@ -3,6 +3,7 @@ name: lint description: "Run polyglot linters and format checks across all affected ecosystems without a full build cycle — auto-detects ecosystems from changed files, honors each tool's config-file opt-in, and supports --fix mode to auto-correct where linters allow. Use for quick lint/format feedback during development; for build+test use /toolchain:check, for full outcome verification use /verification:confirm." user-invocable: true argument-hint: "[ecosystem] [--fix] (e.g., /toolchain:lint, /toolchain:lint dotnet, /toolchain:lint --fix, /toolchain:lint all)" +shell: bash --- ## Pre-computed context diff --git a/plugins/verification/.claude-plugin/plugin.json b/plugins/verification/.claude-plugin/plugin.json index 6fcd67ed31..b033b93323 100644 --- a/plugins/verification/.claude-plugin/plugin.json +++ b/plugins/verification/.claude-plugin/plugin.json @@ -1,8 +1,8 @@ { "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json", "name": "verification", - "version": "0.3.2", - "description": "Outcome-verification stage: prove a change achieved its intended outcome (`/verification:confirm` \u2014 a mechanical build/test/lint prerequisite gate, then intent-match + evidence + verdict with the criterion auto-detected by change type), and verify measurable-improvement claims against a planning-time baseline (`/verification:measure`), never fabricating numbers.", + "version": "0.3.3", + "description": "Outcome-verification stage: prove a change achieved its intended outcome (`/verification:confirm` — a mechanical build/test/lint prerequisite gate, then intent-match + evidence + verdict with the criterion auto-detected by change type), and verify measurable-improvement claims against a planning-time baseline (`/verification:measure`), never fabricating numbers.", "author": { "name": "Melodic Software", "email": "info@melodicsoftware.com" diff --git a/plugins/verification/CHANGELOG.md b/plugins/verification/CHANGELOG.md index 58742cea28..669912f18a 100644 --- a/plugins/verification/CHANGELOG.md +++ b/plugins/verification/CHANGELOG.md @@ -3,6 +3,14 @@ All notable changes to the `verification` plugin are documented here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this plugin uses semantic versioning. +## [0.3.3] + +### Changed + +- Skills with `!` dynamic-context injections now declare `shell: bash` explicitly, per + the pinned precompute convention — bash-only pipelines must not fall through to a + PowerShell host. + ## [0.3.2] ### Changed diff --git a/plugins/verification/skills/confirm/SKILL.md b/plugins/verification/skills/confirm/SKILL.md index 0f7ae1beaf..b23b13d2ff 100644 --- a/plugins/verification/skills/confirm/SKILL.md +++ b/plugins/verification/skills/confirm/SKILL.md @@ -4,6 +4,7 @@ description: "Prove a change achieved its intended outcome: a mechanical build+t user-invocable: true argument-hint: "[mode] [ecosystem] (e.g., /verification:confirm, /verification:confirm outcome, /verification:confirm fix, /verification:confirm refactor, /verification:confirm dotnet)" disable-model-invocation: false +shell: bash --- ## Pre-computed context