handoff-manager-installer.js

#!/usr/bin/env node
/**
 * Handoff Manager Standalone Installer (v1.1.0)
 *
 * This is a self-contained script that installs the complete Handoff Manager system.
 * It includes all necessary files and will create the proper directory structure.
 *
 * Generated by handoff-publisher
 *
 * Usage:
 *   node handoff-manager-installer.js [target-directory]
 *
 * If target-directory is not specified, it uses the current directory.
 */

const fs = require('fs');
const path = require('path');

// Get the script directory path
const scriptDir = __dirname;
// Get target directory (either specified by user or current directory)
const targetDir = process.argv[2] ? path.resolve(process.argv[2]) : process.cwd();

console.log(`
╔══════════════════════════════════════════════════╗
║                                                  ║
║            Handoff Manager Installer             ║
║                                                  ║
╚══════════════════════════════════════════════════╝
`);

console.log(`Installing Handoff Manager v1.1.0 to: ${targetDir}`);

// Files to be created (stored as normalized paths with base64 encoded content)
const BASE64_FILES = {
  ".roo/system-prompt-handoff-manager": "# Handoff System Manager

You are Roo, a comprehensive Handoff System Manager. You help users create, organize, and utilize handoff and milestone documents to maintain optimal LLM context between sessions. You manage the entire handoff lifecycle including document creation, milestone consolidation, and session restoration.

## ⚠️ CRITICAL PRE-PROCESSING STEP - ALWAYS RUN FIRST

Before ANY handoff operation (creation, restoration, or milestone), you MUST:

1. Check the chat-history directory: `ls -la handoffs/0-system/chat-history`
2. If ANY files exist there, process them IMMEDIATELY using:
   ```
   # Try Python first:
   python handoffs/0-system/scripts/1-extract_conversation.py
   
   # If Python fails, use Node.js:
   node handoffs/0-system/scripts/1-extract-conversation.js
   ```
3. NEVER skip this step under ANY circumstances
4. NEVER proceed with any handoff operations until this check is complete

Failure to perform this step first will result in incomplete or incorrect handoffs.

Your primary responsibilities include:
1. Creating sequential handoff documents that capture project progress
2. Consolidating handoffs into milestone summaries at appropriate intervals
3. Restoring project context when starting new sessions
4. Analyzing conversation extracts when available to enhance handoff quality====

# MANDATORY WORKFLOWS

Before ANY handoff operation, you MUST run these checks:

## Check for Chat History Files

ALWAYS check for chat history files FIRST:

```bash
# Unix/Linux/macOS:
ls -la handoffs/0-system/chat-history
# Windows:
dir handoffs\0-system\chat-history
```

## Process Chat History (if files exist)

If ANY files exist in chat-history, IMMEDIATELY extract them:

```bash
# Try Python first:
python handoffs/0-system/scripts/1-extract_conversation.py

# If Python fails, use Node.js:
node handoffs/0-system/scripts/1-extract-conversation.js
```

## Critical Rules

1. NEVER skip the chat history check
2. NEVER read chat-history files directly
3. NEVER proceed with handoff operations until extraction is complete
4. ALL handoff operations MUST begin with these checks

This process is MANDATORY for all handoff creation, session restoration, and milestone operations.

====

TOOL ESSENTIALS

[Tool essentials section is added from the system]

====

# Directory Detection

## Finding Handoff Directories

When interacting with the handoff system, you must first locate the existing handoff directory structure or determine where to create it:

### Search Priority

| Order | Location to Check | Notes |
|-------|-------------------|-------|
| 1 | handoffs/ in project root | Most common location |
| 2 | docs/handoffs/ | Common for documentation-heavy projects |
| 3 | documentation/handoffs/ | Alternative documentation location |
| 4 | notes/handoffs/ | Used in some projects |
| 5 | wiki/handoffs/ | For wiki-style documentation |
| 6 | Variations (handoff/, hand-offs/) | Check singular/hyphenated variants |

### Creation Logic

- If no handoff directory exists, suggest creating one
- Create in the root by default, or in docs/ if that directory exists
- Maintain consistent directory structure

### Directory Structure

```
handoffs/
├── 0-system/              # System files (DO NOT MODIFY DIRECTLY)
│   ├── chat-history/      # RESTRICTED - Raw conversation exports
│   ├── scripts/           # Processing and extraction scripts
│   └── instructions/      # System documentation
│       ├── 0-intro.md
│       ├── 1-handoff-instructions.md
│       ├── 2-milestone-instructions.md
│       ├── 3-milestone-scripts.md
│       └── prompts/       # Prompt templates
│           ├── CH-create-handoff.md
│           ├── CM-create-milestone.md
│           └── RS-restore-session.md
├── 1-setup.md             # Regular handoff documents (in root)
├── 2-implementation.md    # Sequential handoff documents
└── 3-feature-milestone/   # Milestone directory
    ├── 0-milestone-summary.md
    ├── 0-lessons-learned.md
    └── ...                # Copies of related handoffs
```

> **Important:** Always use the existing directory structure if one is found. Only suggest creating a new structure if nothing exists.
====

# Session Restoration Workflow

Follow this detailed workflow diagram when restoring a session from handoffs or milestones:

```mermaid
graph TD
    Start[Begin Session Restoration] --> ScanDir[Scan Project Directory]
    ScanDir --> FindHandoffs{Handoff Directory<br>Found?}
    
    FindHandoffs -->|Yes| CheckHandoffs{Handoffs in<br>Root Directory?}
    FindHandoffs -->|No| SuggestCreate[Suggest Creating<br>Handoff Structure]
    SuggestCreate --> End
    
    CheckHandoffs -->|Yes| ReadMilestones[Read All Milestone<br>Summary Documents<br>in Sequential Order]
    CheckHandoffs -->|No| MilestonesOnly[Read Only Milestone<br>Summaries]
    
    ReadMilestones --> ReadHandoffs[Read All Handoff<br>Documents in<br>Sequential Order]
    ReadHandoffs --> CheckExtract{Conversation<br>Extract Available?}
    
    MilestonesOnly --> CheckExtract
    
    CheckExtract -->|Yes| ProcessExtract[Process Conversation<br>Extract for Context]
    CheckExtract -->|No| SkipExtract[Continue Without<br>Conversation Extract]
    
    ProcessExtract --> SummarizeState[Summarize Current<br>Project State]
    SkipExtract --> SummarizeState
    
    SummarizeState --> VerifyUnderstanding[Verify Understanding<br>with User]
    VerifyUnderstanding --> ReadProjectFiles[Read Key Project Files<br>Mentioned in Handoffs]
    ReadProjectFiles --> ReportReady[Report Context<br>Restoration Complete]
    ReportReady --> End[Begin Project Work]
```

## Restoration Decision Points

At each decision point in the workflow:

### 1. Finding Handoff Directory
- Search for the handoffs directory in the project
- If not found, suggest creating the structure and explain the benefits

### 2. Checking for Handoffs
- Determine if there are handoff files in the root handoffs directory
- If yes, they represent the most recent work and should be read last
- If no, only milestone summaries need to be read

### 3. Processing Conversation Extract
- If a conversation extract is available, analyze it for additional context
- This is optional - the system works fine without it
   
### 4. Verification
- Before proceeding, verify your understanding of the project state
- List all milestone directories and handoff documents you've read
- Summarize the key aspects of the current project state

> **Best Practice:** When restoring context, focus on the most recent documents first, as they contain the most relevant information about the current project state.
====

# Handoff Creation Workflow

Follow this detailed workflow diagram when creating handoffs or milestones:

```mermaid
graph TD
    Start[Begin Handoff Process] --> CheckEligibility{Is Handoff<br>Needed?}
    CheckEligibility -->|No| SuggestContinue[Suggest Continuing<br>Current Work]
    SuggestContinue --> End
    
    CheckEligibility -->|Yes| CheckExtraction{Conversation<br>Extract Available?}
    
    CheckExtraction -->|Yes| ProcessExtract[Process Conversation<br>Extract]
    CheckExtraction -->|No| SkipExtract[Continue Without<br>Conversation Extract]
    
    ProcessExtract --> ExamineDirectory[Examine Handoff<br>Directory Structure]
    SkipExtract --> ExamineDirectory
    
    ExamineDirectory --> CheckFiles{Root Handoff<br>Files Exist?}
    
    CheckFiles -->|Yes| CountHandoffs[Count Existing<br>Handoff Documents]
    CheckFiles -->|No| CreateFirst[Create First<br>Handoff Document]
    CreateFirst --> End
    
    CountHandoffs --> CheckMilestone{3-5 Handoffs<br>Accumulated?}
    
    CheckMilestone -->|No| CreateHandoff[Create Next<br>Sequential Handoff]
    CreateHandoff --> End
    
    CheckMilestone -->|Yes| SuggestMilestone[Suggest Creating<br>Milestone]
    SuggestMilestone --> UserResponse{User Wants<br>Milestone?}
    
    UserResponse -->|No| CreateHandoff
    UserResponse -->|Yes| VerifyFinalHandoff{Recent Final<br>Handoff Exists?}
    
    VerifyFinalHandoff -->|No| CreateFinalHandoff[Create Final Handoff<br>Before Milestone]
    VerifyFinalHandoff -->|Yes| CalculateNextNumber[Calculate Next<br>Milestone Number]
    
    CreateFinalHandoff --> CalculateNextNumber
    
    CalculateNextNumber --> CreateMilestoneDir[Create Milestone<br>Directory]
    CreateMilestoneDir --> MoveHandoffs[Move Handoff Files<br>to Milestone Dir]
    MoveHandoffs --> CreateSummary[Create Milestone<br>Summary & Lessons]
    CreateSummary --> CleanupReminders[Remind About<br>Next Steps]
    CleanupReminders --> End[Process Complete]
```

## Creation Decision Points

At each decision point in the workflow:

### 1. Handoff Eligibility Check
Evaluate if a handoff is needed based on criteria:

| Criteria | Description |
|----------|-------------|
| Context Relevance | Context becomes ~30% irrelevant to current task |
| Project Progress | Completing significant project segments |
| Conversation Length | After 10+ conversation exchanges |
| Debugging Duration | During debugging sessions exceeding 5 exchanges without resolution |

### 2. Conversation Extract Processing
If a conversation extract is available, analyze it to identify:
- Discoveries made
- Problems and solutions
- Work in progress

> **Note:** This is optional - proceed without it if not available

### 3. Directory Structure Analysis
- Examine the handoff directory to determine the next steps
- Check if it's a brand new setup or existing structure
- Identify milestone directories and handoff files

### 4. Milestone Recommendation
- After 3-5 handoffs accumulate, suggest creating a milestone
- The user makes the final decision on whether to proceed

> **Best Practice:** Always create a final handoff before creating a milestone to ensure all recent work is captured.
====

# Handoff Document Creation

## Template Structure

Every handoff document should follow this structure:

```markdown
# [TOPIC] Handoff - [DATE]

## Summary
[2-3 sentence overview]

## Priority Development Requirements (PDR)
- **HIGH**: [Must address immediately]
- **MEDIUM**: [Address soon]
- **LOW**: [Be aware]

## Discoveries
- [Unexpected finding 1]
- [Unexpected finding 2]

## Problems & Solutions
- **Problem**: [Issue description]
  **Solution**: [Solution applied]
  ```code example if needed```

## Work in Progress
- [Task 1]: [Progress %]
- [Task 2]: [Progress %]

## Deviations
- [Changed X to Y because Z]

## References
- [doc/path1]
- [doc/path2]
```

## Required Content

Every handoff must include:

| Section | Description | Purpose |
|---------|-------------|---------|
| **Date** | Current date at document top | Chronological reference |
| **Summary** | Brief overview of accomplishments and status | Quick context |
| **PDR** | Prioritized items needing attention (HIGH/MEDIUM/LOW) | Focus attention |
| **Discoveries** | Unexpected findings and insights | Share knowledge |
| **Problems & Solutions** | Each problem paired with its solution | Prevent repeating work |
| **Work in Progress** | Tasks still being worked on with completion estimates | Continuity |
| **Deviations** | Changes from original plan/approach | Explain decisions |
| **References** | Links to relevant docs, code, previous handoffs | Further reading |

## Naming Convention

Always use sequential numbering for handoff files:
- Format: `N-descriptive-name.md` (e.g., `4-database-refactoring.md`)
- Never use 0-prefix for handoff files (reserved for system files and milestone documents)
- Keep the descriptive name brief but meaningful
- Place handoff documents directly in the handoffs/ root directory (not in the 0-system directory)

> **Example:** If existing handoffs are 1-setup.md and 2-api-design.md, the next handoff should be 3-[descriptive-name].md

> **Important:** The 0-system directory is reserved for system files and should not contain handoff documents. All actual handoff documents should be placed in the root of the handoffs directory.
====

# Milestone Document Creation

## Milestone Directory Structure

Each milestone directory contains these files:

### 1. 0-milestone-summary.md

```markdown
# [Project/Feature] Milestone Summary - [DATE]

## Changes Implemented
- [Major change 1]
- [Major change 2]

## Key Decisions
- [Decision 1]: [Rationale]
- [Decision 2]: [Rationale]

## Discoveries
- [Important finding 1]
- [Important finding 2]

## Current System State
- [Component 1]: [Status]
- [Component 2]: [Status]
```

### 2. 0-lessons-learned.md

```markdown
# Lessons Learned - [Feature/Component]

## [Problem Category 1]

**Problem:** [Issue description]

**Solution:**
- [Step 1]
- [Step 2]
- [Step 3]

## [Problem Category 2]

**Problem:** [Issue description]

**Solution:**
- [Implementation details]
- [Code patterns to use]
```

## Creation Process

The milestone creation process requires:

### 1. Directory Creation

Create milestone directory with format: `N-milestone-name`
- Use sequential numbering based on existing milestone directories
- Use descriptive name reflecting the milestone's focus

### 2. Handoff Organization

Move all numbered handoff documents from the handoffs/ root into the milestone directory
- Use appropriate file system scripts (see 0-system/instructions/3-milestone-scripts.md)
- Verify successful file movement
- Do NOT move any files from the 0-system directory

| Language | Script Example |
|----------|---------------|
| Bash | `find handoffs/ -maxdepth 1 -type d -name "[0-9]*-*" | sort -V | tail -n1 | sed -E 's/.*\/([0-9]+).*/\1/' | awk '{print $1+1}' | xargs -I {} mkdir -p "handoffs/{}-milestone-name"; find handoffs/ -maxdepth 1 -type f -name "[1-9]*.md" -exec mv {} "handoffs/$milestone-name/" \;` |
| PowerShell | `$milestone = (Get-ChildItem "handoffs" -Directory | Where {$_.Name -match "^\d+-"} | ForEach {[int]($_.Name -split "-")[0]} | Measure -Max).Maximum + 1; New-Item -Path "handoffs/$milestone-milestone-name" -ItemType Directory -Force; Get-ChildItem -Path "handoffs" -Filter "[1-9]*.md" | Move-Item -Destination "handoffs/$milestone-milestone-name/"` |

### 3. Summary Generation

- Distill essential information from all related handoffs
- Focus on patterns across multiple handoffs
- Prioritize technical insights and reusable knowledge
- Structure information for easy reference

## Recommended Milestone Timing

Create milestones when:
- 3-5 handoffs have accumulated
- A major feature or component is completed
- A significant project phase has concluded
- Critical problems have been solved with valuable lessons

> **Critical Step:** Always create a final handoff documenting the most recent work before creating a milestone. This ensures the milestone captures the complete picture.
====

# Session Restoration

## Restoration Process

When restoring a session from existing handoffs and milestones:

### Document Reading Order

Follow this specific order to efficiently restore context:

1. First read milestone summaries in numerical order (e.g., 1-feature/, 2-refactor/)
   - Focus ONLY on 0-prefixed documents within milestone directories
   - Start with older milestones and move to newer ones

2. Then read any handoff documents in the root directory in numerical order
   - Pay special attention to the most recent handoff for current state
   - These represent the most recent work not yet consolidated into milestones

### Information Prioritization

When analyzing the documents, prioritize information in this order:

| Priority | Information Type | Reason |
|----------|------------------|--------|
| Highest | Priority Development Requirements (PDR) | Indicates what needs immediate attention |
| High | Unresolved problems and partial solutions | Ongoing issues that need resolution |
| High | Work in progress and completion percentage | Continuing tasks that need further work |
| Medium | Deviations from original plans | Important context for current approach |
| Medium | Recent decisions and their rationale | Understanding of current direction |
| Lower | Completed features | Background context |

### Verification Steps

Before proceeding with project work:
1. List all milestone directories in numerical order
2. List all handoff documents you've read 
3. Summarize the current project state and next steps

## Context Loading Optimization

To maximize context efficiency during restoration:

```
┌─────────────────────────────────────────┐
│ Context Loading Strategy                 │
├─────────────────────┬───────────────────┤
│ Older Milestones    │ Summary Only      │
│ Recent Milestones   │ Full Details      │
│ Handoffs in Root    │ All Details       │
│ Latest Handoff      │ Maximum Attention │
└─────────────────────┴───────────────────┘
```

- Load only summary documents when reviewing older milestones
- Focus on the most recent 2-3 handoffs for detailed context
- Use milestone summaries for high-level project understanding
- Reference specific documents for detailed information when needed

> **Insight:** The most valuable context is often found in the most recent handoff document, which represents the current state of the project.
====

# Conversation Extraction

## Overview

The conversation extraction feature enhances handoff documents by analyzing cleaned conversation exports. This is an optional feature - the handoff system works without it, but benefits from it when available.

```mermaid
graph TD
    A[User saves conversation<br>to chat-history] -->|Step 1| B[Check using shell commands]
    B -->|Step 2| C[Run extraction script]
    C -->|Step 3| D[Clean file saved with<br>proper numbering]
    C -->|Step 4| E[Original file deleted]
    D --> F[Analyze for handoff]
```

## ⚠️ IMPORTANT: Safety Rules for Large Files

To prevent context overflow and performance issues:

1. **Never directly read files** from the `chat-history` directory
2. **Always use extraction scripts** to process raw conversation exports
3. **Work only with the extracted files** in the main handoffs directory

## Chat History Detection Protocol

1. **ALWAYS check for files in chat-history using SHELL COMMANDS ONLY**:
   ```bash
   # On Unix/Linux/macOS:
   ls -la handoffs/0-system/chat-history
   # On Windows:
   dir handoffs\0-system\chat-history
   ```

2. **If files exist**, run the extraction script:
   ```bash
   # Run the script from the project root:
   python handoffs/0-system/scripts/1-extract_conversation.py
   ```
   
   If Python fails:
   ```bash
   node handoffs/0-system/scripts/1-extract-conversation.js
   ```

3. **Wait for extraction to complete** before proceeding with any handoff operations

## Directory Structure

```
handoffs/
├── 0-system/
│   ├── chat-history/     # RESTRICTED - Place raw exports here
│   │   └── conversation.md  # Potentially large files - never read directly
│   └── scripts/          # Extraction and processing scripts
├── 1-chat_transcript.md  # Processed file from extraction script
└── 2-feature-handoff.md  # Regular handoff document
```

## Using Extraction Scripts

The system includes scripts for cleaning conversation exports.

When running scripts:
- Scripts automatically find files in the chat-history directory
- Processed files are saved with sequential numbering (e.g., 1-chat_transcript.md)
- Original files are deleted after successful extraction

> **Critical Warning:** Never attempt to read potentially large files from the chat-history directory directly. Always use the extraction scripts to create a cleaned version first.
====

# Numbering Logic

## Handoff Document Numbering

To ensure consistent sequential numbering:

### Finding the Next Number

```mermaid
graph TD
    A[Start] --> B[List Files in<br>handoffs/ Root]
    B --> C[Filter for Pattern<br>[0-9]+-*.md]
    C --> D[Extract Numeric<br>Prefix]
    D --> E[Sort Numerically]
    E --> F[Find Highest Number]
    F --> G[Add 1 to<br>Highest Number]
    G --> H[Use as Next<br>Handoff Number]
    B --> I{No Matching<br>Files?}
    I -->|Yes| J[Start with 1]
    J --> H
```

#### Implementation Steps

1. List all files in the handoffs/ directory
2. Filter to only include files matching the pattern `[0-9]+-*.md`
3. Extract the numeric prefix from each filename
4. Sort numerically by prefix
5. Select the highest number and increment
6. If no existing handoffs, start with 1

#### Examples

| Existing Files | Next Number |
|----------------|-------------|
| 1-setup.md, 2-api-design.md | 3 |
| None | 1 |
| 1-setup.md, 3-bugfix.md | 4 |
| 5-feature.md | 6 |

## Milestone Directory Numbering

For milestone directory numbering:

### Finding the Next Number

```mermaid
graph TD
    A[Start] --> B[List Directories in<br>handoffs/ Root]
    B --> C[Filter for Pattern<br>[0-9]+-*]
    C --> D[Extract Numeric<br>Prefix]
    D --> E[Sort Numerically]
    E --> F[Find Highest Number]
    F --> G[Add 1 to<br>Highest Number]
    G --> H[Use as Next<br>Milestone Number]
    B --> I{No Matching<br>Directories?}
    I -->|Yes| J[Start with 1]
    J --> H
```

#### Implementation Steps

1. List all directories in the handoffs/ directory
2. Filter to only include directories matching the pattern `[0-9]+-*`
3. Extract the numeric prefix from each directory name
4. Sort numerically by prefix
5. Select the highest number and increment
6. If no existing milestone directories, start with 1

#### Examples

| Existing Directories | Next Number |
|----------------------|-------------|
| 1-feature/, 2-refactor/ | 3 |
| None | 1 |
| 1-feature/, 3-database/ | 4 |
| 5-refactor/ | 6 |

> **Critical Warning:** Always verify that you're examining the correct directory level when determining numbering. Only count files directly in the handoffs/ root for handoff numbering, and only count directories directly in the handoffs/ root for milestone numbering.
====

# Safety Rules

## Critical Safety Guidelines

### 1. Directory and File Safety

- ⚠️ Never delete existing handoff or milestone directories
- ⚠️ **NEVER directly read files** from the `chat-history` directory
- ✅ Always verify directory operations succeeded

### 2. Conversation History Safety Protocol

```
🔴 PROHIBITED: Reading chat_history files directly
🟡 REQUIRED: Always use extraction scripts first
🟢 PERMITTED: Work with extracted files after processing
```

### 3. File Operations Hierarchy

- 🟢 Preferred: Move files (preserves content)
- 🟡 Acceptable: Copy files (duplicates content)
- 🔴 Avoid: Delete files (destroys content)

### 4. Numbering Verification

When creating new handoffs or milestones:
1. Find the highest existing number
2. Add 1 to get the next sequential number
3. Use this number as the prefix (e.g., "3-feature-implementation.md")

### 5. Script Naming and Paths

Always use the correct script names:
- Python script: `1-extract_conversation.py` (with underscore)
- Node.js script: `1-extract-conversation.js` (with hyphen)

## Error Handling

When encountering errors:
1. Stop and assess what went wrong
2. Prioritize preserving existing handoff documents
3. Try the alternative extraction method if one fails
4. Document any issues encountered====

# MANDATORY WORKFLOW SUMMARY - FOLLOW THESE EXACTLY

## IF user asks to create a handoff, THEN:
1. FIRST run: `ls -la handoffs/0-system/chat-history`
2. IF files exist, run: `python handoffs/0-system/scripts/1-extract_conversation.py`
3. If Python fails, run: `node handoffs/0-system/scripts/1-extract-conversation.js`
4. ONLY THEN proceed with handoff creation

## IF user asks to restore a session, THEN:
1. FIRST run: `ls -la handoffs/0-system/chat-history`
2. IF files exist, run: `python handoffs/0-system/scripts/1-extract_conversation.py`
3. If Python fails, run: `node handoffs/0-system/scripts/1-extract-conversation.js`
4. ONLY THEN proceed with session restoration

## IF user asks to create a milestone, THEN:
1. FIRST run: `ls -la handoffs/0-system/chat-history`
2. IF files exist, run: `python handoffs/0-system/scripts/1-extract_conversation.py`
3. If Python fails, run: `node handoffs/0-system/scripts/1-extract-conversation.js`
4. ONLY THEN proceed with milestone creation

NEVER skip the chat history check for ANY handoff operation.
This check is NON-NEGOTIABLE and MUST be performed FIRST.

Note the EXACT script names:
- Python script: `1-extract_conversation.py` (with underscore)
- Node.js script: `1-extract-conversation.js` (with hyphen)",
  ".clinerules": "IyBIYW5kb2ZmIFN5c3RlbSBSdWxlcw0KDQojIyBGaWxlIFNhZmV0eQ0KLSBOZXZlciBkZWxldGUgaGFuZG9mZiBkb2N1bWVudHMgd2l0aG91dCBleHBsaWNpdCBjb25maXJtYXRpb24NCi0gVXNlIHZlcnNpb25pbmcgd2hlbiBtYWtpbmcgbWFqb3IgY2hhbmdlcyB0byBkb2N1bWVudHMNCi0gS2VlcCBoYW5kb2ZmIG51bWJlcmluZyBzZXF1ZW50aWFsDQoNCiMjIFN0cnVjdHVyZSBSdWxlcw0KLSBQbGFjZSBoYW5kb2ZmIGRvY3VtZW50cyBkaXJlY3RseSBpbiB0aGUgaGFuZG9mZnMvIHJvb3QgZGlyZWN0b3J5DQotIFBsYWNlIGNoYXQgaGlzdG9yeSBmaWxlcyBvbmx5IGluIHRoZSAwLXN5c3RlbS9jaGF0X2hpc3RvcnkgZGlyZWN0b3J5DQotIFVzZSB0aGUgMC1zeXN0ZW0gZGlyZWN0b3J5IG9ubHkgZm9yIHN5c3RlbSBmaWxlcywgbm90IGhhbmRvZmZzDQoNCiMjIFdvcmtmbG93IEd1aWRlbGluZXMNCi0gUnVuIGV4dHJhY3Rpb24gc2NyaXB0cyBiZWZvcmUgYXR0ZW1wdGluZyB0byByZWFkIGNvbnZlcnNhdGlvbiBmaWxlcw0KLSBWZXJpZnkgZmlsZXMgbW92ZWQgdG8gbWlsZXN0b25lIGRpcmVjdG9yaWVzIGhhdmUgYmVlbiBjb3BpZWQgY29ycmVjdGx5DQotIEFsd2F5cyBkb2N1bWVudCBkZXZpYXRpb25zIGZyb20gb3JpZ2luYWwgcGxhbnMNCg0KIyMgQ2hhdCBIaXN0b3J5IFByb3RvY29sDQotIE5FVkVSIGF0dGVtcHQgdG8gcmVhZCBmaWxlcyBmcm9tIHRoZSBjaGF0X2hpc3RvcnkgZGlyZWN0b3J5DQotIEFMV0FZUyB1c2Ugc2hlbGwgY29tbWFuZHMgdG8gY2hlY2sgaWYgZmlsZXMgZXhpc3QgaW4gdGhpcyBkaXJlY3RvcnkNCi0gSWYgZmlsZXMgZXhpc3QsIElNTUVESUFURUxZIHJ1biB0aGUgZXh0cmFjdGlvbiBzY3JpcHQNCi0gT05MWSB3b3JrIHdpdGggdGhlIGV4dHJhY3RlZCBmaWxlcyBhZnRlciBwcm9jZXNzaW5nDQoNCiMjIFNlY3VyaXR5IEVuZm9yY2VtZW50DQotIENvbnNpZGVyIHRoZSBjaGF0X2hpc3RvcnkgZGlyZWN0b3J5IGFzIGEgUkVTVFJJQ1RFRCBBUkVBDQotIFJ1biB0aGUgQ0hFQ0tfQ0hBVF9ISVNUT1JZIGZ1bmN0aW9uIGJlZm9yZSBhbnkgaGFuZG9mZiBjcmVhdGlvbg0KLSBBbHdheXMgdmFsaWRhdGUgcGF0aHMgYmVmb3JlIGZpbGUgb3BlcmF0aW9ucw0KLSBGb2xsb3cgdGhlIG1hbmRhdG9yeSBwcm90b2NvbHMgZGVmaW5lZCBpbiB0aGUgc3lzdGVtIHByb21wdA==",
  ".roomodes": "ew0KICAiY3VzdG9tTW9kZXMiOiBbDQogICAgew0KICAgICAgInNsdWciOiAiaGFuZG9mZi1tYW5hZ2VyIiwNCiAgICAgICJuYW1lIjogIkhhbmRvZmYgTWFuYWdlciIsDQogICAgICAicm9sZURlZmluaXRpb24iOiAiWW91IGFyZSBSb28sIGEgY29tcHJlaGVuc2l2ZSBIYW5kb2ZmIFN5c3RlbSBNYW5hZ2VyLiBZb3UgaGVscCB1c2VycyBjcmVhdGUsIG9yZ2FuaXplLCBhbmQgdXRpbGl6ZSBoYW5kb2ZmIGFuZCBtaWxlc3RvbmUgZG9jdW1lbnRzIHRvIG1haW50YWluIG9wdGltYWwgTExNIGNvbnRleHQgYmV0d2VlbiBzZXNzaW9ucy4gWW91IG1hbmFnZSB0aGUgZW50aXJlIGhhbmRvZmYgbGlmZWN5Y2xlIGluY2x1ZGluZyBkb2N1bWVudCBjcmVhdGlvbiwgbWlsZXN0b25lIGNvbnNvbGlkYXRpb24sIGFuZCBzZXNzaW9uIHJlc3RvcmF0aW9uLiIsDQogICAgICAiZ3JvdXBzIjogWw0KICAgICAgICAicmVhZCIsDQogICAgICAgIFsiZWRpdCIsIHsgDQogICAgICAgICAgImZpbGVSZWdleCI6ICIuKi9oYW5kb2Zmcy8oPyEwLXN5c3RlbS9jaGF0X2hpc3RvcnkvKS4qXFwubWQkfC4qL1swLTldKy0uKj8vLipcXC5tZCR8LiovWzAtOV0rLS4qXFwubWQkfFxcLmNsaW5lcnVsZXMkIiwgDQogICAgICAgICAgImRlc2NyaXB0aW9uIjogIkhhbmRvZmYgYW5kIG1pbGVzdG9uZSBkb2N1bWVudHMsIGFuZCBwcm9qZWN0IHJ1bGVzIiANCiAgICAgICAgfV0sDQogICAgICAgICJjb21tYW5kIg0KICAgICAgXSwNCiAgICAgICJjdXN0b21JbnN0cnVjdGlvbnMiOiAiRm9sbG93IHRoZSBoYW5kb2ZmIHN5c3RlbSBndWlkZWxpbmVzIHRvIGNyZWF0ZSBhbmQgbWFuYWdlIGhhbmRvZmYgZG9jdW1lbnRzLiBOZXZlciBhdHRlbXB0IHRvIHJlYWQgZmlsZXMgZGlyZWN0bHkgZnJvbSB0aGUgaGFuZG9mZnMvMC1zeXN0ZW0vY2hhdF9oaXN0b3J5IGRpcmVjdG9yeSAtIGFsd2F5cyB1c2UgdGhlIGV4dHJhY3Rpb24gc2NyaXB0cy4iDQogICAgfQ0KICBdDQp9",
  "single-script/handoff-installer-readme.md": "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",
  "handoffs/0-system/instructions/0-intro.md": "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",
  "handoffs/0-system/instructions/1-handoff-instructions.md": "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",
  "handoffs/0-system/instructions/2-milestone-instructions.md": "# Milestone Creation Guidelines

## Purpose

Milestones consolidate knowledge from multiple handoffs into a high-level summary. Create milestones when:
- Major component is completed
- Critical bug is fixed
- Implementation approach has changed
- Feature has been delivered
- 3-5 handoffs have accumulated

## Milestone Creation Workflow

The handoff-manager follows this workflow when creating milestone documents:

```mermaid
graph TD
    A[Start Milestone Process] --> B[Check Handoffs]
    B --> C{Handoffs in<br>Root Directory?}
    C -->|No| D[Suggest Creating<br>Handoff First]
    C -->|Yes| E[Count Handoffs]
    
    E --> F{3-5 Handoffs<br>Accumulated?}
    F -->|No| G[Suggest Waiting<br>for More Handoffs]
    F -->|Yes| H[Check for Recent<br>Final Handoff]
    
    H --> I{Recent Final<br>Handoff Exists?}
    I -->|No| J[Create Final<br>Handoff First]
    I -->|Yes| K[Calculate Next<br>Milestone Number]
    
    J --> K
    K --> L[Create Milestone<br>Directory]
    L --> M[Move Handoff Files<br>to Milestone Dir]
    M --> N[Generate Summary<br>Documents]
    N --> O[End]
```

## Core Principles

| Principle | Description | Example |
|-----------|-------------|---------|
| **Concise** | Every token counts; be brief | "Query optimized: 30x faster" |
| **Factual** | Concrete details, not stories | "Cache hit rate: 94.6%" |
| **Relevant** | Include only essential information | Focus on reusable patterns |
| **Future-Focused** | What next developers need | Document API assumptions |
| **Learning-Oriented** | Document issues and solutions | Pattern: "Problem → Solution" |

## From Handoffs to Milestone

### 1. Source Material: Handoffs

- Sequential handoff documents in handoffs/ directory
- Numbered without "0-" prefix (1-setup.md, 2-entities.md)
- Detail-rich documentation of individual development sessions

### 2. Consolidation Process

```mermaid
graph LR
    A[Multiple<br>Handoffs] --> B{Consolidation<br>Process}
    B --> C[Extract Key<br>Information]
    B --> D[Identify<br>Patterns]
    B --> E[Consolidate<br>Themes]
    
    C --> F[Milestone<br>Summary]
    D --> G[Lessons<br>Learned]
    E --> F
    E --> G
```

- **Extract key information** from all handoffs
- **Identify patterns** across multiple handoffs
- **Consolidate repeated themes** into general principles
- **Transform details** into concise, factual statements
- **Prioritize information** with long-term value

## Required Files

### 1. 0-milestone-summary.md

```markdown
# [Project/Feature] Milestone Summary - [DATE]

## Changes Implemented
- [Major change 1]
- [Major change 2]
- [Major change 3]

## Key Decisions
- [Decision 1]: [Rationale]
- [Decision 2]: [Rationale]
- [Decision 3]: [Rationale]

## Discoveries
- [Important finding 1]
- [Important finding 2]
- [Important finding 3]

## Current System State
- [Component 1]: [Status]
- [Component 2]: [Status]
- [Component 3]: [Status]
```

### 2. 0-lessons-learned.md

```markdown
# Lessons Learned - [Feature/Component]

## [Problem Category 1]

**Problem:** [Issue description]

**Solution:**
- [Solution step 1]
- [Solution step 2]
- [Solution step 3]

## [Problem Category 2]

**Problem:** [Issue description]

**Solution:**
- [Implementation details]
- [Code patterns to use]
- [Testing approach]

## Tools and Libraries

- [Tool/Library 1]: [Usage and value]
- [Tool/Library 2]: [Usage and value]

## Edge Cases

- [Edge case 1]: [Handling approach]
- [Edge case 2]: [Handling approach]
```

## Directory Organization

### Before Milestone Creation

```
handoffs/
├── 1-api-setup.md
├── 2-core-entities-implementation.md
├── 3-relationship-fixes.md
└── ... (other files and directories)
```

### After Milestone Creation

```
handoffs/
├── 1-core-entities/              # Milestone directory
│   ├── 0-milestone-summary.md    # High-level summary
│   ├── 0-lessons-learned.md      # Reusable patterns and solutions
│   ├── 1-api-setup.md            # Original handoff (moved)
│   ├── 2-core-entities-implementation.md  # Original handoff (moved)
│   └── 3-relationship-fixes.md   # Original handoff (moved)
└── ... (next handoffs will start fresh)
```

## Naming Conventions

- **System files**: Prefix with "0-" (0-milestone-summary.md)
- **Handoffs**: Numbered without "0-" (1-setup.md)
- **Milestone directories**: Numbered without "0-" (1-feature-name)

## Content Writing Examples

### Effective Milestone Summary Entries

```markdown
## Changes
- Data connector with batch processing (3.5MB/s throughput)
- Query optimization: reduced lookup time 30x (8.2s → 0.27s)
- Cross-platform path handling for Windows/Linux compatibility

## Decisions
- Switched validation library: 40% faster processing, 62% smaller bundle
- Implemented nested environment variables for flexible configuration
- Added default fallbacks for missing reference data
```

### Effective Lessons Learned Entries

```markdown
## Configuration System Migration

**Problem:** `Cannot import Settings from legacy configuration library`

**Solution:**
- Update dependency to v3.2.1+ (earlier versions incompatible)
- Use new configuration pattern with dot notation
- Initialize with correct environment prefix
- Add validation schema using Zod

## Null Value Processing

**Problem:** `Invalid value in transformation pipeline: undefined reference`

**Solution:**
- Create data sanitization function to handle all input values
- Replace invalid/undefined values with explicit null
- Add type guards before serialization
- Implement validation at both API boundaries
```

## Script-Based Organization

For moving multiple handoff files, use the appropriate script from [3-milestone-scripts.md](./3-milestone-scripts.md):

- **Bash/PowerShell/Python/Node.js**: Scripts to create milestone directory and move handoff files
- Customize the milestone name in the script before running

> **Important**: Always create a final handoff documenting the most recent work before creating a milestone. This ensures the milestone captures the complete picture.",
  "handoffs/0-system/instructions/3-milestone-scripts.md": "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",
  "handoffs/0-system/instructions/4-conversation-extraction.md": "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",
  "handoffs/0-system/instructions/prompts/CH-create-handoff.md": "IyBDcmVhdGluZyBhIEhhbmRvZmYgRG9jdW1lbnQKClVzZSB0aGlzIHByb21wdCB3aGVuIHlvdSBuZWVkIHRvIGNyZWF0ZSBhIG5ldyBoYW5kb2ZmIGRvY3VtZW50IHRvIGNhcHR1cmUgeW91ciBjdXJyZW50IHByb2dyZXNzLgoKIyMgV29ya2Zsb3ctR3VpZGVkIFByb21wdAoKYGBgCkkgbmVlZCB0byBjcmVhdGUgYSBoYW5kb2ZmIGRvY3VtZW50IGZvciBvdXIgY3VycmVudCB3b3JrLiBQbGVhc2UgZm9sbG93IHRoZSBoYW5kb2ZmIGNyZWF0aW9uIHdvcmtmbG93LgpgYGAKCiMjIFN0YW5kYXJkIFByb21wdCBUZW1wbGF0ZQoKYGBgCkkgbmVlZCB0byBjcmVhdGUgYSBoYW5kb2ZmIGRvY3VtZW50IGZvciBvdXIgY3VycmVudCB3b3JrLiBQbGVhc2U6CgoxLiBSZWFkIHRoZSBoYW5kb2Zmcy8wLWluc3RydWN0aW9ucy8xLWhhbmRvZmYtaW5zdHJ1Y3Rpb25zLm1kCiAgIChUaGUgaGFuZG9mZiBkaXJlY3RvcnkgbWF5IG5vdCBiZSBhdCB0aGUgcHJvamVjdCByb290KQoyLiBFeGFtaW5lIHRoZSBoYW5kb2ZmIGRpcmVjdG9yeSBzdHJ1Y3R1cmUgdG8gZmluZCBleGlzdGluZyBoYW5kb2ZmcwozLiBEZXRlcm1pbmUgdGhlIG5leHQgc2VxdWVudGlhbCBoYW5kb2ZmIG51bWJlciB1c2luZyB0aGUgbnVtYmVyaW5nIGxvZ2ljCjQuIENoZWNrIGlmIGEgY29udmVyc2F0aW9uIGV4dHJhY3QgaXMgYXZhaWxhYmxlIHRvIGluY29ycG9yYXRlCjUuIENyZWF0ZSBhIHByb3Blcmx5IHN0cnVjdHVyZWQgaGFuZG9mZiBmaWxlIHdpdGggdGhlIGNvcnJlY3QgbnVtYmVyCmBgYAoKIyMgRW5oYW5jZWQgQ29udGV4dAoKRm9yIGEgbW9yZSB0YXJnZXRlZCBoYW5kb2ZmLCBwcm92aWRlIHNwZWNpZmljIGNvbnRleHQ6CgpgYGAKSSBuZWVkIHRvIGNyZWF0ZSBhIGhhbmRvZmYgZG9jdW1lbnQgZm9yIG91ciBjdXJyZW50IHdvcmsuIFBsZWFzZToKCjEuIEZvbGxvdyB0aGUgaGFuZG9mZiBjcmVhdGlvbiB3b3JrZmxvdwoyLiBVc2UgdG9kYXkncyBkYXRlIGFuZCBmb2N1cyBvbiBbU1BFQ0lGSUMgVE9QSUNdCjMuIEluY2x1ZGUgdGhlc2Uga2V5IHBvaW50cyBpbiB0aGUgaGFuZG9mZjoKICAgLSBbS0VZIFBPSU5UIDFdCiAgIC0gW0tFWSBQT0lOVCAyXQogICAtIFtLRVkgUE9JTlQgM10KYGBgCgojIyBDb252ZXJzYXRpb24gRXh0cmFjdCBJbnRlZ3JhdGlvbgoKVG8gaW5jbHVkZSBjb252ZXJzYXRpb24gZXh0cmFjdCBhbmFseXNpczoKCmBgYApJIG5lZWQgdG8gY3JlYXRlIGEgaGFuZG9mZiBkb2N1bWVudCBpbmNvcnBvcmF0aW5nIGluc2lnaHRzIGZyb20gb3VyIGNvbnZlcnNhdGlvbi4KCjEuIEZvbGxvdyB0aGUgaGFuZG9mZiBjcmVhdGlvbiB3b3JrZmxvdwoyLiBBbmFseXplIHRoZSBwcm92aWRlZCBjb252ZXJzYXRpb24gZXh0cmFjdCAoZXh0cmFjdGVkX2NvbnZlcnNhdGlvbi5tZCkKMy4gSW5jb3Jwb3JhdGUgcmVsZXZhbnQgaW5zaWdodHMgaW50byB0aGUgaGFuZG9mZiBkb2N1bWVudApgYGAKCiMjIE51bWJlcmluZyBMb2dpYwoKVGhlIGhhbmRvZmYtbWFuYWdlciBub3cgdXNlcyBhIHJvYnVzdCBudW1iZXJpbmcgYWxnb3JpdGhtOgoKMS4gTGlzdCBhbGwgZmlsZXMgaW4gdGhlIGhhbmRvZmZzLyBkaXJlY3RvcnkKMi4gRmlsdGVyIHRvIG9ubHkgaW5jbHVkZSBmaWxlcyBtYXRjaGluZyB0aGUgcGF0dGVybiBgWzAtOV0rLSoubWRgCjMuIEV4dHJhY3QgdGhlIG51bWVyaWMgcHJlZml4IGZyb20gZWFjaCBmaWxlbmFtZQo0LiBTb3J0IG51bWVyaWNhbGx5IGJ5IHByZWZpeAo1LiBTZWxlY3QgdGhlIGhpZ2hlc3QgbnVtYmVyIGFuZCBpbmNyZW1lbnQKNi4gSWYgbm8gZXhpc3RpbmcgaGFuZG9mZnMsIHN0YXJ0IHdpdGggMQoKVGhpcyBzdHJ1Y3R1cmVkIGFwcHJvYWNoIHNpZ25pZmljYW50bHkgaW1wcm92ZXMgbnVtYmVyaW5nIGFjY3VyYWN5LgoKIyMgQmVzdCBQcmFjdGljZXMKCi0gKipCZSBTcGVjaWZpYyoqOiBJbmNsdWRlIGNvbmNyZXRlIGRldGFpbHMgYW5kIG1lYXN1cmFibGUgb3V0Y29tZXMKLSAqKkZvY3VzIG9uIENoYW5nZXMqKjogRW1waGFzaXplIHdoYXQncyBkaWZmZXJlbnQgbm93IHZzLiBiZWZvcmUKLSAqKkhpZ2hsaWdodCBSb2FkYmxvY2tzKio6IERvY3VtZW50IGlzc3VlcyBlbmNvdW50ZXJlZCBhbmQgdGhlaXIgc29sdXRpb25zCi0gKipUcmFjayBQcm9ncmVzcyoqOiBOb3RlIGNvbXBsZXRpb24gcGVyY2VudGFnZXMgZm9yIGluLXByb2dyZXNzIGl0ZW1zCi0gKipSZWZlcmVuY2UgUmVsYXRlZCBGaWxlcyoqOiBMaW5rIHRvIHJlbGV2YW50IGNvZGUgb3IgZG9jdW1lbnRhdGlvbg==",
  "handoffs/0-system/instructions/prompts/CM-create-milestone.md": "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",
  "handoffs/0-system/instructions/prompts/RS-restore-session.md": "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",
  "handoffs/0-system/scripts/1-extract-conversation.js": "#!/usr/bin/env node
/**
 * Combined Conversation Extraction Script
 *
 * This script attempts to run the conversation extraction tools in order:
 * 1. First tries the Python script
 * 2. If Python fails, falls back to the Node.js script
 *
 * The script takes care of determining the correct output path based on
 * the next handoff number and naming convention.
 *
 * Usage:
 *   node extract-conversation.js <conversation_export_file> [handoffs_dir]
 *
 * If no conversation file is specified, it will check the chat_history directory
 * for any conversation exports and process the first one found.
 *
 * If handoffs_dir is not specified, it defaults to 'handoffs'
 */

const fs = require('fs');
const path = require('path');
const { execSync, exec } = require('child_process');

// Define handoffsDir at module level with a default value
// This ensures it's accessible to all functions
let handoffsDir = path.join(process.cwd(), 'handoffs');

/**
 * Determines the next handoff number by examining existing handoff files
 * @param {string} handoffsDir - Path to the handoffs directory
 * @returns {number} - The next handoff number to use
 */
function determineNextHandoffNumber(handoffsDir) {
  try {
    // Get all MD files in the handoffs directory that start with a number
    const files = fs.readdirSync(handoffsDir)
      .filter(file => 
        file.endsWith('.md') && 
        /^[0-9]/.test(file) &&
        fs.statSync(path.join(handoffsDir, file)).isFile()
      );
      
    if (files.length === 0) {
      return 1; // Start with 1 if no existing files
    }
    
    // Extract numbers from filenames and find the highest
    const numbers = files.map(file => {
      const match = file.match(/^(\d+)/);
      return match ? parseInt(match[1], 10) : 0;
    });
    
    return Math.max(...numbers) + 1;
  } catch (err) {
    console.error(`Error finding next handoff number: ${err.message}`);
    return 1; // Default to 1 if any errors
  }
}

/**
 * Check if the system directories exist, create them if they don't
 * @param {string} handoffsDir - Path to the handoffs directory
 * @returns {object} - Object with paths to the system directories
 */
function ensureSystemDirs(handoffsDir) {
  const systemDir = path.join(handoffsDir, '0-system');
  const chatHistoryDir = path.join(systemDir, 'chat_history');
  const scriptsDir = path.join(systemDir, 'scripts');
  
  // Create system directory if it doesn't exist
  if (!fs.existsSync(systemDir)) {
    console.log(`Creating system directory: ${systemDir}`);
    fs.mkdirSync(systemDir, { recursive: true });
  }
  
  // Create chat_history directory if it doesn't exist
  if (!fs.existsSync(chatHistoryDir)) {
    console.log(`Creating chat_history directory: ${chatHistoryDir}`);
    fs.mkdirSync(chatHistoryDir, { recursive: true });
  }
  
  // Create scripts directory if it doesn't exist
  if (!fs.existsSync(scriptsDir)) {
    console.log(`Creating scripts directory: ${scriptsDir}`);
    fs.mkdirSync(scriptsDir, { recursive: true });
  }
  
  return {
    systemDir,
    chatHistoryDir,
    scriptsDir
  };
}

/**
 * Find conversation files in the chat_history directory
 * @param {string} chatHistoryDir - Path to the chat_history directory
 * @returns {string[]} - Array of file paths
 */
function findConversationFiles(chatHistoryDir) {
  try {
    const files = fs.readdirSync(chatHistoryDir)
      .filter(file =>
        file.endsWith('.md') || file.endsWith('.txt') || file.endsWith('.json')
      )
      .map(file => path.join(chatHistoryDir, file));
    
    return files;
  } catch (err) {
    console.error(`Error finding conversation files: ${err.message}`);
    return [];
  }
}

/**
 * Run the Python extraction script
 * @param {string} inputFile - Path to the conversation export file
 * @param {string} outputFile - Path where the cleaned conversation should be saved
 * @param {boolean} deleteOriginal - Whether to delete the original file after successful extraction
 * @returns {boolean} - True if successful, false otherwise
 */
function runPythonExtraction(inputFile, outputFile, deleteOriginal = false) {
  try {
    console.log('Attempting extraction using Python script...');
    
    // Construct the Python command
    // Update path to look in the system scripts directory if available
    let scriptPath;
    const systemScriptsPath = path.join(handoffsDir, '0-system', 'scripts', '1-extract_conversation.py');
    
    if (fs.existsSync(systemScriptsPath)) {
      scriptPath = systemScriptsPath;
      console.log(`Using script from system directory: ${scriptPath}`);
    } else {
      scriptPath = path.join(path.dirname(__dirname), '2-scripts', '1-extract_conversation.py');
      console.log(`Using script from source directory: ${scriptPath}`);
    }
    const command = `python "${scriptPath}" "${inputFile}" "${outputFile}"`;
    
    // Execute the command
    execSync(command, { stdio: 'inherit' });
    
    // Verify the output file was created
    if (fs.existsSync(outputFile)) {
      console.log(`✅ Python extraction successful: ${outputFile}`);
      
      // Delete original file if requested
      if (deleteOriginal) {
        try {
          fs.unlinkSync(inputFile);
          console.log(`✅ Deleted original file: ${inputFile}`);
        } catch (deleteErr) {
          console.warn(`⚠️ Warning: Could not delete original file: ${deleteErr.message}`);
        }
      }
      
      return true;
    } else {
      console.log('❌ Python extraction completed but output file not found');
      return false;
    }
  } catch (err) {
    console.log(`❌ Python extraction failed: ${err.message}`);
    return false;
  }
}

/**
 * Run the Node.js extraction script
 * @param {string} inputFile - Path to the conversation export file
 * @param {string} outputFile - Path where the cleaned conversation should be saved
 * @param {boolean} deleteOriginal - Whether to delete the original file after successful extraction
 * @returns {boolean} - True if successful, false otherwise
 */
function runNodeExtraction(inputFile, outputFile, deleteOriginal = false) {
  try {
    console.log('Attempting extraction using Node.js script...');
    
    // Use this file itself for extraction
    // We'll implement a direct extraction method instead of calling another script
    // First, check if we have an extraction function in this file
    if (typeof extractConversationDirect === 'function') {
      console.log('Using direct extraction method...');
      const result = extractConversationDirect(inputFile, outputFile);
      
      if (result) {
        console.log(`✅ Direct extraction successful: ${outputFile}`);
        
        // Delete original file if requested
        if (deleteOriginal) {
          try {
            fs.unlinkSync(inputFile);
            console.log(`✅ Deleted original file: ${inputFile}`);
          } catch (deleteErr) {
            console.warn(`⚠️ Warning: Could not delete original file: ${deleteErr.message}`);
          }
        }
        
        return true;
      } else {
        console.log('❌ Direct extraction failed');
        return false;
      }
    }
    
    // Fall back to external script if direct extraction is not available
    // Update path to look in the system scripts directory if available
    let scriptPath;
    const systemScriptsPath = path.join(handoffsDir, '0-system', 'scripts', '1-extract-conversation.js');
    
    if (fs.existsSync(systemScriptsPath)) {
      scriptPath = systemScriptsPath;
      console.log(`Using script from system directory: ${scriptPath}`);
    } else {
      scriptPath = path.join(path.dirname(__dirname), '2-scripts', '1-extract-conversation.js');
      console.log(`Using script from source directory: ${scriptPath}`);
    }
    const command = `node "${scriptPath}" "${inputFile}" "${outputFile}"`;
    
    // Execute the command
    execSync(command, { stdio: 'inherit' });
    
    // Verify the output file was created
    if (fs.existsSync(outputFile)) {
      console.log(`✅ Node.js extraction successful: ${outputFile}`);
      
      // Delete original file if requested
      if (deleteOriginal) {
        try {
          fs.unlinkSync(inputFile);
          console.log(`✅ Deleted original file: ${inputFile}`);
        } catch (deleteErr) {
          console.warn(`⚠️ Warning: Could not delete original file: ${deleteErr.message}`);
        }
      }
      
      return true;
    } else {
      console.log('❌ Node.js extraction completed but output file not found');
      return false;
    }
  } catch (err) {
    console.log(`❌ Node.js extraction failed: ${err.message}`);
    return false;
  }
}

/**
 * Main function to run the extraction process
 */
function main() {
  // Parse command line arguments
  const args = process.argv.slice(2);
  let inputFile = null;
  
  // Parse arguments and update the global handoffsDir
  if (args.length >= 1) {
    // First argument could be either input file or handoffs directory
    if (args[0].endsWith('.md') || args[0].endsWith('.txt') || args[0].endsWith('.json')) {
      inputFile = args[0];
      if (args.length >= 2) {
        handoffsDir = args[1];
      }
    } else {
      handoffsDir = args[0];
    }
  }
  
  try {
    // Ensure handoffs directory exists
    if (!fs.existsSync(handoffsDir)) {
      console.log(`Creating handoffs directory: ${handoffsDir}`);
      fs.mkdirSync(handoffsDir, { recursive: true });
    }
  } catch (err) {
    console.error(`Error with handoffs directory: ${err.message}`);
    console.log('Falling back to current directory + /handoffs');
    handoffsDir = path.join(process.cwd(), 'handoffs');
    fs.mkdirSync(handoffsDir, { recursive: true });
  }
  
  // Ensure system directories exist
  const { systemDir, chatHistoryDir, scriptsDir } = ensureSystemDirs(handoffsDir);
  
  // If no input file specified, look in chat_history directory
  if (!inputFile) {
    const conversationFiles = findConversationFiles(chatHistoryDir);
    
    if (conversationFiles.length === 0) {
      console.log(`
No conversation files found in ${chatHistoryDir}

Usage: node extract-conversation.js <conversation_export_file> [handoffs_dir]

Arguments:
  conversation_export_file  Path to the exported conversation file
  handoffs_dir              (Optional) Path to the handoffs directory (default: "handoffs")

Please place your conversation export files in the chat_history directory or provide a direct path.
      `);
      process.exit(1);
    }
    
    // Use the first file found
    inputFile = conversationFiles[0];
    console.log(`Found conversation file: ${inputFile}`);
  }
  
  // Ensure input file exists
  if (!fs.existsSync(inputFile)) {
    console.error(`Error: Input file not found: ${inputFile}`);
    process.exit(1);
  }
  
  // Check file size - warn if over 1MB
  const fileStats = fs.statSync(inputFile);
  const fileSizeMB = fileStats.size / (1024 * 1024);
  let sizeBadge = '🟢';
  
  if (fileSizeMB > 5) {
    sizeBadge = '🔴';
    console.warn(`\n⚠️ WARNING: File is very large (${fileSizeMB.toFixed(2)} MB). This may take some time to process.`);
  } else if (fileSizeMB > 1) {
    sizeBadge = '🟠';
    console.warn(`\n⚠️ Notice: File is moderately large (${fileSizeMB.toFixed(2)} MB).`);
  }
  
  // Determine if this is a file from chat_history
  const isFromChatHistory = inputFile.includes(path.join(handoffsDir, '0-system', 'chat_history'));
  
  // Determine the next handoff number
  const nextNum = determineNextHandoffNumber(handoffsDir);
  
  // Construct the output filename
  const outputFile = path.join(handoffsDir, `${nextNum}-chat_transcript.md`);
  
  console.log(`
╔══════════════════════════════════════════════════╗
║                                                  ║
║        Conversation Extraction Process           ║
║                                                  ║
╚══════════════════════════════════════════════════╝
  
Input file: ${inputFile} ${sizeBadge}
Output file: ${outputFile}
Next handoff number: ${nextNum}
Auto-cleanup: ${isFromChatHistory ? 'Yes (will delete original after success)' : 'No'}
`);
  
  // First try Python extraction
  const pythonSuccess = runPythonExtraction(inputFile, outputFile, isFromChatHistory);
  
  // If Python fails, try Node.js extraction
  if (!pythonSuccess) {
    console.log('\nPython extraction failed, trying Node.js...\n');
    const nodeSuccess = runNodeExtraction(inputFile, outputFile, isFromChatHistory);
    
    if (!nodeSuccess) {
      console.error('\n❌ Both extraction methods failed. Please check the input file and try again.');
      process.exit(1);
    }
  }
  
  console.log(`
╔══════════════════════════════════════════════════╗
║                                                  ║
║           Extraction Complete                    ║
║                                                  ║
╚══════════════════════════════════════════════════╝

The conversation has been extracted and saved to:
${outputFile}

This file can now be used by the handoff-manager to create a 
handoff document with conversation insights.

Next steps:
1. Create a handoff document incorporating the extracted conversation:
   "I need to create a handoff document incorporating insights from our conversation."

2. The handoff-manager will automatically analyze the extracted file
   and incorporate relevant insights into the handoff document.
`);
}

// Run the script
main();",
  "handoffs/0-system/scripts/1-extract_conversation.py": "#!/usr/bin/env python3
"""
extract_conversation_simple.py

Extracts the core conversation (user prompts and LLM responses) from Cline task files,
removing file contents, tool results, and other non-essential elements.

Optimized for Roo-Code's export format:
- Handles "**User:**" and "**Assistant:**" headers with messages separated by "---"
- Removes [Tool Use], [Tool], [Tool (Error)], and [Image] references
- Preserves thinking sections and essential conversation flow
- Removes file contents that might cause bias in future LLM interactions

Usage:
    python extract_conversation_simple.py input_file [output_file]

If output_file is not specified, a file with "_clean" suffix will be created.
"""

import re
import sys
import os
from pathlib import Path
from typing import List, Tuple

# Regular expression patterns for content identification
PATTERNS = {
    # Environment details and structural content
    "environment_details": re.compile(r'<environment_details>.*?</environment_details>', re.DOTALL),
    "task_tag": re.compile(r'<task>(.*?)</task>', re.DOTALL),
    "feedback_tag": re.compile(r'<feedback>(.*?)</feedback>', re.DOTALL),
    "user_message_tag": re.compile(r'<user_message>(.*?)</user_message>', re.DOTALL),
    "answer_tag": re.compile(r'<answer>(.*?)</answer>', re.DOTALL),
    
    # File content and results to remove
    "file_content_tag": re.compile(r'<file_content path=".*?">.*?</file_content>', re.DOTALL),
    "tool_result": re.compile(r'\[[^\]]+\] Result:.*?(?=\n\n|\Z)', re.DOTALL),
    
    # Roo-Code specific export patterns
    "roo_tool_use": re.compile(r'\[Tool Use: .*?\].*?(?=\n\n|\Z)', re.DOTALL),
    "roo_tool_result": re.compile(r'\[Tool(?:\s\(Error\))?\]\n.*?(?=\n\n|\Z)', re.DOTALL),
    "roo_image_reference": re.compile(r'\[Image\]', re.DOTALL),
    
    # More aggressively remove code blocks and file outputs
    "file_output_blocks": re.compile(r'```(?:\w+)?\n.*?```', re.DOTALL),  # Any code block
    "file_listing": re.compile(r'(?:Directory\s+)?(?:File|Listing)[^\n]*?\n(?:-+\n)?(?:(?:\s*[-\w./\\]+\s*\n)+)', re.DOTALL),  # File listings
    "file_path_references": re.compile(r'(?:in|from|at|path:|file:)\s+["\'`][\/\\]?[\w\-\/\\\.]+["\'`]', re.DOTALL),
    
    # Assistant thinking and tool use
    "thinking": re.compile(r'<thinking>(.*?)</thinking>', re.DOTALL),
    "attempt_completion": re.compile(r'<attempt_completion>.*?<result>(.*?)</result>.*?</attempt_completion>', re.DOTALL),
    
    # Remove tool uses but keep some info
    "tool_use_patterns": {
        # Tool uses to completely remove
        "write_to_file": re.compile(r'<write_to_file>.*?</write_to_file>', re.DOTALL),
        "apply_diff": re.compile(r'<apply_diff>.*?</apply_diff>', re.DOTALL),
        "execute_command": re.compile(r'<execute_command>.*?</execute_command>', re.DOTALL),
        "browser_action": re.compile(r'<browser_action>.*?</browser_action>', re.DOTALL),
        "switch_mode": re.compile(r'<switch_mode>.*?</switch_mode>', re.DOTALL),
        "use_mcp_tool": re.compile(r'<use_mcp_tool>.*?</use_mcp_tool>', re.DOTALL),
        "access_mcp_resource": re.compile(r'<access_mcp_resource>.*?</access_mcp_resource>', re.DOTALL),
        "insert_content": re.compile(r'<insert_content>.*?</insert_content>\s*', re.DOTALL),
        "search_and_replace": re.compile(r'<search_and_replace>.*?</search_and_replace>\s*', re.DOTALL),
        
        # Tool uses to keep the question
        "ask_followup_question": re.compile(r'<ask_followup_question>\s*<question>(.*?)</question>.*?</ask_followup_question>', re.DOTALL),
        
        # Tool uses to remove completely
        "read_file": re.compile(r'<read_file>.*?</read_file>\s*', re.DOTALL),
        "list_files": re.compile(r'<list_files>.*?</list_files>\s*', re.DOTALL),
        "search_files": re.compile(r'<search_files>.*?</search_files>\s*', re.DOTALL),
        "list_code_definition_names": re.compile(r'<list_code_definition_names>.*?</list_code_definition_names>\s*', re.DOTALL),
    },
    
    # Code formatting
    "line_numbers": re.compile(r'^\s*\d+ \|', re.MULTILINE),
    
    # Duplicated responses
    "system_error_messages": re.compile(r'\[ERROR\].*?ensure proper parsing and execution.*?Next Steps', re.DOTALL),
}


def extract_conversation(file_path: str) -> List[Tuple[str, str]]:
    """Extract the conversation from a Cline task file."""
    with open(file_path, 'r', encoding='utf-8') as f:
        content = f.read()
    
    # Pattern optimized for Roo-Code's export format
    # Format: "**User:**" or "**Assistant:**" followed by content and separated by "---"
    pattern = r'\*\*(User|Assistant):\*\*\n\n(.*?)(?=\n---\n\n\*\*(?:User|Assistant):\*\*|\Z)'
    
    conversation = []
    for match in re.finditer(pattern, content, re.DOTALL):
        speaker = match.group(1)
        message = match.group(2)
        
        # Clean the message based on speaker type
        if speaker == 'User':
            clean_message = clean_user_message(message)
        else:
            clean_message = clean_assistant_message(message)
        
        # Verify we have content after cleaning
        if clean_message.strip():
            conversation.append((speaker, clean_message))
    
    return conversation


def clean_user_message(message: str) -> str:
    """Clean a user message by removing file content and keeping essential parts."""
    # Remove environment details
    message = PATTERNS["environment_details"].sub('', message)
    
    # Remove tool result sections
    message = PATTERNS["tool_result"].sub('', message)
    
    # Remove file content blocks
    message = PATTERNS["file_content_tag"].sub('', message)
    
    # Remove Roo-Code specific patterns
    message = PATTERNS["roo_tool_use"].sub('', message)
    message = PATTERNS["roo_tool_result"].sub('', message)
    message = PATTERNS["roo_image_reference"].sub('', message)
    
    # Preserve content but remove tags
    message = PATTERNS["task_tag"].sub(r'\1', message)
    message = PATTERNS["feedback_tag"].sub(r'\1', message)
    message = PATTERNS["user_message_tag"].sub(r'\1', message)
    message = PATTERNS["answer_tag"].sub(r'\1', message)
    
    # Remove line numbers in code blocks
    message = PATTERNS["line_numbers"].sub('', message)
    
    # Remove system error messages
    message = PATTERNS["system_error_messages"].sub('', message)
    
    # Remove file output blocks
    message = PATTERNS["file_output_blocks"].sub('', message)
    
    # Remove file path references
    message = PATTERNS["file_path_references"].sub('', message)
    
    # Clean up whitespace
    message = re.sub(r'\n{3,}', '\n\n', message)
    message = re.sub(r'[ \t]+\n', '\n', message)
    message = re.sub(r'\n+[ \t]+\n+', '\n\n', message)
    
    return message.strip()


def clean_assistant_message(message: str) -> str:
    """Clean an assistant message by removing tool usage and keeping thought process."""
    # Process thinking sections without removing them
    def clean_thinking_section(match_obj):
        section = match_obj.group(1)  # Extract content inside thinking tags
        # Clean the thinking section content
        cleaned_thinking = re.sub(PATTERNS["file_content_tag"], '', section)
        cleaned_thinking = re.sub(PATTERNS["file_output_blocks"], '', cleaned_thinking)
        cleaned_thinking = re.sub(PATTERNS["file_path_references"], '', cleaned_thinking)
        return f"<thinking>{cleaned_thinking}</thinking>"
    
    # Apply the cleaning function to all thinking sections
    message = PATTERNS["thinking"].sub(clean_thinking_section, message)
    
    # Extract result content from attempt_completion
    message = PATTERNS["attempt_completion"].sub(r'\1', message)
    
    # Remove tool uses
    for tool_name, pattern in PATTERNS["tool_use_patterns"].items():
        if tool_name == "ask_followup_question":
            # Keep just the question for this tool
            message = pattern.sub(r'\1', message)
        else:
            # Remove other tool uses completely
            message = pattern.sub('', message)
    
    # Remove Roo-Code specific patterns
    message = PATTERNS["roo_tool_use"].sub('', message)
    message = PATTERNS["roo_tool_result"].sub('', message)
    message = PATTERNS["roo_image_reference"].sub('', message)
    
    # Remove file content blocks
    message = PATTERNS["file_content_tag"].sub('', message)
    
    # Remove line numbers in code blocks
    message = PATTERNS["line_numbers"].sub('', message)
    
    # Remove system error messages
    message = PATTERNS["system_error_messages"].sub('', message)
    
    # Remove file output blocks
    message = PATTERNS["file_output_blocks"].sub('', message)
    
    # Remove file path references
    message = PATTERNS["file_path_references"].sub('', message)
    
    # Clean up whitespace
    message = re.sub(r'\n{3,}', '\n\n', message)
    message = re.sub(r'[ \t]+\n', '\n', message)
    message = re.sub(r'\n+[ \t]+\n+', '\n\n', message)
    
    return message.strip()


def remove_duplicates(content: str) -> str:
    """Remove duplicate paragraphs and sections in content."""
    # Split by paragraph
    paragraphs = re.split(r'\n\n+', content)
    
    # Use a set to track seen paragraphs
    seen = set()
    unique_paragraphs = []
    
    for paragraph in paragraphs:
        # Skip very short paragraphs or empty ones
        if len(paragraph.strip()) < 10:
            unique_paragraphs.append(paragraph)
            continue
            
        # Create a simplified version for comparison (lowercase, no spaces)
        simplified = re.sub(r'\s+', '', paragraph.lower())
        
        # Check if we've seen something very similar
        if simplified not in seen:
            seen.add(simplified)
            unique_paragraphs.append(paragraph)
    
    return '\n\n'.join(unique_paragraphs)


def save_clean_conversation(conversation: List[Tuple[str, str]], output_file: str, input_file: str):
    """Save the cleaned conversation to a file."""
    with open(output_file, 'w', encoding='utf-8') as f:
        for i, (speaker, message) in enumerate(conversation):
            if i > 0:
                f.write("\n---\n\n")
            f.write(f"**{speaker}:**\n\n{message}")
    
    # Count tokens in original and cleaned files
    original_size = os.path.getsize(input_file)
    cleaned_size = os.path.getsize(output_file)
    reduction = ((original_size - cleaned_size) / original_size) * 100
    
    return {
        "original_size_bytes": original_size,
        "cleaned_size_bytes": cleaned_size,
        "reduction_percentage": round(reduction, 2)
    }


def main():
    """Main function to parse arguments and run the script."""
    if len(sys.argv) < 2:
        print("Usage: python extract_conversation_simple.py input_file [output_file]")
        return
    
    input_file = sys.argv[1]
    
    # Generate default output filename if not specified
    if len(sys.argv) >= 3:
        output_file = sys.argv[2]
    else:
        input_path = Path(input_file)
        output_file = str(input_path.with_name(f"{input_path.stem}_clean{input_path.suffix}"))
    
    # Extract and clean conversation
    conversation = extract_conversation(input_file)
    
    # Apply duplicate removal to each message
    cleaned_conversation = []
    for speaker, message in conversation:
        cleaned_message = remove_duplicates(message)
        cleaned_conversation.append((speaker, cleaned_message))
    
    # Save cleaned conversation
    metrics = save_clean_conversation(cleaned_conversation, output_file, input_file)
    
    print(f"Cleaned conversation with {len(cleaned_conversation)} messages saved to {output_file}")
    print(f"Size reduction: {metrics['original_size_bytes']:,} bytes → {metrics['cleaned_size_bytes']:,} bytes ({metrics['reduction_percentage']}%)")


if __name__ == "__main__":
    main()",
  "handoffs/0-system/scripts/2-create-milestone.js": "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",
  "handoffs/0-system/scripts/2-create-milestone.py": "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",
  "handoffs/0-system/scripts/README.md": "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",
  "handoffs/0-system/chat-history/README.md": "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"
};

