@zaip-ai/cli 1.0.6 → 1.0.7

package/templates/.agents/dashboard/modules/cost-monitor/src/task-cost-groups.test.ts

@@ -0,0 +1,137 @@
+import type { DashboardTaskProjection } from "@zaip-ai/dashboard-operations/contracts";
+import { describe, expect, it } from "vitest";
+import type { CostRunRow } from "./contracts.js";
+import { aggregateTaskCostRows } from "./task-cost-groups.js";
+
+describe("aggregateTaskCostRows", () => {
+  it("excludes Tasks without cost Runs and uses Task creation time", () => {
+    const tasks = [
+      task("TASK-NEW", "New task", "2026-07-16T23:45:00.000Z"),
+      task("TASK-RUN", "Run task", "2026-07-16T20:25:00.000Z"),
+    ];
+    const rows = [run("TASK-RUN", "2026-07-16T20:28:21.000Z")];
+
+    expect(aggregateTaskCostRows(tasks, rows)).toMatchObject([
+      {
+        key: "TASK-RUN",
+        latest_started_at: "2026-07-16T20:25:00.000Z",
+        run_count: 1,
+        task_count: 1,
+        duration_ms: 60_000,
+        total_tokens: 100,
+      },
+    ]);
+  });
+
+  it("uses the visible financial root when its orchestration parent is not a cost row", () => {
+    const tasks = [task("TASK-RUN", "Run task", "2026-07-16T20:25:00.000Z")];
+    const rows = [
+      {
+        ...run("TASK-RUN", "2026-07-16T20:28:21.000Z"),
+        parent_run_id: "RUN-UNPRICED-ORCHESTRATOR",
+        duration_ms: 60_000,
+      },
+    ];
+
+    expect(aggregateTaskCostRows(tasks, rows)[0]).toMatchObject({
+      duration_ms: 60_000,
+      duration: { known_sum: 60_000, unknown: 0, complete: true, coverage_ratio: 1 },
+    });
+  });
+});
+
+function task(id: string, title: string, createdAt: string): DashboardTaskProjection {
+  return {
+    schema_version: 2,
+    id,
+    revision: 1,
+    change_id: `CHG-${id}`,
+    title,
+    short_name: id.toLowerCase(),
+    objective: title,
+    status: "completed",
+    attempt_count: 1,
+    risk: "lite",
+    priority: "medium",
+    owner: null,
+    requirement_ids: [],
+    acceptance_ids: [],
+    depends_on: [],
+    write_scopes: [],
+    created_at: createdAt,
+    updated_at: createdAt,
+    started_at: createdAt,
+    finished_at: createdAt,
+    result: null,
+    artifact_path: `${id}.md`,
+    progress: 100,
+    spec_id: null,
+    execution_started: true,
+  };
+}
+
+function run(taskId: string, startedAt: string): CostRunRow {
+  return {
+    run_id: "RUN-1",
+    conversation_id: "CONV-1",
+    task_id: taskId,
+    task_title: "Run task",
+    task_status: "completed",
+    priority: "medium",
+    risk: "lite",
+    spec_id: null,
+    prd_id: null,
+    change_id: `CHG-${taskId}`,
+    parent_run_id: null,
+    run_role: "orchestrator",
+    run_kind: "run",
+    run_purpose: "orchestration",
+    requires_finalizer: true,
+    client: "codex",
+    agent: "codex",
+    agent_name: "codex",
+    provider: "openai",
+    model: "gpt-5",
+    requested_model: "gpt-5",
+    reasoning_effort: null,
+    effective_reasoning_effort: null,
+    service_tier: null,
+    call_count: null,
+    status: "completed",
+    phase: "execution",
+    origin: "task",
+    work_type: "new",
+    started_at: startedAt,
+    finished_at: startedAt,
+    duration_ms: 60_000,
+    event_count: 1,
+    input_tokens: 80,
+    cached_input_tokens: 0,
+    output_tokens: 20,
+    reasoning_tokens: 0,
+    total_tokens: 100,
+    uncached_input_tokens: 80,
+    visible_output_tokens: 20,
+    input_rate_usd_per_million: null,
+    cached_input_rate_usd_per_million: null,
+    output_rate_usd_per_million: null,
+    reasoning_rate_usd_per_million: null,
+    context_input_multiplier: null,
+    context_output_multiplier: null,
+    speed_cost_multiplier: null,
+    standard_cost_usd: null,
+    speed_uplift_usd: null,
+    input_cost_usd: null,
+    cached_input_cost_usd: null,
+    output_cost_usd: null,
+    reasoning_cost_usd: null,
+    fx_rate: null,
+    estimated_usd: 0.1,
+    estimated_brl: 0.5,
+    recorded_usd: 0.1,
+    recorded_brl: 0.5,
+    recorded_fx_rate: 5,
+    coverage: { events: 1, tokens: 1, usd: 1, brl: 1 },
+    artifact_path: "run.jsonl",
+  };
+}

