@zaip-ai/cli 1.0.7 → 1.0.8

package/templates/.agents/skills/zaip-skill-growth-strategy-revops/references/growth-revops-framework.md

@@ -0,0 +1,25 @@
+# Framework de Growth e RevOps
+
+Use o framework para orientar decisões, não para substituir evidência por estimativas.
+
+## Diagnóstico
+
+Defina uma árvore de métricas: objetivo de negócio, métricas de resultado, drivers, guardrails, definição, origem, proprietário e período. Defina a unidade de análise, janela temporal, população, funil, métricas e fontes. Verifique cobertura, duplicidade, atrasos de atribuição, mudanças de definição e viés de seleção antes de comparar períodos ou segmentos.
+
+Para RevOps, registre estágios, critérios de entrada e saída, handoffs, SLA, responsável e system of record de marketing, vendas, onboarding, suporte, retenção e expansão. Uma lacuna de source of truth deve aparecer como risco operacional, não ser conciliada por suposição.
+
+## Experimentos
+
+Mantenha um portfólio de experimentos com hipótese, alavanca, população elegível, controle ou comparação, métrica primária, guardrails, duração, critério de parada, decisão esperada, risco, dependências, proprietário e status. Um resultado indisponível ou inconclusivo deve permanecer inconclusivo.
+
+## Caso financeiro
+
+Mostre cenários base, conservador e agressivo, com premissas, fórmula, intervalo e sensibilidade para receita incremental, custo evitado, margem, capacidade ou payback. Diferencie potencial, cenário e resultado observado; somente resultado observado pode ser declarado como realizado.
+
+## Aprendizado histórico
+
+Registre hipótese, execução, resultado, decisão, contexto, limitação e reutilização recomendada. Use resultados anteriores comprovados como evidência condicionada ao contexto; não transforme um aprendizado histórico em regra universal.
+
+## Fronteiras
+
+Robert orienta a priorização estratégica de crescimento e RevOps. Gabi valida dados e métodos quantitativos. Sarah governa marca e posicionamento. Lúcia executa estratégia e ativos de marketing. Nenhuma dessas atividades autoriza abordagem comercial, mudança de preço, campanha, contratação ou publicação externa.

package/templates/.agents/skills/zaip-skill-instalar-agendamento/SKILL.md

@@ -0,0 +1,17 @@
+---
+name: zaip-skill-instalar-agendamento
+description: Install or update the native Codex hourly scheduler for the ready-work queue.
+---
+
+# Instalar agendamento da fila pronta
+
+Use esta skill somente quando a pessoa solicitar instalar, atualizar ou verificar o agendamento local da fila pronta. Ela configura o relógio; não inicia uma execução por conta própria.
+
+1. Confirme que o repositório é ZAIP habilitado e que a automação nativa de tarefas agendadas do Codex Desktop está chamável, com capacidade `automation_update`. Pare com `blocked` se ela não estiver disponível. Nunca use o Agendador do Windows, um arquivo, Git ou uma promessa de execução futura como substituto.
+2. Use `codex_app list_projects` para resolver o projeto Codex atual e seu checkout local real; não invente identificador, diretório ou contexto. Crie ou atualize, sem duplicar, a tarefa standalone de nome estável `ZAIP-AIOS - Fila Pronta Horária`: a cada hora, no minuto 0, em nova conversa no projeto resolvido. Ela abre uma única invocação com o prompt explícito `Ignore Automation memory and $CODEX_HOME. Start immediately by validating the repository and ready queue. First call codex_app set_thread_title without threadId, using America/Sao_Paulo local time in the exact format [YYYY-MM-DD-T-HH-mm] Tarefa Agendada; record a rename failure but continue the queue. Use $zaip-skill-executar-fila-pronta; this user-installed schedule authorizes only canonically ready/eligible items, never promotes draft or resumes blocked or failed work; respect the persisted manual order in .agents/dashboard/work-priority.json.`
+3. Antes de gravar, valide o checkout: raiz Git existente, `.agents/config/project.yaml` com `zaip.enabled: true`, runtime ZAIP disponível e caminho absoluto sem credenciais. Falhe fechado se algum requisito faltar; não registre uma tarefa parcial.
+4. Consulte `$CODEX_HOME/automations/*/automation.toml` somente em leitura, exclusivamente pelo nome estável para resolver identidade e deduplicação. É proibido criar, editar ou apagar TOML, ou usá-lo como fallback. Todas as visualizações e mutações da automação são exclusivamente por `codex_app automation_update`. Se houver mais de uma tarefa com esse nome, pare e reporte o conflito sem apagar nada. Se houver uma, inspecione seu ID, ação, agenda horária, nova conversa e diretório de trabalho e atualize-a; se não houver, crie uma. Preserve tarefas agendadas fora desse nome.
+5. Verifique após criar/atualizar que existe exatamente uma tarefa com o nome, agenda a cada hora no minuto 0, nova conversa, checkout esperado e prompt da skill executora que respeita `.agents/dashboard/work-priority.json`. Registre somente a evidência observada; não afirme que uma hora futura será executada.
+6. Explique que o agendamento pertence à máquina e ao usuário que o instalou. O repositório versiona a skill e o contrato, mas não cria um relógio em clones, nem funciona com a máquina desligada, o Codex Desktop fechado ou sem a automação nativa.
+
+Não use esta skill para selecionar itens, burlar bloqueios, executar todos os itens `planned`, alterar prioridades do Kanban ou fazer deploy/push.