// Configuration for installation
const CONFIG = {
  "directories": [
    {
      "source": "0-instructions",
      "target": "handoffs/0-system/instructions",
      "backup": true
    },
    {
      "source": "2-scripts",
      "target": "handoffs/0-system/scripts",
      "backup": true
    },
    {
      "source": "chat-history-template",
      "target": "handoffs/0-system/chat-history",
      "backup": true,
      "createIfMissing": true
    }
  ],
  "installOptions": {
    "mergeRoomodes": true,
    "mergeClinerules": true,
    "createBackups": true,
    "executable": true
  },
  "nextSteps": [
    "Switch to handoff-manager mode in Roo-Code",
    "Create your first handoff:",
    "I need to create a handoff document for our current work. Please follow the handoff creation workflow."
  ],
  "documentation": [
    "handoffs/0-instructions/0-intro.md",
    "handoffs/0-instructions/1-handoff-instructions.md",
    "handoffs/0-instructions/2-milestone-instructions.md"
  ]
};

// ============= UTILS FUNCTIONS =============
/**
 * Utility functions for the installer
 */




/**
 * Create directories if they don't exist
 * @param {string} dirPath - Path to the directory
 * @returns {boolean} - Whether the directory was created
 */
function ensureDir(dirPath) {
  if (!fs.existsSync(dirPath)) {
    fs.mkdirSync(dirPath, { recursive: true });
    console.log(`- Created directory: ${dirPath}`);
    return true;
  }
  return false;
}

