plcode-linux-arm64-musl 2.1.0

package/.plcode/context/core/workflows/feature-breakdown.md

@@ -0,0 +1,303 @@
+<!-- Context: workflows/task-breakdown | Priority: high | Version: 2.0 | Updated: 2025-01-21 -->
+
+# Task Breakdown Guidelines
+
+## Quick Reference
+
+**When to Use**: 4+ files, >60 min effort, complex dependencies, multi-step coordination
+
+**Process**: Scope → Phases → Small Tasks (1-2h) → Dependencies → Estimates
+
+**Template Sections**: Overview, Prerequisites, Tasks (by Phase), Testing Strategy, Total Estimate, Notes
+
+**Best Practices**: Keep tasks small (1-2h), make dependencies clear, include verification, be realistic with estimates
+
+---
+
+## Purpose
+
+Framework for breaking down complex tasks into manageable, sequential subtasks.
+
+## When to Use
+
+Reference this when:
+
+- Task involves 4+ files
+- Estimated effort >60 minutes
+- Complex dependencies exist
+- Multi-step coordination needed
+- User requests task breakdown
+
+## Breakdown Process
+
+### 1. Understand the Full Scope
+
+- What's the complete requirement?
+- What are all the components needed?
+- What's the end goal?
+- What are the constraints?
+
+### 2. Identify Major Phases
+
+- What are the logical groupings?
+- What must happen first?
+- What can happen in parallel?
+- What depends on what?
+
+### 3. Break Into Small Tasks
+
+- Each task should be 1-2 hours max
+- Clear, actionable items
+- Independently completable
+- Easy to verify completion
+
+### 4. Define Dependencies
+
+- What must be done first?
+- What can be done in parallel?
+- What blocks what?
+- What's the critical path?
+
+### 5. Estimate Effort
+
+- Realistic time estimates
+- Include testing time
+- Account for unknowns
+- Add buffer for complexity
+
+## Breakdown Template
+
+```markdown
+# Task Breakdown: {Task Name}
+
+## Overview
+
+{1-2 sentence description of what we're building}
+
+## Prerequisites
+
+- [ ] {Prerequisite 1}
+- [ ] {Prerequisite 2}
+
+## Tasks
+
+### Phase 1: {Phase Name}
+
+**Goal:** {What this phase accomplishes}
+
+- [ ] **Task 1.1:** {Description}
+  - **Files:** {files to create/modify}
+  - **Estimate:** {time estimate}
+  - **Dependencies:** {none / task X}
+  - **Verification:** {how to verify it's done}
+
+- [ ] **Task 1.2:** {Description}
+  - **Files:** {files to create/modify}
+  - **Estimate:** {time estimate}
+  - **Dependencies:** {task 1.1}
+  - **Verification:** {how to verify it's done}
+
+### Phase 2: {Phase Name}
+
+**Goal:** {What this phase accomplishes}
+
+- [ ] **Task 2.1:** {Description}
+  - **Files:** {files to create/modify}
+  - **Estimate:** {time estimate}
+  - **Dependencies:** {phase 1 complete}
+  - **Verification:** {how to verify it's done}
+
+## Testing Strategy
+
+- [ ] Unit tests for {component}
+- [ ] Integration tests for {flow}
+- [ ] Manual testing: {scenarios}
+
+## Total Estimate
+
+**Time:** {X} hours
+**Complexity:** {Low / Medium / High}
+
+## Notes
+
+{Any important context, decisions, or considerations}
+```
+
+## Example Breakdown
+
+```markdown
+# Task Breakdown: User Authentication System
+
+## Overview
+
+Build authentication system with login, registration, and password reset.
+
+## Prerequisites
+
+- [ ] Database schema designed
+- [ ] Email service configured
+
+## Tasks
+
+### Phase 1: Core Authentication
+
+**Goal:** Basic login/logout functionality
+
+- [ ] **Task 1.1:** Create user model and database schema
+  - **Files:** `models/user.js`, `migrations/001_users.sql`
+  - **Estimate:** 1 hour
+  - **Dependencies:** none
+  - **Verification:** Can create user in database
+
+- [ ] **Task 1.2:** Implement password hashing
+  - **Files:** `utils/password.js`
+  - **Estimate:** 30 min
+  - **Dependencies:** Task 1.1
+  - **Verification:** Passwords are hashed, not plain text
+
+- [ ] **Task 1.3:** Create login endpoint
+  - **Files:** `routes/auth.js`, `controllers/auth.js`
+  - **Estimate:** 1.5 hours
+  - **Dependencies:** Task 1.1, 1.2
+  - **Verification:** Can login with valid credentials
+
+### Phase 2: Registration
+
+**Goal:** New user registration
+
+- [ ] **Task 2.1:** Create registration endpoint
+  - **Files:** `routes/auth.js`, `controllers/auth.js`
+  - **Estimate:** 1 hour
+  - **Dependencies:** Phase 1 complete
+  - **Verification:** Can create new user account
+
+- [ ] **Task 2.2:** Add email validation
+  - **Files:** `utils/validation.js`
+  - **Estimate:** 30 min
+  - **Dependencies:** Task 2.1
+  - **Verification:** Invalid emails rejected
+
+### Phase 3: Password Reset
+
+**Goal:** Users can reset forgotten passwords
+
+- [ ] **Task 3.1:** Generate reset tokens
+  - **Files:** `utils/tokens.js`
+  - **Estimate:** 1 hour
+  - **Dependencies:** Phase 1 complete
+  - **Verification:** Tokens generated and validated
+
+- [ ] **Task 3.2:** Create reset endpoints
+  - **Files:** `routes/auth.js`, `controllers/auth.js`
+  - **Estimate:** 1.5 hours
+  - **Dependencies:** Task 3.1
+  - **Verification:** Can request and complete password reset
+
+- [ ] **Task 3.3:** Send reset emails
+  - **Files:** `services/email.js`
+  - **Estimate:** 1 hour
+  - **Dependencies:** Task 3.2
+  - **Verification:** Reset emails sent successfully
+
+## Testing Strategy
+
+- [ ] Unit tests for password hashing
+- [ ] Unit tests for token generation
+- [ ] Integration tests for login flow
+- [ ] Integration tests for registration flow
+- [ ] Integration tests for password reset flow
+- [ ] Manual testing: Complete user journey
+
+## Total Estimate
+
+**Time:** 8.5 hours
+**Complexity:** Medium
+
+## Notes
+
+- Use bcrypt for password hashing (industry standard)
+- Reset tokens expire after 1 hour
+- Rate limit password reset requests
+- Email service must be configured before Phase 3
+```
+
+## Best Practices
+
+### Keep Tasks Small
+
+- 1-2 hours maximum per task
+- If larger, break it down further
+- Each task should be completable in one sitting
+
+### Make Dependencies Clear
+
+- Explicitly state what must be done first
+- Identify parallel work opportunities
+- Note blocking dependencies
+
+### Include Verification
+
+- How do you know the task is done?
+- What should work when complete?
+- How can it be tested?
+
+### Be Realistic with Estimates
+
+- Include time for testing
+- Account for unknowns
+- Add buffer for complexity
+- Better to overestimate than underestimate
+
+### Group Related Work
+
+- Organize by feature or component
+- Keep related tasks together
+- Make phases logical and cohesive
+
+## Common Patterns
+
+### Database-First Pattern
+
+1. Design schema
+2. Create migrations
+3. Build models
+4. Implement business logic
+5. Add API endpoints
+6. Write tests
+
+### Feature-First Pattern
+
+1. Define requirements
+2. Design interface
+3. Implement core logic
+4. Add error handling
+5. Write tests
+6. Document usage
+
+### Refactoring Pattern
+
+1. Add tests for existing behavior
+2. Refactor small section
+3. Verify tests still pass
+4. Repeat for next section
+5. Clean up and optimize
+6. Update documentation
+
+## Quick Reference
+
+**Good breakdown:**
+
+- Small, focused tasks (1-2 hours)
+- Clear dependencies
+- Realistic estimates
+- Verification criteria
+- Logical phases
+
+**Breakdown checklist:**
+
+- [ ] All requirements captured
+- [ ] Tasks are small and focused
+- [ ] Dependencies identified
+- [ ] Estimates are realistic
+- [ ] Testing included
+- [ ] Verification criteria clear

