freeze

Restrict Edit and Write operations to a specified directory during a session.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) components.

What problem does it solve?

This Skill helps you restrict file edits to a specific directory for the session, preventing accidental changes to unrelated code or files outside the targeted module.

Core Features & Use Cases

  • Edit Restriction: Blocks any Edit or Write operation targeting a file outside the allowed path.
  • Session Boundary: The restriction persists for the session and can be adjusted or removed as needed.
  • Use Case: Ideal for debugging to prevent accidental fixes in unrelated code or when you want to limit changes to a single module.

Quick Start

Run /freeze and specify the directory to restrict edits to. For example: /freeze /path/to/directory.

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?

To restrict file edits to a specific directory, you can use a directory lock mechanism that blocks any Edit or Write operations targeting files outside the allowed path. This ensures changes are confined to the designated directory for the entire session.

What is a session boundary for file edit restriction and when do I need it?

A session boundary for file edit restriction is a persistent lock that prevents modifications outside a specified directory during a coding session. You need it when debugging or doing module-specific development to prevent accidental changes to unrelated code.

How do I set up a directory lock to prevent accidental changes to unrelated files?

You set up a directory lock by running a command with the target directory path, which establishes a session boundary through Bash script execution and state management. This confines all subsequent Edit and Write operations to that specific directory.

Can I adjust or remove the edit restriction after setting the directory lock?

Yes, the directory lock restriction persists for the session and can be adjusted or removed as needed. The state management mechanism allows you to change the allowed path or lift the restriction entirely once your debugging or development task is complete.

Does file edit restriction work with Bash scripts for module-specific development?

Yes, file edit restriction requires Bash script execution and state management to enforce the session boundary. It works by blocking any Edit or Write operation targeting a file outside the allowed path, making it ideal for module-specific development.

Why should I limit changes to a single module when debugging?

Limiting changes to a single module when debugging prevents accidental fixes or modifications in unrelated code. By establishing a directory lock, you ensure all edits remain within the targeted module's path, keeping your debugging scope controlled and isolated.