freeze

Restrict Edit and Write operations to a user-specified directory via a PreToolUse hook.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Edits and writes can escape the intended scope, causing unintended changes; this skill constrains edits to a user-specified directory to prevent drift or mistakes.

Core Features & Use Cases

  • Restrict edits to a chosen directory during a session.
  • Persist boundary across actions until session ends.
  • Safeguard critical code areas while debugging.

Quick Start

Provide a directory path to freeze edits to, then activate the freeze 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 file edits to a specific directory during a coding session?

Restricting file edits to a specific directory involves setting a persistent boundary that blocks Edit and Write operations outside that path. This prevents unintended changes by enforcing the rule via a PreToolUse hook for the current session.

What's the best way to prevent accidental file modifications outside my project scope?

Preventing accidental file modifications outside your project scope requires locking edits to a chosen directory. By resolving a user-specified path to an absolute directory, a boundary file persists across actions to block any out-of-scope operations.

How does a PreToolUse hook enforce a directory boundary for writes?

A PreToolUse hook enforces a directory boundary by intercepting Edit and Write operations before execution. It checks the target path against a persistent boundary file and blocks any operation attempting to modify files outside the resolved absolute directory.

Can I safeguard critical code areas while debugging without modifying dependencies?

Safeguarding critical code areas while debugging is possible without dependencies by activating a session boundary. You provide a directory path to freeze edits to, and the boundary restricts all writes to that specific scope until the session ends.

Does the edit boundary persist across multiple actions in the same session?

The edit boundary persists across multiple actions in the same session by using a persistent boundary file. Once activated, it continuously restricts Edit and Write operations to the specified directory until the current session explicitly ends.

When should I lock writes to a single directory to prevent scope drift?

Locking writes to a single directory to prevent scope drift is necessary when edits might escape intended boundaries and cause unintended changes. Constraining operations to a user-specified directory safeguards against mistakes during sensitive debugging or refactoring tasks.