Best use case
archive is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Archive a completed plan to .devloop/archive/
Teams using archive should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/archive/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How archive Compares
| Feature / Agent | archive | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Archive a completed plan to .devloop/archive/
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Archive - Move Completed Plan to Archive
Archive a completed plan to `.devloop/archive/` and clear the active plan. **You do the work directly.**
## Step 1: Check Plan Status
```bash
"${CLAUDE_PLUGIN_ROOT}/scripts/check-plan-complete.sh" .devloop/plan.md
```
Parse the JSON output to get task counts.
**If no plan exists:**
```
No active plan to archive.
Run /devloop or /devloop:plan to create a new plan.
```
**If plan has pending tasks:**
Show status and ask:
```yaml
AskUserQuestion:
questions:
- question: "Plan has N pending tasks. Archive anyway?"
header: "Incomplete"
multiSelect: false
options:
- label: "Archive anyway"
description: "Force archive incomplete plan"
- label: "Continue work"
description: "Keep working on pending tasks"
- label: "Cancel"
description: "Don't archive"
```
## Step 2: Show What Will Be Archived
Use the **Read** tool with `limit: 20` on `.devloop/plan.md` to show the plan header.
Display:
```
Plan to archive:
Title: [Plan title]
Tasks: N completed / M total
Created: [date]
Archive destination: .devloop/archive/YYYY-MM-DD-{slug}.md
```
## Step 3: Confirm or Auto-Archive
**If plan is complete**: Skip confirmation — execute archive directly.
**If plan is incomplete** (user chose "Archive anyway" in Step 1): Execute archive with `--force`.
**If `--force` argument**: Skip confirmation — execute archive directly.
**Otherwise**: Ask:
```yaml
AskUserQuestion:
questions:
- question: "Archive this plan?"
header: "Confirm"
multiSelect: false
options:
- label: "Archive now"
description: "Move plan to archive, clear active plan"
- label: "Cancel"
description: "Keep plan active"
```
## Step 4: Execute Archive
If confirmed (or auto-archiving complete plan, or --force):
```bash
"${CLAUDE_PLUGIN_ROOT}/scripts/archive-plan.sh" .devloop/plan.md
```
If user selected "Archive anyway" for incomplete plan:
```bash
"${CLAUDE_PLUGIN_ROOT}/scripts/archive-plan.sh" .devloop/plan.md --force
```
Parse the JSON output.
## Step 5: Report Result
**On success:**
```
Plan archived successfully!
Archived to: .devloop/archive/YYYY-MM-DD-{slug}.md
Tasks completed: N
Next steps:
- /devloop:plan --deep "topic" - Start new exploration
- /devloop - Start new plan directly
- git add .devloop/archive/ - Commit archive to git
```
**On failure:**
```
Archive failed: [error message]
```
---
## Quick Reference
| Scenario | Action |
|----------|--------|
| Plan complete | Archive directly |
| Plan incomplete | Ask before force-archive |
| No plan | Show error message |
| --force argument | Skip confirmation |Related Skills
Example Skill
Brief description of what this skill does and the domain expertise it provides.
vulnerability-patterns
Index of vulnerability detection pattern skills. Routes to core patterns (universal) and language-specific patterns for security scanning.
vuln-patterns-languages
Language-specific vulnerability detection patterns for JavaScript/TypeScript, Python, Go, Java, Ruby, and PHP. Provides regex patterns and grep commands for common security vulnerabilities.
vuln-patterns-core
Universal vulnerability detection patterns applicable across all programming languages. Includes hardcoded secrets, SQL/command injection, path traversal, and configuration file patterns.
scan
Run a security assessment using deterministic static analysis tools with LLM-powered triage
results
View the most recent security scan results without re-running the scan
remediation-library
Index of security remediation skills. Routes to specialized skills for injection, cryptography, authentication, and configuration vulnerabilities.
remediation-injection
Security fix patterns for injection vulnerabilities (SQL, Command, XSS). Provides language-specific code examples showing vulnerable and secure implementations.
remediation-crypto
Security fix patterns for cryptographic vulnerabilities (weak algorithms, insecure randomness, TLS issues). Provides language-specific secure implementations.
remediation-config
Security fix patterns for configuration and deployment vulnerabilities (path traversal, debug mode, security headers). Provides language-specific secure implementations.
remediation-auth
Security fix patterns for authentication and authorization vulnerabilities (credentials, JWT, deserialization, access control). Provides language-specific secure implementations.
fix
Fix or guide remediation for a specific security finding from the latest scan report