Scope Agent Skill

Scope — Review a proposed write scope

Review the write scope in the existing bead or caller intent. This skill is

advisory: it does not create a second planning artifact, write a lock, install

a hook, block an edit, or claim paths.

Inputs

• One active behavior and its acceptance scenarios.
• Proposed include and exclude patterns.
• Known generated companions and fixture/projection paths.
• Explicit non-goals.

Procedure

• Map each acceptance criterion to the smallest source paths that may change.
• Add owned generated companions that must move with those sources.
• Check whether any include/exclude patterns overlap or are too broad to prove.
• Identify likely paths the proposal omitted.
• Return a corrected proposal and the reasons for each change, then stop.

The caller decides whether to adopt the proposal in the original intent source,

and Validate independently compares runtime-derived changed paths with that scope.

Axiom-kernel framing

Derive the scope from axioms, not enumeration instinct. State the small set of

facts the acceptance makes true — "behavior X lives in root A", "projection B

is generated from A", "history under C is frozen" — and derive every include

and exclude pattern from exactly one axiom. A pattern with no supporting axiom

is unjustified breadth; an axiom with no pattern is a gap. Both go in the

review output. Scopes assembled by listing directories that feel related are

the vibes perimeter failure mode: they cannot be defended when Validate

finds a path on the boundary, because nobody can say why the line is where it

is. Stop condition: the review is complete when the axiom-to-pattern mapping

has no unmapped members on either side.

Byte-verified recovery ceremony

When the review finds that protected paths were already touched — or the

caller asks how a scope violation should be unwound — the advisory answer is a

ceremony, not a hand-wave: identify the known-good source for each affected

path (committed state, snapshot, or generated-from-source), restore, then

verify byte-for-byte that restored content matches the known-good bytes

(content hash comparison, not visual diff or "looks right"). Recovery declared

on inspection alone is the eyeballed restore failure mode: a file that

looks restored can still differ in bytes that matter. The ceremony's stop

condition is a hash match for every affected path; any path with no

known-good source to verify against is reported as unrecoverable-as-scoped,

and the caller decides.

Output

write_scope:
  include: ["bounded/source/**"]
  exclude: ["bounded/source/generated-by-other-owner/**"]
generated_companions: ["bounded/generated/**"]
gaps: []
ambiguities: []

Checks

• Patterns are normalized repository-relative paths.
• Includes cover the behavior without granting unrelated directories.
• Excludes do not contradict required changes.
• Generated companions are explicit.
• No ownership, scheduling, Git, hook, retry, release, or delivery state is

introduced.

Failure behavior

If the scope cannot be made unambiguous from the supplied acceptance, report

the missing facts and stop. The caller may revise the intent in a new action.