package/templates/.agents/dashboard/modules/cost-monitor/src/task-cost-groups.ts

@@ -0,0 +1,64 @@
+import type { DashboardTaskProjection } from "@zaip-ai/dashboard-operations/contracts";
+import {
+  aggregateDurationCoverage,
+  type CostCoverage,
+  type CostGroupRow,
+  type CostRunRow,
+} from "./contracts.js";
+
+const emptyCoverage: CostCoverage = { events: 0, tokens: 0, usd: 0, brl: 0 };
+
+export function aggregateTaskCostRows(
+  tasks: readonly DashboardTaskProjection[],
+  rows: readonly CostRunRow[],
+): CostGroupRow[] {
+  const rowsByTask = new Map<string, CostRunRow[]>();
+  for (const row of rows) {
+    if (row.task_id === null) continue;
+    rowsByTask.set(row.task_id, [...(rowsByTask.get(row.task_id) ?? []), row]);
+  }
+
+  return tasks
+    .filter((task) => rowsByTask.has(task.id))
+    .map((task) => taskCostRow(task, rowsByTask.get(task.id) ?? []))
+    .sort((left, right) => right.latest_started_at.localeCompare(left.latest_started_at));
+}
+
+function taskCostRow(task: DashboardTaskProjection, rows: readonly CostRunRow[]): CostGroupRow {
+  const duration = aggregateDurationCoverage(rows);
+  return {
+    key: task.id,
+    label: task.title,
+    // In the Tasks view this field is the entity timestamp shown by the generic table.
+    // Costs remain aggregated from Runs, but the row itself is ordered by Task creation.
+    latest_started_at: task.created_at,
+    run_count: rows.length,
+    task_count: 1,
+    tasksCreated: 1,
+    tasksActive: 1,
+    prd_count: 0,
+    spec_count: 0,
+    evidence_count: 0,
+    test_count: task.test_count ?? 0,
+    event_count: rows.reduce((sum, row) => sum + row.event_count, 0),
+    total_tokens: completeSum(rows.map((row) => row.total_tokens)),
+    estimated_usd: completeSum(rows.map((row) => row.estimated_usd)),
+    estimated_brl: completeSum(rows.map((row) => row.estimated_brl)),
+    duration_ms: duration.complete ? duration.known_sum : null,
+    duration,
+    coverage: rows.reduce(
+      (sum, row) => ({
+        events: sum.events + row.coverage.events,
+        tokens: sum.tokens + row.coverage.tokens,
+        usd: sum.usd + row.coverage.usd,
+        brl: sum.brl + row.coverage.brl,
+      }),
+      emptyCoverage,
+    ),
+  };
+}
+
+function completeSum(values: readonly (number | null)[]): number | null {
+  if (values.length === 0 || values.some((value) => value === null)) return null;
+  return values.reduce<number>((sum, value) => sum + (value as number), 0);
+}

package/templates/.agents/dashboard/modules/cost-monitor/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../../../tsconfig.base.json",
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "lib": ["ES2024", "DOM"],
+    "noEmit": true,
+    "types": ["node", "vite/client"]
+  },
+  "include": ["composition-root.ts", "src/**/*.ts", "src/**/*.tsx"]
+}

