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-02T00:00:00.000Z"
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-18T00:00:00.000Z"
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 do you), sensitive/never-surface memory, or a safety-critical guard, do not auto-apply: surface it via mayor-coordinator escalation for operator review.

When to skip

• Frontmatter-only edit → skill-frontmatter-doctor owns it.
• The edit adds or expands content — nothing is being removed.
• The target is README/docs/prose the agent reads but does not execute — this is scoped to instruction bodies the agent LOADS and follows.
• You are curating footprint, not text: if a skill should shrink because it is net-negative, that is a retire/repair decision for skill-causal-curation, not a lossy rewrite of a skill worth keeping.

Integration

• skill-frontmatter-doctor — frontmatter-only sibling; this covers the body it does not touch.
• skill-causal-curation — the keep/repair/retire layer; if compression keeps failing to preserve anchors, the honest move is retire/repair there, not a smaller lossy body here.
• skill-forge — this runs inside forge's edit step, before validate → critique → ship, so a shipped skill is never quietly hollowed out.
• skill-counterfactual-audit — after a rewrite passes this gate, its paired with/without probe confirms behaviour did not regress.