@tgoodington/intuition 1.0.0

package/skills/intuition-initialize/references/bugs_template.md

@@ -0,0 +1,41 @@
+# Bug Log Template
+
+This file demonstrates the format for logging bugs and their solutions. Keep entries brief and chronological.
+
+## Format
+
+Each bug entry should include:
+- Date (YYYY-MM-DD)
+- Brief description of the bug/issue
+- Solution or fix applied
+- Any prevention notes (optional)
+
+Use bullet lists for simplicity. Older entries can be manually removed when they become irrelevant.
+
+## Example Entries
+
+### 2025-01-15 - Docker Architecture Mismatch
+- **Issue**: Container failing to start with "exec format error"
+- **Root Cause**: Built on ARM64 Mac but deploying to AMD64 Cloud Run
+- **Solution**: Added `--platform linux/amd64` to docker build command
+- **Prevention**: Always specify platform in Dockerfile and build scripts
+
+### 2025-01-20 - Cloud Scheduler HTTPS Requirement
+- **Issue**: Cloud Scheduler jobs failing with "URL must use HTTPS"
+- **Root Cause**: Forgot Cloud Run URLs require HTTPS by default
+- **Solution**: Updated all scheduler job URLs from http:// to https://
+- **Prevention**: Remember GCP services enforce HTTPS; check URLs in infrastructure code
+
+### 2025-01-22 - Database Connection Pool Exhaustion
+- **Issue**: API returning 500 errors under load
+- **Root Cause**: Connection pool size too small (default 5)
+- **Solution**: Increased pool_size to 20 and max_overflow to 10 in SQLAlchemy config
+- **Prevention**: Load test APIs before production deployment
+
+## Tips
+
+- Keep descriptions under 2-3 lines
+- Focus on what was learned, not exhaustive details
+- Include enough context for future reference
+- Date entries so you know how recent the issue is
+- Periodically clean out very old entries (6+ months)

package/skills/intuition-initialize/references/decisions_template.md

@@ -0,0 +1,92 @@
+# Architectural Decisions Template
+
+This file demonstrates the format for logging architectural decisions (ADRs). Use bullet lists for clarity.
+
+## Format
+
+Each decision should include:
+- Date and ADR number
+- Context (why the decision was needed)
+- Decision (what was chosen)
+- Alternatives considered
+- Consequences (trade-offs, implications)
+
+## Example Entries
+
+### ADR-001: Use Workload Identity Federation for GitHub Actions (2025-01-10)
+
+**Context:**
+- Need secure authentication from GitHub Actions to GCP
+- Service account keys are deprecated and considered insecure
+- Want to avoid managing long-lived credentials
+
+**Decision:**
+- Use Workload Identity Federation (WIF) for GitHub Actions authentication
+- Configure via `WIF_PROVIDER` and `WIF_SERVICE_ACCOUNT` secrets
+
+**Alternatives Considered:**
+- Service account JSON keys → Rejected: security risk, manual rotation required
+- Environment-specific credentials → Rejected: harder to manage across repos
+
+**Consequences:**
+- ✅ More secure (no long-lived credentials)
+- ✅ Automatic credential rotation
+- ✅ Better audit trail
+- ❌ Slightly more complex initial setup
+- ❌ Requires GitHub OIDC support
+
+### ADR-002: Use Alembic for Database Migrations (2025-01-12)
+
+**Context:**
+- Need version control for database schema changes
+- Multiple developers working on database schema
+- Want to avoid manual SQL scripts and migration conflicts
+
+**Decision:**
+- Use Alembic as the database migration tool
+- Store migrations in `alembic/versions/` directory
+- Use auto-generate feature for model changes
+
+**Alternatives Considered:**
+- Raw SQL scripts → Rejected: no versioning, error-prone
+- Flask-Migrate → Rejected: too tied to Flask framework
+- Django migrations → Rejected: using FastAPI, not Django
+
+**Consequences:**
+- ✅ Version-controlled schema changes
+- ✅ Automatic migration generation from models
+- ✅ Easy rollback capability
+- ❌ Learning curve for team
+- ❌ Must remember to generate migrations after model changes
+
+### ADR-003: Use AlloyDB Instead of Cloud SQL (2025-01-15)
+
+**Context:**
+- Need PostgreSQL-compatible database in GCP
+- Require high availability and automatic backups
+- Performance-critical application with complex queries
+
+**Decision:**
+- Use AlloyDB for PostgreSQL instead of Cloud SQL
+- Configure with automated backups and point-in-time recovery
+
+**Alternatives Considered:**
+- Cloud SQL PostgreSQL → Rejected: slower query performance
+- Self-managed PostgreSQL on GCE → Rejected: high operational overhead
+- Firestore → Rejected: need relational data model and SQL
+
+**Consequences:**
+- ✅ Better query performance (2-4x faster than Cloud SQL)
+- ✅ PostgreSQL compatibility
+- ✅ Managed service (automated backups, HA)
+- ❌ Higher cost than Cloud SQL
+- ❌ Newer service, less community documentation
+
+## Tips
+
+- Number decisions sequentially (ADR-001, ADR-002, etc.)
+- Always include date for context
+- Be honest about trade-offs (use ✅ and ❌)
+- Keep alternatives brief but clear
+- Update decisions if they're revisited/changed
+- Focus on "why" not "how" (implementation details go elsewhere)

