@zaip-ai/cli 1.0.4 → 1.0.7

package/templates/.agents/dashboard/modules/operations/src/duration-population.ts

@@ -0,0 +1,35 @@
+/**
+ * Canonical duration population shared by Operations and Cost Monitor.
+ *
+ * Durations represent root execution wall time. Delegated Sub-Runs remain
+ * visible as calls, but never add elapsed time after their visible execution
+ * parent has already contributed it.
+ */
+export interface DurationPopulationRun {
+  id: string;
+  phase?: string;
+  parent_run_id?: string | null;
+}
+
+export function uniqueExecutionRuns<T extends DurationPopulationRun>(runs: readonly T[]): T[] {
+  const unique = new Map<string, T>();
+  for (const run of runs) {
+    if ((run.phase === undefined || run.phase === "execution") && !unique.has(run.id))
+      unique.set(run.id, run);
+  }
+  return [...unique.values()];
+}
+
+export function rootExecutionDurationRuns<T extends DurationPopulationRun>(
+  runs: readonly T[],
+): T[] {
+  const unique = new Map<string, T>();
+  for (const run of runs) if (!unique.has(run.id)) unique.set(run.id, run);
+  const population = [...unique.values()];
+  const visibleIds = new Set(population.map((run) => run.id));
+  return population.filter(
+    (run) =>
+      (run.phase === undefined || run.phase === "execution") &&
+      (run.parent_run_id == null || !visibleIds.has(run.parent_run_id)),
+  );
+}

package/templates/.agents/dashboard/modules/operations/src/react/EntityDetailsDialog.tsx

