@zaip-ai/cli 1.0.7 → 1.0.8

package/templates/.agents/dashboard/modules/operations/src/react/operations-page-contract.ts

@@ -0,0 +1,136 @@
+import type { ReactNode } from "react";
+import type { DashboardTaskProjection, MacroProjection, OperationsProjection } from "../contracts.js";
+import type { OperationDatePreset, OperationDateRange } from "./operation-date-range.js";
+import type { OperationsView } from "./operations-page-filters.js";
+import type { OperationsLocale } from "./status-labels.js";
+import type { WorkStage, WorkTypeFilter } from "./work-board-model.js";
+
+export interface DashboardGlobalFilters {
+  query: string;
+  datePreset: OperationDatePreset;
+  dateRange?: OperationDateRange;
+}
+
+export type OverviewStatusKind = "task" | "spec" | "prd";
+export type OverviewClassification = "lite" | "standard" | "critical" | "empty" | "structured" | "rework";
+
+/** A remounted Trabalho (Lista) selector always starts on "all". */
+export function workListTypeOnViewChange(nextView: OperationsView): WorkTypeFilter | null {
+  return nextView === "work-list" ? "all" : null;
+}
+
+export interface OverviewStatusPage {
+  items: readonly (DashboardTaskProjection | MacroProjection)[];
+  total: number;
+  loading: boolean;
+  error: string | null;
+}
+
+/** Canonical, server-paginated population behind an Overview classification slice. */
+export interface OverviewClassificationPage extends OverviewStatusPage {}
+
+export interface OperationsPageProps {
+  alternateContent?: ReactNode | ((filters: DashboardGlobalFilters) => ReactNode);
+  boardTotals?: Partial<Record<WorkStage, number>>;
+  boardKindTotals?: Partial<
+    Record<WorkStage, { all: number; task: number; prd: number; spec: number }>
+  >;
+  boardStates?: Partial<Record<WorkStage, { loading: boolean; error: string | null }>>;
+  /** Immutable, filtered board snapshot supplied by the composition root for XLSX. */
+  boardExportSource?: (filters: {
+    query: string;
+    status: string;
+    risk: string;
+    origin: string;
+  }) => {
+    prepare: () => Promise<{
+      totalRows: number;
+      pages: () => AsyncGenerator<readonly Record<string, unknown>[]>;
+    }>;
+  };
+  capabilityNavigation: ReactNode;
+  data: OperationsProjection;
+  dashboardTitle?: string;
+  loading: boolean;
+  onLoadingChange?: (loading: boolean) => void;
+  currency: "BRL" | "USD";
+  locale: OperationsLocale;
+  onLocaleChange: (locale: OperationsLocale) => void;
+  onOpenDocument: (kind: "prd" | "spec", id: string) => void;
+  onOpenTask: (taskId: string) => Promise<boolean>;
+  onPriorityChange: (itemIds: readonly string[]) => Promise<void>;
+  onDetailDataRequest?: (view: OperationsView) => void;
+  entityPage?: {
+    offset: number;
+    total: number | null;
+    loading: boolean;
+    error: string | null;
+    aggregation?: "canonical_entity" | "page_partial" | undefined;
+  };
+  onEntityPageChange?: (offset: number) => void;
+  onEntityFiltersChange?: (
+    view: "runs" | "conversations" | "executions" | "changes" | "decisions",
+    filters: { query: string; status: string; risk: string },
+  ) => void;
+  onBoardFiltersChange?: (filters: {
+    query: string;
+    status: string;
+    risk: string;
+    origin: string;
+  }) => void;
+  /** Full, server-paginated work collection for Trabalho (Lista). */
+  onWorkListFiltersChange?: (filters: {
+    query: string;
+    status: string;
+    risk: string;
+    origin: string;
+  }) => void;
+  onBoardTypeChange?: (kind: WorkTypeFilter) => void;
+  onWorkListTypeChange?: (kind: WorkTypeFilter) => void;
+  onLoadMoreBoard?: (stage: WorkStage) => void;
+  /** A dedicated, server-filtered status collection; never a mixed Kanban page. */
+  statusPage?: (stage: WorkStage, kind: OverviewStatusKind) => OverviewStatusPage | undefined;
+  onLoadStatusPage?: (stage: WorkStage, kind: OverviewStatusKind, offset: number) => void;
+  classificationPage?: (
+    kind: OverviewStatusKind,
+    classification: OverviewClassification,
+  ) => OverviewClassificationPage | undefined;
+  onLoadClassificationPage?: (
+    kind: OverviewStatusKind,
+    classification: OverviewClassification,
+    offset: number,
+  ) => void;
+  datePreset?: OperationDatePreset | undefined;
+  dateRange?: OperationDateRange | undefined;
+  onDateChange?: (preset: OperationDatePreset, range: OperationDateRange) => void;
+  onPeriodChange?: (preset: OperationDatePreset, range: OperationDateRange) => void;
+  onRefresh: () => void;
+  repositoryName?: string;
+  settings?: ReactNode;
+  /** Cost Monitor provides the factual value in the dashboard-selected currency. */
+  resolveRunCost?: ((runId: string) => number | null) | undefined;
+  /**
+   * Coherent Cost Monitor summary total for the active period and currency.
+   * This is needed when its compact snapshot intentionally omits Run rows.
+   */
+  factualCostTotal?: number | null | undefined;
+  /** Factual Cost Monitor rows matching the active global period. */
+  factualCostPeriods?: Partial<
+    Record<"day" | "month" | "year", readonly { key: string; estimated_usd: number | null; estimated_brl: number | null }[]>
+  > | undefined;
+}
+
+/** Single-source period contract for App-controlled Operations navigation. */
+export function resolveOperationsPeriodControl(input: {
+  datePreset?: OperationDatePreset | undefined;
+  dateRange?: OperationDateRange | undefined;
+  fallbackPreset: OperationDatePreset;
+  fallbackRange: OperationDateRange;
+}) {
+  const controlled = input.datePreset !== undefined && input.dateRange !== undefined;
+  return {
+    controlled,
+    datePreset: input.datePreset ?? input.fallbackPreset,
+    dateRange: input.dateRange ?? input.fallbackRange,
+  };
+}