package/skills/intuition-initialize/references/issues_template.md

@@ -0,0 +1,76 @@
+# Issues/Work Log Template
+
+This file demonstrates the format for logging work completed on tickets. Keep it simple - just enough to remember what was done. Full details live in Jira/GitHub.
+
+## Format
+
+Each entry should include:
+- Date (YYYY-MM-DD)
+- Ticket ID
+- Brief description (1-2 lines)
+- URL to ticket (if available)
+- Status (optional: completed, in-progress, blocked)
+
+Use bullet lists for simplicity. This is NOT a replacement for your ticket system - it's a quick reference log.
+
+## Example Entries
+
+### 2025-01-15 - PROJ-123: Implement Contact API
+- **Status**: Completed
+- **Description**: Created FastAPI endpoints for contact CRUD operations with validation
+- **URL**: https://jira.company.com/browse/PROJ-123
+- **Notes**: Added unit tests, coverage at 85%
+
+### 2025-01-16 - PROJ-124: Fix Docker Build Issues
+- **Status**: Completed
+- **Description**: Fixed architecture mismatch for Cloud Run deployment
+- **URL**: https://jira.company.com/browse/PROJ-124
+- **Notes**: See bugs.md for details on the fix
+
+### 2025-01-18 - PROJ-125: Database Migration to AlloyDB
+- **Status**: Completed
+- **Description**: Migrated from Cloud SQL to AlloyDB with Pulumi infrastructure code
+- **URL**: https://jira.company.com/browse/PROJ-125
+- **Notes**: Multi-phase migration completed over 3 days
+
+### 2025-01-20 - GH-45: Add OAuth2 Authentication
+- **Status**: In Progress
+- **Description**: Implementing OAuth2 flow with Google provider
+- **URL**: https://github.com/company/repo/issues/45
+- **Notes**: Backend complete, frontend integration pending
+
+### 2025-01-22 - PROJ-130: Performance Optimization
+- **Status**: Blocked
+- **Description**: Optimize slow queries in contact search endpoint
+- **URL**: https://jira.company.com/browse/PROJ-130
+- **Notes**: Waiting for DBA review of proposed indexes
+
+## Alternative Format (Grouped by Week)
+
+### Week of 2025-01-15
+
+**Completed:**
+- PROJ-123: Contact API implementation → https://jira.company.com/browse/PROJ-123
+- PROJ-124: Docker build fix → https://jira.company.com/browse/PROJ-124
+
+**In Progress:**
+- PROJ-125: AlloyDB migration (phase 2 of 3)
+
+### Week of 2025-01-22
+
+**Completed:**
+- PROJ-125: AlloyDB migration completed → https://jira.company.com/browse/PROJ-125
+- GH-45: OAuth2 backend done → https://github.com/company/repo/issues/45
+
+**Blocked:**
+- PROJ-130: Query optimization (waiting on DBA) → https://jira.company.com/browse/PROJ-130
+
+## Tips
+
+- Keep descriptions brief (1-2 lines max)
+- Always include ticket URL for easy reference
+- Update status if work gets blocked or resumed
+- Optional: Group by week or sprint for better organization
+- Don't duplicate ticket details - link to source of truth
+- Clean out very old entries periodically (3+ months)
+- Include both Jira and GitHub tickets as appropriate