@@ -0,0 +1,309 @@
+import { formatCompactNumber, formatCurrency, formatDateTime } from "@zaip-ai/dashboard-ui";
+import { createPortal } from "react-dom";
+import type {
+  ChangeProjection,
+  DecisionProjection,
+  ExecutionProjection,
+  RunProjection,
+} from "../contracts.js";
+import { formatOperationDuration, operationalDurationMs } from "./operation-duration.js";
+import type { OperationsLocale } from "./status-labels.js";
+import "./entity-details-dialog.css";
+
+export type EntityDetails =
+  | { kind: "change"; row: ChangeProjection }
+  | { kind: "decision"; row: DecisionProjection }
+  | { kind: "execution"; row: ExecutionProjection }
+  | { kind: "run"; row: RunProjection };
+
+export function EntityDetailsDialog({
+  details,
+  locale,
+  onClose,
+}: {
+  details: EntityDetails;
+  locale: OperationsLocale;
+  onClose: () => void;
+}) {
+  const copy = entityDetailsCopy(locale);
+  const title =
+    details.kind === "change" || details.kind === "decision" ? details.row.title : details.row.id;
+  return createPortal(
+    <dialog
+      className="operations-status-dialog-backdrop"
+      onMouseDown={(event) => event.currentTarget === event.target && onClose()}
+      open
+    >
+      <section
+        aria-label={`${copy.details} ${entityLabel(details.kind, locale)}`}
+        aria-modal="true"
+        className="operations-status-dialog operations-entity-details"
+        role="dialog"
+      >
+        <header>
+          <div>
+            <span>{entityLabel(details.kind, locale)}</span>
+            <h2>{title}</h2>
+            <p>{details.row.id}</p>
+          </div>
+          <button
+            aria-label={locale === "pt-BR" ? "Fechar" : "Close"}
+            onClick={onClose}
+            type="button"
+          >
+            ×
+          </button>
+        </header>
+        <div className="operations-entity-details-scroll">
+          {details.kind === "change" ? <ChangeDetails locale={locale} row={details.row} /> : null}
+          {details.kind === "decision" ? (
+            <DecisionDetails locale={locale} row={details.row} />
+          ) : null}
+          {details.kind === "execution" ? (
+            <ExecutionDetails locale={locale} row={details.row} />
+          ) : null}
+          {details.kind === "run" ? <RunDetails locale={locale} row={details.row} /> : null}
+        </div>
+      </section>
+    </dialog>,
+    document.body,
+  );
+}
+
+function ChangeDetails({ row, locale }: { row: ChangeProjection; locale: OperationsLocale }) {
+  const copy = entityDetailsCopy(locale);
+  return (
+    <DetailGrid
+      items={[
+        [copy.status, row.status],
+        [copy.risk, row.risk],
+        [copy.origin, sourceLabel(row.source)],
+        [copy.created, formatDateTime(row.created_at, locale)],
+        [copy.tasks, String(row.task_ids.length)],
+        [copy.requirements, list(row.requirement_ids)],
+        [copy.acceptanceCriteria, list(row.acceptance_ids)],
+        [copy.result, row.result ?? "—"],
+        [copy.file, row.artifact_path],
+      ]}
+    />
+  );
+}
+
+function DecisionDetails({ row, locale }: { row: DecisionProjection; locale: OperationsLocale }) {
+  const copy = entityDetailsCopy(locale);
+  return (
+    <DetailGrid
+      items={[
+        [copy.origin, row.origin],
+        [copy.scopeType, row.scope_type],
+        [copy.scope, row.scope_id],
+        [copy.created, formatDateTime(row.created_at, locale)],
+        [copy.file, row.artifact_path],
+      ]}
+    />
+  );
+}
+
+function ExecutionDetails({ row, locale }: { row: ExecutionProjection; locale: OperationsLocale }) {
+  const copy = entityDetailsCopy(locale);
+  return (
+    <DetailGrid
+      items={[
+        [copy.status, row.status],
+        [copy.workStatus, row.work_status],
+        [copy.origin, sourceLabel(row.origin)],
+        [copy.created, formatDateTime(row.created_at, locale)],
+        [copy.tasksInDag, String(row.dag.nodes.length)],
+        [
+          locale === "pt-BR" ? "Invocações do orquestrador" : "Orchestrator invocations",
+          String(row.orchestrator_run_count),
+        ],
+        [
+          locale === "pt-BR" ? "Invocações delegadas" : "Delegated invocations",
+          String(row.subagent_run_count),
+        ],
+        [
+          locale === "pt-BR" ? "Tasks finalizadas" : "Finalized Tasks",
+          `${row.finalized_task_count}/${row.task_count} (${row.finalizer_run_count} ${
+            locale === "pt-BR" ? "chamadas finalizadoras" : "finalizer calls"
+          })`,
+        ],
+        [copy.topologicalOrder, list(row.dag.topological_order)],
+        [
+          copy.dependencies,
+          row.dag.nodes.map((node) => `${node.task_id}: ${list(node.depends_on)}`).join("\n") ||
+            "—",
+        ],
+        [copy.result, row.result ?? "—"],
+        [copy.file, row.artifact_path],
+      ]}
+    />
+  );
+}
+
+function RunDetails({ row, locale }: { row: RunProjection; locale: OperationsLocale }) {
+  const copy = entityDetailsCopy(locale);
+  return (
+    <DetailGrid
+      items={[
+        [copy.status, row.status],
+        [copy.phase, row.phase],
+        [copy.entrypoint, row.entrypoint],
+        [copy.type, row.work_type],
+        [
+          locale === "pt-BR" ? "Tipo da chamada" : "Call type",
+          row.run_kind === "run"
+            ? locale === "pt-BR"
+              ? "Invocação do orquestrador"
+              : "Orchestrator invocation"
+            : locale === "pt-BR"
+              ? "Invocação delegada"
+              : "Delegated invocation",
+        ],
+        [locale === "pt-BR" ? "Propósito" : "Purpose", row.run_purpose],
+        [
+          locale === "pt-BR" ? "Exige finalizador" : "Requires finalizer",
+          row.requires_finalizer ? "sim" : "não",
+        ],
+        [locale === "pt-BR" ? "Invocação pai" : "Parent invocation", row.parent_run_id ?? "—"],
+        [copy.client, row.client],
+        [copy.agent, row.agent_name],
+        [copy.provider, row.provider ?? "—"],
+        [locale === "pt-BR" ? "Modelo planejado" : "Planned model", row.model],
+        [locale === "pt-BR" ? "Effort planejado" : "Planned effort", row.reasoning_effort ?? "—"],
+        [
+          locale === "pt-BR" ? "Modelo efetivo" : "Effective model",
+          row.effective_config_mixed
+            ? locale === "pt-BR"
+              ? "Misto"
+              : "Mixed"
+            : (row.effective_model ?? "—"),
+        ],
+        [
+          locale === "pt-BR" ? "Effort efetivo" : "Effective effort",
+          row.effective_config_mixed
+            ? locale === "pt-BR"
+              ? "Misto"
+              : "Mixed"
+            : (row.effective_reasoning_effort ?? "—"),
+        ],
+        ["Task", row.task_id ?? "—"],
+        ["SPEC", row.spec_id ?? "—"],
+        ["PRD", row.prd_id ?? "—"],
+        ["Change", row.change_id ?? "—"],
+        ["Execution", row.execution_id ?? "—"],
+        [copy.start, formatDateTime(row.started_at, locale)],
+        [copy.end, formatDateTime(row.finished_at, locale)],
+        [copy.duration, formatOperationDuration(operationalDurationMs(row), locale)],
+        ["Tokens", formatCompactNumber(row.usage.total.tokens.total, locale)],
+        [copy.costBrl, formatCurrency(row.usage.total.cost.brl, "BRL", locale)],
+        [copy.costUsd, formatCurrency(row.usage.total.cost.usd, "USD", locale)],
+        [copy.file, row.artifact_path],
+      ]}
+    />
+  );
+}
+
+function DetailGrid({ items }: { items: Array<[string, string]> }) {
+  return (
+    <dl className="operations-entity-detail-grid">
+      {items.map(([label, value]) => (
+        <div key={label}>
+          <dt>{label}</dt>
+          <dd>{value}</dd>
+        </div>
+      ))}
+    </dl>
+  );
+}
+
+function sourceLabel(source: ChangeProjection["source"] | ExecutionProjection["origin"]): string {
+  if (source.type === "task") return `Task: ${source.task_id}`;
+  if (source.type === "spec") return `SPEC: ${source.spec_id}`;
+  if (source.type === "interaction") return `Conversation: ${source.conversation_id}`;
+  return `PRD: ${source.prd_id}${"spec_id" in source && source.spec_id ? ` · SPEC: ${source.spec_id}` : ""}`;
+}
+
+function list(values: readonly string[]): string {
+  return values.length === 0 ? "—" : values.join(", ");
+}
+
+function entityLabel(kind: EntityDetails["kind"], locale: OperationsLocale): string {
+  const pt = {
+    change: "Mudança",
+    decision: "Decisão",
+    execution: "Execução ZAIP",
+    run: "Invocação de Agente",
+  } as const;
+  const en = {
+    change: "Change",
+    decision: "Decision",
+    execution: "Execution",
+    run: "Agent Invocation",
+  } as const;
+  return (locale === "pt-BR" ? pt : en)[kind];
+}
+
+export function entityDetailsCopy(locale: OperationsLocale) {
+  return locale === "pt-BR"
+    ? {
+        details: "Detalhes de",
+        status: "Status",
+        risk: "Risco",
+        origin: "Origem",
+        created: "Criada",
+        tasks: "Tasks",
+        requirements: "Requisitos",
+        acceptanceCriteria: "Critérios de aceite",
+        result: "Resultado",
+        file: "Arquivo",
+        scopeType: "Tipo de escopo",
+        scope: "Escopo",
+        workStatus: "Status do trabalho",
+        tasksInDag: "Tasks na DAG",
+        topologicalOrder: "Ordem topológica",
+        dependencies: "Dependências",
+        phase: "Fase",
+        entrypoint: "Entrada",
+        type: "Tipo",
+        client: "Cliente",
+        agent: "Agente",
+        provider: "Provider",
+        model: "Modelo",
+        start: "Início",
+        end: "Fim",
+        duration: "Duração",
+        costBrl: "Custo BRL",
+        costUsd: "Custo USD",
+      }
+    : {
+        details: "Details for",
+        status: "Status",
+        risk: "Risk",
+        origin: "Origin",
+        created: "Created",
+        tasks: "Tasks",
+        requirements: "Requirements",
+        acceptanceCriteria: "Acceptance criteria",
+        result: "Result",
+        file: "File",
+        scopeType: "Scope type",
+        scope: "Scope",
+        workStatus: "Work status",
+        tasksInDag: "Tasks in DAG",
+        topologicalOrder: "Topological order",
+        dependencies: "Dependencies",
+        phase: "Phase",
+        entrypoint: "Entrypoint",
+        type: "Type",
+        client: "Client",
+        agent: "Agent",
+        provider: "Provider",
+        model: "Model",
+        start: "Start",
+        end: "End",
+        duration: "Duration",
+        costBrl: "Cost BRL",
+        costUsd: "Cost USD",
+      };
+}