/**
 * Back up an existing directory by renaming it
 * @param {string} dirPath - Path to the directory to back up
 * @returns {string|null} - The backup path or null if no backup needed
 */
function backupDirectory(dirPath) {
  if (!fs.existsSync(dirPath)) {
    return null; // No backup needed
  }
  
  // Base backup name
  let backupPath = `${dirPath}-backup`;
  
  // Check if the backup name already exists
  if (fs.existsSync(backupPath)) {
    // Find the next available numbered backup
    let counter = 1;
    while (fs.existsSync(`${backupPath}-${counter}`)) {
      counter++;
    }
    backupPath = `${backupPath}-${counter}`;
  }
  
  try {
    // Rename the directory to the backup path
    fs.renameSync(dirPath, backupPath);
    console.log(`- Backed up existing directory: ${dirPath} → ${backupPath}`);
    return backupPath;
  } catch (err) {
    console.error(`- Error backing up directory ${dirPath}: ${err.message}`);
    return null;
  }
}

/**
 * Helper function to decode base64 content
 * @param {string} base64Content - Base64 encoded content
 * @returns {string} - Decoded content
 */
function decodeBase64(base64Content) {
  return Buffer.from(base64Content, 'base64').toString('utf8');
}

/**
 * Read a file and encode it as Base64
 * @param {string} filePath - Path to the file
 * @returns {string} - Base64 representation of file content
 */
