Curadoria profunda — UsageStore + runCurator, a metade do descarte

Fig. 2 — O ciclo de vida completo de uma skill: as duas linhas de corte, a reativação e a regra de que archive é recuperável (gerada à parte).

Uma skill de agente atravessa três estados. As transições são dirigidas por uma âncora de inatividade e duas linhas de corte derivadas do Clock: staleCutoff (30 dias atrás) e archiveCutoff (90 dias atrás). Tudo em milissegundos, para ser determinístico e replayável.

Clique em um estado para ver o que o curador faz com uma skill que está nele — e qual transição (ou não-transição) ele decide. O diagrama acende o nó correspondente.

O painel é alimentado pela mesma lógica de nextState — nada é decorativo.

A decisão é uma função pura sobre uma âncora de inatividade e duas linhas de corte. A ordem dos ramos — archive primeiro, depois stale, depois reativar — espelha apply_automatic_transitions exatamente:

// 0 significa nunca-ativa, ancorada a +Infinity (mais nova que qualquer corte)
const nextState = (record, staleCutoff, archiveCutoff): SkillState => {
  const anchor = record.lastActivityAt > 0
    ? record.lastActivityAt
    : Number.POSITIVE_INFINITY;          // nunca-ativa ⇒ nunca velha
  const current = record.state;
  if (anchor <= archiveCutoff && current !== 'archived') return 'archived';
  if (anchor <= staleCutoff   && current === 'active')   return 'stale';
  if (anchor >  staleCutoff   && current === 'stale')    return 'active'; // reativa
  return current;
};

Por que archive-primeiro?

Uma skill active ociosa além da linha de archive deve cair em archived diretamente — pulando stale — então o ramo de archive precisa vencer antes do ramo de stale. Inverter a ordem não é "mais lento": é incorreto, porque atrasaria o arquivamento por uma passada inteira.

Antes de qualquer transição, runCurator aplica dois opt-outs ortogonais. Só skills autoradas pelo agente são geridas pelo curador, e uma skill pinned é isenta em todo caminho:

for (const name of names) {
  const record = sidecar[name];
  if (record.createdBy !== 'agent') { skipped.push({ name, reason: 'not-agent-created' }); continue; }
  if (record.pinned)             { skipped.push({ name, reason: 'pinned' });           continue; }
  const to = nextState(record, staleCutoff, archiveCutoff);
  if (to === record.state)       { skipped.push({ name, reason: 'no-change' });        continue; }
  const persisted = await deps.usage.put(name, { ...record, state: to });
  if (!persisted.ok) return persisted;     // fail-closed: não reporta trabalho não-salvo
  transitioned.push({ name, from: record.state, to });
}

Os skips são reportados, não escondidos — o CuratorReport carrega tanto transitioned[] quanto skipped[] (cada um com um motivo tipado: pinned / not-agent-created / no-change), ambos em ordem estável por nome. E a persistência é por transição: se um put falha, a passada aborta com esse err em vez de reportar uma mudança de estado que não aconteceu de forma durável.

Fig. 7 — Os dois portões e o relatório honesto: cada decisão desvia para um skipped tipado ou avança para transitioned; put falho é fail-closed (gerada à parte).

Resposta da "agora você": transitioned[] como {from:'stale', to:'active'} — reativação, porque anchor > staleCutoff e o estado era stale.

O UsageStore registra eventos incrementando um contador e carimbando lastActivityAt = clock(). Ele carrega a mesma assimetria leitura/escrita do store de memória — um sidecar corrompido lê como vazio (nunca quebra um hot path), mas uma escrita falha aparece como err:

private async load(): Promise<UsageSidecar> {
  const stat = await tryCatchAsync(() => this.fs.stat(this.sidecarPath));
  if (!stat.ok || !stat.value) return {};        // ausente ⇒ vazio
  const read = await tryCatchAsync(() => this.fs.readText(this.sidecarPath));
  if (!read.ok) return {};                         // erro de IO ⇒ vazio
  const parsed = tryParseJson(read.value);
  if (!parsed.ok) return {};                       // JSON ruim ⇒ vazio
  const valid = usageSidecarSchema.safeParse(parsed.value);
  if (!valid.success) return {};                   // forma errada ⇒ vazio
  return valid.data;
}

Cinco cartas que resumem a metade de descarte do loop. Use as setas do teclado ou os botões.