package/templates/.agents/dashboard/modules/operations/composition-root.ts

@@ -0,0 +1,19 @@
+import type { WorkspaceFileSystem, WorkspaceLayout } from "@zaip-ai/core";
+import type { ProjectionTimeFilter } from "./src/contracts.js";
+import {
+  buildOperationsProjection,
+  readPrdDetail,
+  readSpecDetail,
+  readTaskDetail,
+} from "./src/server/index.js";
+
+export function createOperationsModule(filesystem: WorkspaceFileSystem, layout: WorkspaceLayout) {
+  if (layout.version !== 2) throw new Error("Operations module requires WorkspaceLayout V2");
+  return {
+    project: (filter: Partial<ProjectionTimeFilter> = {}) =>
+      buildOperationsProjection(filesystem, layout, filter),
+    prdDetail: (prdId: string) => readPrdDetail(filesystem, layout, prdId),
+    specDetail: (specId: string) => readSpecDetail(filesystem, layout, specId),
+    taskDetail: (taskId: string) => readTaskDetail(filesystem, layout, taskId),
+  };
+}

package/templates/.agents/dashboard/modules/operations/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@zaip-ai/dashboard-operations",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    "./contracts": "./src/contracts.ts",
+    "./server": "./src/server/index.ts",
+    "./react": "./src/react/index.ts",
+    "./composition-root": "./composition-root.ts"
+  },
+  "scripts": {
+    "clean": "node ../../../../scripts/clean.mjs",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@zaip-ai/core": "workspace:*",
+    "@zaip-ai/costs": "workspace:*",
+    "@zaip-ai/dashboard-contracts": "workspace:*",
+    "@zaip-ai/dashboard-ui": "workspace:*",
+    "@zaip-ai/decisions": "workspace:*",
+    "@zaip-ai/lifecycle-manifests": "workspace:*",
+    "@zaip-ai/specs": "workspace:*",
+    "@zaip-ai/tasks": "workspace:*",
+    "lucide-react": "^0.468.0",
+    "react": "19.2.7",
+    "react-dom": "19.2.7"
+  }
+}

package/templates/.agents/dashboard/modules/operations/src/contracts.ts

