@cronicorn/mcp-server 1.7.0 → 1.8.0

package/dist/docs/core-concepts.md

@@ -225,9 +225,3 @@ AI behavior:
 - Never exceeds API rate limits (min)
 - Ensures data freshness (max)
 ```
-
-## Next Steps
-
-- **[Introduction](./introduction.md)** - Why use Cronicorn
-- **[Quick Start](./quick-start.md)** - Create your first job
-- **[Technical Documentation](./technical/system-architecture.md)** - For developers and self-hosters

package/dist/docs/developers/quick-start.md

@@ -77,8 +77,3 @@ pnpm dev
 
 **Database errors?**  
 → Ensure Docker is running, then `pnpm db`
-
-## Next Steps
-
--  [Authentication](./authentication.md) - Configure authentication methods
--  [Architecture](../technical/system-architecture.md) - System design

package/dist/docs/developers/workspace-structure.md

@@ -172,8 +172,3 @@ Central docs folder that is used by the docs app and mcp-server
 | AI prompts | `packages/worker-ai-planner/src/` |
 | HTTP dispatcher | `packages/adapter-http/` |
 | Business logic | `packages/services/` |
-
-## Next Steps
-
-- **[System Architecture](../technical/system-architecture.md)** - How components interact at runtime
-- **[Quick Start](./quick-start.md)** - Set up your dev environment

package/dist/docs/introduction.md

@@ -21,6 +21,40 @@ mcp:
 
 **Cronicorn** is an intelligent scheduler that automatically adapts to your application's behavior. Set baseline schedules and let AI optimize execution timing based on real-world patterns.
 
+---
+
+## 🤖 Recommended: Use the MCP Server
+
+**The easiest way to use Cronicorn is through your AI assistant.** Just chat to create jobs, monitor executions, and debug issues—no forms, no clicking.
+
+[![npm version](https://badge.fury.io/js/@cronicorn%2Fmcp-server.svg)](https://www.npmjs.com/package/@cronicorn/mcp-server)
+
+```bash
+npm install -g @cronicorn/mcp-server
+```
+
+Configure it with GitHub Copilot, Claude Desktop, or any MCP-compatible AI assistant. Then just talk:
+
+- *"Set up a job that checks my API health every 5 minutes"*
+- *"Show me why that endpoint is failing"*
+- *"Migrate my 10 Vercel cron jobs to Cronicorn"*
+
+**[→ Learn more about the MCP Server](./mcp-server.md)**
+
+---
+
+## Quick Navigation
+
+**Getting Started**
+- [Quick Start](./quick-start.md) - Create your first scheduled job in 5 minutes
+- [Core Concepts](./core-concepts.md) - Understand jobs, endpoints, and scheduling
+
+**Learn More**
+- [Use Cases & Examples](./use-cases.md) - Real-world scenarios across industries
+- [Technical Architecture](./technical/system-architecture.md) - Deep dive - How Cronicorn works behind the scenes
+
+---
+
 ## What is Cronicorn?
 
 Cronicorn is a scheduling service that combines:
@@ -89,44 +123,6 @@ When enabled, the AI planner:
 - **Multi-tenant isolation**: Secure separation between accounts
 - **API & Web UI**: Manage jobs programmatically or visually
 
-## Use Cases
-
-### API Health Monitoring
-
-Monitor your APIs with adaptive frequency:
-
-- Baseline: Check every 5 minutes
-- AI increases to every 30 seconds when errors detected
-- AI backs off to every 15 minutes when stable
-- Stays within your min (30s) and max (15min) constraints
-
-### Data Synchronization
-
-Sync data between systems efficiently:
-
-- Baseline: Sync every hour
-- AI increases during business hours when changes are frequent
-- AI decreases overnight when activity is low
-- Respects API rate limits with max interval constraints
-
-### Scheduled Maintenance
-
-Run cleanup and maintenance tasks:
-
-- Baseline: Daily at 2am via cron expression
-- Pause during known maintenance windows
-- Monitor execution duration trends over time
-- Track success/failure for audit compliance
-
-### Webhook Retry Logic
-
-Retry failed webhooks intelligently:
-
-- Baseline: Immediate retry, then exponential backoff
-- AI adjusts retry timing based on downstream service patterns
-- Automatic pause after sustained failures
-- Resume when downstream recovers
-
 ## How It Works
 
 1. **Create a Job** - Logical container for related endpoints
@@ -141,15 +137,3 @@ Retry failed webhooks intelligently:
 - **E-commerce teams** syncing inventory and order data
 - **DevOps engineers** running scheduled maintenance tasks
 - **Integration developers** managing webhook retries and polling
-
-## Getting Started
-
-- **Using Cronicorn as a service**: See [Quick Start](./quick-start.md)
-- **Self-hosting Cronicorn**: See [Technical Documentation](./technical/system-architecture.md)
-- **AI assistant integration**: Use our [MCP Server](https://www.npmjs.com/package/@cronicorn/mcp-server)
-
-## Next Steps
-
-- **[Core Concepts](./core-concepts.md)** - Understand jobs, endpoints, and scheduling
-- **[Quick Start](./quick-start.md)** - Create your first scheduled job
-- **[Technical Deep Dive](./technical/system-architecture.md)** - For developers and self-hosters

package/dist/docs/mcp-server.md

@@ -0,0 +1,127 @@
+---
+id: mcp-server
+title: MCP Server
+description: Control Cronicorn through your AI assistant - no forms, no clicking, just conversation
+tags:
+  - getting-started
+  - integrations
+  - ai
+sidebar_position: 3
+mcp:
+  uri: file:///docs/mcp-server.md
+  mimeType: text/markdown
+  priority: 0.9
+---
+
+# Chat Your Way to Scheduled Jobs
+
+[![npm version](https://badge.fury.io/js/@cronicorn%2Fmcp-server.svg)](https://www.npmjs.com/package/@cronicorn/mcp-server)
+
+**What if you could manage cron jobs by just talking to your AI assistant?**
+
+```
+You: "Set up a job that checks my API health every 5 minutes"
+
+AI: *Creates the job, adds the endpoint, configures the schedule*
+    ✅ Done! Your health check is now running every 5 minutes.
+```
+
+**No forms. No clicking. Just conversation.**
+
+## Quick Start
+
+### Install
+
+```bash
+npm install -g @cronicorn/mcp-server
+```
+
+### Configure Your AI Assistant
+
+Add the Cronicorn MCP server to your AI assistant's configuration. The exact setup varies by tool:
+
+- **GitHub Copilot**: Add to VS Code settings
+- **Claude Desktop**: Add to `claude_desktop_config.json`
+- **Cline/Continue/Cursor**: Check your extension's MCP settings
+
+See the [full installation guide](https://github.com/weskerllc/cronicorn/tree/main/apps/mcp-server#installation) for platform-specific instructions.
+
+### Authenticate
+
+First time you use it, you'll authenticate once via OAuth (browser opens, you approve, done). The MCP server remembers you for 30 days.
+
+## What You Can Do
+
+**Create jobs instantly:**
+```
+"Check https://api.myapp.com/health every 5 minutes"
+```
+
+**Debug failures:**
+```
+"My payment-processor job is timing out - fix it"
+```
+
+**Monitor everything:**
+```
+"Show me my dashboard stats"
+"What's wrong with that failing endpoint?"
+```
+
+**Migrate from other systems:**
+```
+"Help me move my 15 Vercel cron jobs to Cronicorn"
+```
+
+## Built-In Guides
+
+The MCP server includes interactive slash commands that guide you through common workflows:
+
+**`/setup-first-job`** - Perfect for getting started or migrating
+- Learn jobs vs endpoints, baseline schedules, AI adaptation, safety constraints
+- Get step-by-step guidance for your first scheduled task
+
+**`/troubleshoot-failures`** - Debug failing endpoints
+- Systematic diagnostic process
+- Common issues and fixes (timeouts, rate limits, auth)
+- Emergency actions when needed
+
+## 30+ Tools Available
+
+Your AI assistant has access to tools for:
+
+- **Job Management** - Create, list, update, pause, resume, delete
+- **Endpoint Control** - Add, configure, update URLs/timeouts/schedules
+- **AI Scheduling** - Apply hints, trigger immediate runs, pause/resume
+- **Monitoring** - Health summaries, execution history, run details, dashboard stats
+
+[See all available tools →](https://github.com/weskerllc/cronicorn/tree/main/apps/mcp-server#available-tools)
+
+## Example Use Cases
+
+**Health monitoring with AI adaptation:**
+```
+"Monitor https://api.acme.com/health every minute. 
+Check more frequently if slow, relax to 5 minutes when healthy."
+```
+→ AI auto-adjusts interval based on latency in response
+
+**Data sync with queue monitoring:**
+```
+"Sync https://api.acme.com/sync every 5 minutes.
+Speed up when queue_depth > 100, slow down when < 10."
+```
+→ AI monitors queue_depth and adjusts schedule dynamically
+
+**Daily cleanup:**
+```
+"Run cleanup at https://api.acme.com/cleanup daily at 2 AM Pacific"
+```
+→ Simple cron-based schedule
+
+## Security & Compatibility
+
+**Secure authentication** via OAuth 2.0 Device Flow (same as AWS CLI, GitHub CLI). Credentials stored locally with strict permissions. Tokens refresh automatically, re-auth every 30 days.
+
+**Works with** GitHub Copilot, Claude Desktop, Cline, Continue, Cursor, and any MCP-compatible AI assistant.
+

package/dist/docs/quick-start.md

@@ -217,16 +217,3 @@ If you're hitting rate limits:
 1. Increase **Min Interval** (e.g., from 30s to 60s)
 2. Adjust **Baseline Schedule** to be less frequent
 3. Let AI adapt (it will back off automatically)
-
-## Next Steps
-
-- **[Core Concepts](./core-concepts.md)** - Understand jobs, endpoints, and AI scheduling
-- **[API Reference](https://cronicorn.com/docs/api)** - Full API documentation
-- **[Self-Hosting Guide](./technical/system-architecture.md)** - Deploy Cronicorn yourself
-
-## Getting Help
-
-- 📖 [Documentation](https://cronicorn.com/docs)
-- 💬 [Discord Community](https://discord.gg/cronicorn)
-- 📧 [Email Support](mailto:support@cronicorn.com)
-- 🐛 [Report Issues](https://github.com/weskerllc/cronicorn/issues)

package/dist/docs/technical/configuration-and-constraints.md

@@ -407,9 +407,3 @@ Expensive operation runs every 10 minutes normally, AI can relax to hourly or ti
 7. **Min/max apply relative to `now`, not `lastRunAt`**
 
 Configure conservatively. The system is designed to be safe by default. Add constraints when you encounter real problems, not anticipated ones.
-
-## Next Steps
-
-- **[How Scheduling Works](./how-scheduling-works.md)** - Understand how Governor applies constraints
-- **[How AI Adaptation Works](./how-ai-adaptation-works.md)** - Learn how AI proposes intervals
-- **[Reference](./reference.md)** - Quick lookup for defaults and field ranges

package/dist/docs/technical/coordinating-multiple-endpoints.md

@@ -449,9 +449,3 @@ When coordination isn't working:
 7. **Cross-job coordination**: Embed external status checks in responses
 
 These patterns give you the building blocks for complex workflows. Mix and match based on your needs.
-
-## Next Steps
-
-- **[Configuration and Constraints](./configuration-and-constraints.md)** - Set up endpoints for optimal coordination
-- **[How AI Adaptation Works](./how-ai-adaptation-works.md)** - Understand how AI reads and acts on signals
-- **[Reference](./reference.md)** - Quick lookup for tools and response body patterns

package/dist/docs/technical/how-ai-adaptation-works.md

@@ -445,9 +445,3 @@ This ensures that even if AI becomes unavailable or too expensive, your jobs kee
 9. **Quota controls costs**: AI unavailable ≠ jobs stop running
 
 Understanding how AI adaptation works helps you design endpoints that benefit from intelligent scheduling, structure response bodies effectively, and debug unexpected schedule changes.
-
-## Next Steps
-
-- **[Coordinating Multiple Endpoints](./coordinating-multiple-endpoints.md)** - Use AI to orchestrate workflows
-- **[Configuration and Constraints](./configuration-and-constraints.md)** - Set up endpoints for optimal AI behavior
-- **[Reference](./reference.md)** - Quick lookup for tools, fields, and defaults

package/dist/docs/technical/how-scheduling-works.md

@@ -260,9 +260,3 @@ This is the power of database-mediated communication: the Scheduler and AI Plann
 6. **Sources provide auditability**: Every decision is traceable
 
 Understanding how scheduling works gives you the foundation to configure endpoints effectively, debug unexpected behavior, and reason about how AI adaptation affects execution timing.
-
-## Next Steps
-
-- **[How AI Adaptation Works](./how-ai-adaptation-works.md)** - Learn how the AI Planner writes hints
-- **[Configuration and Constraints](./configuration-and-constraints.md)** - Guide to setting up endpoints safely
-- **[Reference](./reference.md)** - Quick lookup for fields, defaults, and sources

package/dist/docs/technical/reference.md

@@ -394,11 +394,3 @@ Calculate current backoff multiplier:
 ```
 failureCount > 0 ? 2^min(failureCount, 5) : 1
 ```
-
-## Next Steps
-
-For detailed explanations, see:
-- **[System Architecture](./system-architecture.md)** - Understand the big picture
-- **[How Scheduling Works](./how-scheduling-works.md)** - Deep-dive into Governor and Scheduler
-- **[How AI Adaptation Works](./how-ai-adaptation-works.md)** - Learn about hints and tools
-- **[Configuration Guide](./configuration-and-constraints.md)** - Set up endpoints correctly

package/dist/docs/technical/system-architecture.md

@@ -292,14 +292,6 @@ To use Cronicorn effectively, you need to understand:
 
 5. **The system is eventually consistent**: Don't expect instant reactions to every change. The AI analyzes every 5 minutes, and hints apply on the next execution. Plan for minutes, not seconds.
 
-## Next Steps
-
-Now that you understand the architecture, you can dive deeper:
-
-- **[How Scheduling Works](./how-scheduling-works.md)** - Deep-dive into the Scheduler worker and Governor logic
-- **[How AI Adaptation Works](./how-ai-adaptation-works.md)** - Deep-dive into the AI Planner and hint system
-- **[Coordinating Multiple Endpoints](./coordinating-multiple-endpoints.md)** - Patterns for building workflows
-- **[Configuration and Constraints](./configuration-and-constraints.md)** - How to configure endpoints effectively
 
 ---
 

package/dist/docs/use-cases.md

@@ -0,0 +1,208 @@
+---
+id: use-cases
+title: Use Cases & Examples
+description: Real-world scenarios showing how Cronicorn adapts to your application needs
+tags:
+  - user
+  - examples
+sidebar_position: 3
+mcp:
+  uri: file:///docs/use-cases.md
+  mimeType: text/markdown
+  priority: 0.8
+---
+
+# Use Cases & Examples
+
+Cronicorn's adaptive scheduling shines in scenarios where static cron jobs fall short. Here are real-world examples across different industries.
+
+## E-Commerce: Flash Sale Monitoring
+
+You're running a Black Friday sale and traffic spikes 5× normal volume. Your checkout system needs close monitoring, but you don't want to manually adjust schedules every hour.
+
+**Setup:**
+
+| Endpoint | Baseline | Purpose |
+|----------|----------|---------|
+| Traffic Monitor | Every 5 min | Track visitors and page load times |
+| Order Processor Health | Every 3 min | Monitor checkout performance |
+| Inventory Sync Check | Every 10 min | Ensure stock accuracy |
+
+**What Happens:**
+
+- **9am (sale starts)**: Traffic surges detected. AI tightens monitoring to every 30 seconds for the next hour.
+- **10am (struggling)**: Slow pages detected. AI activates cache warm-up (one-shot) and increases monitoring.
+- **11am (recovering)**: Performance stabilizes. AI gradually relaxes back to baseline over 30 minutes.
+- **2pm (stable)**: All endpoints return to normal 3-10 minute intervals.
+
+**Result**: Your team gets real-time visibility during the surge without manual schedule changes. The system backs off automatically when things stabilize.
+
+
+## Marketing: Content Publishing & Engagement Tracking
+
+You publish blog posts and want to monitor engagement closely for the first 24 hours, then back off to daily checks.
+
+**Setup:**
+
+| Endpoint | Baseline | Behavior |
+|----------|----------|----------|
+| Publish Post | Cron: "0 9 * * MON" | Publishes every Monday at 9am |
+| Track Analytics | Every 30 min | Page views, time on page |
+| Check Email Opens | Every hour | Newsletter engagement |
+| Promote Top Posts | Paused | Activates when engagement crosses threshold |
+
+**What Happens:**
+
+- **Monday 9am**: Post publishes on schedule
+- **9am-6pm**: AI tightens analytics tracking to every 5 minutes (fresh content gets attention)
+- **Tuesday-Friday**: AI relaxes to hourly checks (engagement is stable)
+- **Friday**: High engagement detected, AI activates promotional boost endpoint
+- **Next Monday**: Analytics reset to baseline 30 min intervals
+
+**Result**: You get real-time engagement data when it matters most, without paying for excessive API calls once traffic stabilizes.
+
+## DevOps: Infrastructure Health & Auto-Remediation
+
+Your SaaS platform runs background monitoring that should attempt automatic fixes before paging engineers at 2am.
+
+**Setup:**
+
+- **Health checks** run continuously: API latency, error rates, database connections, queue depth
+- **Investigation endpoints** start paused: slow query logs, memory profilers, distributed traces
+- **Remediation actions** fire as one-shots: restart unhealthy pods, flush caches, scale workers
+- **Alerts** escalate intelligently: Slack ops → Slack support → PagerDuty on-call
+
+**What Happens:**
+
+1. Database latency increases above threshold
+2. AI activates slow query investigation (was paused)
+3. Investigation identifies problematic query
+4. System fires one-shot remediation to kill long-running queries
+5. If fixed: Alert sent to Slack, investigation pauses again
+6. If not fixed after 3 attempts: Page on-call engineer
+
+**Result**: Most issues self-heal without waking anyone up. Engineers only get paged when automation can't resolve the problem.
+
+## Data Engineering: ETL Pipeline Coordination
+
+You run nightly data syncs from Salesforce, transform the data, and load it into your warehouse. The transformation step should only run after extraction succeeds.
+
+**Setup:**
+
+| Endpoint | Schedule | Notes |
+|----------|----------|-------|
+| Extract from Salesforce | Cron: "0 2 * * *" | Daily at 2am |
+| Transform Records | Paused | Activates only after extraction |
+| Load to Warehouse | Paused | Activates after transformation |
+| Check Pipeline Lag | Every 2 min | Monitors data freshness |
+
+**What Happens:**
+
+- **2:00am**: Salesforce extraction starts
+- **2:15am**: Extraction completes successfully. AI activates transformation endpoint for immediate one-shot run.
+- **2:20am**: Transformation finishes. AI activates warehouse load for one-shot run.
+- **2:25am**: Full pipeline complete. Investigation endpoints pause until tomorrow.
+- **If extraction fails**: Transformation and loading stay paused. Alert fires.
+
+**Result**: You coordinate complex dependencies without writing custom orchestration code. Each step waits for upstream success.
+
+## SaaS Operations: Usage Monitoring & Billing
+
+You need to track customer API usage hourly, send quota warnings at specific thresholds, and generate invoices monthly.
+
+**Setup:**
+
+- **Usage tracking**: Aggregate API calls every hour
+- **Quota monitoring**: Check for overages every 10 minutes
+- **Warning emails**: One-shot sends at 80%, 90%, 100% of quota
+- **Invoice generation**: Cron runs on 1st of each month
+- **Payment reminders**: Escalating sequence (3 days → 7 days → 14 days → 30 days overdue)
+
+**What Happens:**
+
+- **Throughout month**: Usage tracked hourly, quota checked every 10 min
+- **Customer approaching limit**: AI fires one-shot warning emails at each threshold
+- **1st of month at midnight**: Invoices generated for all accounts
+- **Payment not received**: Reminder sequence starts automatically (paused between emails)
+- **Payment received**: AI pauses further reminders
+
+**Result**: Billing runs like clockwork with minimal manual intervention. Customers get timely warnings, and dunning sequences are fully automated.
+
+## Web Scraping: Competitive Price Monitoring
+
+You track competitor pricing across multiple sites, but need to respect their rate limits and adapt when they change.
+
+**Setup:**
+
+| Endpoint | Baseline | Constraints |
+|----------|----------|-------------|
+| Scrape Prices | Every 4 hours | Min: 30 min, Max: 12 hours |
+| Validate Data | After each scrape | Checks for blocks/CAPTCHAs |
+| Check Proxy Health | Every 5 min | Monitors rotating proxies |
+| Alert Price Drop | Paused | Fires when competitor drops price |
+
+**What Happens:**
+
+- **Normal operation**: Scraping every 4 hours
+- **Rate limit warning detected**: AI backs off to every 6 hours for next day
+- **Competitor sale detected**: AI tightens to every 30 minutes (respects min interval)
+- **CAPTCHA encountered**: Validation fails, AI pauses scraping for 2 hours
+- **Proxy recovery**: Health check passes, AI resumes scraping
+
+**Result**: You adapt to site changes automatically. Scrapers respect rate limits, pause when blocked, and intensify during competitor sales.
+
+## Common Patterns
+
+### Adaptive Monitoring Frequency
+
+Start with a baseline, tighten when issues detected, relax when stable:
+
+```
+Baseline: Every 5 minutes
+During issues: Every 30 seconds (respects min interval)
+When stable: Every 15 minutes (respects max interval)
+```
+
+### Conditional Endpoint Activation
+
+Keep expensive operations paused until needed:
+
+```
+Investigation endpoints: Paused by default
+Activate: When health checks fail
+Deactivate: When issues resolve or timeout expires
+```
+
+### One-Shot Actions with Cooldowns
+
+Fire immediate actions that shouldn't repeat too quickly:
+
+```
+Cache warm-up: Fire once now, don't repeat for 15 minutes
+Alert escalation: Send once, pause for 1 hour before next
+Scale workers: Trigger immediately, cooldown for 20 minutes
+```
+
+### Calendar-Based + Adaptive Hybrid
+
+Use cron for time-sensitive tasks, intervals for everything else:
+
+```
+Daily reports: Cron "0 9 * * *" (always 9am)
+Monitoring: Interval 300000ms (adapts between min/max)
+Monthly billing: Cron "0 0 1 * *" (1st of month)
+```
+
+## When to Use Cronicorn
+
+**Great fit:**
+- You adjust cron schedules manually based on metrics
+- You need backoff logic after failures
+- You want tight monitoring during critical periods
+- You coordinate multiple dependent endpoints
+- You respect rate limits that vary by usage
+
+**Probably overkill:**
+- Simple daily backup at 2am (basic cron is fine)
+- Completely static schedules that never change
+- Sub-second precision required (use a real-time system)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cronicorn/mcp-server",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "type": "module",
   "description": "MCP server for Cronicorn - enables AI agents to manage cron jobs via Model Context Protocol",
   "author": "Cronicorn",

package/dist/docs/mcp-server/troubleshooting.md

@@ -1,82 +0,0 @@
----
-title: Troubleshooting Authentication
-description: How to resolve authentication issues with the Cronicorn MCP Server
-mcp:
-  uri: "cronicorn://troubleshooting/authentication"
-  priority: 10
-tags: [user, assistant]
----
-
-# Troubleshooting Authentication
-
-## Authentication Failed (401 Unauthorized)
-
-If you see this error:
-```
-Authentication failed. Invalid or expired token. Please restart the MCP server to re-authenticate.
-```
-
-**What happened:**
-- Your authentication token is no longer valid
-- The MCP server has automatically cleared the invalid credentials
-
-**How to fix:**
-
-1. **Restart your editor/IDE:**
-   - **VS Code**: Reload the window (`Cmd+Shift+P` → "Developer: Reload Window")
-   - **Other editors**: Restart the application
-
-2. **Complete the device flow:**
-   - A browser window will automatically open
-   - Sign in with your GitHub account
-   - Approve the device authorization request
-   - The MCP server will save the new credentials
-
-3. **Try your operation again**
-
-## Token Expired
-
-If you see messages about an expired token during startup, don't worry! The MCP server automatically:
-1. Detects the expired token
-2. Deletes the invalid credentials
-3. Starts a new device authorization flow
-
-Just complete the browser-based approval and you're good to go.
-
-## Manual Credential Reset
-
-If you need to manually reset your credentials:
-
-```bash
-# Delete the credentials file
-rm ~/.cronicorn/credentials.json
-
-# Restart your editor/IDE
-```
-
-## Where Are Credentials Stored?
-
-Credentials are stored in: `~/.cronicorn/credentials.json`
-
-This file contains:
-- `access_token`: Your authentication token
-- `refresh_token`: Token for refreshing (currently not used)
-- `expires_at`: Unix timestamp when the token expires
-
-The file has restricted permissions (0600) so only you can read it.
-
-## Common Issues
-
-### Browser Doesn't Open Automatically
-- Manually navigate to the verification URL shown in the server logs
-- Enter the user code displayed
-
-### Device Code Expired
-- You have 30 minutes to approve the device
-- If it expires, just restart the MCP server to get a new code
-
-### Still Having Issues?
-- Check that the Cronicorn API is accessible
-- Verify your internet connection
-- Look for error messages in the MCP server logs (stderr)
-- Report issues on [GitHub Discussions](https://github.com/weskerllc/cronicorn/discussions)