package/templates/.agents/skills/zaip-skill-instalar-agendamento/agents/openai.yaml

@@ -0,0 +1,6 @@
+interface:
+  display_name: "ZAIP Instalar Agendamento"
+  short_description: "Instale ou atualize o agendamento horário nativo do Codex."
+  default_prompt: "Use $zaip-skill-instalar-agendamento para instalar ou atualizar com segurança o agendamento horário nativo do Codex Desktop, com validação imediata da fila e sua ordem manual persistida."
+policy:
+  allow_implicit_invocation: false

package/templates/.agents/skills/zaip-skill-marketing/SKILL.md

@@ -5,6 +5,6 @@ description: Plan evidence-grounded marketing strategy, copy, campaigns, assets,
 
 # Planejar marketing
 
-1. Delimitar público, objetivo, canal, mensagem, evidência disponível e métrica de sucesso.
-2. Produzir estratégia, copy, campanha, ativos ou briefing de imagem proporcionais ao objetivo; distinguir fatos fornecidos de hipóteses.
-3. Encaminhar website para Jonny, frontend de produto para Doug e regra visual central para Manu quando o escopo não for marketing.
+1. Delimitar público, objetivo, canal, mensagem, Brandbook aprovado como input somente-leitura, evidência disponível e métrica de sucesso.
+2. Produzir estratégia, copy, campanha, conteúdo, aplicação de marca ou ativo proporcionais ao objetivo; distinguir fatos fornecidos de hipóteses. Copy de marketing ambígua permanece com Lúcia.
+3. Escalar Sarah somente se uma decisão de marca estiver ausente, contraditória ou precisar ser criada; um Brandbook aprovado não redireciona a entrega para Branding. Encaminhar script voltado a vendas para Aaron, estratégia empresarial/RevOps para Robert, website para Jonny, frontend de produto para Doug e regra visual central para Manu.

package/templates/.agents/skills/zaip-skill-reconcile-telemetry/scripts/reconcile-local-telemetry.mjs

@@ -3,9 +3,11 @@ import { join, resolve } from "node:path";
 import {
   aggregate,
   duplicateUsageAssignments,
+  duplicateUsageImpact,
   exactCompletedSegment,
   filesUnder,
   jsonLines,
+  isExactDuplicateUsageGroup,
   loadSegments,
   pricingFor,
   recordOccurredAt,
@@ -14,9 +16,13 @@ import {
   sameCost,
   usageStatus,
   usageView,
+  supersedableUsageBeforeTerminal,
   withSequence,
 } from "./reconcile-telemetry-lib.mjs";
-import { remeasureSelectedRuns } from "./reconcile-telemetry-remeasurement.mjs";
+import {
+  remeasureSelectedRuns,
+  timingEnrichmentRunIds,
+} from "./reconcile-telemetry-remeasurement.mjs";
 
 const workspace = resolve(process.cwd());
 const apply = process.argv.includes("--apply");
@@ -39,9 +45,21 @@ const selectedRunIds = new Set(
         : [],
   ),
 );
