🔐 Permission System

The Permission System enforces mode-specific operational boundaries, preventing accidental modifications and ensuring safe AI assistance throughout your development workflow.

🎯 Why Permissions Matter

Without permission control, AI might:

• 🚫 Write code during research
• 🚫 Modify plans while executing
• 🚫 Delete files unexpectedly
• 🚫 Search web during focused coding

The permission system creates operational safety through mode-based restrictions.

🔑 CRUD Permission Model

Permission Matrix (ℙ)

ℙ = {C: create, R: read, U: update, D: delete}

Each mode has specific CRUD permissions:

Mode	Symbol	Create	Read	Update	Delete
Research	Ω₁	✗	✓	✗	✗
Innovate	Ω₂	~	✓	✗	✗
Plan	Ω₃	✓	✓	~	✗
Execute	Ω₄	✓	✓	✓	~
Review	Ω₅	✗	✓	✗	✗

Legend:

• ✓ = Allowed
• ✗ = Forbidden
• ~ = Conditional/Limited

📊 Mode Permissions Breakdown

🔍 Research Mode (Ω₁)

ℙ(Ω₁) = {R: ✓, C: ✗, U: ✗, D: ✗}

Can Do:

• Read all files
• Analyze code structure
• Search documentation
• Review git history
• Access databases (read-only)

Cannot Do:

• Create any files
• Modify existing code
• Delete anything
• Write to databases

Example Allowed Operations:

// ✓ Allowed
const data = await readFile('config.json');
const users = await db.select('*').from('users');

// ✗ Forbidden  
await writeFile('output.txt', data);
await db.insert({name: 'John'}).into('users');

💡 Innovate Mode (Ω₂)

ℙ(Ω₂) = {R: ✓, C: ~, U: ✗, D: ✗}

Can Do:

• Read everything
• Create conceptual designs
• Suggest theoretical approaches
• Draft pseudo-code

Cannot Do:

• Create actual files
• Modify any code
• Delete anything
• Implement ideas

Conditional Creation (~):

// ✓ Allowed: Conceptual creation
"We could create a service like:
class AuthService {
  validateUser() { }
  generateToken() { }
}"

// ✗ Forbidden: Actual file creation
await writeFile('auth.service.js', serviceCode);

📝 Plan Mode (Ω₃)

ℙ(Ω₃) = {R: ✓, C: ✓, U: ~, D: ✗}

Can Do:

• Read everything
• Create specifications
• Create plan documents
• Update planning files only
• Design architectures

Cannot Do:

• Update production code
• Delete anything
• Execute plans

Conditional Updates (~):

// ✓ Allowed: Update plan documents
await updateFile('architecture.md', newDesign);
await updateFile('plan-checklist.md', tasks);

// ✗ Forbidden: Update code
await updateFile('src/app.js', newCode);

⚙️ Execute Mode (Ω₄)

ℙ(Ω₄) = {R: ✓, C: ✓, U: ✓, D: ~}

Can Do:

• All file operations
• Create new code
• Modify existing code
• Limited deletion
• Database writes

Cannot Do:

• Search web (focus!)
• Deviate from plan
• Mass deletion

Conditional Deletion (~):

// ✓ Allowed: Targeted deletion
await deleteFile('temp-file.js');
await db.delete().from('sessions').where('expired', true);

// ✗ Forbidden: Mass deletion
await deleteDirectory('src/');
await db.delete().from('users'); // No WHERE clause

🔎 Review Mode (Ω₅)

ℙ(Ω₅) = {R: ✓, C: ✗, U: ✗, D: ✗}

Can Do:

• Read all files
• Analyze changes
• Run tests (read-only)
• Generate reports
• Compare versions

Cannot Do:

• Modify anything
• Fix issues found
• Create new files
• Delete anything

Example Operations:

// ✓ Allowed
const testResults = await runTests();
const coverage = await analyzeCoverage();
const diff = await gitDiff('main', 'feature');

// ✗ Forbidden
await fixBug(issue);
await updateTestCase(test);

🔄 Operation Categories

𝕆ᵣₑₐₗ - Real Operations

Physical changes to the system:

𝕆ᵣₑₐₗ = {
  modify_files,
  write_code, 
  delete_content,
  refactor,
  create_files,
  update_database
}

