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.