package/templates/.agents/dashboard/modules/operations/src/react/operations-period-scope.test.ts

@@ -0,0 +1,160 @@
+import { describe, expect, it } from "vitest";
+import { executionMetricTotals } from "./execution-metrics.js";
+import { macroClassificationStats } from "./OperationsOverview.helpers.js";
+import { macroStatusDistribution } from "./OperationsOverview.js";
+import { macrosWithPeriodActivity } from "./operations-period-scope.js";
+
+const inAugust = (value: string | null | undefined) => value?.startsWith("2026-08") ?? false;
+
+describe("macrosWithPeriodActivity", () => {
+  it("keeps blocked macro work visible outside its update month", () => {
+    const blocked = {
+      ...macro("SPEC-BLOCKED", null, "2026-08-02T12:00:00.000Z"),
+      lifecycle_status: "blocked",
+    };
+    const result = macrosWithPeriodActivity({
+      datePreset: "last-month",
+      matchesSelectedDate: (value) => value?.startsWith("2026-07") ?? false,
+      prds: [],
+      runs: [],
+      specs: [blocked] as never,
+      tasks: [],
+    });
+
+    expect(result.specs).toEqual([blocked]);
+  });
+  it("propagates a period Task to its SPEC and its parent PRD", () => {
+    const result = macrosWithPeriodActivity({
+      datePreset: "this-month",
+      matchesSelectedDate: inAugust,
+      tasks: [{ id: "TASK-AUG", spec_id: "SPEC-1" }],
+      runs: [],
+      specs: [macro("SPEC-1", "PRD-1")],
+      prds: [macro("PRD-1")],
+    });
+
+    expect(result.specs.map(({ id }) => id)).toEqual(["SPEC-1"]);
+    expect(result.prds.map(({ id }) => id)).toEqual(["PRD-1"]);
+  });
+
+  it("excludes inactive terminal macros with no current-period activity", () => {
+    const result = macrosWithPeriodActivity({
+      datePreset: "this-month",
+      matchesSelectedDate: inAugust,
+      tasks: [],
+      runs: [],
+      specs: [macro("SPEC-JUL", "PRD-JUL", "2026-07-31T12:00:00.000Z")],
+      prds: [macro("PRD-JUL", null, "2026-07-31T12:00:00.000Z")],
+    });
+
+    expect(result).toEqual({ specs: [], prds: [] });
+  });
+
+  it.each([
+    ["Este Mês", "2026-08", "TASK-AUG", "SPEC-AUG", "PRD-AUG", "blocked", 800],
+    ["Mês Passado", "2026-07", "TASK-JUL", "SPEC-JUL", "PRD-JUL", "completed", 700],
+  ] as const)("%s keeps cards, status, classification and metrics on the same SPEC/PRD population", (_label, month, taskId, specId, prdId, expectedStatus, expectedDuration) => {
+    const macros = {
+      specs: [
+        detailedMacro(
+          specId,
+          prdId,
+          month,
+          expectedStatus,
+          1,
+          expectedStatus === "blocked" ? 1 : 0,
+        ),
+        detailedMacro("SPEC-OTHER", "PRD-OTHER", "2026-06", "completed", 4, 0),
+      ],
+      prds: [
+        detailedMacro(
+          prdId,
+          null,
+          month,
+          expectedStatus,
+          1,
+          expectedStatus === "blocked" ? 1 : 0,
+          "prd",
+        ),
+        detailedMacro("PRD-OTHER", null, "2026-06", "completed", 4, 0, "prd"),
+      ],
+    };
+    const result = macrosWithPeriodActivity({
+      datePreset: month === "2026-08" ? "this-month" : "last-month",
+      matchesSelectedDate: (value) => value?.startsWith(month) ?? false,
+      tasks: [{ id: taskId, spec_id: specId }],
+      runs: [{ id: `RUN-${month}`, spec_id: specId, prd_id: prdId }],
+      ...macros,
+    });
+
+    for (const selected of [result.specs, result.prds]) {
+      expect(selected).toHaveLength(1);
+      expect(
+        macroStatusDistribution(selected as never, [], "pt-BR").find(
+          (row) => row.key === expectedStatus,
+        )?.count,
+      ).toBe(1);
+      expect(
+        macroClassificationStats(selected as never, "pt-BR").reduce(
+          (total, row) => total + row.count,
+          0,
+        ),
+      ).toBe(1);
+    }
+    expect(executionMetricTotals([run(taskId, expectedDuration, specId, prdId)])).toMatchObject({
+      durationMs: expectedDuration,
+      tokens: expectedDuration / 10,
+      costBrl: expectedDuration / 100,
+    });
+  });
+});
+
+function macro(id: string, parentId: string | null = null, updatedAt = "2026-07-01T12:00:00.000Z") {
+  return {
+    id,
+    parent_id: parentId,
+    created_at: updatedAt,
+    updated_at: updatedAt,
+    lifecycle_status: "completed" as const,
+    run_ids: [],
+    task_ids: [],
+  };
+}
+
+function detailedMacro(
+  id: string,
+  parentId: string | null,
+  month: string,
+  status: "blocked" | "completed",
+  taskCount: number,
+  reworkRunCount: number,
+  kind: "spec" | "prd" = "spec",
+) {
+  return {
+    ...macro(id, parentId, `${month}-10T12:00:00.000Z`),
+    kind,
+    lifecycle_status: status,
+    work_status: status,
+    task_count: taskCount,
+    rework_run_count: reworkRunCount,
+  };
+}
+
+function run(taskId: string, duration: number, specId: string, prdId: string) {
+  return {
+    id: `RUN-${taskId}`,
+    phase: "execution",
+    task_id: taskId,
+    parent_run_id: null,
+    spec_id: specId,
+    prd_id: prdId,
+    duration_ms: duration,
+    source_duration_ms: duration,
+    usage: {
+      total: {
+        tokens: { total: duration / 10 },
+        cost: { brl: duration / 100 },
+      },
+    },
+  };
+}