package/.plcode/context/core/workflows/navigation.md

@@ -0,0 +1,44 @@
+# Core Workflows Navigation
+
+**Purpose**: Process workflows for common development tasks
+
+---
+
+## Files
+
+| File                    | Topic                    | Priority | Load When               |
+| ----------------------- | ------------------------ | -------- | ----------------------- |
+| `code-review.md`        | Code review process      | ⭐⭐⭐⭐ | Reviewing code          |
+| `task-delegation.md`    | Delegating to subagents  | ⭐⭐⭐⭐ | Using task tool         |
+| `feature-breakdown.md`  | Breaking down features   | ⭐⭐⭐⭐ | 4+ files, complex tasks |
+| `session-management.md` | Managing sessions        | ⭐⭐⭐   | Session cleanup         |
+| `design-iteration.md`   | Design iteration process | ⭐⭐⭐   | Design work             |
+
+---
+
+## Loading Strategy
+
+**For code review**:
+
+1. Load `code-review.md` (high)
+2. Depends on: `../standards/code-quality.md`, `../standards/security-patterns.md`
+
+**For task delegation**:
+
+1. Load `task-delegation.md` (high)
+
+**For complex features**:
+
+1. Load `feature-breakdown.md` (high)
+2. Depends on: `task-delegation.md`
+
+**For session management**:
+
+1. Load `session-management.md` (medium)
+
+---
+
+## Related
+
+- **Standards** → `../standards/navigation.md`
+- **OpenAgents Delegation** → `../../openagents-repo/guides/subagent-invocation.md`

