@zaip-ai/cli 1.0.6 → 1.0.7

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

@@ -1,6 +1,6 @@
 ---
 name: zaip-skill-prd
-description: Create, refine, prepare, and analyze ZAIP PRDs that map business outcomes to SPECs and Task DAGs while preserving draft status until the user explicitly requests ready or execution.
+description: Create, refine, prepare, and analyze complete ZAIP PRDs with technical SPECs and Task blueprints. Use for explicit requests to create a PRD or to think, develop, improve, or refine one; distinguish conversation from materialized creation and preserve draft until explicit ready or execution intent.
 ---
 
 # Trabalhar com PRDs
@@ -16,25 +16,41 @@ PRD é opcional e permanece em Definição com `status: draft` durante criação
 
 ## Create e refine
 
-1. Registre problema, usuários, valor, outcomes mensuráveis, restrições, hipóteses, riscos e não objetivos sem executar nada.
-2. Mantenha o PRD agnóstico de linguagem, framework, banco, infraestrutura e fornecedor. Uma tecnologia só aparece quando for restrição externa real de negócio, regulação ou compatibilidade contratual; registre-a como restrição, não como desenho da solução.
-3. Permita múltiplos PRDs pendentes; compare por valor, risco, custo e evidência, e refine somente os escolhidos.
-4. Crie uma ou mais SPECs técnicas ligadas ao PRD quando solicitado. PRD e SPECs novas continuam em `draft`; cada Change planejada deve pertencer exatamente a uma dessas SPECs.
-5. Não crie Tasks, Changes, Executions ou Runs de execução durante conversa/refinamento; telemetria de conversation/planning pode registrar o uso sem torná-lo executável.
-6. Para refine Git-native, edite somente o arquivo canônico retornado pelo create enquanto `status: draft`; preserve ID/`created_at`, incremente `revision`, atualize `updated_at` e valide com `zaip prd show <ID>`. Não use `prepare` como encerramento automático da criação. Depois de `ready`, não faça patch manual: gere nova revisão do plano antes da execução ou rework após materialização.
+1. Diferencie “me ajude a pensar/explorar um PRD”, que permanece Conversation, de “crie um PRD”, que autoriza persistir o pacote completo em `draft`.
+2. Antes de criar, revise o prompt. Faça até cinco perguntas críticas em um turno e use até três turnos no total apenas se respostas continuarem ambíguas. Depois, assuma decisões delegáveis e registre origem IA. Nunca presuma autoridade externa/destrutiva, credencial, obrigação legal ou risco de segurança não delegável.
+3. Registre problema, usuários, valor, outcomes mensuráveis, restrições, hipóteses, riscos e não objetivos sem executar o produto.
+4. Mantenha o PRD agnóstico de implementação; tecnologia macro informada pelo usuário entra como restrição/preferência, e desenho concreto fica nas SPECs.
+5. Gere todas as SPECs técnicas e o PreparedPlan no mesmo fluxo de criação. Use uma SPEC por padrão; adicione outra somente quando ambas puderem ser implementadas e verificadas em paralelo contra contratos estáveis, sem dependência ou conflito de write scope.
+6. Persista apenas blueprints compactos de Tasks no PreparedPlan para leitura rápida. Não crie registros Task, Change ou Execution `delivery` antes de `ready|execute`.
+7. A criação, o rework e o prepare do PRD exigem uma Run delegada e ativa da Bia (`zaip-agent-analyst`), com propósito `execution`, sob o orquestrador do turno raiz atual; passe essa Run em `--run`. Em `prd create --plan`, delegue também ao Rafa e passe sua Run ativa e distinta em `--spec-run`: o PRD recebe o `creation_run_id` da Bia e cada SPEC recebe o do Rafa. Replays históricos ou identidades trocadas falham antes da escrita. Agregue duração, tokens e custo da definição ao macro somente quando observados ou reconciliados; preserve `null`/indisponível sem inventar zero.
+8. Para refine Git-native, edite somente o draft canônico e incremente `revision`. Depois de materializado, preserve o snapshot e use rework; PRD cancelado cria sucessor com tag `rework` e `rework_of_prd_id`.
+
+### Quantidade de SPECs
+
+Escolha sempre a menor quantidade que preserve paralelismo real:
+
+| Quantidade | Critério | Exemplo |
+| --- | --- | --- |
+| 1 | Padrão. Um outcome vertical com etapas ordenadas, contratos ainda evoluindo ou qualquer dependência entre frentes. | Recuperação de senha ponta a ponta: UI, API, token, e-mail e persistência ficam na DAG da mesma SPEC. |
+| 2 | Duas capacidades independentes, com contrato congelado, escopos de escrita separados e testes próprios. | Clientes Web e Mobile implementados em paralelo contra uma API já estável. |
+| 3 | Três capacidades autônomas, cada uma entregável e verificável sem aguardar as demais; a integração é gate do PRD. | Integrações independentes de identidade, cobrança e notificações contra portas estáveis. |
+| 4 | Quatro workstreams raros, claramente delimitados por ownership e diretórios sem sobreposição. | Adaptadores fiscais de quatro países implementando a mesma interface estável. |
+| 5 | Limite excepcional para cinco implementações simétricas, realmente paralelas e com contrato comum já validado. | Canais Email, SMS, WhatsApp, Push e Inbox implementando a mesma interface de mensagens. |
+
+Se uma SPEC produzir contrato, migração, dado ou código necessário por outra, una ambas e represente a ordem na DAG interna. Acima de cinco, reavalie o recorte do PRD ou registre uma decisão de exceção; nunca aumente a quantidade apenas para distribuir trabalho.
 
 Durante essa etapa, a Execution universal `interaction` e sua Run raiz continuam obrigatórias para telemetria e rastreabilidade; a proibição acima refere-se somente a Execution `delivery` e a Runs de execução.
 
 ## Prepare
 
