freeze

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

Updated Apr 1, 2026
One-click install
npx skills add https://github.com/bajajvinamr/little-wins --skill freeze-bajajvinamr
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: freeze
Source: https://github.com/bajajvinamr/little-wins/tree/main/.claude/skills/gstack/freeze
Command: npx skills add https://github.com/bajajvinamr/little-wins --skill freeze-bajajvinamr

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Freeze file edits to a specific directory during a session, preventing edits outside the allowed path and reducing accidental changes.

Core Features & Use Cases

  • Boundary-based edit restriction: blocks Edit and Write operations outside the configured directory while Read and non-editing commands remain unaffected.
  • Safe debugging and scoped changes: enables focused work on a module without touching other code areas.
  • Use Case: when debugging a single module, set a freeze boundary to ensure all edits stay within that module.

Quick Start

Provide a directory path to restrict edits to.

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 an active coding session?

You can restrict file edits to a specific directory by applying a directory lock that blocks Write and Edit operations outside the configured path. This enforcement persists for the session via a PreToolUse hook and boundary-check script.

Can I still read files and run bash commands outside the locked directory boundary?

Yes, the directory lock only constrains Edit and Write operations. Read, Bash, Glob, and Grep commands remain completely unaffected, allowing you to inspect files and run non-editing commands outside the boundary.

How do I prevent accidental changes to other code areas when debugging a single module?

To prevent accidental changes when debugging a single module, set a freeze boundary around that target directory. This ensures all your edits stay strictly within the module's path, reducing accidental modifications to other code areas.

How does a PreToolUse hook enforce scoped changes for safe debugging?

A PreToolUse hook enforces scoped changes by intercepting tool calls before they execute and running a boundary-check script. If an Edit or Write operation targets a path outside the allowed directory, the hook blocks the action for the session.

What is the best way to sandbox edits to a target directory without affecting read access?

The best way to sandbox edits is to establish an edits-boundary that isolates Write and Edit actions to a target directory. This approach secures your modifications while maintaining full read access to the broader file system.

Are there limitations to using a session-based directory lock for scoped changes?

The primary limitation of a session-based directory lock is that the boundary enforcement is temporary and does not persist after the session ends. It also only restricts editing tools, meaning non-editing commands can still execute outside the target directory.