package/templates/.agents/dashboard/modules/operations/src/react/EntityTables.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import { displayedExecutionCount, displayedRunAgent, runPhaseLabel } from "./EntityTables.js";
+
+describe("displayedExecutionCount", () => {
+  it("shows zero instead of leaving legacy or incomplete projection counts blank", () => {
+    expect(displayedExecutionCount(undefined)).toBe(0);
+    expect(displayedExecutionCount(null)).toBe(0);
+    expect(displayedExecutionCount(Number.NaN)).toBe(0);
+    expect(displayedExecutionCount(-1)).toBe(0);
+  });
+
+  it("preserves valid relationship counts", () => {
+    expect(displayedExecutionCount(0)).toBe(0);
+    expect(displayedExecutionCount(3)).toBe(3);
+  });
+});
+
+describe("Run display labels", () => {
+  it("preserves codex when a ZAIP agent was not actually used", () => {
+    expect(displayedRunAgent({ agent: "codex", agent_name: "zaip-agent-orchestrator" })).toBe(
+      "codex",
+    );
+    expect(displayedRunAgent({ agent: "agent-builder", agent_name: "zaip-agent-builder" })).toBe(
+      "zaip-agent-builder",
+    );
+  });
+
+  it("uses clear Portuguese labels for run stages", () => {
+    expect(runPhaseLabel("conversation", "pt-BR")).toBe("Conversa");
+    expect(runPhaseLabel("planning", "pt-BR")).toBe("Planejamento");
+    expect(runPhaseLabel("execution", "pt-BR")).toBe("Execução");
+  });
+});