package/.plcode/context/core/workflows/review.md

@@ -0,0 +1 @@
+code-review.md

package/.plcode/context/core/workflows/session-management.md

@@ -0,0 +1,162 @@
+<!-- Context: workflows/sessions | Priority: medium | Version: 2.0 | Updated: 2025-01-21 -->
+
+# Session Management
+
+## Quick Reference
+
+**Key Principle**: Lazy initialization - only create when needed
+
+**Session ID**: `{timestamp}-{random-4-chars}` (e.g., `20250118-143022-a4f2`)
+
+**Cleanup**: Always ask user confirmation before deleting
+
+**Safety**: NEVER delete outside current session, ONLY delete tracked files, ALWAYS confirm
+
+---
+
+## Lazy Initialization
+
+**Only create session when first context file needed**
+
+- Don't create sessions for simple questions or direct execution
+- Initialize on first delegation that requires context file
+- Session ID format: `{timestamp}-{random-4-chars}`
+- Example: `20250118-143022-a4f2`
+
+## Session Structure
+
+```
+.tmp/sessions/{session-id}/
+├── .manifest.json
+├── features/
+│   └── {task-name}-context.md
+├── documentation/
+│   └── {task-name}-context.md
+├── code/
+│   └── {task-name}-context.md
+├── tasks/
+│   └── {task-name}-tasks.md
+└── general/
+    └── {task-name}-context.md
+```
+
+## Session Isolation
+
+**Each session has unique ID - prevents concurrent agent conflicts**
+
+✅ Multiple agent instances can run simultaneously
+✅ No file conflicts between sessions
+✅ Each session tracks only its own files
+✅ Safe cleanup - only deletes own session folder
+
+## Manifest Structure
+
+**Location**: `.tmp/sessions/{session-id}/.manifest.json`
+
+```json
+{
+  "session_id": "20250118-143022-a4f2",
+  "created_at": "2025-01-18T14:30:22Z",
+  "last_activity": "2025-01-18T14:35:10Z",
+  "context_files": {
+    "features/user-auth-context.md": {
+      "created": "2025-01-18T14:30:22Z",
+      "for": "@TaskManager",
+      "keywords": ["user-auth", "authentication", "features"]
+    },
+    "tasks/user-auth-tasks.md": {
+      "created": "2025-01-18T14:32:15Z",
+      "for": "@TaskManager",
+      "keywords": ["user-auth", "tasks", "breakdown"]
+    }
+  },
+  "context_index": {
+    "user-auth": ["features/user-auth-context.md", "tasks/user-auth-tasks.md"]
+  }
+}
+```
+
+## Activity Tracking
+
+**Update timestamp after each context file creation or delegation**
+
+- Update `last_activity` field in manifest
+- Used for stale session detection
+- Helps identify active vs abandoned sessions
+
+## Cleanup Policy
+
+### Manual Cleanup (Preferred)
+
+**Ask user confirmation before cleanup**
+
+After task completion:
+
+1. Ask: "Should I clean up temporary session files at `.tmp/sessions/{session-id}/`?"
+2. Wait for user confirmation
+3. Only delete files tracked in current session's manifest
+4. Remove entire session folder: `.tmp/sessions/{session-id}/`
+
+### Safety Rules
+
+- **NEVER** delete files outside current session
+- **ONLY** delete files tracked in manifest
+- **ALWAYS** confirm with user before cleanup
+
+### Stale Session Cleanup
+
+**Auto-remove sessions >24 hours old**
+
+- Check `last_activity` timestamp in manifest
+- Safe to run periodically (see `scripts/cleanup-stale-sessions.sh`)
+- Won't affect active sessions
+
+## Error Handling
+
+### Subagent Failure
+
+- Report error to user
+- Ask if should retry or abort
+- Don't auto-retry without approval
+
+### Context File Error
+
+- Fall back to inline context in delegation prompt
+- Warn user that context file creation failed
+- Continue with task if possible
+
+### Session Creation Error
+
+- Continue without session
+- Warn user
+- Use inline context for delegation
+- Don't block task execution
+
+## Best Practices
+
+1. **Lazy Init**: Only create session when actually needed
+2. **Track Everything**: Add all context files to manifest
+3. **Update Activity**: Touch `last_activity` on each operation
+4. **Clean Promptly**: Remove files after task completion
+5. **Isolate Sessions**: Never access files from other sessions
+6. **Confirm Cleanup**: Always ask user before deleting
+
+## Example Workflow
+
+```bash
+# User: "Build user authentication system"
+# → Complex task, needs context file
+# → Create session: 20250118-143022-a4f2
+# → Create: .tmp/sessions/20250118-143022-a4f2/features/user-auth-context.md
+# → Delegate to @task-manager
+
+# User: "Implement login component"
+# → Same session, add context
+# → Create: .tmp/sessions/20250118-143022-a4f2/code/login-context.md
+# → Delegate to @coder-agent
+
+# Task complete
+# → Ask: "Clean up session files?"
+# → User confirms
+# → Delete: .tmp/sessions/20250118-143022-a4f2/
+```