package/skills/intuition-initialize/references/key_facts_template.md

@@ -0,0 +1,158 @@
+# Key Facts Template
+
+This file demonstrates the format for storing project constants, configuration, and frequently-needed **non-sensitive** information. Organize by category using bullet lists.
+
+## ⚠️ SECURITY WARNING: What NOT to Store Here
+
+**NEVER store passwords, API keys, or sensitive credentials in this file.** This file is typically committed to version control and should only contain non-sensitive reference information.
+
+**❌ NEVER store:**
+- Passwords or passphrases
+- API keys or authentication tokens
+- Service account JSON keys or credentials
+- Database passwords
+- OAuth client secrets
+- Private keys or certificates
+- Session tokens
+- Any secret values from environment variables
+
+**✅ SAFE to store:**
+- Database hostnames, ports, and cluster names
+- Client names and project identifiers
+- JIRA project keys and Confluence space names
+- AWS/GCP account names and profile names
+- API endpoint URLs (public URLs only)
+- Service account email addresses (not the keys!)
+- GCP project IDs and region names
+- Docker registry names
+- Environment names and deployment targets
+
+**Where to store secrets:**
+- `.env` files (excluded via `.gitignore`)
+- Password managers (1Password, LastPass, Bitwarden)
+- Secrets managers (AWS Secrets Manager, GCP Secret Manager, HashiCorp Vault)
+- CI/CD environment variables (GitHub Secrets, GitLab Variables)
+- Platform credential stores (Kubernetes Secrets, Cloud Run)
+
+## Format
+
+Organize information into logical categories:
+- GCP/Cloud configuration
+- Database connection details (hostnames, ports, cluster names)
+- API endpoints (URLs only, not credentials)
+- Local development setup (ports, service names)
+- Important URLs
+- Service accounts and permissions (emails and roles, not keys)
+
+Use bullet lists for simplicity and easy scanning.
+
+## Example Structure
+
+### GCP Project Information
+
+**Current Project:**
+- Project ID: `my-company-prod`
+- Project Number: `123456789012`
+- Region: `us-central1`
+- Zone: `us-central1-a`
+
+**Old Project (Deprecated):**
+- Project ID: `my-company-dev-old`
+- Migration Date: 2025-01-10
+- Status: Archived, do not use
+
+### Database Configuration
+
+**AlloyDB Cluster:**
+- Cluster Name: `prod-cluster`
+- Instance Name: `prod-primary`
+- Region: `us-central1`
+- Private IP: `10.0.0.5`
+- Port: `5432`
+- Database Name: `contacts`
+
+**Connection:**
+- Use AlloyDB Auth Proxy for local development
+- Proxy command: `./alloydb-auth-proxy "projects/my-company-prod/locations/us-central1/clusters/prod-cluster/instances/prod-primary"`
+- Local port: `5432`
+
+**Authentication:**
+- Service Account (email only): `alloydb-client@my-company-prod.iam.gserviceaccount.com`
+- Service Account Key: Stored in `.env` as `GOOGLE_APPLICATION_CREDENTIALS` (not in git!)
+- Connection String Template: `postgresql://user:${DB_PASSWORD}@localhost:5432/contacts`
+- Password Location: Stored in `.env` file (excluded via `.gitignore`)
+
+### API Configuration
+
+**Backend API:**
+- Production URL: `https://api.mycompany.com`
+- Staging URL: `https://api-staging.mycompany.com`
+- Local Development: `http://localhost:8000`
+
+**Authentication:**
+- OAuth Client ID (public): `123456789-abcdefg.apps.googleusercontent.com`
+- OAuth Client Secret: Stored in GCP Secret Manager as `oauth-client-secret` (not in git!)
+- Local Development Secret: Stored in `.env` as `OAUTH_CLIENT_SECRET` (not in git!)
+- Scopes: `openid email profile`
+
+### Local Development Ports
+
+**Services:**
+- Backend API: `8000`
+- Frontend: `3000`
+- AlloyDB Proxy: `5432`
+- Redis: `6379`
+- Prometheus: `9090`
+
+### Service Accounts
+
+**GitHub Actions:**
+- Service Account: `github-actions@my-company-prod.iam.gserviceaccount.com`
+- Roles: `roles/run.admin`, `roles/secretmanager.secretAccessor`
+- WIF Pool: `projects/123456789012/locations/global/workloadIdentityPools/github-pool`
+
+**Cloud Run Service:**
+- Service Account: `cloud-run-sa@my-company-prod.iam.gserviceaccount.com`
+- Roles: `roles/alloydb.client`, `roles/secretmanager.secretAccessor`
+
+### Important URLs
+
+**Documentation:**
+- API Docs: `https://docs.mycompany.com/api`
+- Internal Wiki: `https://wiki.mycompany.com`
+- Runbook: `https://wiki.mycompany.com/runbook`
+
+**Monitoring:**
+- Cloud Console: `https://console.cloud.google.com/home/dashboard?project=my-company-prod`
+- Logs: `https://console.cloud.google.com/logs?project=my-company-prod`
+- Monitoring: `https://console.cloud.google.com/monitoring?project=my-company-prod`
+
+**Deployment:**
+- Cloud Run Service: `https://console.cloud.google.com/run?project=my-company-prod`
+- Cloud Build: `https://console.cloud.google.com/cloud-build?project=my-company-prod`
+- Artifact Registry: `https://console.cloud.google.com/artifacts?project=my-company-prod`
+
+### Infrastructure as Code
+
+**Pulumi:**
+- Stack: `prod`
+- Backend: `gs://my-company-pulumi-state`
+- Config Passphrase: Stored in team password manager (1Password vault: "Infrastructure")
+- State: Stored in GCS bucket with versioning enabled
+- Note: Never commit `Pulumi.prod.yaml` with unencrypted secrets
+
+**Configuration:**
+- Cloud Run Image: `us-central1-docker.pkg.dev/my-company-prod/app/backend:latest`
+- VPC Connector: `prod-vpc-connector`
+- Max Instances: `10`
+- Min Instances: `1`
+
+## Tips
+
+- Keep entries current (update when things change)
+- Remove deprecated information after migration is complete
+- Include both production and development details
+- Add URLs to make navigation easier
+- Use consistent formatting (same structure for similar items)
+- Group related information together
+- Mark deprecated items clearly with dates