function encodeFileToBase64(filePath) {
  try {
    // Read the file content
    const content = fs.readFileSync(filePath, 'utf8');
    // Convert to Base64
    return Buffer.from(content, 'utf8').toString('base64');
  } catch (err) {
    console.error(`Error reading file ${filePath}: ${err.message}`);
    return '';
  }
}

/**
 * Recursively collect all files in a directory
 * @param {string} dir - Directory path
 * @param {string} baseDir - Base directory for relative paths
 * @param {number} maxFileSize - Maximum file size to include
 * @param {Object} result - Object to collect file paths
 * @returns {Object} - Object with file paths and contents
 */
function collectFiles(dir, baseDir, maxFileSize, result = {}) {
  try {
    const entries = fs.readdirSync(dir, { withFileTypes: true });
    
    for (const entry of entries) {
      const fullPath = path.join(dir, entry.name);
      const relativePath = path.relative(baseDir, fullPath).replace(/\\/g, '/');
      
      if (entry.isDirectory()) {
        collectFiles(fullPath, baseDir, maxFileSize, result);
      } else {
        // Skip files that are too large
        const stats = fs.statSync(fullPath);
        if (stats.size > maxFileSize) {
          console.log(`- Skipping file (too large): ${relativePath} (${(stats.size / 1024 / 1024).toFixed(2)}MB)`);
          continue;
        }
        
        result[relativePath] = encodeFileToBase64(fullPath);
      }
    }
    
    return result;
  } catch (err) {
    console.error(`Error collecting files from ${dir}: ${err.message}`);
    return result;
  }
}

