# Plan Harvest and Retire

> Retire a stalled or indefinitely-deferred plan without losing its value. Candidate scan, harvest, distribute, sweep, archive and codify.

**Skill · v1.0 · Updated 2026-07-10**

Plan Harvest and Retire is a skill for closing a plan that stalled without pretending the thinking behind it was wasted. A lean candidate scan finds plans stuck in value-plus-deferral (not staleness alone), then a six-step sequence sorts the plan into implementable slivers, durable vision and cross-plan breadcrumbs, distributes each pile to a home where it survives, sweeps every reference and archives the file clean. The queue gets lighter. Nothing of worth gets lost.

## Install

### Claude Code (CLI / WSL / Git Bash)

```
/plugin marketplace add https://www.infinitegameos.io/marketplace.json
/plugin install plan-harvest-and-retire@igos-library
```

### Claude Code (VS Code)

[Install in VS Code](vscode://anthropic.claude-code/install-plugin?plugin=plan-harvest-and-retire&marketplace=https%3A%2F%2Fwww.infinitegameos.io%2Fmarketplace.json)

Opens the Claude Code plugins dialog with the marketplace and skill prefilled. Requires the Claude Code VS Code extension installed and signed in. Or paste the snippet below into `.claude/settings.json` for VS Code, JetBrains or any setup that prefers manual config:

```json
{
  "extraKnownMarketplaces": {
    "igos-library": {
      "source": {
        "source": "url",
        "url": "https://www.infinitegameos.io/marketplace.json"
      }
    }
  },
  "enabledPlugins": {
    "plan-harvest-and-retire@igos-library": true
  }
}
```

### Direct markdown URL

```
curl https://www.infinitegameos.io/markdown/skills/plan-harvest-and-retire
```

Or send `Accept: text/markdown` to https://www.infinitegameos.io/skills/plan-harvest-and-retire

_This URL returns the narrative concept page. The plugin install path above delivers the operational SKILL.md instruction file._

### Cursor

```
curl -O https://www.infinitegameos.io/install/cursor/plan-harvest-and-retire.mdc
```

### Aider, Cline, any agent with --read

```
curl -O https://www.infinitegameos.io/markdown/skills/plan-harvest-and-retire
aider --read plan-harvest-and-retire.md
```

## Definition

Plan Harvest and Retire retires a stalled or indefinitely-deferred Pending Plan without losing its value. A lightweight candidate scan runs first: read the plans index, shortlist anything stale and in an early-stage status, grep for deferral language, confirm the value is preservable elsewhere and the build gate is genuinely far-off. That scan is read-only and presents a candidate list; nothing archives without per-plan consent. For a confirmed candidate, the plan gets read once and sorted into three piles: implementable-now slivers, durable vision or architecture, and cross-plan breadcrumbs. Each pile distributes to its own durable home (a focused new plan, a deferred-items tracker entry, or another active plan's log) before a full reference sweep repoints every active mention away from the retiring plan. Only then does the file archive, with status set to retired and a superseded-by field pointing at wherever the value now lives. A final optional step codifies any meta-lesson the retire surfaced into a durable doc, gated on the same sign-off your team already uses for governance changes.

## Scan, sort, distribute, sweep, archive, codify

The candidate scan stays lean by design: an index read plus a targeted grep, never a full-corpus body read. The retire signal requires both a stale, early-stage status AND deferral language AND a genuinely far-off build gate, so a plan simply waiting its turn in the queue never gets flagged. A plan parked on a near, dated activation gate is explicitly protected as an anti-signal.

Once a candidate is confirmed, the value gets sorted into three piles and each pile lands in a home built to hold it: slivers become their own small plan, durable vision goes to a deferred-items tracker with an explicit promotion signal naming what would resurrect it, and cross-plan notes append to whatever plan they actually belong to. Only after every inbound reference has been swept and repointed does the file move to archive. The retirement is not complete until that sweep has run.

## Use Cases

**A stalled plan clogging the active queue**

A plan has sat at proposed status for two months with placeholder language throughout ("not designed yet", "long-horizon"). The candidate scan surfaces it, the operator confirms, and the skill sorts its actual content: one implementable sliver ships as its own small plan immediately, the rest of the vision moves to a deferred-items tracker with a clear promotion signal. The queue is lighter and nothing is lost.

**Distinguishing parked from orphaned**

Two plans both look stale on the surface. One is gated on a specific event three weeks out; it stays parked, untouched. The other has no real gate at all, just inherited urgency that never materialized; it becomes a retire candidate. The value-plus-deferral signal keeps the scan from flagging the wrong one.

**A meta-lesson worth keeping after the fact**

A retire surfaces a pattern: three plans in a row stalled for the same structural reason. Step 6 codifies that pattern into a standing rule in the team's conventions doc, gated on the usual sign-off, so the next plan of that shape gets caught earlier instead of running the same stall again.

## FAQ

**How is this different from just deleting a stalled plan?**

Deletion loses the thinking behind the plan. This skill never deletes. It distributes every pile of value to a durable home first, then archives the now-empty queue item. The archive is a lifecycle step, not a loss.

**Does the scan run automatically?**

No. It is operator-invoked, or it can surface as a one-line lens inside a regular weekly review. The scan itself is read-only and safe to run freely; the harvest and archive steps that follow always wait on per-plan consent.

**What if I do not have a deferred-items tracker yet?**

Build the simplest version first: one markdown file, one entry per deferred idea, with a source, a deferred reason, a promotion signal and context notes. The skill needs somewhere for durable vision to land before it can retire a plan into it.

## Related

- [Pending Plan Implementation](https://www.infinitegameos.io/skills/pending-plan-implementation)
- [Plan Challenger](https://www.infinitegameos.io/skills/plan-challenger)
- [Batch Archival](https://www.infinitegameos.io/skills/batch-archival)
- [Source Harvest](https://www.infinitegameos.io/skills/source-harvest)

---

Plan Harvest and Retire closes the loop that Plan Challenger and Pending Plan Implementation open. If you want the design frame for which plans are worth running (and worth retiring) in the first place, the Sovereign Life Playbook is the upstream architecture.

[See the Sovereign Life Playbook](https://www.sidequesthq.co/products/sovereign-life-playbook)

---

_Provenance: This skill began as an internal planning-hygiene process and graduated to the public library in July 2026. Template repo: https://github.com/infinitegameplayer/sovereign-ecosystem_

---
*[Infinite Game OS](https://www.infinitegameos.io) · [Skills](https://www.infinitegameos.io/skills) · [Plan Harvest and Retire](https://www.infinitegameos.io/skills/plan-harvest-and-retire)*