convez.ai
SkillProdutividadeIntermediário
hanhanhan0831

Ongoing Task

hanhanhan0831/ongoing-task

Diários de tarefas retomáveis para esforços que atravessam múltiplas sessões

Ver no GitHub
InicialPluginScore · de 0 a 100

Skill que transforma o trabalho de uma sessão em diários de tarefas retomáveis, permitindo que sessões futuras continuem esforços multi-sessão sem perder contexto. Ideal para investigações prolongadas, monitoramento de performance e projetos que se estendem por dias ou semanas.

Instalação

$npx convez-ai hanhanhan0831/ongoing-task

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
2
Forks
1
Acompanhando
0
Saúde
42%
Último commit
há 5 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Monitoramento contínuo de performance e Web Vitals
  • Investigações de funil e retenção que se estendem por semanas
  • Refatorações e migrações em fases
  • Rastreamento de descobertas, armadilhas e próximas ações entre sessões

Veredito

Ferramenta prática para quem trabalha em investigações e projetos que naturalmente se estendem além de uma sessão. Resolve um problema real: perda de contexto ao retomar esforços, mas seu valor depende de disciplina em manter o diário atualizado.

README

A tradução para o português deste README ainda está na fila.

ongoing-task

A Claude Code / Agent skill that turns the work from one session into a resumable task journal — so a future session (tomorrow, next week, with zero context) can pick the effort back up without re-deriving everything.

Why this exists

It came out of a real session that started as a one-off: "go look at our page-performance data and tell me what to optimize."

That request didn't stay one-off. It became a loop:

  1. Pull the Web Vitals data → find the worst pages.
  2. Draw a conclusion.
  3. Get challenged — "could it just be caching?"
  4. Re-test under the right conditions → discover the first read was wrong: warm-cache lab numbers had made a genuinely slow first visit look fast — a misread that almost shipped the wrong conclusion.
  5. Make code changes.
  6. End with a list of things that could only be verified days later, after deploy.

Halfway through came the realization: this task doesn't end when the session ends. When you come back to check the latest numbers, a fresh session remembers none of it — not how the data was pulled, not what was concluded, not the traps already hit, not what to look at next. Every return trip would start from scratch and risk repeating the same dead ends.

The fix: capture the effort as a living document you can hand back to continue — how to reproduce the data, the current conclusions, the traps, and the concrete next steps.

What problems it solves

For any effort that spans more than one sitting — performance monitoring, a funnel/retention investigation, a staged refactor or migration, a content/SEO program — the journal answers the questions a fresh session otherwise can't:

  • "What did we already conclude?" — so you don't re-derive or re-litigate settled findings.
  • "How do I get the same data?" — copy-pasteable queries/commands, tools, and access limits (including what you can't reach, and why).
  • "What traps did we already hit?" — debunked assumptions and reversed calls, so you don't repeat them.
  • "What's the next step, exactly?" — concrete actions with success criteria, so resuming is mechanical, not archaeological.
  • Cross-session continuity — hand the file to a new session and it continues from the right place.

It is deliberately not a one-off report. A report describes a moment; this keeps a moving effort resumable.

What it does

/ongoing-task save <name>     # snapshot/update the current work into a journal
/ongoing-task resume <name>   # read it, restate where things stand, continue the next steps
/ongoing-task list            # list journals with status + last-updated

Journals live in the current project (auto-located: claudedocs/ongoing-tasks/, else docs/ongoing-tasks/, else ongoing-tasks/). Each is one markdown file: goal · how to reproduce/fetch the data · current conclusions · traps/lessons · changes made · next steps · iteration log.

Two shapes

  • Single file — a simple task fits in one .md.
  • Index journal — a task that spans several docs (a PRD, a regression baseline, a detailed log) keeps a "control-tower" file with goal/conclusions/next-steps + links to the supporting docs, so nothing is duplicated.

Install

Clone into your personal skills directory so it's available in every project:

git clone https://github.com/hanhanhan0831/ongoing-task ~/.claude/skills/ongoing-task

Or keep it as its own repo and symlink (so you can keep improving it in one place):

git clone https://github.com/hanhanhan0831/ongoing-task ~/ongoing-task
ln -s ~/ongoing-task ~/.claude/skills/ongoing-task

The skill is defined in SKILL.md (frontmatter name + description drive triggering). Edit it freely — iterating on it is the point.

License

MIT — see LICENSE.

Ver o original no GitHub

Bom para

Relacionados