freeze

Restrict file edit and write operations to a user-specified directory.

Updated May 27, 2026
One-click install
npx skills add https://github.com/Shmurdoc/EasyRide-v1 --skill freeze-shmurdoc
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: freeze
Source: https://github.com/Shmurdoc/EasyRide-v1/tree/main/.opencode/skills/gstack-freeze
Command: npx skills add https://github.com/Shmurdoc/EasyRide-v1 --skill freeze-shmurdoc

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Accidental edits to unrelated files during debugging or module-specific development can introduce bugs, waste time reverting unwanted changes, and disrupt your workflow. This skill eliminates that risk by locking all file edit and write operations to a directory you specify for the entire session.

Core Features & Use Cases

  • Edit Scope Locking: Blocks all Edit and Write operations targeting files outside the user-defined allowed directory, with no warnings for out-of-scope edits.
  • Debugging Safety: Perfect for debugging sessions where you want to focus changes on a single module without accidentally modifying unrelated code.
  • Scoped Development Workflows: Use it when a user requests to "only edit this folder" or "restrict changes to the src/utils directory" to ensure all edits stay within the required boundary.

Quick Start

Use the freeze skill to lock all file edits to your current working project module directory for the duration of this debugging 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 a debugging session?

You can restrict file edits to a specific directory by applying a session-wide edit scope lock that enforces path boundary checks on all write and edit operations, blocking any modifications targeting files outside the allowed folder.

What is write blocking for scoped development workflows?

Write blocking for scoped development is a mechanism that prevents accidental code modifications by intercepting edit and write tool inputs, ensuring operations only execute if the target path resides within a user-specified project folder.

How do I stop accidental changes to unrelated code outside my current module?

To stop accidental changes to unrelated code, you lock edits to your current working module directory, which blocks all out-of-scope write operations silently for the entire duration of your development session.

Can I lock edit operations to the src/utils directory for my entire session?

Yes, you can lock edit operations to the src/utils directory by setting it as your allowed scope, which enforces path boundary checks on all edit and write tool inputs throughout the active session.

Does the edit scope lock provide warnings for out-of-scope file modifications?

No, the edit scope lock blocks all edit and write operations targeting files outside the user-defined allowed directory silently, providing no warnings for out-of-scope edits to ensure strict debugging safety.

When should I use directory lock restrictions for code editing?

You should use directory lock restrictions during debugging sessions or module-specific development workflows when you need to focus changes on a single project folder and prevent any accidental modifications to unrelated code paths.