/10x-archive - closing out the change

The Foundation survived the fall because it wrote knowledge down in time - this skill does the same with a finished change.This skill closes out a finished change: it confirms it is complete and moves it to the archive. /10x-archive checks the completeness of the unit of work, appends lessons to context/foundation/lessons.md and moves the folder from context/changes/ to context/archive/. That way changes/ shows only work in progress, and the knowledge from a closed change stays in the project.

/10X-ARCHIVE // FROM A FINISHED CHANGE TO LESSONS AND THE ARCHIVE

WHYFoundation · The Encyclopedia

The problem: "done" with no record

"What is written survives the fall; the rest becomes legend."

- a principle of the Encyclopedia Galactica, Foundation

A change that is "merged and forgotten" leaves two debts: changes/ swells with old work so you can no longer see what is in progress, and the knowledge from that work - the pitfalls, the decisions - evaporates with the conversation window. /10x-archive pays both off: it closes out the unit of work on the record, not from memory.

It is the last step of the chain - deliberately after review and merge. It does not touch code; it operates on an already-finished change to leave a durable trace of it in the project context.

GOAL:

run after review and merge - it closes the CSC loop: what the change taught you lands in foundation, and its folder moves to the archive.

Marcin and Przemek cross a vast vault of completed changes while placing another capsule into project memory — WHY → KEEP THE CHANGE HISTORY
A closed session does not take its decisions away: the complete change history remains in the repository.

INPUT → OUTPUT

From a finished change to a durable record

The input is a finished change - the context/changes/<change-id>/ folder with plan.md, a checked-off Progress section and phase commits. The skill assumes the work is done; its job is to confirm and close it out, not to finish the implementation.

The output is twofold: lessons appended to the shared context/foundation/lessons.md and the change folder moved in full to context/archive/ - with its history preserved (change, research, plan, reviews).

Input: a finished change in context/changes/<change-id>/ (a plan with checked-off Progress)
Output: lessons in context/foundation/lessons.md + the folder in context/archive/
Effect: changes/ shows only work in progress

Marcin and Przemek check a completed change and split it into a lesson and a sealed archive capsule — INPUT → OUTPUT
A completed change passes a completeness check before its history and lessons are stored.

COMPLETENESS CHECK

"Closed out" should mean done

Commits per phase: every phase in Progress should have a commit (short SHA) - proof that the step really closed, rather than being quietly skipped.
Manual phase: a purely manual phase creates no commit and stays without a SHA - that is an informational warning, not an error, but it is recorded explicitly.
State consistency: the skill compares the claims in Progress with the folder contents before it moves anything to the archive.

RULE:

archiving surfaces gaps instead of "fixing" them. The warning stays on the record so the close-out is honest.

Marcin and Przemek archive the change and pass its extracted lesson into the next work cycle — MECHANISM → PROJECT MEMORY
The folder enters the archive while its lesson enters shared project memory for the next change.

LESSONS

The knowledge stays in the project

A change's most valuable by-product is what you learned doing it: a recurring pitfall, a non-obvious decision, a pattern worth repeating. Without a record, that knowledge dies with the session.

/10x-archive files the lessons into context/foundation/lessons.md, shared across the whole project. The next changes - and the next runs of /10x-research and /10x-plan - start from that knowledge instead of rediscovering it.

What goes in: recurring pitfalls, decisions worth remembering, patterns from this change
Where: context/foundation/lessons.md - the durable project context
Why: the next changes do not repeat the same mistakes

Marcin and Przemek move a golden lesson from a pink archive capsule into a living project-memory network — LESSONS → MEMORY THAT KEEPS WORKING
A reusable insight enters shared project knowledge instead of remaining buried in the archive.

BOUNDARIES

What /10x-archive does not do

Does not change code: it operates on an already-closed change - it neither adds nor fixes implementation.
Does not replace review: judging quality belongs to /10x-impl-review; archive confirms completeness, not correctness.
Does not read the archive: the archive is a historical record - nothing reaches into it routinely, but it is all there.
Does not enforce: a missing phase commit is a warning, not a hard error that blocks the close-out.

ON THE CHAIN PAGE:

back to step 06 (archive) on the Core Skills Chain page - the context of the whole chain and the neighboring steps.