+const selectedSessionFiles = process.argv
+  .flatMap((argument, index, values) =>
+    argument === "--session-file"
+      ? [String(values[index + 1] ?? "")]
+      : argument.startsWith("--session-file=")
+        ? [argument.slice("--session-file=".length)]
+        : [],
+  )
+  .filter(Boolean);
 if (remeasure && selectedRunIds.size === 0) {
   throw new Error("--remeasure requires at least one explicit --run <RUN-ID>");
 }
+if (apply && deduplicate && selectedRunIds.size === 0) {
+  throw new Error("--apply --deduplicate requires at least one explicit --run <RUN-ID>");
+}
 const applyBackfill = apply && !deduplicate && !remeasure;
 
 const runFiles = await filesUnder(join(workspace, ".agents", "records", "runs"), ".jsonl");
@@ -166,20 +184,35 @@ for (const file of runFiles) {
     if (event.source_segment_key && event.tokens?.total !== null)
       usedKeys.add(event.source_segment_key);
   const { measured, deduplicated } = usageStatus(usage);
-  if (started) runs.push({ file, records, started, usage, measured, deduplicated });
+  if (started) runs.push({ file, records, started, usage, measured, deduplicated, nativeMeasured });
 }
 
-const allSegments = await loadSegments(workspace);
-const remeasurement = remeasure
-  ? await remeasureSelectedRuns({
-      apply,
-      allSegments,
-      runs,
-      selectedRunIds,
-      timingOnly,
-      workspace,
-    })
-  : [];
+const allSegments = await loadSegments(
+  workspace,
+  selectedSessionFiles.length === 0 ? null : selectedSessionFiles,
+);
+// Native usage can be captured before the Codex session emits task_complete.
+// A normal backfill must not replace those observed tokens or costs, but it can
+// append an exact, timing-only correction once that terminal boundary appears.
+const timingRunIds = timingEnrichmentRunIds({
+  remeasure,
+  applyBackfill,
+  selectedRunIds,
+  runs,
+});
+const remeasurement =
+  remeasure || (applyBackfill && timingRunIds.size > 0)
+    ? await remeasureSelectedRuns({
+        apply,
+        allSegments,
+        runs,
+        selectedRunIds: timingRunIds,
+        // Automatic backfill is intentionally timing-only. Explicit remeasurement
+        // retains its existing token/cost correction behavior unless requested.
+        timingOnly: remeasure ? timingOnly : true,
+        workspace,
+      })
+    : [];
 const unfinished = runs.filter(
   (run) => !run.records.some((record) => recordType(record) === "run.finished"),
 );
@@ -351,7 +384,21 @@ for (const run of runs) {
 }
 
 const duplicateGroups = duplicateUsageAssignments(runs);