𝕆ᵥᵢᵣₜᵤₐₗ - Virtual Operations

Conceptual work without changes:

𝕆ᵥᵢᵣₜᵤₐₗ = {
  suggest_ideas,
  explore_concepts,
  evaluate_approaches,
  design_architecture,
  plan_implementation
}

𝕆ₒᵦₛₑᵣᵥₑ - Observation Operations

Read-only analysis:

𝕆ₒᵦₛₑᵣᵥₑ = {
  read_files,
  analyze_content,
  identify_patterns,
  review_code,
  check_status
}

🛡️ Permission Enforcement

Mode Operation Sets

𝕊(Ω₁) = {𝕆ₒᵦₛₑᵣᵥₑ: ✓, 𝕆ᵥᵢᵣₜᵤₐₗ: ~, 𝕆ᵣₑₐₗ: ✗}
𝕊(Ω₂) = {𝕆ₒᵦₛₑᵣᵥₑ: ✓, 𝕆ᵥᵢᵣₜᵤₐₗ: ✓, 𝕆ᵣₑₐₗ: ✗}
𝕊(Ω₃) = {𝕆ₒᵦₛₑᵣᵥₑ: ✓, 𝕆ᵥᵢᵣₜᵤₐₗ: ✓, 𝕆ᵣₑₐₗ: ~}
𝕊(Ω₄) = {𝕆ₒᵦₛₑᵣᵥₑ: ✓, 𝕆ᵥᵢᵣₜᵤₐₗ: ~, 𝕆ᵣₑₐₗ: ✓}
𝕊(Ω₅) = {𝕆ₒᵦₛₑᵣᵥₑ: ✓, 𝕆ᵥᵢᵣₜᵤₐₗ: ~, 𝕆ᵣₑₐₗ: ✗}

Permission Check Function

Ξ(op, Ω) = op ∈ 𝕊(Ω) ? allow(op) : 𝕍(op, Ω)

Translation: "If operation is permitted in current mode, allow it; otherwise, trigger violation handler."

⚠️ Violation Handling

Violation Detection

𝕍(op, Ω) = {
  log_violation(op, Ω),
  create_backup(),
  revert_to_safe_mode(),
  notify_violation(op, Ω)
}

Violation Severity Levels

CRITICAL Violations

Operations that could cause data loss:

- Delete in RESEARCH mode
- Mass updates in REVIEW mode
- Database drops in any mode

HIGH Violations

Operations that break mode discipline:

- Writing code in PLAN mode
- Modifying plans in EXECUTE mode
- Creating files in RESEARCH mode

MEDIUM Violations

Conceptual boundary crossing:

- Implementing in INNOVATE mode
- Searching web in EXECUTE mode
- Fixing bugs in REVIEW mode

LOW Violations

Minor infractions:

- Suggesting code in RESEARCH mode
- Planning details in INNOVATE mode

Violation Response

⚠️ PERMISSION VIOLATION DETECTED
━━━━━━━━━━━━━━━━━━━━━━━━━━━
Operation: write_code
Current Mode: RESEARCH (Ω₁)
Severity: HIGH

Action Taken:
✅ Backup created
🔄 Switched to safe mode (PLAN)
📝 Violation logged

Suggestion:
To write code, switch to EXECUTE mode:
/execute

🔐 Permission Commands

Check Permissions

Command	Description	Example Output
!ckp	Current mode permissions	"EXECUTE: Create ✓, Read ✓, Update ✓, Delete ~"
!pm write_code	Check specific operation	"❌ Not permitted in RESEARCH mode"
!sp plan	Show mode permissions	"PLAN: C:✓ R:✓ U:~ D:✗"
!vm delete_file	Suggest appropriate mode	"Use EXECUTE mode for deletion"

📊 Permission Matrices

File System Permissions

Mode	Create File	Read File	Update File	Delete File
Research	✗	✓	✗	✗
Innovate	✗	✓	✗	✗
Plan	✓*	✓	✓*	✗
Execute	✓	✓	✓	✓**
Review	✗	✓	✗	✗

*Plan documents only **With confirmation

Database Permissions

Mode	Insert	Select	Update	Delete
Research	✗	✓	✗	✗
Innovate	✗	✓	✗	✗
Plan	✗	✓	✗	✗
Execute	✓	✓	✓	✓*
Review	✗	✓	✗	✗