package/skills/intuition-initialize/references/project_plan_template.md

@@ -0,0 +1,151 @@
+# Project Plan Template
+
+This file demonstrates the format for creating a comprehensive project plan. Use this template during first-time activation to collaboratively build a shared understanding of the project with the user.
+
+## Format
+
+A project plan should include:
+- Metadata (creation date, current status)
+- Project overview (brief description of what you're building)
+- Goals (primary objectives)
+- Current phase (where you are in the development lifecycle)
+- Architecture overview (high-level technical approach)
+- Completed milestones (what's been done)
+- Next steps (actionable items)
+- Open questions (unresolved decisions)
+- Notes (additional context)
+
+## Example Structure
+
+---
+
+# Project Plan: [Project Name]
+
+**Created:** 2025-01-15
+**Last Updated:** 2025-01-20
+**Status:** Planning / In Implementation / Complete
+
+## Project Overview
+
+[2-3 sentence description of what you're building and why]
+
+**Example:**
+Building a contact management API using FastAPI and AlloyDB on GCP. The API will provide CRUD operations for contacts with authentication and will be deployed to Cloud Run with CI/CD via GitHub Actions.
+
+## Goals
+
+[Primary objectives for this project - what success looks like]
+
+**Example:**
+- Create a production-ready REST API for contact management
+- Implement secure authentication and authorization
+- Deploy to GCP Cloud Run with automated CI/CD
+- Achieve <100ms response time for read operations
+- Support 1000+ concurrent users
+
+## Current Phase
+
+[Where you are in the development lifecycle]
+
+**Possible phases:**
+- Discovery / Planning
+- Initial Setup / Scaffolding
+- MVP Development
+- Feature Enhancement
+- Testing & Refinement
+- Production Deployment
+- Maintenance & Support
+
+**Example:**
+MVP Development - Core CRUD operations implemented, working on authentication integration.
+
+## Architecture Overview
+
+[High-level technical approach - key technologies and how they fit together]
+
+**Example:**
+- **Backend:** FastAPI (Python 3.11) with Pydantic validation
+- **Database:** AlloyDB for PostgreSQL with Alembic migrations
+- **Authentication:** OAuth 2.0 with Google Sign-In
+- **Deployment:** Cloud Run (containerized with Docker)
+- **CI/CD:** GitHub Actions with Workload Identity Federation
+- **Infrastructure:** Pulumi for IaC
+- **Monitoring:** Cloud Logging and Cloud Monitoring
+
+## Completed Milestones
+
+[What's been accomplished so far - include dates for context]
+
+**Example:**
+- **2025-01-10:** Initial project setup and repository creation
+  - Created FastAPI project structure
+  - Set up development environment with Poetry
+  - Configured pre-commit hooks and linting
+
+- **2025-01-12:** Database setup completed
+  - Provisioned AlloyDB cluster in GCP
+  - Implemented Alembic migrations
+  - Created Contact model with SQLAlchemy
+
+- **2025-01-15:** Core CRUD operations implemented
+  - Added POST /contacts endpoint
+  - Added GET /contacts and GET /contacts/{id} endpoints
+  - Added PUT and DELETE endpoints
+  - Implemented input validation with Pydantic
+
+## Next Steps
+
+[Actionable checklist items - what needs to be done next]
+
+**Example:**
+- [ ] Implement OAuth 2.0 authentication
+  - [ ] Set up Google OAuth client credentials
+  - [ ] Add authentication middleware to FastAPI
+  - [ ] Protect endpoints with auth decorators
+- [ ] Write unit tests for CRUD operations
+  - [ ] Set up pytest with coverage
+  - [ ] Test happy paths and error cases
+  - [ ] Achieve 80%+ code coverage
+- [ ] Create Dockerfile and container image
+  - [ ] Write optimized multi-stage Dockerfile
+  - [ ] Test local container build
+  - [ ] Push to Artifact Registry
+- [ ] Set up CI/CD pipeline
+  - [ ] Configure GitHub Actions workflow
+  - [ ] Set up Workload Identity Federation
+  - [ ] Automate deployments to Cloud Run
+
+## Open Questions
+
+[Unresolved items that need decisions or clarification]
+
+**Example:**
+- How should we handle rate limiting? (per-user vs. global)
+- Do we need pagination for GET /contacts? What page size?
+- Should we implement soft deletes or hard deletes?
+- What monitoring alerts do we need to set up?
+- Do we need a staging environment or just dev/prod?
+
+## Notes
+
+[Additional context, constraints, or important information]
+
+**Example:**
+- AlloyDB cluster is in `us-central1` - all other resources should use same region
+- OAuth client ID is approved for company domain only
+- Cloud Run quotas: max 10 instances to control costs
+- Database backup retention: 7 days (configured in AlloyDB)
+- Team timezone: PST - schedule deployments accordingly
+
+---
+
+## Tips
+
+- Update the plan regularly as the project evolves
+- Move completed next steps to the milestones section with dates
+- Keep the overview concise - details go in other memory files
+- Use open questions to track decisions that need to be made
+- Reference architectural decisions by ADR number (e.g., "See ADR-003")
+- Mark deprecated goals or cancelled features clearly
+- Keep next steps actionable and specific
+- Break large tasks into smaller checklist items

package/skills/intuition-initialize/references/state_template.json

@@ -0,0 +1,26 @@
+{
+  "_comment": "State template for project-memory skill personalization tracking",
+  "_description": "This file tracks the state of project interactions and personalization features",
+
+  "initialized": true,
+  "_initialized_description": "Boolean indicating whether project-memory personalization has been initialized for this project",
+
+  "version": "1.0",
+  "_version_description": "Schema version for this state file format",
+
+  "personalization": {
+    "_comment": "Tracks personalization features and user interaction states",
+
+    "waldo_greeted": false,
+    "_waldo_greeted_description": "Boolean flag indicating whether Waldo has greeted the user in this project (first-time setup)",
+
+    "plan_created": false,
+    "_plan_created_description": "Boolean flag indicating whether a project plan has been created",
+
+    "plan_status": "none",
+    "_plan_status_description": "Current status of the project plan. Valid values: 'none' (no plan yet), 'planned' (plan created, not started), 'implementing' (actively working on plan tasks), 'complete' (plan completed)",
+
+    "plan_file": "docs/project_notes/project_plan.md",
+    "_plan_file_description": "Relative path to the project plan document (relative to project root)"
+  }
+}

package/skills/intuition-plan/SKILL.md

@@ -0,0 +1,109 @@
+---
+name: intuition-plan
+description: Thought partner for planning. Develop structured plans through collaborative dialogue.
+model: haiku
+tools: Read, Write, Glob, Grep, Task, AskUserQuestion
+---
+
+# Waldo - Planning Thought Partner
+
+Welcome! I'm Waldo, your planning thought partner. I help you think through features, architecture, and complex tasks through collaborative dialogue, rigorous self-reflection, and strategic planning.
+
+## What I Do
+
+I'm a dedicated planning agent - I don't execute changes myself. Instead, I work directly with you to:
+
+- **Explore your ideas** through clarifying questions and dialogue
+- **Research the codebase** to understand constraints and patterns
+- **Create structured plans** with clear tasks, dependencies, and risk assessments
+- **Reflect and refine** plans before finalizing them
+- **Hand off to The Architect** for coordinated execution
+
+## How to Use This Skill
+
+Ask Waldo to help you plan by describing what you want to accomplish:
+
+- **"Plan a new feature for..."** - I'll ask clarifying questions and develop a detailed plan
+- **"Help me think through the architecture for..."** - I'll explore options and help you decide
+- **"What's the best approach to..."** - I'll research patterns and propose a structured approach
+- **"Refine this plan..."** - I'll critique an existing plan and suggest improvements
+
+## Key Capabilities
+
+- **Collaborative Planning**: Direct dialogue with you to refine ideas and assumptions
+- **Codebase Exploration**: Research and analysis to understand your project structure
+- **Structured Plans**: Clear, actionable plans with tasks, dependencies, and confidence scores
+- **Reflection & Refinement**: Self-critique to identify gaps and improve plan quality
+- **Sub-Agent Delegation**: Parallel research and analysis while you focus on planning
+- **Project Memory Integration**: Context-aware planning based on your project history
+
+## Planning Process
+
+I follow a structured approach to planning:
+
+1. **Understand** - Ask clarifying questions about your goal and constraints
+2. **Explore** - Research the codebase and gather information
+3. **Draft** - Create an initial plan with tasks and dependencies
+4. **Reflect** - Critique the plan for completeness and feasibility
+5. **Refine** - Address gaps and improve before finalizing
+6. **Present** - Submit for your approval and iteration
+
+## Plan Output
+
+When ready, I provide plans in this structure:
+
+```
+# Plan: [Title]
+
+## Objective
+[What will be accomplished]
+
+## Assumptions
+[Explicit assumptions with confidence scores]
+
+## Context
+[Relevant background from research]
+
+## Approach
+[High-level strategy]
+
+## Tasks
+[Numbered, decomposed tasks with acceptance criteria]
+
+## Dependencies
+[Task ordering and constraints]
+
+## Risks & Mitigations
+[Key risks identified during planning]
+
+## Open Questions
+[Any items needing your input]
+
+## Self-Reflection Notes
+[Key refinements during planning process]
+```
+
+## Understanding Project Memory
+
+If your project has a memory system (`docs/project_notes/`), I integrate with it for:
+
+- **Context awareness** - Understanding your project's architecture and patterns
+- **Decision consistency** - Checking existing decisions before proposing changes
+- **Progress tracking** - Updating plan status as work progresses
+- **Status awareness** - Recognizing whether you're starting fresh or continuing work
+
+On first activation with project memory, I'll greet you warmly and offer to create a project plan that tracks your priorities and progress.
+
+## Important Notes
+
+- **Planning only** - I don't execute changes; I prepare plans and documentation for The Architect
+- **Reflection matters** - I spend time refining plans before presenting them
+- **Your input is essential** - Planning is collaborative; I ask questions and iterate based on your feedback
+- **Confidence scoring** - I flag assumptions and tasks with low confidence so you know where uncertainty exists
+- **Specification details** - For comprehensive methodology, see `references/waldo_core.md`
+
+## Ready to Plan?
+
+Describe what you'd like to plan, and let's get started. I'll ask clarifying questions, research your codebase as needed, and develop a clear plan for you to review.
+
+Sound good?