/operational-anchor-preservation

name: operational-anchor-preservation
description: >
  Use before you shorten, compress, or rewrite the BODY of an existing SKILL.md
  or agent .md — the moment you are about to cut text to reduce length. First
  inventory the file's operational anchors (exact code / command / API snippets,
  fail-closed workflow guards, and rule / threshold statements), preserve every
  one, then judge the rewrite by expected downstream task cost (exploration,
  debugging, recovery tokens) rather than by the resulting line count. A shorter
  skill that strips an anchor makes the agent MORE expensive per task, so length
  is never the objective and rewrite is not compression. Backed by Preserving
  Operational Anchors When Compressing Agent Instructions (arxiv 2606.09421v2).
  Triggers on shortening or refactoring a skill or agent body.
description-frequency: on-demand
user-invocable: true
version: 1.0.0
format: 2025-10-02
triggers:
  - "shorten or compress this SKILL.md"
  - "rewrite an agent body to reduce length"
  - "refactor a skill without losing what makes it work"
updated: 2026-07-18
status: ACTIVE
source: arxiv 2606.09421v2 (Preserving Operational Anchors When Compressing Agent Instructions)

Operational Anchor Preservation

When you rewrite, compress, or shorten the body of an existing SKILL.md or agent `.md`, first find its **operational anchors** — the exact fragments the agent executes against — preserve every one, and score the rewrite by expected task cost, not by line count. This is a heuristic lens, not a deterministic gate: there is no universally best compression, so the objective is a body the downstream agent can act on cheaply, not a shorter file.

Why

In this self-modifying system a skill body is not documentation — it is the procedure the agent loads and follows. `skill-forge` edits these bodies, `skill-integration` proposes new ones from repeated tool sequences, and `token-budget` pressure during convoy work is a standing reason to trim them. The failure mode: a rewrite that drops an exact command, a fail-closed guard, or a numeric branch reads as a clean 40% cut but forces the next agent to re-grep a path, re-derive a flag, or trip a chokepoint to rediscover a rule it deleted. Those re-exploration and recovery tokens dwarf the tokens saved. Length went down; cost per task went up. That is a lossy edit wearing the mask of cleanup.

Data classes touched

Skill and agent files (`project-claude/skills/**`, `.claude/skills/**`, `.claude/agents/*.md`) — **project-internal**. A sub-class is safety-critical: a body may encode `security-hygiene` guards, `ProcessContext`/`LoaderContext` chokepoint requirements, or a boundary sentence that references a **never-surface** record (private origins, Fox Companies IP, credentials, Center Camp trust rules). Boundary rule: never strip a safety-critical guard or a never-surface boundary statement to save length, and never let removed text leak a protected value into the commit message, diff comment, or the rewrite itself. Rewrites of a safety-critical body escalate (below), they do not auto-apply.

How

1. **Confirm scope.** This fires only when the intent is to *reduce* the body of an existing skill/agent. Frontmatter-only change → hand to `skill-frontmatter-doctor` and stop. Expanding or authoring new content → no anchors are at removal risk, stop. Sanitizing a STRANGER untrusted file → that is `skill-injection-guardian`'s static pass, not a cost-aware rewrite.

2. **Inventory anchors from the CURRENT body, before editing.** Tag every fragment in three classes:

• **Code/API** — anything inside a fenced block; inline-backticked commands;

file paths (contain `/` or a dot-extension); tool/function names; ALL_CAPS env vars; CLI flags. Preserve **character-exact**.

• **Guard** — any sentence carrying MUST / NEVER / fail closed / escalate /

do-not-auto / chokepoint / HITL / never-surface / boundary. Preserve as an enforceable imperative at **equal modal strength**.

• **Rule/threshold** — any number, if/then conditional, decision branch,

invariant, or formula. Preserve the **number and the branch structure**.

3. **Rewrite may reflow prose, not anchors.** Collapse redundant narration, merge examples, cut restatement — but each inventoried anchor must reappear with equal force. If a rewrite would drop or soften one, that is a behaviour change, not compression: restore it or go to escalation.

4. **Score by expected task cost.** Ask: would removing this fragment force the agent into ≥1 extra exploratory tool call (re-grep a path, re-derive a command, trip a guard to relearn it, replan a recovery)? If yes, it is an anchor — keep it, whatever it costs in lines. Accept the rewrite only when the full inventory survives AND expected task cost is non-increasing. Line reduction is a side effect of that, never its acceptance criterion.

Robustness rule

Judge by **effect, not surface phrasing**. A rewrite that keeps the words but turns "MUST escalate on conflict" into "consider escalating" has destroyed a guard anchor even though the diff looks small. Conversely, a terser sentence that preserves the enforceable effect and the exact command is a valid cut. Do not score by diff size or word overlap — score by whether the agent can still do the task without rediscovering what you removed.

Confidence / failure model

This wraps an LLM **judgment** — "is this fragment load-bearing?" and "does this raise task cost?" are semi-decidable, not a deterministic check, and it reduces rather than eliminates the risk of silently degrading a skill. Fail-closed default: when uncertain whether a fragment is an anchor, **treat it as one and keep it** — a retained non-anchor costs a few tokens; a dropped anchor costs the next agent a debugging loop. For any rewrite touching shared repo state (a skill two convoy branches both edited — `refinery-merge` never auto-resolves that, neither