long-running-agents — independently scanned and version-tracked by SaferSkills.
SaferSkills independently audited long-running-agents (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.
A task that runs for hours will exceed any context window and outlive any single process. The failures are predictable: context rot (quality degrades as the window fills), alignment drift (the goal blurs through successive summaries), and lost work when a process dies. The fix is to stop treating the model's context as the source of truth and move durable state to the filesystem — plan, progress, and decisions in files the agent re-reads — so any fresh agent can reconstitute where things stand and continue.
This skill provides the long-horizon mechanics that [[autonomous-loops]] relies on. It composes [[context-curation]] (what each turn reads), [[parallel-subagents]] (the worker fleet), and [[agent-verification]] (the judge); it does not replace them.
completion checks as distinct roles)
Skip when the work fits comfortably in a single session — use [[orchestrated-delivery]] or a direct task skill; this machinery is overhead you don't need for short work.
Not a substitute for [[autonomous-loops]] (the supervision/stop/triage discipline) or [[agent-verification]] (trustworthy "done") — pair with both for an unattended long run.
Write the goal, the testable done-conditions, and the task list to files before execution (a PRD/feature list + a plan file). The agent edits these as understanding evolves — they are the source of truth, not the chat history. Done-conditions written externally can't be redefined mid-run to declare a premature win.
Maintain a running progress file (e.g. claude-progress.txt) plus CHANGELOG.md: every meaningful decision, what changed, and what's next — portable lab notes that survive resets and hand off cleanly. Prefer structured artifacts (PRs, test output, briefs) over scrolling raw logs for auditing.
Each completed unit is a commit ([[git-flow]]) — commits are your durable progress markers. Work that isn't committed is work you can lose at the next context reset.
When the window fills, summarize to a handoff file and reset rather than letting quality degrade. Reconstitute the next turn from the plan + progress + handoff, not from a bloated transcript ([[context-curation]]). Treat each reset as a clean baton-pass with a written handoff.
A fresh container/agent must be able to rebuild where things stand from the durable files alone: read plan → read progress → read last handoff → resume. Test this: kill the session and confirm a cold start continues correctly. This is what makes checkpoint-and-resume real, not aspirational.
For big runs, separate planner (explores, maintains the plan), workers (execute scoped tasks, in [[parallel-subagents]] / isolated worktrees), and judge (verifies completion, refuses bad "done" per [[agent-verification]]). Avoid flat multi-agent setups sharing locks — they thrash and churn. Coordinate through the plan file and PRs, not shared mutable state.
Watch for the memory-reintroduction bug (a fix in an early turn undone nine turns later) and for procedural shortcuts learned from one odd interaction being applied everywhere. Re-derive against the plan and tests, not against fuzzy recollection; let the progress log and the test suite be the memory.
On crash or reset, run the reconstitution path (step 5) and continue from the last checkpoint — never redo completed, committed work.
~30 seconds. Free. No account. Every finding cites a rule and a line of evidence.