fix(claude-config): let unhobble classify and trim hybrid hook entries

plugins/claude-config/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "claude-config",
-  "version": "0.28.0",
+  "version": "0.28.1",
   "description": "Seven configuration-health skills (plus setup) 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), audit-instructions (locally-owned instruction surfaces vs current model capability — proposes removals/rewrites of instructions the model no longer needs, and detects cross-surface instruction conflicts), audit-prompting-postures (the additive lane — posture guidance the prompting guide says a component's purpose needs but the component does not carry), audit-pass (one coordinated, ordered, resumable pass over a named target — three-scope inventory, run-time-derived exclusion set, stable finding identity, suppression memory, resume, one human gate — delegating every check to the plugin that owns it), and unhobble (the empirical bare-baseline experiment: reversibly strip a repo's standing instructions, log real stumbles against the current model, re-add only what evidence earns).",
   "author": {
     "name": "Melodic Software",

plugins/claude-config/CHANGELOG.md

@@ -3,6 +3,21 @@
 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.28.1]
+
+### Fixed
+
+- **`unhobble`: the classification contract can now represent a hybrid hook entry.** The phase-1
+  contract allowed only `policy` | `behavioral` | `convention` per hook entry and reserved
+  splitting for instruction files, while phase 2 removed a behavioral entry's wiring whole — so a
+  hook carrying both a policy gate and behavioral prose could only be over-stripped or
+  over-kept, contradicting the marketplace rubric's trim-not-delete rule for hybrids
+  (PLUGIN-PHILOSOPHY "Classifying a hook"; flagged by review on the rubric PR #2033). Phase 1 adds
+  the `hybrid` class (delegating the rubric itself to the philosophy doc), phase 2 strips a
+  hybrid's behavioral surface via the hook's own kill switch or config where one exists and
+  otherwise records `unstripped-hybrid-hook` with the observe-phase confound noted, and the
+  manifest enum carries the new class.
+
 ## [0.28.0]
 
 ### Added

plugins/claude-config/skills/unhobble/SKILL.md

@@ -62,7 +62,7 @@ checkout before acting; a mismatch aborts with the conflicting path named. `snap
 an existing experiment directory: a fresh run mints a fresh id, and resuming an open experiment
 means passing its phase commands from inside the same checkout its manifest names.
 
-- `manifest.json` — every surface found, its classification (`behavioral` | `policy` | `convention`),
+- `manifest.json` — every surface found, its classification (`behavioral` | `policy` | `hybrid` | `convention`),
   what was stripped, how to restore it (path, restore mechanism, backup location), branch name,
   target model, phase timestamps.
 - `stumbles.md` — the observation ledger (one row per observed failure: date, task, what the model
@@ -81,13 +81,26 @@ means passing its phase commands from inside the same checkout its manifest name
 3. Classify **every surface the strip plan will touch** — hooks, rules, instruction files
    (CLAUDE.md / CLAUDE.local.md, `.claude/skills/`, `.claude/agents/`), and project-enabled
    plugins alike: `policy` (enforces team/safety policy regardless of model — kept), `behavioral`
-   (corrects or scaffolds model behavior — stripped), `convention` (team conventions in git —
-   operator's call, default kept per the official carve-out). Classification is per unit that
+   (corrects or scaffolds model behavior — stripped), `hybrid` (one unit carrying both, with the
+   split named — trimmed, never removed whole), or `convention` (team conventions in git —
+   operator's call, default kept per the official carve-out). For hook entries specifically, the
+   classification rubric — mechanism vs class, the hybrid trim-not-delete rule, and the
+   ground-truth-oracle carve-out (behavioral purpose with a non-derivable machine oracle is a
+   keep) — is owned by the marketplace's PLUGIN-PHILOSOPHY "Classifying a hook" section; this
+   phase applies it to hooks, never re-derives it. Non-hook surfaces (rules, instruction files,
+   skills, agents, plugins) classify by the class definitions above; `hybrid` applies to any unit
+   whose behavioral and policy surfaces can be split in place. Classification is per unit that
    Phase 2 acts on: a hook entry, a rule file, a skill, an agent, a plugin. A **mixed** instruction
    file — a CLAUDE.md carrying both convention sections and behavioral lines is the common case —
    is not classified whole: split it in the strip plan, naming which sections are stripped and
    which are preserved (extracted to a retained file or left in place), so the convention
-   carve-out holds at section granularity rather than being deleted wholesale with the file.
+   carve-out holds at section granularity rather than being deleted wholesale with the file. A
+   **hybrid hook entry** gets the same treatment at its own granularity: the strip plan names the
+   behavioral surface (an injected prose payload, a coaching string) and the policy residue (the
+   gate, the finding relay), and strips only the former — via the hook's own kill switch or
+   config where one exists, otherwise recorded as `unstripped-hybrid-hook` with the confound
+   noted for the observe phase. Never remove a hybrid entry's wiring whole; that takes the policy
+   residue down with the behavioral surface.
 4. Write `manifest.json`; present the strip plan (what goes, what stays and why) and stop for
    confirmation.
 
@@ -98,17 +111,31 @@ Apply the confirmed strip plan:
 - Tracked instruction files: per the plan's per-file (and, for mixed files, per-section)
   classification — `git rm` / `git mv` a file classified behavioral whole; for a mixed file,
   remove the behavioral sections and keep the convention sections in place or in an extracted
-  retained file. One commit, message
+  retained file. A file classified `hybrid` operationalizes exactly like a mixed file — strip the
+  behavioral sections, keep the policy residue in place or extracted — the classes differ in what
+  the residue is (policy vs convention), not in the mechanics. One commit, message
   `experiment: strip instruction surfaces for unhobble baseline`.
 - Project-settings hook entries classified `behavioral`: back up the settings file to `backups/`,
-  remove the entries, record the exact JSON paths removed in the manifest.
+  remove the entries, record the exact JSON paths removed in the manifest. An entry classified
+  `hybrid` is never removed whole: strip its behavioral surface through the hook's own kill switch
+  or config where one exists, else leave it wired and record `unstripped-hybrid-hook` (observe
+  phase notes the confound), per the plan's named split.
 - Project-enabled plugins: record the current enabled set in the manifest, then disable the ones
   classified `behavioral` for this project (leave policy/tooling plugins the operator marked keep).
-  Plugins toggle whole — project settings offer no partial disable — so a **mixed** plugin that
-  bundles any `policy`-classified surface (e.g. a policy hook alongside behavioral convenience
-  skills) is **kept whole**, with its behavioral components recorded in the manifest as
-  `unstripped-mixed-plugin`; the observe phase notes them as still-loaded confounds rather than
-  silently taking the policy gate down with the plugin.
+  Plugins toggle whole — project settings offer no partial disable — so a plugin classified
+  **`hybrid`** (any `policy`-classified surface alongside behavioral components, e.g. a policy
+  hook next to behavioral convenience skills; older strip plans say "mixed" for the same class)
+  is **kept whole**, with its behavioral components recorded in the manifest as
+  `unstripped-mixed-plugin` (label unchanged for manifest continuity); the observe phase notes
+  them as still-loaded confounds rather than
+  silently taking the policy gate down with the plugin. Within a kept-whole mixed plugin, a
+  behavioral or hybrid HOOK may still be individually stripped when the plugin exposes a per-hook
+  kill switch (a `<hook>_enabled`-style userConfig option): record the option flipped and its
+  prior value in the manifest as a partial strip, restoring by flipping it back. No per-hook
+  switch → the hook stays loaded, recorded by its own class — `unstripped-behavioral-hook` for a
+  plain behavioral hook (nothing of it is legitimately loaded; the whole hook is the confound),
+  `unstripped-hybrid-hook` for a hybrid (its policy residue is legitimately loaded; only the
+  behavioral surface is the confound) — alongside the plugin's confound note.
 - Print the "you are bare" summary: what a fresh session will now load (ideally: nothing but the
   code) and how to restore everything (`readd` phase reads the manifest; `git` holds the files).