# Curse Shield

> Use Curse Shield when Hermes should protect a surface in a way that makes contact linger on the attacker. The shield is not just there to absorb the next hit or throw an immediate counter; it tags hostile touch with a lasting penalty, mark, or contamination that follows the offender after impact. In practice, Curse Shield is for defended surfaces that impose audit burden, throttling, suspicion, reduced trust, quarantine, follow-up scrutiny, or another durable consequence on whatever keeps pressing into them.

- Skill: `hmbown/curse-shield-2` (Agent Skill)
- Install (CLI): `npx skillmds@latest add hmbown/curse-shield-2`
- Raw SKILL.md: https://api.skillmd.com/api/skills/hmbown/curse-shield-2/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Security
- License: CC0-1.0
- Author: Hmbown (https://skillmd.com/u/hmbown)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/hmbown/curse-shield-2

---

# Curse Shield
Raise a shield that protects the target and curses whatever makes hostile contact with it.
## What This Skill Does
Use Curse Shield when Hermes should protect a surface in a way that makes contact linger on the attacker. The shield is not just there to absorb the next hit or throw an immediate counter; it tags hostile touch with a lasting penalty, mark, or contamination that follows the offender after impact. In practice, Curse Shield is for defended surfaces that impose audit burden, throttling, suspicion, reduced trust, quarantine, follow-up scrutiny, or another durable consequence on whatever keeps pressing into them.
In this chip pack, Curse Shield is treated as a hybrid battle-chip procedure with a shipping-now delivery profile.
Canonical reference input: Curse Shield.
Hermes shelf: [Defense and Recovery](../DESCRIPTION.md).
## When To Use

- You need a protective layer that does more than soak damage: hostile contact should leave a durable mark or penalty behind.
- The same actor, process, or source keeps touching a protected surface and should become easier to track, rate-limit, isolate, or distrust after doing so.
- Immediate retaliation is less useful than making future contact progressively more expensive, visible, or constrained.

## Prerequisites

- Name which part of this move is real tool use versus battle-chip framing before you act.
- These procedures rely on the normal tools already present in the active Hermes runtime; this repo does not ship a separate integration layer.

## Operator Inputs

- Name the exact asset, workflow step, boundary, interface, or operator surface that needs shielding.
- Describe what hostile contact means here: invalid writes, abusive requests, repeated probes, policy violations, tampering, or another concrete touch event.
- State what lasting curse Hermes should impose on the toucher after contact: tagging, rate reduction, scrutiny, sandboxing, restricted access, forced review, or another durable penalty.
- Say how long the curse should last and what clears it: timeout, remediation, review, manual pardon, or successful migration to a clean path.
- Identify any actors whose contact must be exempt or handled differently so the shield does not curse legitimate maintenance or allied traffic.

## Procedure

1. Restate the target, success condition, and no-touch boundaries before you spend the chip.
2. Collect the operator inputs below so the chip lands on the right panel.
3. Name the exact surface, boundary, or workflow Hermes should shield and define what counts as hostile contact with it.
4. Choose the curse Hermes should attach to contact: mark, quarantine, audit trail, trust reduction, cooldown, rate limit, or another persistent penalty that survives the initial hit.
5. Apply the shield so it protects the defended surface now while ensuring any hostile toucher leaves carrying the curse into later interactions.
6. Package the result with concrete evidence, what stayed untouched, and the next recommended chip only if follow-up is truly needed.

## Deliverables

- One bounded defensive layer around a named surface that both protects it and applies a durable consequence to hostile contact.
- A short note defining the curse itself: what mark or penalty is applied, how long it lasts, and how operators should use that information afterward.

## Output Contract

- One explicit defensive shield on a named surface, with the protected boundary and hostile-contact trigger clearly defined.
- A durable post-contact mark or penalty that follows the offending actor, process, or request beyond the first touch rather than ending as a one-shot counter.
- A concrete explanation of how the curse changes future handling: slower lane, lower trust, extra review, containment, or another persistent operational consequence.
- A clear expiry, cleanse, or override path so the curse remains bounded and governable.

## Do Not Use For

- Pure one-hit absorption where no lasting consequence should be attached to contact; that is Barrier.
- Single-trigger reactive counters where the response should fire once and be done; that is Anti Damage.
- Poisoning a fixed location or camping spot rather than the toucher; that is Poison Face.
- Contaminating a repeatedly worn interface or workflow surface rather than defending a shielded boundary; that is Poison Mask.
- Unbounded blacklist logic, permanent stigma, or penalties with no clear review or removal path.

## Pair With

- Curse Shield + Barrier: absorb the first impact cleanly, then let repeated hostile contact start carrying a durable penalty.
- Curse Shield + Killer Eye: watch the approach lane, then mark and constrain whatever actually touches the defended surface.
- Curse Shield + North Wind: strip the enemy's protective cover first, then make any retaliatory contact with your restored boundary carry a curse.
- Curse Shield + Poison Mask: curse those who touch the defended boundary, then contaminate the old interface they keep retreating to so both contact and fallback become costly.

## Pitfalls / Guardrails

- Keep the theatrical framing, but name the concrete mechanism that makes the chip useful right now.
- Curse Shield must defend first. If there is no real protected surface, you are inventing a curse mechanic without a shield.
- The curse should persist beyond the triggering touch, but it must stay proportionate and reviewable; do not smuggle in uncontrolled retaliation.
- Do not confuse a cursed marker with general suspicion. The penalty needs a concrete operational effect, expiry, or cleanse condition.
- If you only need one reactive hit back on the next attack, use Anti Damage. If you need a threshold shell that ignores weak hits, use Aura. If you need a defensive wrapper that mainly counters on release, use Leaf Shield.
- Keep the chip metaphor anchored to a real operating move; do not let flavor substitute for procedure.

## Verification

- Check that the response includes every promised deliverable and leaves an inspectable audit trail.
- Check that confirmed facts, assumptions, and proposed follow-up are visibly separated.
- Confirm Hermes names a real defended surface and does not present Curse Shield as a free-floating punishment mechanic.
- Confirm the consequence persists after contact as a mark, restriction, audit burden, or trust change rather than collapsing into a one-time counterattack.
- Confirm the curse is operationally specific: who carries it, what it changes, how long it lasts, and how it is removed.
- Check which parts are concrete actions versus framing, so the operator can tell what is real now.

## Example Invocation
```text
Use Curse Shield on this sensitive workflow boundary: protect it now, and make any hostile touch leave a review mark and temporary trust penalty that follows the offender into later requests.
Use Curse Shield here so repeated tampering with this interface does not just bounce off once; I want the toucher tagged, throttled, and easier to isolate for the next few interactions.
```