package/templates/.agents/dashboard/modules/operations/src/react/operations-period-scope.ts

@@ -0,0 +1,47 @@
+import type { DashboardTaskProjection, MacroProjection, RunProjection } from "../contracts.js";
+import type { OperationDatePreset } from "./operation-date-range.js";
+
+export function macrosWithPeriodActivity({
+  datePreset,
+  matchesSelectedDate,
+  prds,
+  runs,
+  specs,
+  tasks,
+}: {
+  datePreset: OperationDatePreset;
+  matchesSelectedDate: (value: string | null | undefined) => boolean;
+  prds: OperationsMacro[];
+  runs: readonly Pick<RunProjection, "id" | "prd_id" | "spec_id">[];
+  specs: OperationsMacro[];
+  tasks: readonly Pick<DashboardTaskProjection, "id" | "spec_id">[];
+}): { prds: OperationsMacro[]; specs: OperationsMacro[] } {
+  const visibleTaskIds = new Set(tasks.map((task) => task.id));
+  const terminal = new Set(["completed", "delivered", "cancelled", "failed"]);
+  const hasPeriodActivity = (row: OperationsMacro, kind: "spec" | "prd") =>
+    datePreset === "all" ||
+    !terminal.has(row.lifecycle_status) ||
+    matchesSelectedDate(row.updated_at ?? row.created_at) ||
+    row.task_ids.some((taskId) => visibleTaskIds.has(taskId)) ||
+    (kind === "spec" && tasks.some((task) => task.spec_id === row.id)) ||
+    runs.some(
+      (run) =>
+        row.run_ids.includes(run.id) ||
+        (kind === "spec" ? run.spec_id === row.id : run.prd_id === row.id),
+    );
+  const activeSpecs = specs.filter((spec) => hasPeriodActivity(spec, "spec"));
+  const activeSpecIds = new Set(activeSpecs.map((spec) => spec.id));
+  return {
+    specs: activeSpecs,
+    prds: prds.filter(
+      (prd) =>
+        hasPeriodActivity(prd, "prd") ||
+        specs.some((spec) => spec.parent_id === prd.id && activeSpecIds.has(spec.id)),
+    ),
+  };
+}
+
+type OperationsMacro = Pick<
+  MacroProjection,
+  "id" | "created_at" | "updated_at" | "parent_id" | "run_ids" | "task_ids" | "lifecycle_status"
+>;