-1. Bloqueie PRD sem SPEC, SPEC de outro PRD, referência quebrada, AC vago, DAG cíclica ou write scopes concorrentes.
-2. Construa uma DAG global que pode atravessar SPECs e inclua integração/gates como dependências explícitas.
-3. Gere e valide o PreparedPlan conforme [o contrato compacto](../zaip-skill-execution/references/prepared-plan.md), persista-o e pré-aloque IDs sem materializar trabalho executável nem mudar `draft` para `ready`.
+1. Bloqueie PRD sem SPEC, SPEC de outro PRD, referência quebrada, AC vago, DAG cíclica, dependência entre SPECs ou write scopes concorrentes.
+2. Construa uma DAG por SPEC; dependências nunca atravessam SPECs. Mantenha integração e outcomes como gates parentais do PRD.
+3. Gere e valide o PreparedPlan conforme [o contrato compacto](../zaip-skill-execution/references/prepared-plan.md), persista-o e pré-aloque IDs sem materializar trabalho executável nem mudar `draft` para `ready`. Um pedido explícito posterior de `prd ready` materializa, na mesma operação idempotente, a DAG selecionada em Execution, Changes e Tasks `planned`, sem iniciar a execução.
 4. Após `prepare`, mostre que o PRD continua em Definição e pare; não encadeie `prd ready` ou `prd execute` sem a solicitação explícita correspondente.
 
 ## Handoff e analyze
 
-1. Pare em Definição após `prepare`. Somente após pedido explícito de promoção, use `$zaip-skill-move-prd`; somente após pedido explícito de execução, delegue materialização, ativação e orquestração para `$zaip-skill-execution`.
+1. Pare em Definição após `prepare`. Somente após pedido explícito de promoção, use `$zaip-skill-move-prd`: `prd ready` deixa PRD/SPECs selecionadas em `ready` e materializa a DAG sem executá-la; cada Task materializada `planned` e nunca iniciada aparece em Pronto para Executar, mesmo vinculada a SPEC. Somente após pedido explícito de execução, delegue a persistência da continuação, ativação e orquestração para `$zaip-skill-execution`.
 2. Na análise, mostre visão macro por PRD: SPECs, Tasks, Executions, Runs, outcomes, AC/evidência, retrabalho, tokens e custo por fase/total.
 
 ## Assurance de outcomes

package/templates/.agents/skills/zaip-skill-reconcile-telemetry/SKILL.md

@@ -12,13 +12,12 @@ description: Auditar e reparar telemetria ausente de Runs e tarefas ZAIP usando
 4. Para novos Runs Codex, exigir correspondência exata por `client_turn_id` com `task_started.payload.turn_id` do arquivo local. Usar ID da Run, ID da Task, Conversation ID, contenção temporal ou vizinhança temporal mútua de até dois minutos somente para Runs legados sem `client_turn_id`:
    `node .agents/skills/zaip-skill-reconcile-telemetry/scripts/reconcile-local-telemetry.mjs --apply`
    O mesmo comando pode encerrar uma Run ainda marcada como `running` somente quando existir um único segmento local concluído com o mesmo `client_turn_id`; usar o `finished_at` desse segmento como fim real, nunca o relógio atual.
