task-state-ledger — independently scanned and version-tracked by SaferSkills.
SaferSkills independently audited task-state-ledger (Agent Skill) and scored it 100/100 (green). The audit ran 55 deterministic rules across Security, Supply Chain, Maintenance, Transparency, and Community; it found 0 high-severity and 0 lower-severity findings. The full rule-by-rule trace and per-finding evidence are below. Free, methodology-open.
Findings & checks · 0 flagged
Every scanned point with the score it earned and what moved between them.
First recorded scan — no prior version to compare against.
The primary manifest — the file an agent reads to learn what this artifact does.
You re-derive state every turn (where's the PR, what's on main, what's deployed) with expensive gh/git/curl dumps. The dumps flood context, bury the signal, and you lose the thread. This is the "constantly stuck and lost" failure. The fix is mechanical: write state down once, update it as you go, read it instead of re-deriving it. (Anthropic context-engineering: external structured note-taking is one of the three core long-horizon techniques, alongside compaction and sub-agents — see https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents)
For any task with 3+ steps or that crosses a turn, the FIRST action is to create or open a ledger at .thumbgate/implementation-notes.md or a task-specific gitignored .thumbgate/implementation-notes/<date>-<task>.md. Do not write operator scratchpads under tracked .claude/implementation-notes/; those are private working notes, not product documentation. The ledger is the single source of truth.
# <task> — <date>
## Goal (one sentence)
<the actual end state that means "done">
## Current step
<the ONE thing in flight right now>
## State (verified facts only — each with how/when verified)
- main HEAD: <sha> (git rev-parse origin/main @ HH:MM)
- deployed buildSha: <sha> (curl /health @ HH:MM)
- PR #NNNN: <state>/<mergeState> (gh pr view @ HH:MM)
## Steps (sequential — one in_progress at a time)
- [x] step that's done — evidence
- [ ] step in flight ← YOU ARE HERE
- [ ] next step
- [ ] ...
## Decisions & corrections
- <decision> because <why> (mark VERIFIED / UNVERIFIED)
- WRONG: <thing I claimed that was false> → corrected to <truth> @ HH:MM
## Blockers / open questions for the CEO
- <thing only the user can unblock>exists, read it instead of re-deriving state.
When you run the verifying command, write its result + timestamp into the ledger.
— see the scope-discipline skill.
the WRONG→corrected line. This stops you re-making the same wrong claim.
how you stop being "lost": the answer to "where am I" is a file read, not 10 tool calls.
| Pattern | Fix |
|---|---|
10 gh/git calls to recover "where am I" | Read the ledger; it has verified state + timestamps |
| State lives only in your head across turns | State lives in the file; head is cache |
| "I'll remember to update notes at the end" | Update after each step — there may be no clean end |
| Re-running a verify you already ran this session | Check the ledger's State block first |
The ledger's Goal is met, every step is [x] with evidence, and the State block's verified facts confirm it (e.g. deployed buildSha == main HEAD). Then — and only then — say "done", once, with the evidence inline.
~30 seconds. Free. No account. Every finding cites a rule and a line of evidence.