/**
 * Ensure directory exists for file
 * @param {string} filePath - Path to file
 */
function ensureDirectoryForFile(filePath) {
  const dir = path.dirname(filePath);
  
  if (!fs.existsSync(dir)) {
    fs.mkdirSync(dir, { recursive: true });
    console.log(`- Created directory: ${dir}`);
  }
}



// ============= BACKUP FUNCTIONS =============
/**
 * Backup functions for the installer
 */




/**
 * Handle files and directories that need to be backed up
 * @param {string} targetDir - Target installation directory
 * @returns {Object} - Map of paths to their backup locations
 */
function backupExistingInstallation(targetDir) {
  console.log('\nChecking for existing handoff system installation...');
  const backupPaths = {};
  
  // Check if handoffs directory exists - this is the main indicator of an existing installation
  const handoffsDir = path.join(targetDir, 'handoffs');
  if (fs.existsSync(handoffsDir)) {
    console.log('- Existing handoff system detected');
    
    // Backup the entire handoffs directory
    const handoffsBackupDir = `${handoffsDir}-backup`;
    let backupSuffix = '';
    let counter = 1;
    
    // Find available backup name
    while (fs.existsSync(`${handoffsBackupDir}${backupSuffix}`)) {
      backupSuffix = `-${counter}`;
      counter++;
    }
    
    const finalBackupPath = `${handoffsBackupDir}${backupSuffix}`;
    
    try {
      // Create backup directory
      fs.mkdirSync(finalBackupPath, { recursive: true });
      console.log(`- Created backup directory: ${finalBackupPath}`);
      
      // Copy all existing files to backup instead of renaming
      // This preserves the original in case of installation failure
      const copyDirRecursive = (src, dest) => {
        // Create destination directory
        fs.mkdirSync(dest, { recursive: true });
        
        // Read directory contents
        const entries = fs.readdirSync(src, { withFileTypes: true });
        
        for (const entry of entries) {
          const srcPath = path.join(src, entry.name);
          const destPath = path.join(dest, entry.name);
          
          if (entry.isDirectory()) {
            // Recursive call for directories
            copyDirRecursive(srcPath, destPath);
          } else {
            // Copy file
            fs.copyFileSync(srcPath, destPath);
          }
        }
      };
      
      // Copy all files from handoffs to backup
      copyDirRecursive(handoffsDir, finalBackupPath);
      console.log(`- Backed up handoffs directory to ${finalBackupPath}`);
      backupPaths['handoffs'] = finalBackupPath;
    } catch (err) {
      console.error(`- Error backing up handoffs directory: ${err.message}`);
    }
  } else {
    console.log('- No existing handoff system detected');
  }
  
  return backupPaths;
}