@@ -0,0 +1,409 @@
+import type { ProjectionTimeFilter, ReadonlyV2Projection } from "@zaip-ai/dashboard-contracts";
+
+export type { ProjectionTimeFilter };
+
+/** The dashboard's business calendar is fixed, independently of browser/server locale. */
+export const SAO_PAULO_TIME_ZONE = "America/Sao_Paulo";
+
+/** Immutable aggregate baseline; never attribute it to an individual Run or dimension. */
+export const LEGACY_EFFORT_DAILY_MS = {
+  "2026-08-02": 4_809_511,
+  "2026-08-01": 8_894_527,
+  "2026-07-31": 9_472_804,
+  "2026-07-30": 5_167_818,
+  "2026-07-29": 11_336_221,
+  "2026-07-28": 8_262_282,
+  "2026-07-27": 4_862_150,
+  "2026-07-26": 970_899,
+  "2026-07-25": 7_465_970,
+  "2026-07-24": 9_041_538,
+  "2026-07-23": 19_750,
+  "2026-07-22": 1_371_560,
+  "2026-07-21": 14_992_543,
+  "2026-07-20": 3_168_460,
+  "2026-07-19": 929_990,
+  "2026-07-18": 9_232_700,
+  "2026-07-17": 16_882_853,
+  "2026-07-16": 20_054_785,
+  "2026-07-15": 35_459_620,
+  "2026-07-14": 24_078_852,
+  "2026-07-13": 22_611_635,
+  "2026-07-12": 8_339_738,
+  "2026-07-11": 1_859_980,
+} as const;
+
+export const LEGACY_EFFORT_SNAPSHOT = {
+  cutoff: "2026-08-02T03:14:00.000Z",
+  cutoffDay: "2026-08-02",
+  durationMs: Object.values(LEGACY_EFFORT_DAILY_MS).reduce((sum, value) => sum + value, 0),
+  costXlsxSha256: "C3EE0495667289FB81DD8F9268697CEB7692433C14CB19934C89B5F39129902A",
+  operationsXlsxSha256: "94E9577A7CA27F7FDD277D81E34156296CB28FE39CF6D7636B259EBBB7E56BCC",
+} as const;
+
+export function isAfterLegacyEffortCutoff(value: string | null | undefined): boolean {
+  return (
+    value !== null &&
+    value !== undefined &&
+    Date.parse(value) >= Date.parse(LEGACY_EFFORT_SNAPSHOT.cutoff)
+  );
+}
+
+export function globalLegacyEffortDurationMs<T extends { id: string; started_at?: string | null }>(
+  runs: readonly T[],
+  durationOf: (run: T) => number | null,
+): number {
+  const unique = new Map<string, T>();
+  for (const run of runs) if (!unique.has(run.id)) unique.set(run.id, run);
+  return (
+    LEGACY_EFFORT_SNAPSHOT.durationMs +
+    [...unique.values()]
+      .filter((run) => isAfterLegacyEffortCutoff(run.started_at))
+      .reduce((sum, run) => sum + (durationOf(run) ?? 0), 0)
+  );
+}
+
+export function saoPauloPeriodKey(
+  value: string | null | undefined,
+  granularity: "day" | "month" | "year",
+): string | null {
+  if (value === null || value === undefined) return null;
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return null;
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone: SAO_PAULO_TIME_ZONE,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  }).formatToParts(date);
+  const part = (type: Intl.DateTimeFormatPartTypes) =>
+    parts.find((item) => item.type === type)?.value;
+  const year = part("year");
+  const month = part("month");
+  const day = part("day");
+  if (year === undefined || month === undefined || day === undefined) return null;
+  if (granularity === "year") return year;
+  if (granularity === "month") return `${year}-${month}`;
+  return `${year}-${month}-${day}`;
+}
+
+export interface UsageCoverage {
+  events: number;
+  tokens: number;
+  usd: number;
+  brl: number;
+}
+
+export interface UsageMetricProjection {
+  events: number;
+  tokens: {
+    input: number | null;
+    cached_input: number | null;
+    output: number | null;
+    reasoning: number | null;
+    total: number | null;
+  };
+  cost: { usd: number | null; brl: number | null };
+  coverage: UsageCoverage;
+}
+
+export interface UsageProjection {
+  conversation: UsageMetricProjection;
+  planning: UsageMetricProjection;
+  execution: UsageMetricProjection;
+  total: UsageMetricProjection;
+  new_work: UsageMetricProjection;
+  rework: UsageMetricProjection;
+}
+
+export type MetricProvenance = "observed" | "reconciled" | "legacy_inferred" | "estimated";
+
+export interface MetricCoverageProjection {
+  population: number;
+  known: number;
+  unknown: number;
+  known_sum: number;
+  coverage_ratio: number;
+  complete: boolean;
+  provenance: Record<MetricProvenance, number>;
+}
+
+export interface MacroMetricCoverage {
+  duration_ms: MetricCoverageProjection;
+  tokens: MetricCoverageProjection;
+  estimated_usd: MetricCoverageProjection;
+  estimated_brl: MetricCoverageProjection;
+}
+
+export interface QualityProjection {
+  completed_tasks: number;
+  task_completion_rate: number;
+  terminal_runs: number;
+  successful_runs: number;
+  terminal_success_rate: number;
+  rework_rate: number;
+}
+
+export interface PlannedTaskPreview {
+  id: string;
+  title: string;
+  objective: string;
+  depends_on: string[];
+}
+
+export interface MacroProjection {
+  id: string;
+  title: string;
+  created_at: string | null;
+  updated_at?: string | null;
+  kind: "prd" | "spec";
+  parent_id: string | null;
+  artifact_path: string;
+  lifecycle_status: string;
+  work_status:
+    | "planning"
+    | "executing"
+    | "verifying"
+    | "completed"
+    | "blocked"
+    | "failed"
+    | "cancelled";
+  is_active?: boolean;
+  execution_ids: string[];
+  task_ids: string[];
+  planned_tasks: PlannedTaskPreview[];
+  run_ids: string[];
+  execution_count: number;
+  task_count: number;
+  run_count: number;
+  duration_ms: number | null;
+  duration_provenance?: "observed" | "reconciled" | "legacy_inferred" | "estimated" | "unavailable";
+  estimation_basis?: string | null;
+  decisions: { human: number; agent: number };
+  rework_run_count: number;
+  quality: QualityProjection;
+  usage: UsageProjection;
+}
+
+export type TaskStatus =
+  | "draft"
+  | "planned"
+  | "executing"
+  | "verifying"
+  | "completed"
+  | "failed"
+  | "blocked"
+  | "cancelled";
+
+export interface DashboardTaskProjection {
+  schema_version: 2;
+  id: string;
+  revision: number;
+  change_id: string;
+  title: string;
+  short_name: string;
+  objective: string;
+  status: TaskStatus;
+  attempt_count: number | null;
+  risk: "lite" | "standard" | "critical";
+  priority: "low" | "medium" | "high" | "urgent";
+  owner: string | null;
+  requirement_ids: string[];
+  acceptance_ids: string[];
+  depends_on: string[];
+  write_scopes: string[];
+  created_at: string;
+  updated_at: string;
+  started_at: string | null;
+  finished_at: string | null;
+  result: { summary: string; changed_files: string[]; evidence_ids: string[] } | null;
+  artifact_path: string;
+  progress: number;
+  spec_id: string | null;
+  execution_started: boolean;
+  execution_ids?: string[];
+  execution_count?: number;
+  telemetry?: {
+    duration_ms: number | null;
+    tokens: number | null;
+    cost_brl: number | null;
+  } | null;
+  is_active?: boolean;
+  test_count?: number;
+}
+
+export interface ChangeProjection {
+  id: string;
+  title: string;
+  created_at: string | null;
+  status: string;
+  risk: string;
+  source:
+    | { type: "task"; task_id: string }
+    | { type: "spec"; spec_id: string }
+    | { type: "prd"; prd_id: string; spec_id: string | null };
+  requirement_ids: string[];
+  acceptance_ids: string[];
+  task_ids: string[];
+  result: string | null;
+  artifact_path: string;
+}
+
+export interface ExecutionProjection {
+  id: string;
+  kind?: "interaction" | "delivery";
+  client_turn_id?: string | null;
+  created_at: string | null;
+  status: string;
+  work_status: string;
+  origin:
+    | { type: "task"; task_id: string }
+    | { type: "spec"; spec_id: string }
+    | { type: "prd"; prd_id: string }
+    | { type: "interaction"; conversation_id: string };
+  dag: {
+    nodes: Array<{ task_id: string; change_id: string; depends_on: string[] }>;
+    topological_order: string[];
+  };
+  result: string | null;
+  artifact_path: string;
+  agent_call_count: number;
+  orchestrator_run_count: number;
+  subagent_run_count: number;
+  finalizer_run_count: number;
+  finalized_task_count: number;
+  llm_call_count: number;
+  llm_call_count_complete: boolean;
+  task_count: number;
+  spec_count: number;
+  prd_count: number;
+  duration_ms: number | null;
+}
+
+export interface RunProjection {
+  id: string;
+  artifact_path: string;
+  status: "running" | "completed" | "failed" | "cancelled";
+  phase: string;
+  entrypoint: "conversation" | "task" | "spec" | "prd";
+  work_type: "new" | "rework";
+  run_role: "intake" | "orchestrator" | "subagent";
+  run_kind: "run" | "subrun";
+  run_purpose: "intake" | "orchestration" | "execution" | "review" | "audit" | "finalization";
+  requires_finalizer: boolean;
+  parent_run_id: string | null;
+  client: string;
+  agent: string;
+  agent_name: string;
+  provider: string | null;
+  model: string;
+  reasoning_effort: string | null;
+  effective_model: string | null;
+  effective_reasoning_effort: string | null;
+  effective_config_mixed: boolean;
+  service_tier?: string | null;
+  call_count: number | null;
+  terminal_call_count: number | null;
+  failed_call_count: number | null;
+  cancelled_call_count: number | null;
+  conversation_id: string;
+  client_thread_id?: string | null;
+  client_turn_id?: string | null;
+  is_active?: boolean;
+  execution_id: string | null;
+  task_id: string | null;
+  spec_id: string | null;
+  prd_id: string | null;
+  change_id: string | null;
+  started_at: string;
+  finished_at: string | null;
+  duration_ms: number | null;
+  duration_provenance?: "observed" | "reconciled" | "legacy_inferred" | "estimated" | "unavailable";
+  estimation_basis?: string | null;
+  source_started_at?: string | null;
+  source_finished_at?: string | null;
+  source_duration_ms?: number | null;
+  capture_lag_ms?: number | null;
+  pricing_segments?: Array<{
+    phase: "conversation" | "planning" | "execution";
+    provider: string | null;
+    model: string | null;
+    service_tier?: string | null;
+    input_tokens: number | null;
+    cached_input_tokens: number | null;
+    output_tokens: number | null;
+    reasoning_tokens: number | null;
+    total_tokens: number | null;
+    recorded_usd?: number | null;
+    recorded_brl?: number | null;
+    recorded_fx_rate?: number | null;
+  }>;
+  usage: UsageProjection;
+}
+
+export interface DecisionProjection {
+  id: string;
+  title: string;
+  origin: "human" | "agent";
+  scope_type: "change" | "execution";
+  scope_id: string;
+  artifact_path: string;
+  created_at: string;
+}
+
+export interface OperationsProjection extends ReadonlyV2Projection {
+  filters: ProjectionTimeFilter;
+  summary: {
+    prd_count: number;
+    spec_count: number;
+    execution_count: number;
+    task_count: number;
+    run_count: number;
+    execution_duration_ms?: number;
+    execution_day_count?: number;
+    /** Server-side totals retained when `scope=overview` omits the Run collection. */
+    overview_metrics?: {
+      duration_ms: number | null;
+      execution_day_count: number;
+      tokens: number | null;
+      cost_brl: number | null;
+    };
+    decisions: { human: number; agent: number };
+    source_latest_at: string | null;
+    quality: QualityProjection;
+    reconciliation: {
+      phase_tokens_match_total: boolean;
+      phase_usd_match_total: boolean;
+      phase_brl_match_total: boolean;
+      origin_tokens_match_total: boolean;
+    };
+    usage: UsageProjection;
+  };
+  origins: Record<"conversation" | "task" | "spec" | "prd", UsageProjection>;
+  prds: MacroProjection[];
+  specs: MacroProjection[];
+  tasks: DashboardTaskProjection[];
+  changes: ChangeProjection[];
+  executions: ExecutionProjection[];
+  runs: RunProjection[];
+  decisions: DecisionProjection[];
+}
+
+export interface TaskDetailProjection {
+  task: DashboardTaskProjection;
+  body: string;
+  artifact_path: string;
+}
+
+export interface PrdDetailProjection {
+  id: string;
+  title: string;
+  body: string;
+  artifact_path: string;
+}
+
+export interface SpecDetailProjection {
+  id: string;
+  title: string;
+  body: string;
+  artifact_path: string;
+}

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

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { rootExecutionDurationRuns } from "./duration-population.js";
+
+describe("rootExecutionDurationRuns", () => {
+  it("excludes an execution child when its visible parent is planning or conversation", () => {
+    const runs = [
+      { id: "RUN-PLANNING", phase: "planning", parent_run_id: null },
+      { id: "RUN-CHILD", phase: "execution", parent_run_id: "RUN-PLANNING" },
+      { id: "RUN-CONVERSATION", phase: "conversation", parent_run_id: null },
+      { id: "RUN-CONVERSATION-CHILD", phase: "execution", parent_run_id: "RUN-CONVERSATION" },
+      { id: "RUN-ROOT", phase: "execution", parent_run_id: null },
+    ];
+
+    expect(rootExecutionDurationRuns(runs).map((run) => run.id)).toEqual(["RUN-ROOT"]);
+  });
+});