freeze

Block Edit and Write operations outside a specified directory per session.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/JonOlsenCa/gstack-main --skill freeze-jonolsenca
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: freeze
Source: https://github.com/JonOlsenCa/gstack-main/tree/main/freeze
Command: npx skills add https://github.com/JonOlsenCa/gstack-main --skill freeze-jonolsenca

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Restricting edits to a user-specified directory during a session prevents accidental or scope-busting changes, aiding debugging and focused development.

Core Features & Use Cases

  • Enforces a per-session boundary so Edit and Write operations outside the allowed path are blocked.
  • Enables safe, scoped changes to a single module or folder, reducing drift during debugging and reviews.
  • Use Case: while debugging a feature, set the boundary to the target module to ensure all edits remain within that area.

Quick Start

Ask the user which directory should be frozen, then apply the boundary with /freeze.

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 development session?

To restrict file edits to a directory, you can set a per-session boundary that blocks Edit and Write operations outside the specified path, preventing unintended changes during scoped development or debugging.

Can I lock edits to a single module while debugging to avoid scope drift?

Locking edits to a single module while debugging prevents scope drift by enforcing a boundary that blocks all Write and Edit operations outside the target folder, ensuring changes remain localized.

How do I block accidental file modifications outside a project folder?

Blocking accidental modifications outside a project folder requires setting a session boundary that intercepts and denies Edit and Write operations outside the allowed directory while logging the denial events.

How does a directory boundary work to prevent unintended code changes?

A directory boundary prevents unintended code changes by persisting a freeze path for the session, actively intercepting edit operations, and blocking any attempts to write files outside that defined scope.

What is the best way to enforce scoped changes to a single folder during code reviews?

The best way to enforce scoped changes during reviews is applying a per-session freeze boundary that automatically blocks any edits outside the designated folder, reducing drift and keeping modifications focused.

Do I need to specify a freeze path each time I want to block edits outside a directory?

Specifying a freeze path persists the boundary for the entire session, so you only need to set it once to continuously block edits and writes outside that directory until the session concludes.