freeze

Block file edits outside a designated directory for the current session.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/gfires/motion-analysis --skill freeze-gfires
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: freeze
Source: https://github.com/gfires/motion-analysis/tree/main/freeze
Command: npx skills add https://github.com/gfires/motion-analysis --skill freeze-gfires

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Restrict file edits to a specific directory for the session. Blocks Edit and Write outside the allowed path. Use when debugging to prevent accidentally "fixing" unrelated code, or when you want to scope changes to one module. Use when asked to "freeze", "restrict edits", "only edit this folder", or "lock down edits". (gstack)

Core Features & Use Cases

  • Boundary enforcement: Edits outside the frozen directory are blocked during the session.
  • PreToolUse hook checks: A check-freeze.sh script runs before Edit/Write to verify the boundary.
  • Session persistence: The freeze boundary lasts for the current session until reset or end.

Quick Start

Ask the user which directory should be frozen, then set the boundary for the current session.

Frequently Asked Questions about freeze

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I restrict code edits to a specific folder during debugging?

To restrict code edits to a specific folder during debugging, you can freeze a designated directory path to establish a session boundary. This blocks any Edit or Write operations outside that scoped module to prevent unintended changes.

Can I lock down file modifications to a single module for my current session?

Yes, you can lock down file modifications to a single module for your current session. By setting a designated directory path, the boundary persists and uses a PreToolUse hook to enforce the edit restriction rule.

How does a PreToolUse hook enforce edit boundaries for scoped code changes?

A PreToolUse hook enforces edit boundaries by running a check script before any Edit or Write tool executes. This script verifies whether the target file falls inside the frozen directory and blocks the operation if it falls outside.

What is the best way to prevent accidentally editing unrelated code when debugging?

The best way to prevent accidentally editing unrelated code when debugging is to freeze edits to a specific directory. This constrains all modifications to a single module, ensuring changes stay scoped to the designated path.

Does the freeze edit boundary persist across different files during the session?

Yes, the freeze edit boundary persists across different files during the entire session. Once you provide a directory path to set the boundary, the edit restriction remains active until the session ends or you manually reset it.

When should I not use a scoped edit restriction for file modifications?

You should not use a scoped edit restriction when your task requires modifying files across multiple different directories or modules. The freeze creates a strict boundary that blocks all Write and Edit operations outside the single designated folder.