freeze

Restrict file edits to a specified directory during a session.

Updated Mar 31, 2026
One-click install
npx skills add https://github.com/huichen/gstack --skill freeze-huichen
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: freeze
Source: https://github.com/huichen/gstack/tree/main/freeze
Command: npx skills add https://github.com/huichen/gstack --skill freeze-huichen

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It restricts edits to a user-specified directory for the current session, preventing changes outside that boundary and helping you avoid accidental modifications during debugging or scoped work.

Core Features & Use Cases

  • Freeze file edits to a specific directory for the duration of a session.
  • Enforce an explicit boundary on edits, enabling safer, scoped work within a module or feature.
  • Use case: when debugging or coordinating changes, ensure edits stay inside the intended directory.

Quick Start

Specify the directory to freeze and confirm the boundary is enforced by the system.

Frequently Asked Questions about freeze

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

FAQPage Schema
How do I restrict file edits to a specific directory during a coding session?

You can restrict file edits to a specific directory by setting a freeze boundary in a state file, which the system reads to confine changes. This enforces an explicit directory boundary, preventing accidental modifications outside the target module.

What is directory freeze enforcement and how does it work?

Directory freeze enforcement locks edits to a single folder during a session. It works by reading a defined boundary from a state file and applying a PreToolUse hook that actively blocks any edit operations attempted outside that specified directory.

Can I lock code changes to a single module for scope-limited debugging?

Yes, you can lock code changes to a single module for scope-limited debugging. By defining a directory boundary, the system ensures that all edits remain confined within the intended folder, preventing unintended modifications to other parts of the codebase.

What's the best way to prevent accidental modifications outside a target folder?

The best way to prevent accidental modifications outside a target folder is to establish a directory freeze. This creates an explicit boundary enforced by a PreToolUse hook, which blocks edits outside the specified path for the duration of your session.

Does the directory edit restriction work automatically after specifying the folder?

Yes, the directory edit restriction works automatically. Once you specify the directory to freeze, the system reads this boundary from a state file and automatically enforces it via a PreToolUse hook, blocking any subsequent edit attempts outside that folder.

When should I not use a directory freeze for my workflow?

You should not use a directory freeze when your work requires modifying multiple directories or modules simultaneously. It is specifically designed for debugging or scope-limited changes, and will block any edits attempted outside the defined boundary.