package/.plcode/context/core/workflows/task-delegation.md

@@ -0,0 +1,95 @@
+<!-- Context: workflows/delegation | Priority: high | Version: 2.0 | Updated: 2025-01-21 -->
+
+# Delegation Context Template
+
+## Quick Reference
+
+**Process**: Create context → Populate → Delegate → Cleanup
+
+**Location**: `.tmp/sessions/{timestamp}-{task-slug}/context.md`
+
+**Template Sections**: Request, Requirements, Decisions, Files, Static Context, Constraints, Progress, Instructions
+
+---
+
+Use this template when creating temporary context files for task delegation.
+
+## Template Structure
+
+**Location**: `.tmp/sessions/{timestamp}-{task-slug}/context.md`
+
+```markdown
+# Task Context: {Task Name}
+
+Session ID: {id}
+Created: {timestamp}
+Status: in_progress
+
+## Current Request
+
+{What user asked for}
+
+## Requirements
+
+- {requirement 1}
+- {requirement 2}
+
+## Decisions Made
+
+- {decision 1 - approach/constraints}
+- {decision 2}
+
+## Files to Modify/Create
+
+- {file 1} - {purpose}
+- {file 2} - {purpose}
+- {file 3} - {purpose}
+- {file 4} - {purpose}
+
+## Static Context Available
+
+- .plcode/context/core/standards/code-quality.md (for code quality)
+- .plcode/context/core/standards/test-coverage.md (for test requirements)
+- .plcode/context/core/{standards|workflows}/{other-relevant}.md
+
+## Constraints/Notes
+
+{Important context, preferences, compatibility}
+
+## Progress
+
+- [ ] {task 1}
+- [ ] {task 2}
+
+---
+
+**Instructions for Subagent:**
+{Specific instructions on what to do}
+```
+
+## Delegation Process
+
+**Step 1: Create temporary context**
+
+- Location: `.tmp/sessions/{timestamp}-{task-slug}/context.md`
+- Use template above
+
+**Step 2: Populate context file**
+
+- Fill in all sections with relevant details
+- Reference static context files (don't duplicate content)
+
+**Step 3: Delegate with context path**
+
+```
+Task: {brief description}
+Context: .tmp/sessions/{id}/context.md
+
+Read the context file for full details on requirements, decisions, and instructions.
+Reference static context files as needed (lazy load).
+```
+
+**Step 4: Cleanup after completion**
+
+- Ask user: "Task complete. Clean up session files at .tmp/sessions/{id}/?"
+- If approved: Delete session directory

package/.plcode/context/data/README.md

@@ -0,0 +1,18 @@
+# Data Context
+
+This directory contains context files for data analysis, visualization, and statistical methods.
+
+## Available Context Files
+
+_No context files yet. This category is ready for data-related context._
+
+## Planned Context Files
+
+- **analysis-frameworks.md** - Statistical analysis methods, hypothesis testing, A/B testing
+- **visualization-patterns.md** - Chart selection, dashboard design, data storytelling
+- **data-cleaning.md** - Data quality, cleaning techniques, validation methods
+- **sql-patterns.md** - Query optimization, common patterns, best practices
+
+## Usage
+
+These context files will be referenced by data-focused agents to ensure consistent analysis methodologies, visualization standards, and data quality practices.

package/.plcode/context/data/navigation.md

@@ -0,0 +1,18 @@
+# Data Context
+
+This directory contains context files for data analysis, visualization, and statistical methods.
+
+## Available Context Files
+
+_No context files yet. This category is ready for data-related context._
+
+## Planned Context Files
+
+- **analysis-frameworks.md** - Statistical analysis methods, hypothesis testing, A/B testing
+- **visualization-patterns.md** - Chart selection, dashboard design, data storytelling
+- **data-cleaning.md** - Data quality, cleaning techniques, validation methods
+- **sql-patterns.md** - Query optimization, common patterns, best practices
+
+## Usage
+
+These context files will be referenced by data-focused agents to ensure consistent analysis methodologies, visualization standards, and data quality practices.

package/.plcode/context/development/README.md

@@ -0,0 +1,52 @@
+# Development Context
+
+This directory contains context files for software development best practices, patterns, and guidelines.
+
+## Available Context Files
+
+### clean-code.md
+
+Core coding standards and best practices for writing clean, maintainable code across all languages.
+
+**Topics covered**:
+
+- Meaningful naming conventions
+- Function design principles
+- Error handling patterns
+- Language-specific guidelines (JavaScript, Python, Go, Rust)
+
+**Used by**: frontend-specialist, backend-specialist, devops-specialist, codebase-agent
+
+### react-patterns.md
+
+Modern React patterns, hooks usage, and component design principles.
+
+**Topics covered**:
+
+- Functional components and hooks
+- Custom hooks for reusable logic
+- State management patterns
+- Performance optimization
+- Code splitting and lazy loading
+
+**Used by**: frontend-specialist
+
+### api-design.md
+
+REST API design principles, GraphQL patterns, and API versioning strategies.
+
+**Topics covered**:
+
+- RESTful resource design
+- HTTP methods and status codes
+- GraphQL schema design
+- API versioning strategies
+- Authentication and authorization
+
+**Used by**: backend-specialist
+
+## Usage
+
+These context files are referenced by development-focused agents to ensure consistent coding standards and best practices across the project.
+
+Agents load these files before implementing code to align with established patterns and conventions.