-const duplicateAssignments = duplicateGroups.flatMap((group) => group.slice(1));
+const exactDuplicateGroups = duplicateGroups.filter(isExactDuplicateUsageGroup);
+const aliasReviewGroups = duplicateGroups.filter((group) => !isExactDuplicateUsageGroup(group));
+const selectedDuplicateGroups = selectedRunIds.size === 0
+  ? exactDuplicateGroups
+  : exactDuplicateGroups.filter((group) =>
+      group.some(({ run }) => selectedRunIds.has(run.started.run_id)),
+    );
+const selectedAliasReviewGroups = selectedRunIds.size === 0
+  ? aliasReviewGroups
+  : aliasReviewGroups.filter((group) =>
+      group.some(({ run }) => selectedRunIds.has(run.started.run_id)),
+    );
+const duplicateAssignments = selectedDuplicateGroups.flatMap((group) =>
+  group.slice(1).filter(({ run }) => selectedRunIds.size === 0 || selectedRunIds.has(run.started.run_id)),
+);
 let deduplicatedEvents = 0;
 if (apply && deduplicate) {
   for (const { run, usage } of duplicateAssignments) {
@@ -600,26 +647,25 @@ const eligible = candidates.filter(
 
 if (applyBackfill) {
   for (const { run, segment, confidence } of eligible) {
+    // Re-read each Run under the serial apply loop: a preceding timing repair may
+    // have reordered or appended a correction after the initial scan.
+    const persistedRecords = jsonLines(await readFile(run.file, "utf8"));
+    const finishIndex = persistedRecords.findIndex((record) => recordType(record) === "run.finished");
+    const insertAt = finishIndex < 0 ? persistedRecords.length : finishIndex;
     const tokens = aggregate(segment);
     const model = segment.model ?? run.started.model ?? null;
     const cost = await pricingFor(workspace, model, tokens);
-    const superseded = [...run.usage]
-      .reverse()
-      .find(
-        (event) =>
-          event.tokens?.total === null &&
-          !run.usage.some((other) => other.supersedes_event_id === event.event_id),
-      );
-    const sequence = Math.max(...run.records.map((record) => recordSequence(record) ?? 0)) + 1;
+    const superseded = supersedableUsageBeforeTerminal(persistedRecords);
+    const sequence = Math.max(...persistedRecords.map((record) => recordSequence(record) ?? 0)) + 1;
     const event = {
       schema_version: 2,
       event_id: `${run.started.run_id}:reconcile:${String(sequence).padStart(6, "0")}`,
       run_id: run.started.run_id,
       sequence,
-      occurred_at: run.records.find((record) => recordType(record) === "run.finished")
+      occurred_at: persistedRecords.find((record) => recordType(record) === "run.finished")
         ? new Date(
             Date.parse(
-              recordOccurredAt(run.records.find((record) => recordType(record) === "run.finished")),
+              recordOccurredAt(persistedRecords.find((record) => recordType(record) === "run.finished")),
             ) - 1,
           ).toISOString()
         : new Date().toISOString(),
@@ -640,9 +686,7 @@ if (applyBackfill) {
       ...(segment.finished_at ? { source_finished_at: segment.finished_at } : {}),
       runtime: { reasoning_effort: segment.effort, service_tier: segment.service_tier },
     };
-    const finishIndex = run.records.findIndex((record) => recordType(record) === "run.finished");
-    const insertAt = finishIndex < 0 ? run.records.length : finishIndex;
-    const updated = [...run.records.slice(0, insertAt), event, ...run.records.slice(insertAt)].map(
+    const updated = [...persistedRecords.slice(0, insertAt), event, ...persistedRecords.slice(insertAt)].map(
       (record, index) => withSequence(record, index + 1),
     );
     const temporary = `${run.file}.reconcile.tmp`;
@@ -722,6 +766,11 @@ console.log(
       ).length,
       duplicated_correction_segments: correctionKeys.length - new Set(correctionKeys).size,
       duplicate_segment_groups: duplicateGroups.length,
+      exact_source_key_groups: exactDuplicateGroups.length,
+      canonical_alias_review_groups: aliasReviewGroups.length,
+      selected_duplicate_segment_groups: selectedDuplicateGroups.length,
+      selected_canonical_alias_review_groups: selectedAliasReviewGroups.length,
+      selected_duplicate_segment_impact: duplicateUsageImpact(duplicateAssignments),
       duplicate_segment_assignments: duplicateAssignments.length,
       duplicate_segment_run_ids: duplicateGroups.map((group) =>
         group.map(({ run }) => run.started.run_id),

package/templates/.agents/skills/zaip-skill-reconcile-telemetry/scripts/reconcile-telemetry-lib.mjs

@@ -112,6 +112,18 @@ export function usageView(record) {
   };
 }
 
+export function supersedableUsageBeforeTerminal(records) {
+  const finishIndex = records.findIndex((record) => recordType(record) === "run.finished");
+  const beforeTerminal = records.slice(0, finishIndex < 0 ? records.length : finishIndex);
+  const usage = beforeTerminal.map(usageView).filter(Boolean);
+  return [...usage]
+    .reverse()
+    .find(
+      (event) =>
+        event.tokens?.total === null && !usage.some((other) => other.supersedes_event_id === event.event_id),
+    ) ?? null;
+}
+
 export function withSequence(record, sequence) {
   if (!Array.isArray(record)) return { ...record, sequence };
   const copy = [...record];
@@ -127,6 +139,10 @@ export function canonicalSegmentKey(sourceSegmentKey) {
   return (sessionsMarker < 0 ? normalized : normalized.slice(sessionsMarker + 1)).toLowerCase();
 }
 
+function normalizedRawSegmentKey(sourceSegmentKey) {
+  return String(sourceSegmentKey).replaceAll("\\", "/").toLowerCase();
+}
+
 export function usageStatus(usage) {
   const superseded = new Set(usage.map((event) => event.supersedes_event_id).filter(Boolean));
   const effective = usage.filter((event) => !superseded.has(event.event_id));
@@ -153,26 +169,22 @@ export function duplicateUsageAssignments(runs) {
         continue;
       }
       const baseSegmentKey = canonicalSegmentKey(usage.source_segment_key);
-      const signature = JSON.stringify([
-        baseSegmentKey,
-        run.started.client_turn_id ?? null,
-        usage.tokens.input,
-        usage.tokens.cached_input,
-        usage.tokens.output,
-        usage.tokens.reasoning,
-        usage.tokens.total,
-      ]);
-      groups.set(signature, [
-        ...(groups.get(signature) ?? []),
-        { run, usage, base_segment_key: baseSegmentKey },
+      groups.set(baseSegmentKey, [
+        ...(groups.get(baseSegmentKey) ?? []),
+        {
+          run,
+          usage,
+          base_segment_key: baseSegmentKey,
+          raw_segment_key: normalizedRawSegmentKey(usage.source_segment_key),
+        },
       ]);
     }
   }
   return [...groups.values()]
     .filter((group) => new Set(group.map(({ run }) => run.started.run_id)).size > 1)
     .map((group) =>
-      [...group].sort(
-        (left, right) =>
+      [...group].sort((left, right) =>
+          provenanceRank(left.usage) - provenanceRank(right.usage) ||
           String(left.run.started.occurred_at).localeCompare(
             String(right.run.started.occurred_at),
           ) || left.run.started.run_id.localeCompare(right.run.started.run_id),
@@ -180,6 +192,48 @@ export function duplicateUsageAssignments(runs) {
     );
 }
 
+export function isExactDuplicateUsageGroup(group) {
+  return new Set(group.map(({ raw_segment_key }) => raw_segment_key)).size === 1;
+}
+
+export function duplicateUsageImpact(assignments) {
+  const impact = {
+    assignments: assignments.length,
+    input_tokens: 0,
+    output_tokens: 0,
+    total_tokens: 0,
+    cost_usd: 0,
+    cost_brl: 0,
+    duration_ms: 0,
+    duration_assignments: 0,
+  };
+  for (const { usage } of assignments) {
+    for (const [key, value] of [
+      ["input_tokens", usage.tokens?.input],
+      ["output_tokens", usage.tokens?.output],
+      ["total_tokens", usage.tokens?.total],
+      ["cost_usd", usage.cost?.usd],
+      ["cost_brl", usage.cost?.brl],
+    ]) {
+      if (Number.isFinite(value)) impact[key] += value;
+    }
+    const start = Date.parse(usage.source_started_at ?? "");
+    const finish = Date.parse(usage.source_finished_at ?? "");
+    if (Number.isFinite(start) && Number.isFinite(finish) && finish >= start) {
+      impact.duration_ms += finish - start;
+      impact.duration_assignments += 1;
+    }
+  }
+  return impact;
+}
+
+function provenanceRank(usage) {
+  const source = usage.classification_source ?? "";
+  if (source === "current_context" || source.startsWith("exact_")) return 0;
+  if (usage.activity_kind !== "retrospective_local_reconciliation") return 1;
+  return source === "legacy_inferred" ? 2 : 1;
+}
+
 export function exactCompletedSegment(started, segments) {
   if (!started?.client_turn_id) return { segment: null, ambiguous: false };
   const runStartedAt = Date.parse(started.occurred_at ?? "");
@@ -198,7 +252,13 @@ export function exactCompletedSegment(started, segments) {
   };
 }
 
-export function exactRemeasurementSegment(started, sourceSegmentKey, segments) {
+export function exactRemeasurementSegment(
+  started,
+  sourceSegmentKey,
+  segments,
+  sourceOccurredAt = null,
+  sourceTokens = null,
+) {
   const turnMatch = exactCompletedSegment(started, segments);
   if (turnMatch.segment !== null || turnMatch.ambiguous) return turnMatch;
   if (typeof sourceSegmentKey !== "string") return turnMatch;
@@ -207,9 +267,50 @@ export function exactRemeasurementSegment(started, sourceSegmentKey, segments) {
       segment.finished_at !== null &&
       canonicalSegmentKey(segment.key) === canonicalSegmentKey(sourceSegmentKey),
   );
+  if (matches.length === 1) return { segment: matches[0], ambiguous: false };
+
+  const sourceFinishedAt = Date.parse(sourceOccurredAt ?? "");
+  const sourceFile = canonicalSegmentKey(sourceSegmentKey).replace(/#\d+$/, "");
+  const timeMatches = Number.isFinite(sourceFinishedAt)
+    ? segments.filter(
+        (segment) =>
+          segment.finished_at !== null &&
+          Date.parse(segment.finished_at) === sourceFinishedAt &&
+          canonicalSegmentKey(segment.key).replace(/#\d+$/, "") === sourceFile,
+      )
+    : [];
+  if (timeMatches.length === 1) return { segment: timeMatches[0], ambiguous: false };
+
+  const tokenMatches =
+    sourceTokens !== null
+      ? segments.filter((segment) => {
+          if (canonicalSegmentKey(segment.key).replace(/#\d+$/, "") !== sourceFile) return false;
+          if (segment.finished_at === null || !Array.isArray(segment.usage)) return false;
+          const tokens = aggregate(segment);
+          const last = segment.usage.at(-1);
+          const lastTokens = last
+            ? {
+                input: last.input_tokens,
+                cached_input: last.cached_input_tokens,
+                output: last.output_tokens,
+                reasoning: last.reasoning_output_tokens,
+                total: last.total_tokens,
+              }
+            : null;
+          const same = (candidate) =>
+            candidate !== null &&
+            ["input", "cached_input", "output", "reasoning", "total"].every(
+              (key) => candidate[key] === sourceTokens[key],
+            );
+          return same(tokens) || same(lastTokens);
+        })
+      : [];
   return {
-    segment: matches.length === 1 ? matches[0] : null,
-    ambiguous: matches.length > 1,
+    segment: tokenMatches.length === 1 ? tokenMatches[0] : null,
+    ambiguous:
+      timeMatches.length > 1 ||
+      tokenMatches.length > 1 ||
+      (timeMatches.length === 0 && tokenMatches.length === 0 && matches.length > 1),
   };
 }
 
@@ -217,11 +318,10 @@ function normalized(path) {
   return resolve(path).replaceAll("\\", "/").toLowerCase();
 }
 
-export async function loadSegments(workspace) {
-  const sessionFiles = await filesUnder(join(homedir(), ".codex", "sessions"), ".jsonl");
+export async function loadSegments(workspace, sessionFiles = null) {
+  const files = sessionFiles ?? (await filesUnder(join(homedir(), ".codex", "sessions"), ".jsonl"));
   const segments = [];
-  for (const file of sessionFiles) {
-    const fileSegmentStart = segments.length;
+  for (const file of files) {
     let canonicalSessionMetaSeen = false;
     let workspaceMatches = false;
     let sessionId = null;
@@ -245,17 +345,21 @@ export async function loadSegments(workspace) {
       }
       const payload = record?.payload && typeof record.payload === "object" ? record.payload : null;
       if (record.type === "session_meta" && typeof payload?.cwd === "string") {
+        const nextSessionId = canonicalSessionId(payload);
+        const sameSession = canonicalSessionMetaSeen && nextSessionId === sessionId;
+        if (sameSession) {
+          workspaceMatches = normalized(payload.cwd) === normalized(workspace);
+          continue;
+        }
         if (canonicalSessionMetaSeen) {
-          segments.splice(fileSegmentStart);
           current = null;
           index = 0;
           latestCumulativeUsage = null;
           latestIncrementalUsage = null;
-          continue;
         }
         canonicalSessionMetaSeen = true;
         workspaceMatches = normalized(payload.cwd) === normalized(workspace);
-        sessionId = canonicalSessionId(payload);
+        sessionId = nextSessionId;
       }
       if (!workspaceMatches) continue;
       const settings = payload?.type === "thread_settings_applied" ? payload.thread_settings : null;

package/templates/.agents/skills/zaip-skill-reconcile-telemetry/scripts/reconcile-telemetry-lib.test.mjs

@@ -8,13 +8,16 @@ import {
   canonicalSessionId,
   cumulativeSnapshotDelta,
   duplicateUsageAssignments,
+  duplicateUsageImpact,
   exactCompletedSegment,
   exactRemeasurementSegment,
   jsonLines,
+  isExactDuplicateUsageGroup,
   pricingFor,
   recordSequence,
   recordType,
   sameTokenSnapshot,
+  supersedableUsageBeforeTerminal,
   usageStatus,
   usageView,
   withSequence,
@@ -23,6 +26,20 @@ import {
 const roots = [];
 after(async () => Promise.all(roots.map((root) => rm(root, { recursive: true, force: true }))));
 
+test("sums duplicate assignment impact without inventing duration", () => {
+  assert.deepEqual(duplicateUsageImpact([{ usage: { tokens: { input: 2, output: 3, total: 5 }, cost: { usd: 1, brl: 5 }, source_started_at: "2026-01-01T00:00:00Z", source_finished_at: "2026-01-01T00:00:01Z" } }]), { assignments: 1, input_tokens: 2, output_tokens: 3, total_tokens: 5, cost_usd: 1, cost_brl: 5, duration_ms: 1000, duration_assignments: 1 });
+});
+
+test("never supersedes usage recorded after run.finished", () => {
+  const records = [
+    { type: "run.started", sequence: 1 },
+    { type: "usage.recorded", sequence: 2, event_id: "before", tokens: { total: null } },
+    { type: "run.finished", sequence: 3 },
+    { type: "usage.recorded", sequence: 4, event_id: "after", tokens: { total: null } },
+  ];
+  assert.equal(supersedableUsageBeforeTerminal(records)?.event_id, "before");
+});
+
 test("normalizes compact and object Run records without changing usage totals", () => {
   const compact = [
     2,
@@ -193,6 +210,70 @@ test("remeasurement falls back only to the exact persisted source segment key",
     ),
     { segment: null, ambiguous: true },
   );
+
+  const resumedTarget = {
+    ...target,
+    key: "c:/users/test/.codex/sessions/2026/07/25/child.jsonl#18",
+    finished_at: "2026-07-25T04:15:30.000Z",
+  };
+  assert.deepEqual(
+    exactRemeasurementSegment(
+      { client_turn_id: null, occurred_at: "2026-07-25T04:00:00.000Z" },
+      "sessions/2026/07/25/child.jsonl#2",
+      [target, resumedTarget],
+      "2026-07-25T04:15:30.000Z",
+    ),
+    { segment: resumedTarget, ambiguous: false },
+  );
+
+  const tokenTarget = {
+    ...resumedTarget,
+    finished_at: "2026-07-25T04:16:00.000Z",
+    usage: [
+      {
+        input_tokens: 90,
+        cached_input_tokens: 80,
+        output_tokens: 10,
+        reasoning_output_tokens: 2,
+        total_tokens: 100,
+      },
+    ],
+  };
+  assert.deepEqual(
+    exactRemeasurementSegment(
+      { client_turn_id: null, occurred_at: "2026-07-25T04:00:00.000Z" },
+      "sessions/2026/07/25/child.jsonl#2",
+      [target, tokenTarget],
+      "2026-07-25T04:15:59.000Z",
+      { input: 90, cached_input: 80, output: 10, reasoning: 2, total: 100 },
+    ),
+    { segment: tokenTarget, ambiguous: false },
+  );
+
+  const cumulativeSnapshotTarget = {
+    ...tokenTarget,
+    key: "c:/users/test/.codex/sessions/2026/07/25/child.jsonl#19",
+    usage: [
+      tokenTarget.usage[0],
+      {
+        input_tokens: 40,
+        cached_input_tokens: 30,
+        output_tokens: 4,
+        reasoning_output_tokens: 1,
+        total_tokens: 44,
+      },
+    ],
+  };
+  assert.deepEqual(
+    exactRemeasurementSegment(
+      { client_turn_id: null, occurred_at: "2026-07-25T04:00:00.000Z" },
+      "sessions/2026/07/25/child.jsonl#2",
+      [target, cumulativeSnapshotTarget],
+      null,
+      { input: 40, cached_input: 30, output: 4, reasoning: 1, total: 44 },
+    ),
+    { segment: cumulativeSnapshotTarget, ambiguous: false },
+  );
 });
 
 test("detects only exact duplicate segment assignments across Runs", () => {
@@ -237,10 +318,11 @@ test("detects only exact duplicate segment assignments across Runs", () => {
   const groups = duplicateUsageAssignments([duplicate, legitimateDelta, first]);
 
   assert.equal(groups.length, 1);
-  assert.deepEqual(
-    groups[0].map(({ run: item }) => item.started.run_id),
-    ["RUN-FIRST", "RUN-DUPLICATE"],
-  );
+  assert.deepEqual(groups[0].map(({ run: item }) => item.started.run_id), [
+    "RUN-FIRST",
+    "RUN-DUPLICATE",
+    "RUN-DELTA",
+  ]);
   assert.equal(groups[0][0].base_segment_key, "sessions/2026/07/17/session.jsonl#1");
 });
 
@@ -264,3 +346,39 @@ test("keeps duplicate reconciliation unavailable and protected from backfill", (
   assert.equal(status.deduplicated, true);
   assert.deepEqual(status.effective, [correction]);
 });
+
+test("prefers later current-context assignment over earlier legacy assignment", () => {
+  const run = (id, occurred_at, client_turn_id, classification_source, total) => ({
+    started: { run_id: id, occurred_at, client_turn_id },
+    usage: [{ event_id: `${id}:usage`, source_segment_key: "sessions/x.jsonl#1", supersedes_event_id: null, classification_source, tokens: { input: total - 1, output: 1, total } }],
+  });
+  const [group] = duplicateUsageAssignments([
+    run("XCHW", "2026-07-01T00:00:00.000Z", "legacy-turn", "legacy_inferred", 9_278_701),
+    run("HF77", "2026-07-01T00:01:00.000Z", "exact-turn", "current_context", 577),
+  ]);
+  assert.equal(group[0].run.started.run_id, "HF77");
+  assert.equal(group[1].run.started.run_id, "XCHW");
+});
+
+test("keeps canonical aliases in review instead of making them apply candidates", () => {
+  const run = (id, source_segment_key) => ({
+    started: { run_id: id, occurred_at: "2026-07-01T00:00:00.000Z" },
+    usage: [{
+      event_id: `${id}:usage`,
+      source_segment_key,
+      supersedes_event_id: null,
+      tokens: { input: 1, output: 1, total: 2 },
+    }],
+  });
+  const [aliasGroup] = duplicateUsageAssignments([
+    run("RUN-A", "sessions/x.jsonl#1@RUN-A"),
+    run("RUN-B", "sessions/x.jsonl#1@RUN-B"),
+  ]);
+  const [exactGroup] = duplicateUsageAssignments([
+    run("RUN-C", "sessions/x.jsonl#2"),
+    run("RUN-D", "SESSIONS\\x.jsonl#2"),
+  ]);
+
+  assert.equal(isExactDuplicateUsageGroup(aliasGroup), false);
+  assert.equal(isExactDuplicateUsageGroup(exactGroup), true);
+});