package/templates/.agents/dashboard/modules/operations/src/react/operations-query.ts

@@ -0,0 +1,10 @@
+export function matchesQuery(
+  query: string,
+  values: readonly (string | null | undefined)[],
+): boolean {
+  const normalized = query.trim().toLocaleLowerCase();
+  return (
+    normalized.length === 0 ||
+    values.some((value) => value?.toLocaleLowerCase().includes(normalized))
+  );
+}

package/templates/.agents/dashboard/modules/operations/src/react/operations-responsive.css

@@ -48,6 +48,9 @@
     width: 100%;
     min-width: 0;
   }
+  .operations-tab-export {
+    justify-content: flex-end;
+  }
   .operations-content {
     padding: 10px;
   }

package/templates/.agents/dashboard/modules/operations/src/react/operations-view-labels.ts

@@ -0,0 +1,28 @@
+import type { OperationsView } from "./operations-page-filters.js";
+
+export const viewLabels: Record<"pt-BR" | "en-US", Record<OperationsView, string>> = {
+  "pt-BR": {
+    "work-kanban": "Visão de Quadro (Kanban)",
+    "work-list": "Visão de Lista",
+    changes: "Mudanças",
+    executions: "Execuções",
+    runs: "Invocações de agentes",
+    conversations: "Conversas",
+    decisions: "Decisões",
+    daily: "Diário",
+    monthly: "Mensal",
+    yearly: "Anual",
+  },
+  "en-US": {
+    "work-kanban": "Work (Kanban)",
+    "work-list": "Work (List)",
+    changes: "Changes",
+    executions: "Executions",
+    runs: "Agent invocations",
+    conversations: "Conversations",
+    decisions: "Decisions",
+    daily: "Daily",
+    monthly: "Monthly",
+    yearly: "Annual",
+  },
+};