-5. Reconstruir projeções com `node packages/cli/dist/index.js projection rebuild --confirm-full-scan --json`.
+5. Reconstruir o lifecycle manifest com `node packages/cli/dist/index.js manifest rebuild --confirm-full-scan --json`.
 6. Reexecutar o diagnóstico. Exigir `eligible: 0` e confirmar que a cobertura aumentou ou permaneceu igual.
 7. Para corrigir segmentos exatamente duplicados entre Runs sem aplicar o backfill geral, diagnosticar e revisar `duplicate_segment_groups` e `duplicate_segment_assignments`:
    `node .agents/skills/zaip-skill-reconcile-telemetry/scripts/reconcile-local-telemetry.mjs --deduplicate`
    Aplicar somente após confirmação humana explícita com `--apply --deduplicate`. O modo preserva o evento original, insere uma supersessão indisponível antes de `run.finished` e protege o Run corrigido contra o backfill geral posterior.
-8. Quando ainda houver lacunas, executar `python .agents/skills/zaip-skill-reconcile-telemetry/scripts/inspect-local-sqlite.py`. Usar SQLite apenas como índice de threads e fonte de investigação; `threads.tokens_used` e `total_usage_tokens` de logs são acumulados e não substituem input/output por Run.
-9. Somente com autorização humana explícita para aproximação, executar primeiro o diagnóstico `node .agents/skills/zaip-skill-reconcile-telemetry/scripts/reconcile-local-telemetry.mjs --approximate`. O score combina distância entre data/hora/minuto/segundo de criação e 35% da diferença de duração. Aplicar com `--apply --approximate`; persistir esses vínculos como `legacy_inferred`.
+8. Somente com autorização humana explícita para aproximação, executar primeiro o diagnóstico `node .agents/skills/zaip-skill-reconcile-telemetry/scripts/reconcile-local-telemetry.mjs --approximate`. O score combina distância entre data/hora/minuto/segundo de criação e 35% da diferença de duração. Aplicar com `--apply --approximate`; persistir esses vínculos como `legacy_inferred`.
 
 ## Normalizar identidade de agentes
 
@@ -32,7 +31,7 @@ Com autorização explícita para o backfill, aplique com `--apply` e reconstrua
 
 - Tratar cache como subconjunto de entrada e reasoning como subconjunto de saída.
 - Calcular `total = input + output`.
-- Reutilizar preços locais editáveis em `.zaip-aios/pricing/models.json` e câmbio local quando presentes.
+- Reutilizar preços locais editáveis em `.agents/config/pricing/models.json` e câmbio local quando presentes.
 - Preservar eventos históricos e inserir o evento corretivo, com `supersedes_event_id`, imediatamente antes de `run.finished`, conforme a ordem canônica do Run V2.
 - Usar cada segmento local no máximo uma vez.
 - Persistir `client_thread_id` e `client_turn_id` em todo novo `run.started` criado dentro do Codex; o ID do turn é a chave canônica de reconciliação.

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

@@ -16,13 +16,33 @@ import {
   usageView,
   withSequence,
 } from "./reconcile-telemetry-lib.mjs";
+import { remeasureSelectedRuns } from "./reconcile-telemetry-remeasurement.mjs";
 
 const workspace = resolve(process.cwd());
 const apply = process.argv.includes("--apply");
 const approximate = process.argv.includes("--approximate");
 const reprice = process.argv.includes("--reprice");
 const deduplicate = process.argv.includes("--deduplicate");
-const applyBackfill = apply && !deduplicate;
+const remeasure = process.argv.includes("--remeasure");
+const timingOnly = process.argv.includes("--timing-only");
+if (timingOnly && !remeasure) {
+  throw new Error("--timing-only requires --remeasure");
+}
+const selectedRunIds = new Set(
+  process.argv.flatMap((argument, index, values) =>
+    argument === "--run"
+      ? String(values[index + 1] ?? "")
+          .split(",")
+          .filter(Boolean)
+      : argument.startsWith("--run=")
+        ? argument.slice("--run=".length).split(",").filter(Boolean)
+        : [],
+  ),
+);
+if (remeasure && selectedRunIds.size === 0) {
+  throw new Error("--remeasure requires at least one explicit --run <RUN-ID>");
+}
+const applyBackfill = apply && !deduplicate && !remeasure;
 
 const runFiles = await filesUnder(join(workspace, ".agents", "records", "runs"), ".jsonl");
 const runs = [];