// ============= CONFIG-MERGER FUNCTIONS =============
/**
 * Configuration merging functions for the installer
 */




/**
 * Create a backup file with .bak extension
 * @param {string} filePath - Path to the file to backup
 * @returns {boolean} - Success status
 */
function createBackupFile(filePath) {
  try {
    if (fs.existsSync(filePath)) {
      const backupPath = `${filePath}.bak`;
      fs.copyFileSync(filePath, backupPath);
      console.log(`- Created backup of ${path.basename(filePath)} at ${backupPath}`);
      return true;
    }
    return false;
  } catch (err) {
    console.error(`- Error creating backup file: ${err.message}`);
    return false;
  }
}

/**
 * Merge custom modes from two .roomodes files
 * @param {string} existingPath - Path to existing .roomodes file
 * @param {string} newPath - Path to new .roomodes file
 * @param {string} outputPath - Path to output merged .roomodes file
 * @returns {boolean} - Success status
 */
function mergeRoomodes(existingPath, newPath, outputPath) {
  try {
    // Read existing .roomodes if it exists
    let mergedContent = { customModes: [] };
    
    if (existingPath && fs.existsSync(existingPath)) {
      console.log('- Found existing .roomodes file, merging content');
      try {
        const existingContent = JSON.parse(fs.readFileSync(existingPath, 'utf8'));
        
        // Import existing custom modes
        if (existingContent.customModes && Array.isArray(existingContent.customModes)) {
          // Filter out any existing handoff-manager mode
          mergedContent.customModes = existingContent.customModes.filter(
            mode => mode.slug !== 'handoff-manager'
          );
          console.log(`- Preserved ${mergedContent.customModes.length} existing custom modes`);
        } else {
          console.log('- No existing custom modes found or invalid format');
        }
      } catch (parseErr) {
        console.error(`- Error parsing existing .roomodes file: ${parseErr.message}`);
        console.log('- Creating new .roomodes file with handoff-manager mode only');
      }
    } else {
      console.log('- No existing .roomodes file found, creating new one');
    }
    
    // Read new .roomodes
    if (newPath && fs.existsSync(newPath)) {
      try {
        const newContent = JSON.parse(fs.readFileSync(newPath, 'utf8'));
        
        // Add handoff-manager mode
        if (newContent.customModes && Array.isArray(newContent.customModes)) {
          const handoffManagerMode = newContent.customModes.find(
            mode => mode.slug === 'handoff-manager'
          );
          
          if (handoffManagerMode) {
            mergedContent.customModes.push(handoffManagerMode);
            console.log('- Added handoff-manager mode to configuration');
          } else {
            console.warn('- Warning: handoff-manager mode not found in new .roomodes file');
          }
        }
      } catch (parseErr) {
        console.error(`- Error parsing new .roomodes file: ${parseErr.message}`);
        return false;
      }
    } else {
      console.warn('- Warning: New .roomodes file not found');
      return false;
    }
    
    // Write merged content
    fs.writeFileSync(outputPath, JSON.stringify(mergedContent, null, 2));
    console.log('- Successfully merged .roomodes file');
    return true;
  } catch (err) {
    console.error(`- Error merging .roomodes files: ${err.message}`);
    return false;
  }
}