package/templates/.agents/dashboard/modules/operations/src/react/operations-view-order.test.ts

@@ -1,19 +1,36 @@
 import { readFileSync } from "node:fs";
 import { describe, expect, it } from "vitest";
 
-describe("operations tab order", () => {
-  it("offers Kanban and list work views before the operational entity tabs", () => {
-    const source = readFileSync(new URL("OperationsPage.tsx", import.meta.url), "utf8");
-    const start = source.indexOf('aria-label="Entidades do ciclo de trabalho"');
-    const end = source.indexOf("</nav>", start);
-    const navigation = source.slice(start, end);
+describe("operations tab navigation", () => {
+  it("offers only the Kanban board and work list views", () => {
+    const navigation = readFileSync(
+      new URL("OperationsPageNavigation.tsx", import.meta.url),
+      "utf8",
+    );
 
     expect(navigation).toContain('"work-kanban"');
     expect(navigation).toContain('"work-list"');
     expect(navigation).not.toContain('"tasks"');
     expect(navigation).not.toContain('"specs"');
     expect(navigation).not.toContain('"prds"');
+    expect(navigation).not.toContain('"executions"');
+    expect(navigation).not.toContain('"runs"');
+    expect(navigation).not.toContain('"decisions"');
+    expect(navigation).not.toContain('"changes"');
+    expect(navigation).not.toContain('"conversations"');
+    expect(navigation).not.toContain('"daily"');
+    expect(navigation).not.toContain('"monthly"');
+    expect(navigation).not.toContain('"yearly"');
     expect(navigation.indexOf('"work-kanban"')).toBeLessThan(navigation.indexOf('"work-list"'));
-    expect(navigation.indexOf('"work-list"')).toBeLessThan(navigation.indexOf('"changes"'));
+  });
+
+  it("uses the simplified Portuguese labels", () => {
+    const labels = readFileSync(
+      new URL("operations-view-labels.ts", import.meta.url),
+      "utf8",
+    );
+
+    expect(labels).toContain('"work-kanban": "Visão de Quadro (Kanban)"');
+    expect(labels).toContain('"work-list": "Visão de Lista"');
   });
 });

package/templates/.agents/dashboard/modules/operations/src/react/operations.css

@@ -189,6 +189,7 @@
 }
 .operations-toolbar nav {
   display: flex;
+  min-width: 0;
   flex-wrap: wrap;
   gap: 6px;
   overflow-x: visible;
@@ -205,6 +206,36 @@
   background: var(--accent-soft);
   color: var(--accent);
 }
+.operations-tab-export {
+  display: flex;
+  flex: 0 0 auto;
+  justify-content: flex-end;
+}
+.operations-tab-export .excel-export-action {
+  min-height: 44px;
+  gap: 6px;
+  border: 1px solid transparent;
+  border-radius: 999px;
+  padding: 0 10px;
+  background: linear-gradient(135deg, #00b0f0 0%, #72f4fb 100%);
+  color: #042330;
+  font-size: 0.82rem;
+  font-weight: 650;
+}
+.operations-tab-export .excel-export-action svg {
+  width: 14px;
+  height: 14px;
+}
+.operations-tab-export .excel-export-action:hover:not(:disabled) {
+  border-color: rgba(114, 244, 251, 0.72);
+  background: linear-gradient(135deg, #00b0f0 0%, #72f4fb 100%);
+  color: #042330;
+}
+.operations-toolbar nav button:focus-visible,
+.operations-tab-export .excel-export-action:focus-visible {
+  outline: 3px solid #00b0f0;
+  outline-offset: 2px;
+}
 .operations-toolbar input {
   min-width: 260px;
   min-height: 42px;
@@ -751,3 +782,14 @@
   background: rgba(37, 99, 235, 0.16);
   color: #cde3ff;
 }
+
+.operations-content-skeleton {
+  display: grid;
+  gap: 16px;
+  min-height: 360px;
+  padding: 24px;
+  border: 1px solid var(--line);
+  border-radius: 18px;
+  background: rgba(17, 24, 39, 0.68);
+  color: var(--muted);
+}

package/templates/.agents/dashboard/modules/operations/src/react/period-summary-population.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { periodSummaryPopulation } from "./period-summary-population.js";
+
+describe("periodSummaryPopulation", () => {
+  it("uses creation time for entities and start time for Runs, not recent activity", () => {
+    const population = periodSummaryPopulation(
+      {
+        prds: [entity("PRD-JUL", "2026-07-30T12:00:00.000Z")],
+        specs: [entity("SPEC-JUL", "2026-07-30T12:00:00.000Z")],
+        tasks: [entity("TASK-JUL", "2026-07-30T12:00:00.000Z")],
+        runs: [run("RUN-AUG", "2026-08-02T12:00:00.000Z")],
+      } as never,
+      (value) => value?.startsWith("2026-08-0") ?? false,
+    );
+
+    expect(population.prds).toEqual([]);
+    expect(population.specs).toEqual([]);
+    expect(population.tasks).toEqual([]);
+    expect(population.runs.map(({ id }) => id)).toEqual(["RUN-AUG"]);
+  });
+
+  it("keeps the August fixture at 89 created Tasks, not 109 active or 74 financial", () => {
+    const population = periodSummaryPopulation(
+      {
+        prds: [entity("PRD-JUL", "2026-07-20T12:00:00.000Z")],
+        specs: [entity("SPEC-JUL", "2026-07-20T12:00:00.000Z")],
+        tasks: [
+          ...Array.from({ length: 89 }, (_, index) =>
+            entity(`TASK-AUG-${index}`, "2026-08-02T12:00:00.000Z"),
+          ),
+          ...Array.from({ length: 20 }, (_, index) =>
+            entity(`TASK-JUL-${index}`, "2026-07-20T12:00:00.000Z"),
+          ),
+        ],
+        runs: Array.from({ length: 74 }, (_, index) =>
+          run(`RUN-AUG-${index}`, "2026-08-02T12:00:00.000Z"),
+        ),
+      } as never,
+      (value) => value?.startsWith("2026-08-0") ?? false,
+    );
+
+    expect(population).toMatchObject({ prds: [], specs: [] });
+    expect(population.tasks).toHaveLength(89);
+    expect(population.runs).toHaveLength(74);
+  });
+});
+
+function entity(id: string, created_at: string) {
+  return { id, created_at, updated_at: "2026-08-02T12:00:00.000Z", is_active: true };
+}
+
+function run(id: string, started_at: string) {
+  return { id, started_at };
+}

package/templates/.agents/dashboard/modules/operations/src/react/period-summary-population.ts

@@ -0,0 +1,32 @@
+import type { OperationsProjection } from "../contracts.js";
+
+/**
+ * Period reports describe work created in the selected window. This is kept
+ * separate from the activity-oriented work board population.
+ */
+export function periodSummaryPopulation(
+  data: Pick<
+    OperationsProjection,
+    "prds" | "specs" | "tasks" | "runs" | "evidences" | "validations"
+  >,
+  matchesSelectedDate: (value: string | null | undefined) => boolean,
+): Pick<OperationsProjection, "prds" | "specs" | "tasks" | "runs" | "evidences" | "validations"> {
+  return {
+    prds: data.prds.filter((prd) => matchesSelectedDate(prd.created_at)),
+    specs: data.specs.filter((spec) => matchesSelectedDate(spec.created_at)),
+    tasks: data.tasks.filter((task) => matchesSelectedDate(task.created_at)),
+    runs: data.runs.filter((run) => matchesSelectedDate(run.started_at)),
+    ...(data.evidences === undefined
+      ? {}
+      : {
+          evidences: data.evidences.filter((evidence) => matchesSelectedDate(evidence.observed_at)),
+        }),
+    ...(data.validations === undefined
+      ? {}
+      : {
+          validations: data.validations.filter((validation) =>
+            matchesSelectedDate(validation.executed_at),
+          ),
+        }),
+  };
+}