*With WHERE clause

External Service Permissions

Mode	Web Search	API Calls	Git Operations	Package Install
Research	✓	✓*	✓*	✗
Innovate	✓	✓*	✓*	✗
Plan	✓	✓*	✓*	✓**
Execute	✗	✓	✓	✓
Review	✓	✓*	✓*	✗

*Read-only **In package.json

💡 Permission Strategies

1. Mode-First Thinking

Before any operation, check mode:

Current mode: RESEARCH
Want to: Write code
Action: Switch to EXECUTE first

2. Progressive Permissions

Build up permissions as needed:

Research → Read only
Innovate → Read + Conceptual
Plan → Read + Create specs
Execute → Full permissions
Review → Read only again

3. Permission Boundaries

Respect hard limits:

// In EXECUTE mode
if (operation === 'delete' && !hasWhereClause) {
  throw new PermissionError('Mass deletion forbidden');
}

4. Safe Fallbacks

On violation, revert to safe state:

Current: EXECUTE with error
Fallback: PLAN mode
Action: Re-plan approach

🎯 Common Permission Patterns

Feature Development

RESEARCH: Read existing code (R: ✓)
INNOVATE: Design approach (C: ~)
PLAN: Create specifications (C: ✓)
EXECUTE: Implement feature (C: ✓, U: ✓)
REVIEW: Verify implementation (R: ✓)

Bug Fix Flow

RESEARCH: Read bug reports (R: ✓)
PLAN: Design fix (C: ✓ for plan)
EXECUTE: Apply fix (U: ✓)
REVIEW: Verify fix (R: ✓)

Refactoring Process

RESEARCH: Analyze current code (R: ✓)
INNOVATE: Design new structure (C: ~)
PLAN: Create migration plan (C: ✓)
EXECUTE: Refactor code (U: ✓, D: ~)
REVIEW: Ensure functionality (R: ✓)

🚨 Permission Edge Cases

1. Emergency Fixes

Need immediate fix but in wrong mode:

Solution: Quick mode switch
/execute
// Fix critical bug
/review

2. Exploration During Execution

Need to research while coding:

Solution: Note question, finish current task, then:
/research
// Investigate approach
/execute

3. Plan Changes During Execute

Realize plan needs adjustment:

Solution: Pause execution
/plan
// Update plan
/execute
// Continue with new plan

4. Accidental Violations

Tried forbidden operation:

Response:
- Operation blocked
- Backup created
- Clear guidance provided
- No harm done

🛡️ Permission Safety Features

Automatic Backups

Before risky operations:

if (isDestructive(operation)) {
  createBackup();
  confirmOperation();
}

Transaction Rollback

For database operations:

try {
  await db.transaction(async (trx) => {
    // Permitted operations
  });
} catch (error) {
  // Auto rollback
}

File System Protection

Prevent catastrophic deletions:

const PROTECTED_PATHS = ['/', '/src', '/node_modules'];
if (PROTECTED_PATHS.includes(path)) {
  throw new PermissionError('Cannot delete protected path');
}

📋 Permission Reference Card

Quick Permission Check

Research: Read-only
Innovate: Read + Think
Plan: Read + Design  
Execute: Full access
Review: Read-only

Operation Quick Guide

Want to...	Need Mode
Read code	Any mode
Write code	EXECUTE
Create plan	PLAN
Delete file	EXECUTE
Search web	NOT EXECUTE
Fix bug	EXECUTE
Check quality	REVIEW

🎓 Permission Examples

Example 1: Research Violation

[MODE: RESEARCH]
User: "Create a new authentication service"

Response: ⚠️ Cannot create files in RESEARCH mode
To create files, switch to EXECUTE mode:
/execute

Example 2: Execute Limitation

[MODE: EXECUTE]
User: "Search for best authentication practices"

Response: ⚠️ Web search disabled in EXECUTE mode
Complete current task, then:
/research

Example 3: Conditional Permission

[MODE: PLAN]
User: "Update the architecture diagram"

Response: ✓ Updating architecture.md (planning document)

📚 Related Topics

• RIPER Modes
• Violation Handling
• Permission Commands
• Mode Transitions

---

← Context References | Home | Cross-References →