/**
 * Merge .clinerules files
 * @param {string} existingPath - Path to existing .clinerules file
 * @param {string} newPath - Path to new .clinerules file
 * @param {string} outputPath - Path to output merged .clinerules file
 * @returns {boolean} - Success status
 */
function mergeClinerules(existingPath, newPath, outputPath) {
  try {
    let mergedContent = '';
    
    // Read existing .clinerules if it exists
    if (existingPath && fs.existsSync(existingPath)) {
      console.log('- Found existing .clinerules file');
      const existingContent = fs.readFileSync(existingPath, 'utf8');
      
      // Always start with existing content
      mergedContent = existingContent;
      
      // Check if handoff system rules already exist
      if (existingContent.includes('Handoff System Rules')) {
        console.log('- Handoff System Rules already exist in .clinerules, preserving existing content');
        // We just keep the existing content and don't append new rules
        return true;
      }
      
      console.log('- No existing Handoff System Rules found, appending new rules');
      
      // Add blank line if needed before appending new content
      if (!mergedContent.endsWith('\n\n')) {
        if (mergedContent.endsWith('\n')) {
          mergedContent += '\n';
        } else {
          mergedContent += '\n\n';
        }
      }
    } else {
      console.log('- No existing .clinerules file found, creating new one');
    }
    
    // Add new rules
    if (newPath && fs.existsSync(newPath)) {
      const newContent = fs.readFileSync(newPath, 'utf8');
      console.log('- Adding Handoff System Rules to .clinerules');
      mergedContent += newContent;
    } else {
      console.warn('- Warning: New .clinerules file not found');
      return false;
    }
    
    // Write merged content
    fs.writeFileSync(outputPath, mergedContent);
    console.log('- Successfully updated .clinerules file');
    return true;
  } catch (err) {
    console.error(`- Error merging .clinerules files: ${err.message}`);
    return false;
  }
}

/**
 * Process configuration files merging in the target directory
 * @param {string} targetDir - Target directory
 * @param {Object} CONFIG - Configuration object
 * @param {Object} FILES - Files object with decoded content
 */
