freeze

Block Edit and Write operations outside a user-specified directory.

Updated May 22, 2026
One-click install
npx skills add https://github.com/shekerkamma/peopletech-marketplace --skill freeze-shekerkamma
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: freeze
Source: https://github.com/shekerkamma/peopletech-marketplace/tree/main/plugins/gstack/freeze
Command: npx skills add https://github.com/shekerkamma/peopletech-marketplace --skill freeze-shekerkamma

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

When working on a specific module or debugging code, it is easy to accidentally edit files outside your intended scope, leading to unintended side effects and broken functionality that requires time-consuming fixes.

Core Features & Use Cases

  • Session-Scoped Edit Restriction: Blocks all Edit and Write operations outside a user-specified directory for the entire session.
  • Accidental Change Prevention: Ideal for debugging, single-module refactoring, or any workflow where changes must be limited to a defined boundary.
  • Easy Boundary Management: Users can set or update the allowed directory at any time, or remove the restriction entirely to resume normal editing.

Quick Start

Use the freeze skill to lock all file edits to your specified project directory for the current session to avoid accidental changes to unrelated code.

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 code debugging?

To restrict file edits to a specific directory during code debugging, you can apply session-scoped edit restrictions that block all Edit and Write operations outside your allowed path. This prevents accidental modifications to unrelated files.

Can I lock a codebase boundary to prevent accidental out-of-scope changes?

Yes, you can lock a codebase boundary by setting a user-specified directory restriction that blocks out-of-scope changes. This prevents accidental modification of files outside the allowed directory throughout your development session.

Does session-scoped edit restriction work for single-module refactoring?

Session-scoped edit restriction works effectively for single-module refactoring by blocking all Edit and Write operations outside a user-specified directory. It ensures changes remain limited to your defined codebase boundary.

How do I update or remove directory boundaries after locking file edits?

You can update or remove directory boundaries after locking file edits by adjusting the allowed directory at any time. Removing the restriction entirely resumes normal editing capabilities across your entire project.

What is the best way to prevent accidental file modification outside a project directory?

The best way to prevent accidental file modification outside a project directory is to use pre-execution hook validation that blocks Edit and Write tool operations targeting paths outside the allowed boundary, maintaining persistent state for the session.

Why should I use directory boundaries when debugging code?

You should use directory boundaries when debugging code because it is easy to accidentally edit files outside your intended scope, leading to unintended side effects and broken functionality that requires time-consuming fixes.