@@ -150,6 +170,16 @@ for (const file of runFiles) {
 }
 
 const allSegments = await loadSegments(workspace);
+const remeasurement = remeasure
+  ? await remeasureSelectedRuns({
+      apply,
+      allSegments,
+      runs,
+      selectedRunIds,
+      timingOnly,
+      workspace,
+    })
+  : [];
 const unfinished = runs.filter(
   (run) => !run.records.some((record) => recordType(record) === "run.finished"),
 );
@@ -606,6 +636,8 @@ if (applyBackfill) {
       source_segment_key: segment.key,
       supersedes_event_id: superseded?.event_id ?? null,
       source_occurred_at: segment.finished_at ?? segment.started_at,
+      ...(segment.started_at ? { source_started_at: segment.started_at } : {}),
+      ...(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");
@@ -643,18 +675,23 @@ console.log(
         ? apply
           ? "apply-deduplicate"
           : "dry-run-deduplicate"
-        : apply
-          ? reprice
-            ? "apply-reprice"
-            : approximate
-              ? "apply-approximate"
-              : "apply"
-          : reprice
-            ? "dry-run-reprice"
-            : approximate
-              ? "dry-run-approximate"
-              : "dry-run",
+        : remeasure
+          ? apply
+            ? "apply-remeasure"
+            : "dry-run-remeasure"
+          : apply
+            ? reprice
+              ? "apply-reprice"
+              : approximate
+                ? "apply-approximate"
+                : "apply"
+            : reprice
+              ? "dry-run-reprice"
+              : approximate
+                ? "dry-run-approximate"
+                : "dry-run",
       run_files: runs.length,
+      remeasurement,
       local_session_files: new Set(segments.map((segment) => segment.file)).size,
       local_segments_available: segments.length,
       already_measured: runs.filter((run) => run.measured).length,
@@ -672,7 +709,16 @@ console.log(
       ).length,
       corrections_recorded: corrections.length,
       invalid_correction_totals: corrections.filter(
-        (usage) => usage.tokens.total !== usage.tokens.input + usage.tokens.output,
+        (usage) =>
+          !(
+            (usage.tokens.total === null &&
+              usage.tokens.input === null &&
+              usage.tokens.output === null) ||
+            (usage.tokens.total !== null &&
+              usage.tokens.input !== null &&
+              usage.tokens.output !== null &&
+              usage.tokens.total === usage.tokens.input + usage.tokens.output)
+          ),
       ).length,
       duplicated_correction_segments: correctionKeys.length - new Set(correctionKeys).size,
       duplicate_segment_groups: duplicateGroups.length,

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

@@ -67,6 +67,10 @@ export function recordOccurredAt(record) {
   return Array.isArray(record) ? record[4] : record.occurred_at;
 }
 
+export function recordPhase(record) {
+  return Array.isArray(record) ? record[5] : record.phase;
+}
+
 export function usageView(record) {
   if (recordType(record) !== "usage.recorded") return null;
   if (!Array.isArray(record)) return record;
@@ -92,6 +96,8 @@ export function usageView(record) {
     provider: record[10] ?? null,
     model: record[11] ?? null,
     source_occurred_at: record[14] ?? null,
+    source_started_at: record[17] ?? null,
+    source_finished_at: record[18] ?? null,
     context_stats: Array.isArray(record[15])
       ? {
           initial_pack_tokens: record[15][0],
@@ -113,7 +119,7 @@ export function withSequence(record, sequence) {
   return copy;
 }
 
-function canonicalSegmentKey(sourceSegmentKey) {
+export function canonicalSegmentKey(sourceSegmentKey) {
   const marker = sourceSegmentKey.lastIndexOf("@RUN-");
   const withoutRun = marker < 0 ? sourceSegmentKey : sourceSegmentKey.slice(0, marker);
   const normalized = withoutRun.replaceAll("\\", "/");
@@ -192,6 +198,21 @@ export function exactCompletedSegment(started, segments) {
   };
 }
 
+export function exactRemeasurementSegment(started, sourceSegmentKey, segments) {
+  const turnMatch = exactCompletedSegment(started, segments);
+  if (turnMatch.segment !== null || turnMatch.ambiguous) return turnMatch;
+  if (typeof sourceSegmentKey !== "string") return turnMatch;
+  const matches = segments.filter(
+    (segment) =>
+      segment.finished_at !== null &&
+      canonicalSegmentKey(segment.key) === canonicalSegmentKey(sourceSegmentKey),
+  );
+  return {
+    segment: matches.length === 1 ? matches[0] : null,
+    ambiguous: matches.length > 1,
+  };
+}
+
 function normalized(path) {
   return resolve(path).replaceAll("\\", "/").toLowerCase();
 }
@@ -200,6 +221,8 @@ export async function loadSegments(workspace) {
   const sessionFiles = await filesUnder(join(homedir(), ".codex", "sessions"), ".jsonl");
   const segments = [];
   for (const file of sessionFiles) {
+    const fileSegmentStart = segments.length;
+    let canonicalSessionMetaSeen = false;
     let workspaceMatches = false;
     let sessionId = null;
     let current = null;
@@ -207,6 +230,8 @@ export async function loadSegments(workspace) {
     let model = null;
     let effort = null;
     let serviceTier = null;
+    let latestCumulativeUsage = null;
+    let latestIncrementalUsage = null;
     const lines = createInterface({
       input: createReadStream(file, { encoding: "utf8" }),
       crlfDelay: Infinity,
@@ -220,13 +245,17 @@ 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") {
+        if (canonicalSessionMetaSeen) {
+          segments.splice(fileSegmentStart);
+          current = null;
+          index = 0;
+          latestCumulativeUsage = null;
+          latestIncrementalUsage = null;
+          continue;
+        }
+        canonicalSessionMetaSeen = true;
         workspaceMatches = normalized(payload.cwd) === normalized(workspace);
-        sessionId =
-          typeof payload.session_id === "string"
-            ? payload.session_id
-            : typeof payload.id === "string"
-              ? payload.id
-              : null;
+        sessionId = canonicalSessionId(payload);
       }
       if (!workspaceMatches) continue;
       const settings = payload?.type === "thread_settings_applied" ? payload.thread_settings : null;
@@ -249,6 +278,7 @@ export async function loadSegments(workspace) {
         if (current) current.model = model;
       }
       if (payload?.type === "task_started") {
+        latestIncrementalUsage = null;
         index += 1;
         current = {
           key: `${normalized(file)}#${index}`,
@@ -264,13 +294,26 @@ export async function loadSegments(workspace) {
           raw: [],
         };
       }
-      if (!current) continue;
-      if (line.includes("RUN-") || line.includes("TASK-")) current.raw.push(line);
       if (payload?.type === "token_count") {
-        const usage = payload?.info?.last_token_usage;
-        if (usage && typeof usage === "object")
+        const cumulative = tokenSnapshot(payload?.info?.total_token_usage);
+        const incremental = tokenSnapshot(payload?.info?.last_token_usage);
+        if (cumulative === null && incremental === null) continue;
+        const previous = latestCumulativeUsage;
+        if (cumulative !== null) latestCumulativeUsage = cumulative;
+        if (!current) continue;
+        const usage =
+          cumulative === null
+            ? incremental !== null && sameTokenSnapshot(latestIncrementalUsage, incremental)
+              ? null
+              : incremental
+            : cumulativeSnapshotDelta(previous, cumulative);
+        if (cumulative === null && incremental !== null) latestIncrementalUsage = incremental;
+        if (usage !== null && hasPositiveTokenDelta(usage)) {
           current.usage.push({ ...usage, source_timestamp: record.timestamp ?? null });
+        }
       }
+      if (!current) continue;
+      if (line.includes("RUN-") || line.includes("TASK-")) current.raw.push(line);
       if (payload?.type === "task_complete") {
         current.finished_at = record.timestamp ?? null;
         if (current.usage.length) segments.push(current);
@@ -282,29 +325,89 @@ export async function loadSegments(workspace) {
   return segments.map((segment) => ({ ...segment, raw: segment.raw.join("\n") }));
 }
 
+export function sameTokenSnapshot(left, right) {
+  return (
+    left !== null &&
+    left.input_tokens === right.input_tokens &&
+    left.cached_input_tokens === right.cached_input_tokens &&
+    left.output_tokens === right.output_tokens &&
+    left.reasoning_output_tokens === right.reasoning_output_tokens &&
+    left.total_tokens === right.total_tokens
+  );
+}
+
+export function canonicalSessionId(payload) {
+  const spawn = payload?.source?.subagent?.thread_spawn;
+  return spawn && typeof spawn === "object" && typeof payload.id === "string"
+    ? payload.id
+    : typeof payload?.session_id === "string"
+      ? payload.session_id
+      : typeof payload?.id === "string"
+        ? payload.id
+        : null;
+}
+
 export function aggregate(segment) {
-  const result = { input: 0, cached_input: 0, output: 0, reasoning: 0, total: 0 };
-  for (const usage of segment.usage) {
-    const input = Number.isFinite(usage.input_tokens) ? usage.input_tokens : 0;
-    const output = Number.isFinite(usage.output_tokens) ? usage.output_tokens : 0;
-    result.input += input;
-    result.cached_input += Number.isFinite(usage.cached_input_tokens)
-      ? usage.cached_input_tokens
-      : 0;
-    result.output += output;
-    result.reasoning += Number.isFinite(usage.reasoning_output_tokens)
-      ? usage.reasoning_output_tokens
-      : 0;
-    result.total += input + output;
-  }
-  return result;
+  const completeSum = (key) =>
+    segment.usage.length > 0 && segment.usage.every((usage) => Number.isFinite(usage[key]))
+      ? segment.usage.reduce((sum, usage) => sum + usage[key], 0)
+      : null;
+  const input = completeSum("input_tokens");
+  const output = completeSum("output_tokens");
+  const reportedTotal = completeSum("total_tokens");
+  return {
+    input,
+    cached_input: completeSum("cached_input_tokens"),
+    output,
+    reasoning: completeSum("reasoning_output_tokens"),
+    total: reportedTotal ?? (input !== null && output !== null ? input + output : null),
+  };
+}
+
+function tokenSnapshot(value) {
+  if (typeof value !== "object" || value === null) return null;
+  const finite = (key) => (Number.isFinite(value[key]) && value[key] >= 0 ? value[key] : null);
+  return {
+    input_tokens: finite("input_tokens"),
+    cached_input_tokens: finite("cached_input_tokens"),
+    output_tokens: finite("output_tokens"),
+    reasoning_output_tokens: finite("reasoning_output_tokens"),
+    total_tokens: finite("total_tokens"),
+  };
+}
+
+export function cumulativeSnapshotDelta(previous, current) {
+  const delta = (key) => {
+    const value = current[key];
+    if (!Number.isFinite(value)) return null;
+    const baseline = previous?.[key];
+    if (!Number.isFinite(baseline)) return value;
+    return value >= baseline ? value - baseline : value;
+  };
+  return {
+    input_tokens: delta("input_tokens"),
+    cached_input_tokens: delta("cached_input_tokens"),
+    output_tokens: delta("output_tokens"),
+    reasoning_output_tokens: delta("reasoning_output_tokens"),
+    total_tokens: delta("total_tokens"),
+  };
+}
+
+function hasPositiveTokenDelta(usage) {
+  return [
+    usage.input_tokens,
+    usage.cached_input_tokens,
+    usage.output_tokens,
+    usage.reasoning_output_tokens,
+    usage.total_tokens,
+  ].some((value) => value !== null && value > 0);
 }
 
 export async function pricingFor(workspace, model, tokens) {
   let catalog;
   try {
     catalog = JSON.parse(
-      await readFile(join(workspace, ".zaip-aios", "pricing", "models.json"), "utf8"),
+      await readFile(join(workspace, ".agents", "config", "pricing", "models.json"), "utf8"),
     );
   } catch {
     return { usd: null, brl: null };
@@ -343,7 +446,7 @@ export async function pricingFor(workspace, model, tokens) {
         (price.reasoning_per_million_usd ?? price.output_per_million_usd) *
         outputMultiplier) /
     1_000_000;
-  const fxFiles = await filesUnder(join(workspace, ".zaip-aios", "pricing", "fx"), ".json");
+  const fxFiles = await filesUnder(join(workspace, ".agents", "config", "pricing", "fx"), ".json");
   let rate = null;
   if (fxFiles.length) {
     try {

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

@@ -5,12 +5,16 @@ import { join } from "node:path";
 import { after, test } from "node:test";
 import {
   aggregate,
+  canonicalSessionId,
+  cumulativeSnapshotDelta,
   duplicateUsageAssignments,
   exactCompletedSegment,
+  exactRemeasurementSegment,
   jsonLines,
   pricingFor,
   recordSequence,
   recordType,
+  sameTokenSnapshot,
   usageStatus,
   usageView,
   withSequence,
@@ -63,12 +67,63 @@ test("normalizes compact and object Run records without changing usage totals",
   );
 });
 
+test("deduplicates cumulative snapshots and starts a new epoch after reset", () => {
+  const snapshot = (input, cached, output, reasoning) => ({
+    input_tokens: input,
+    cached_input_tokens: cached,
+    output_tokens: output,
+    reasoning_output_tokens: reasoning,
+    total_tokens: input + output,
+  });
+  assert.deepEqual(
+    cumulativeSnapshotDelta(snapshot(100, 80, 20, 5), snapshot(100, 80, 20, 5)),
+    snapshot(0, 0, 0, 0),
+  );
+  assert.deepEqual(
+    cumulativeSnapshotDelta(snapshot(100, 80, 20, 5), snapshot(140, 110, 35, 9)),
+    snapshot(40, 30, 15, 4),
+  );
+  assert.deepEqual(
+    cumulativeSnapshotDelta(snapshot(140, 110, 35, 9), snapshot(12, 8, 3, 1)),
+    snapshot(12, 8, 3, 1),
+  );
+});
+
+test("deduplicates only consecutive identical last_token_usage fallback snapshots", () => {
+  const snapshot = {
+    input_tokens: 10,
+    cached_input_tokens: 2,
+    output_tokens: 3,
+    reasoning_output_tokens: 1,
+    total_tokens: 13,
+  };
+  assert.equal(sameTokenSnapshot(snapshot, { ...snapshot }), true);
+  assert.equal(sameTokenSnapshot(snapshot, { ...snapshot, output_tokens: 4 }), false);
+  assert.equal(sameTokenSnapshot(null, snapshot), false);
+});
+
+test("keeps the child session id when a child rollout embeds its root session id", () => {
+  assert.equal(
+    canonicalSessionId({
+      id: "child-session",
+      session_id: "root-session",
+      source: {
+        subagent: {
+          thread_spawn: { parent_thread_id: "root-session", agent_path: "/root/child" },
+        },
+      },
+    }),
+    "child-session",
+  );
+  assert.equal(canonicalSessionId({ id: "session", session_id: "root-session" }), "root-session");
+});
+
 test("prices only exact or governed model identities", async () => {
   const root = await mkdtemp(join(tmpdir(), "zaip-reconcile-lib-"));
   roots.push(root);
-  await mkdir(join(root, ".zaip-aios", "pricing"), { recursive: true });
+  await mkdir(join(root, ".agents", "config", "pricing"), { recursive: true });
   await writeFile(
-    join(root, ".zaip-aios", "pricing", "models.json"),
+    join(root, ".agents", "config", "pricing", "models.json"),
     JSON.stringify({
       models: [
         {
@@ -116,6 +171,30 @@ test("selects only one completed local segment for an exact Run turn", () => {
   );
 });
 
+test("remeasurement falls back only to the exact persisted source segment key", () => {
+  const target = {
+    key: "c:/users/test/.codex/sessions/2026/07/25/child.jsonl#1",
+    turn_id: "actual-child-turn",
+    finished_at: "2026-07-25T03:01:00.000Z",
+  };
+  assert.deepEqual(
+    exactRemeasurementSegment(
+      { client_turn_id: "legacy-wrong-turn", occurred_at: "2026-07-25T03:00:00.000Z" },
+      "sessions/2026/07/25/child.jsonl#1@RUN-OLD",
+      [target],
+    ),
+    { segment: target, ambiguous: false },
+  );
+  assert.deepEqual(
+    exactRemeasurementSegment(
+      { client_turn_id: "legacy-wrong-turn", occurred_at: "2026-07-25T03:00:00.000Z" },
+      "sessions/2026/07/25/child.jsonl#1",
+      [target, { ...target }],
+    ),
+    { segment: null, ambiguous: true },
+  );
+});
+
 test("detects only exact duplicate segment assignments across Runs", () => {
   const usage = (
     runId,