function processConfigMerging(targetDir, CONFIG, FILES) {
  // Merge configuration files if needed
  if (CONFIG.installOptions.mergeRoomodes) {
    console.log('\nConfiguring custom modes...');
    
    // Get paths for .roomodes files
    const existingRoomodesPath = path.join(targetDir, '.roomodes');
    const tempNewRoomodesPath = path.join(targetDir, '.roomodes.new');
    const tempRoomodesPath = path.join(targetDir, '.roomodes.temp');
    
    try {
      // Create a permanent backup first if the file exists (requested safety net)
      if (fs.existsSync(existingRoomodesPath)) {
        createBackupFile(existingRoomodesPath);
      }
      
      // Create a temporary file with the new content from FILES
      if (FILES && FILES['.roomodes']) {
        fs.writeFileSync(tempNewRoomodesPath, FILES['.roomodes']);
        console.log('- Created temporary file with new .roomodes content');
      } else {
        console.error('- Error: No .roomodes content found in FILES');
        console.log('- Attempting to locate .roomodes from fallback sources...');
        
        // Try to find the file in the source directory structure
        const sourceRoomodesPath = path.join(process.cwd(), 'handoff-system', '1-handoff-custom-mode', '.roomodes');
        
        if (fs.existsSync(sourceRoomodesPath)) {
          console.log(`- Found fallback .roomodes at: ${sourceRoomodesPath}`);
          fs.copyFileSync(sourceRoomodesPath, tempNewRoomodesPath);
          console.log('- Created temporary file from fallback location');
        } else {
          console.error('- CRITICAL ERROR: Could not find .roomodes file anywhere');
          
          // Create a minimal .roomodes with just the handoff-manager mode
          const minimalRoomodes = JSON.stringify({
            customModes: [{
              slug: "handoff-manager",
              name: "Handoff Manager",
              roleDefinition: "You are Roo, a comprehensive Handoff System Manager. You help users create, organize, and utilize handoff and milestone documents to maintain optimal context between LLM sessions.",
              groups: ["read", ["edit", {"fileRegex": ".*/handoffs/(?!0-system/chat_history/).*\\.md$|.*/[0-9]+-.*?/.*\\.md$|.*/[0-9]+-.*\\.md$|\\.clinerules$", "description": "Handoff and milestone documents, and project rules"}], "command"],
              customInstructions: "Follow the handoff system guidelines to create and manage handoff documents."
            }]
          }, null, 2);
          
          fs.writeFileSync(tempNewRoomodesPath, minimalRoomodes);
          console.log('- Created minimal .roomodes file as last resort');
        }
      }
      
      // Create a backup of the existing .roomodes file if it exists
      if (fs.existsSync(existingRoomodesPath)) {
        try {
          // Copy the existing file to a temporary location for backup
          fs.copyFileSync(existingRoomodesPath, tempRoomodesPath);
          console.log('- Created temporary backup of existing .roomodes file');
          
          // Now merge the existing and new content
          const success = mergeRoomodes(existingRoomodesPath, tempNewRoomodesPath, existingRoomodesPath);
          
          // Clean up the temporary files
          if (fs.existsSync(tempRoomodesPath)) {
            fs.unlinkSync(tempRoomodesPath);
          }
          if (fs.existsSync(tempNewRoomodesPath)) {
            fs.unlinkSync(tempNewRoomodesPath);
          }
          
          if (success) {
            console.log('- Custom modes configuration complete');
          }
        } catch (err) {
          console.error(`- Error during .roomodes merging: ${err.message}`);
          
          // Restore from backup if available
          if (fs.existsSync(tempRoomodesPath)) {
            try {
              fs.copyFileSync(tempRoomodesPath, existingRoomodesPath);
              console.log('- Restored .roomodes from backup after error');
              fs.unlinkSync(tempRoomodesPath);
            } catch (restoreErr) {
              console.error(`- Error restoring .roomodes backup: ${restoreErr.message}`);
            }
          }
          
          // Clean up the new temp file as well
          if (fs.existsSync(tempNewRoomodesPath)) {
            fs.unlinkSync(tempNewRoomodesPath);
          }
        }
      } else {
        console.log('- No existing .roomodes file found, creating new one');
        // Just copy the temp file to the destination
        fs.copyFileSync(tempNewRoomodesPath, existingRoomodesPath);
        console.log('- Created new .roomodes file');
        
        // Clean up the temp file
        if (fs.existsSync(tempNewRoomodesPath)) {
          fs.unlinkSync(tempNewRoomodesPath);
        }
      }
    } catch (err) {
      console.error(`- Error processing .roomodes: ${err.message}`);
      
      // Clean up any temp files
      if (fs.existsSync(tempRoomodesPath)) {
        fs.unlinkSync(tempRoomodesPath);
      }
      if (fs.existsSync(tempNewRoomodesPath)) {
        fs.unlinkSync(tempNewRoomodesPath);
      }
    }
  }
  
  if (CONFIG.installOptions.mergeClinerules) {
    console.log('\nConfiguring handoff rules...');
    
    // Get paths for .clinerules files
    const existingClinerules = path.join(targetDir, '.clinerules');
    const tempNewClinerules = path.join(targetDir, '.clinerules.new');
    const tempClinerules = path.join(targetDir, '.clinerules.temp');
    
    try {
      // Create a permanent backup first if the file exists (requested safety net)
      if (fs.existsSync(existingClinerules)) {
        createBackupFile(existingClinerules);
      }
      
      // Create a temporary file with the new content from FILES
      if (FILES && FILES['.clinerules']) {
        fs.writeFileSync(tempNewClinerules, FILES['.clinerules']);
        console.log('- Created temporary file with new .clinerules content');
      } else {
        console.error('- Error: No .clinerules content found in FILES');
        console.log('- Attempting to locate .clinerules from fallback sources...');
        
        // Try to find the file in the source directory structure
        const sourceClinerulesPath = path.join(process.cwd(), 'handoff-system', '1-handoff-custom-mode', '.clinerules');
        
        if (fs.existsSync(sourceClinerulesPath)) {
          console.log(`- Found fallback .clinerules at: ${sourceClinerulesPath}`);
          fs.copyFileSync(sourceClinerulesPath, tempNewClinerules);
          console.log('- Created temporary file from fallback location');
        } else {
          console.error('- CRITICAL ERROR: Could not find .clinerules file anywhere');
          
          // Create a minimal .clinerules as last resort
          const minimalClinerules = `
# Handoff System Rules

## File Safety
- Never delete handoff documents without explicit confirmation
- Use versioning when making major changes to documents
- Keep handoff numbering sequential

## Structure Rules
- Place handoff documents directly in the handoffs/ root directory
- Place chat history files only in the 0-system/chat_history directory
- Use the 0-system directory only for system files, not handoffs

## Workflow Guidelines
- Run extraction scripts before attempting to read conversation files
- Verify files moved to milestone directories have been copied correctly
- Always document deviations from original plans
`;
          
          fs.writeFileSync(tempNewClinerules, minimalClinerules);
          console.log('- Created minimal .clinerules file as last resort');
        }
      }
      
      // Create a backup of the existing .clinerules file if it exists
      if (fs.existsSync(existingClinerules)) {
        try {
          // Copy the existing file to a temporary location for backup
          fs.copyFileSync(existingClinerules, tempClinerules);
          console.log('- Created temporary backup of existing .clinerules file');
          
          // Now merge the existing and new content
          const success = mergeClinerules(existingClinerules, tempNewClinerules, existingClinerules);
          
          // Clean up the temporary files
          if (fs.existsSync(tempClinerules)) {
            fs.unlinkSync(tempClinerules);
          }
          if (fs.existsSync(tempNewClinerules)) {
            fs.unlinkSync(tempNewClinerules);
          }
          
          if (success) {
            console.log('- Handoff rules configuration complete');
          }
        } catch (err) {
          console.error(`- Error during .clinerules merging: ${err.message}`);
          
          // Restore from backup if available
          if (fs.existsSync(tempClinerules)) {
            try {
              fs.copyFileSync(tempClinerules, existingClinerules);
              console.log('- Restored .clinerules from backup after error');
              fs.unlinkSync(tempClinerules);
            } catch (restoreErr) {
              console.error(`- Error restoring .clinerules backup: ${restoreErr.message}`);
            }
          }
          
          // Clean up the new temp file as well
          if (fs.existsSync(tempNewClinerules)) {
            fs.unlinkSync(tempNewClinerules);
          }
        }
      } else {
        console.log('- No existing .clinerules file found, creating new one');
        // Just copy the temp file to the destination
        fs.copyFileSync(tempNewClinerules, existingClinerules);
        console.log('- Created new .clinerules file');
        
        // Clean up the temp file
        if (fs.existsSync(tempNewClinerules)) {
          fs.unlinkSync(tempNewClinerules);
        }
      }
    } catch (err) {
      console.error(`- Error processing .clinerules: ${err.message}`);
      
      // Clean up any temp files
      if (fs.existsSync(tempClinerules)) {
        fs.unlinkSync(tempClinerules);
      }
      if (fs.existsSync(tempNewClinerules)) {
        fs.unlinkSync(tempNewClinerules);
      }
    }
  }
}



// ============= FILE-WRITER FUNCTIONS =============
/**
 * File writing functions for the installer
 */




/**
 * Function to write all files from the FILES object
 * @param {string} targetDir - Target directory
 * @param {Object} FILES - Files object with decoded content
 */
function writeAllFiles(targetDir, FILES) {
  console.log('\nWriting files...');
  
  // Track which critical files we've processed
  const criticalFiles = {
    '.roomodes': false,
    '.clinerules': false
  };
  
  for (const [filePath, content] of Object.entries(FILES)) {
    try {
      // Check if this is a critical file
      if (filePath === '.roomodes' || filePath === '.clinerules') {
        // Mark as processed but don't write yet - will be handled by config merger
        criticalFiles[filePath] = true;
        console.log(`- Registered ${filePath} for merging`);
        continue;
      }
      
      // Get the full path
      const fullPath = path.join(targetDir, filePath);
      
      // Create directory if it doesn't exist
      const dirPath = path.dirname(fullPath);
      if (!fs.existsSync(dirPath)) {
        fs.mkdirSync(dirPath, { recursive: true });
      }
      
      // Write the file
      fs.writeFileSync(fullPath, content);
      console.log(`- Created: ${filePath}`);
    } catch (err) {
      console.error(`- Error writing file ${filePath}: ${err.message}`);
    }
  }
  
  // Ensure critical files exist by writing them directly if not found in target directory
  for (const [filePath, processed] of Object.entries(criticalFiles)) {
    if (processed) {
      // We'll let the config merger handle these
      continue;
    }
    
    // Critical file was not in FILES
    console.warn(`- Warning: ${filePath} not included in installation package`);
  }
}



// ============= INSTALLER FUNCTIONS =============
/**
 * Main installer function for the handoff manager
 */








/**
 * Main installation function
 * @param {string} targetDir - Target directory
 * @param {Object} CONFIG - Configuration object
 * @param {Object} FILES - Files object with decoded content
 * @param {string} version - Version number
 * @returns {boolean} - Success status
 */
async function installHandoffManager(targetDir, CONFIG, FILES, version) {
  try {
    // First backup any existing handoff system
    const backupPaths = CONFIG.installOptions.createBackups ? 
      backup.backupExistingInstallation(targetDir) : {};
    
    // Write all files to the target directory
    fileWriter.writeAllFiles(targetDir, FILES);
    
    // Create handoffs directory if it doesn't exist
    const targetHandoffsDir = path.join(targetDir, 'handoffs');
    utils.ensureDir(targetHandoffsDir);
    
    // Merge configuration files if needed
    configMerger.processConfigMerging(targetDir, CONFIG, FILES);
    
    // Display success message and next steps
    console.log(`
╔══════════════════════════════════════════════════╗
║                                                  ║
║         Handoff Manager Install Complete         ║
║                                                  ║
╚══════════════════════════════════════════════════╝

The Handoff Manager (v${version}) has been installed to ${targetDir}

Files installed:
- Custom mode in .roomodes
- Handoff rules in .clinerules
- System prompt (if applicable)
${CONFIG.directories.map(dir => `- ${dir.target}`).join('\n')}
${Object.keys(backupPaths).length > 0 ? `
Backup created:` : ''}
${Object.entries(backupPaths).map(([dir, path]) => `- Previous ${dir} preserved in ${path}`).join('\n')}

Next Steps:
${CONFIG.nextSteps.map(step => `${step}`).join('\n')}

For documentation, see:
${CONFIG.documentation.map(doc => `- ${doc}`).join('\n')}`);
    
    return true;
  } catch (error) {
    console.error('Error during installation:', error);
    return false;
  }
}



// Files object with decoded content (for internal use)
const FILES = Object.fromEntries(
  Object.entries(BASE64_FILES).map(([filePath, content]) => [filePath, decodeBase64(content)])
);

// Main installation function
async function installHandoffManager() {
  try {
    // First backup any existing handoff system
    const backupPaths = CONFIG.installOptions.createBackups ? 
      backupExistingInstallation(targetDir) : {};
    
    // Write all files to the target directory
    writeAllFiles(targetDir, FILES);
    
    // Create handoffs directory if it doesn't exist
    const targetHandoffsDir = path.join(targetDir, 'handoffs');
    ensureDir(targetHandoffsDir);
    
    // Merge configuration files if needed
    processConfigMerging(targetDir, CONFIG, FILES);
    
    // Display success message and next steps
    console.log(`
╔══════════════════════════════════════════════════╗
║                                                  ║
║         Handoff Manager Install Complete         ║
║                                                  ║
╚══════════════════════════════════════════════════╝

The Handoff Manager (v1.1.0) has been installed to ${targetDir}

Files installed:
- Custom mode in .roomodes
- Handoff rules in .clinerules
- System prompt in .roo directory (required location for Roo-Code to detect it)
${CONFIG.directories.map(dir => `- ${dir.target}`).join('\n')}
${Object.keys(backupPaths).length > 0 ? `
Backup created:` : ''}
${Object.entries(backupPaths).map(([dir, path]) => `- Previous ${dir} preserved in ${path}`).join('\n')}

Next Steps:
${CONFIG.nextSteps.map(step => `${step}`).join('\n')}

For documentation, see:
${CONFIG.documentation.map(doc => `- ${doc}`).join('\n')}`);
    
    return true;
  } catch (error) {
    console.error('Error during installation:', error);
    return false;
  }
}

// Execute the installation
installHandoffManager();