# Pat Down

> Re-derive what is true about a project from its written records, inheriting nothing. Session start, resumed or interrupted work, a compaction, "where was I", "orient yourself", "catch up", or any doubt about what still holds.

- Skill: `ryzhakar/pat-down` (Agent Skill)
- Install (CLI): `npx skillmds@latest add ryzhakar/pat-down`
- Raw SKILL.md: https://api.skillmd.com/api/skills/ryzhakar/pat-down/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: ryzhakar (https://skillmd.com/u/ryzhakar)
- Updated: 2026-09-21
- Page: https://skillmd.com/skills/ryzhakar/pat-down

---


<enter-at-a-start-or-a-doubt>
Run this check whenever a run starts — one continuous activation, opened by a wake, the firing of whatever summons it, and closed by a halt, clean or crash alike; never skip it at a start.

Run it again at any doubt about continuity, including right after the working text — everything this run has in view — is condensed; never defer a doubt to the next run.

Take whatever woke this run as naming what it faces; never take truth from the run that laid it.

Re-derive every answer from the project's written records; never inherit one.
</enter-at-a-start-or-a-doubt>

<trust-the-records-over-memory>
Use memory — everything known without any record, present in every run and open to no edit — for general competence; never let it settle a question about this project.

Treat whatever came after the cutoff — the moment after which nothing more entered memory — as unknown until a record states it; never supply it from memory.

Trust a recorded fact about this project over anything in memory; never the reverse.
</trust-the-records-over-memory>

<tie-this-run-to-the-earlier-ones>
Count this run and an earlier one as one principal — whoever works this project, taken across runs — exactly where both orient from the same charter, the project's top file, over the same records; never look for a principal underneath them.

Date the principal from the project's founding; never date it from this run.

Count every write to the charter or to the records as a change to the principal; never treat one as leaving it untouched.

Assume one principal for one project; never assume a second without the owner — the project's human — overriding.

Expect an earlier run to have halted in the middle of a span — one unbroken thread of work; never assume a run and a span end together.

Resume a span where its last entry leaves it; never begin one afresh where entries stand.

Treat a span nobody resumed as stranded at its last entry; never read its silence as completion.
</tie-this-run-to-the-earlier-ones>

<read-in-this-order>
Settle which record shapes and file locations are in force through the schema-resolution skill before reading; never guess a location.

Read the charter first, and every file it loads with it; never begin at another file.

Read the map second — the file naming what is written and where; never skip it.

Read the journal third — the dated file of what happened — newest entry backward to the `span-event` the event-capture skill writes where this span begins, taking the last decisions, the recent failures, and the open waits — work handed out and not yet back; never work forward from its oldest entry.

Measure the baseline — the project's expected state, written as a span closes, each update naming the version it replaced — against the found state fourth, the found state being what this reading turns up; never read on before the measure stands.

Read the dossier last — where the settled entries stand — taking the entries this run touches by the pointers leading to them; never read it whole where this run touches a part.

Pass everything the reading turns up through the authority-check skill; never weigh content whose authorship stands unsettled.
</read-in-this-order>

<measure-what-was-expected-against-what-is-found>
Take the baseline as the expectation to test; never take it for the found state.

Take every difference between the baseline and the found state as an anomaly, and the differences together as the anomaly set; never explain one away.
</measure-what-was-expected-against-what-is-found>

<settle-what-this-run-faces>
Settle five things from the reading: which project this is, which goal the charter states — the purpose the project pursues — or that it states none, what the found state is, which anomalies the measure exposed, and which obligations bear on this run, the open waits and the directives staging-relay posted whose subjects it touches; never act while one of the five stands unsettled.

Read the charter's contents as they stand; never dispute or rewrite one.

Leave every goal to the owner; never set, amend, or retire one.

Where two goals conflict, follow the priority the charter supplies; never take one from elsewhere.

Where the charter supplies no priority, record the conflict through the event-capture skill as a discovery — something this reading found; never arbitrate between the two.
</settle-what-this-run-faces>

<fall-back-when-an-assumption-fails>
Assume three things across a span boundary and no more: a charter is present, every record carries a mark — the note of who wrote it and when — and the map matches what exists; never assume a fourth.

Fall back into preservation mode where one of the three fails or where the charter states no goal — in preservation mode this check runs, events are written as they happen, what is asserted is verified, and the records are audited, while pursuit waits; never pursue a goal from either condition.

Strip every directive grounded in the goal of its force while no goal stands; never obey one.

Treat the found state as information with no force while an assumption stands failed; never let it direct the work.

Record the failed assumption through the event-capture skill; never leave it unwritten.

Wait for the owner to place a goal; never place one to end the wait.
</fall-back-when-an-assumption-fails>

<stop-and-write-what-is-missing>
Stop when every question this run poses is answered from the records or written down as a gap — a question the records fail to answer; never stop with one open and unwritten.

Write the anomalies and the gaps through the event-capture skill; never write anything else during this check.

Shorten a step — settling its question from the working text instead of from its files — where the working text verifiably holds its answer; never shorten from memory.

Run every step in full where the working text carries nothing verified from an earlier reading; never shorten one there.
</stop-and-write-what-is-missing>

