@zaip-ai/cli 1.0.7 → 1.0.8

package/templates/.agents/dashboard/packages/local-runtime/src/server-projections.ts

@@ -0,0 +1,483 @@
+import type { WorkspaceFileSystem, WorkspaceLayout } from "@zaip-ai/core";
+import { PricingRepository, queryInvocationManifestPage } from "@zaip-ai/costs";
+import type { CostMonitorProjection } from "@zaip-ai/dashboard-cost-monitor/contracts";
+import { buildCostMonitorProjection } from "@zaip-ai/dashboard-cost-monitor/server";
+import type { RunProjection } from "@zaip-ai/dashboard-operations/contracts";
+import {
+  buildOperationsProjection,
+  projectExecutionDurations,
+  recalculateOperationsRunSummary,
+} from "@zaip-ai/dashboard-operations/server";
+import type { Context } from "hono";
+import { mergeManifestRuns } from "./manifest-runs.js";
+import {
+  configuredAgentNames,
+  invocationSummariesForPeriod,
+  queryValues,
+  selectedCurrency,
+} from "./server-summary-helpers.js";
+
+const WORK_PRIORITY_PATH = ".agents/dashboard/work-priority.json";
+
+export async function buildCanonicalOperationsProjection(
+  filesystem: WorkspaceFileSystem,
+  layout: WorkspaceLayout,
+  filter: { from: string | null; to: string | null },
+  overviewOnly = false,
+  includeOverviewChanges = false,
+) {
+  const unrankedOperations = await buildOperationsProjection(filesystem, layout, filter, {
+    overviewOnly,
+    includeOverviewChanges,
+  });
+  const operations = applyWorkPriority(
+    unrankedOperations,
+    await readWorkPriority(filesystem, knownWorkIds(unrankedOperations)),
+  );
+  if (overviewOnly || filter.from === null || filter.to === null) return operations;
+  const summaries = await invocationSummariesForPeriod(filesystem, {
+    from: filter.from,
+    to: filter.to,
+  });
+  return summaries.length === 0
+    ? operations
+    : recalculateOperationsRunSummary({
+        ...operations,
+        runs: projectExecutionDurations(mergeKnownManifestRuns(operations.runs, summaries)),
+      });
+}
+
+type WorkPriority = { schema_version: 1; item_ids: string[]; updated_at: string | null };
+
+export async function readWorkPriority(
+  filesystem: WorkspaceFileSystem,
+  knownIds?: ReadonlySet<string>,
+): Promise<WorkPriority> {
+  try {
+    const priority = normalizeWorkPriority(
+      JSON.parse(await filesystem.readText(WORK_PRIORITY_PATH)),
+      false,
+    );
+    return knownIds === undefined
+      ? priority
+      : { ...priority, item_ids: priority.item_ids.filter((id) => knownIds.has(id)) };
+  } catch {
+    return { schema_version: 1, item_ids: [], updated_at: null };
+  }
+}
+
+export function knownWorkIds(operations: {
+  prds: readonly { id: string }[];
+  specs: readonly { id: string }[];
+  tasks: readonly { id: string }[];
+}): Set<string> {
+  return new Set([
+    ...operations.prds.map((row) => row.id),
+    ...operations.specs.map((row) => row.id),
+    ...operations.tasks.map((row) => row.id),
+  ]);
+}
+
+export function normalizeWorkPriority(value: unknown, stamp = true): WorkPriority {
+  const input =
+    typeof value === "object" && value !== null
+      ? (value as { item_ids?: unknown; updated_at?: unknown })
+      : {};
+  const itemIds = Array.isArray(input.item_ids)
+    ? [
+        ...new Set(
+          input.item_ids.filter((id): id is string => typeof id === "string" && id.length > 0),
+        ),
+      ]
+    : [];
+  return {
+    schema_version: 1,
+    item_ids: itemIds,
+    updated_at:
+      typeof input.updated_at === "string" && !stamp ? input.updated_at : new Date().toISOString(),
+  };
+}
+
+function applyWorkPriority<
+  T extends {
+    prds: Array<{ id: string; manual_order?: number | null }>;
+    specs: Array<{ id: string; manual_order?: number | null }>;
+    tasks: Array<{ id: string; manual_order?: number | null }>;
+  },
+>(operations: T, priority: WorkPriority): T {
+  const ranks = new Map(priority.item_ids.map((id, index) => [id, index]));
+  const rank = (id: string) => ranks.get(id) ?? null;
+  return {
+    ...operations,
+    prds: operations.prds.map((row) => ({ ...row, manual_order: rank(row.id) })),
+    specs: operations.specs.map((row) => ({ ...row, manual_order: rank(row.id) })),
+    tasks: operations.tasks.map((row) => ({ ...row, manual_order: rank(row.id) })),
+  };
+}
+
+export async function buildCurrentCostProjection(
+  filesystem: WorkspaceFileSystem,
+  operations: Awaited<ReturnType<typeof buildCanonicalOperationsProjection>>,
+  currency: "BRL" | "USD",
+) {
+  const pricing = new PricingRepository(filesystem);
+  const [catalog, fxRate] = await Promise.all([
+    pricing.readCatalog(),
+    currency === "BRL" ? pricing.readLatestFxRate() : Promise.resolve(null),
+  ]);
+  const agentNames = await configuredAgentNames(filesystem);
+  return buildCostMonitorProjection(operations, { catalog, fxRate, currency }, agentNames);
+}
+
+export async function buildManifestFirstCostProjection(
+  filesystem: WorkspaceFileSystem,
+  operations: Awaited<ReturnType<typeof buildCanonicalOperationsProjection>>,
+  context: Context,
+) {
+  const from = context.req.query("from") ?? null;
+  const to = context.req.query("to") ?? null;
+  if (from === null || to === null) {
+    return buildCurrentCostProjection(filesystem, operations, selectedCurrency(context));
+  }
+  const filters = {
+    providers: queryValues(context, "provider"),
+    models: queryValues(context, "model"),
+    zaip_agents: queryValues(context, "agent"),
+    phases: queryValues(context, "phase"),
+    statuses: queryValues(context, "status"),
+  };
+  const summaries = await invocationSummariesForPeriod(filesystem, { from, to, filters });
+  if (summaries.length === 0)
+    return buildCurrentCostProjection(filesystem, operations, selectedCurrency(context));
+  const runs = projectExecutionDurations(mergeKnownManifestRuns(operations.runs, summaries));
+  return buildCurrentCostProjection(filesystem, { ...operations, runs }, selectedCurrency(context));
+}
+
+/** Enrichment cannot reintroduce a Run excluded by the lifecycle time filter. */
+export function mergeKnownManifestRuns(
+  runs: readonly RunProjection[],
+  summaries: Parameters<typeof mergeManifestRuns>[1],
+): RunProjection[] {
+  const ids = new Set(runs.map((run) => run.id));
+  return mergeManifestRuns(
+    runs,
+    summaries.filter((summary) => ids.has(summary.run_id)),
+  );
+}
+
+/** Page-first Cost Run reader. Aggregates stay on the summary endpoint. */
+export async function buildManifestCostRunPage(
+  filesystem: WorkspaceFileSystem,
+  layout: WorkspaceLayout,
+  context: Context,
+  period: { from: string | null; to: string | null },
+  offset: number,
+  limit: number,
+) {
+  const range = await manifestRunRange(filesystem, period.from, period.to);
+  const { from, to } = range;
+  const filters = {
+    providers: queryValues(context, "provider"),
+    models: queryValues(context, "model"),
+    zaip_agents: queryValues(context, "agent"),
+    phases: queryValues(context, "phase"),
+    statuses: queryValues(context, "status"),
+  };
+  const hasTelemetryFilters =
+    filters.providers.length > 0 ||
+    filters.models.length > 0 ||
+    filters.zaip_agents.length > 0 ||
+    // API callers may request Run terminal status; absent telemetry never
+    // matches an explicit status and remains visible only without this filter.
+    filters.statuses.length > 0;
+  const [operations, page, lifecycleSummary] = await Promise.all([
+    // This compact projection reads the durable manifest summary plus Tasks;
+    // it intentionally does not materialise Run records.
+    import("@zaip-ai/dashboard-operations/server").then(({ buildQuickOperationsProjection }) =>
+      buildQuickOperationsProjection(filesystem, layout, { from, to }),
+    ),
+    queryInvocationManifestPage(filesystem, { from, to, filters, offset, limit }),
+    filesystem
+      .readText(".agents/records/lifecycle/summary.json")
+      .then((value) => JSON.parse(value) as { run_metrics?: CompactRunMetric[] }),
+  ]);
+  const compactRuns = (lifecycleSummary.run_metrics ?? [])
+    .filter((run) => runTimestampInRange(run.finished_at ?? run.started_at, from, to))
+    .sort(
+      (left, right) =>
+        (right.finished_at ?? right.started_at).localeCompare(
+          left.finished_at ?? left.started_at,
+        ) || left.id.localeCompare(right.id),
+    );
+  // The lifecycle index is the complete population. Telemetry is only a left
+  // join, so a Run with no InvocationSummary remains visible with null usage.
+  const lifecycleCandidates =
+    filters.phases.length === 0
+      ? compactRuns
+      : compactRuns.filter((run) => run.phase !== null && filters.phases.includes(run.phase));
+  const telemetryRunIds = new Set(page.summaries.map((summary) => summary.run_id));
+  const baseRuns = hasTelemetryFilters
+    ? // Provider/model/agent filters are telemetry dimensions. Their candidate
+      // population is therefore the authenticated manifest page itself.
+      lifecycleCandidates.filter((run) => telemetryRunIds.has(run.id)).map(compactRunProjection)
+    : lifecycleCandidates.slice(offset, offset + limit).map(compactRunProjection);
+  const merged = mergeLifecycleRunPage(baseRuns, page.summaries);
+  const runs = projectExecutionDurations(merged);
+  const projection = await buildCurrentCostProjection(
+    filesystem,
+    { ...operations, runs },
+    selectedCurrency(context),
+  );
+  return {
+    ...projection,
+    // Rows are a transport page, never a disguised aggregate projection.
+    page_only: true,
+    overview: {
+      ...projection.overview,
+      run_count: 0,
+      event_count: 0,
+      total_tokens: null,
+      estimated_usd: null,
+      estimated_brl: null,
+      recorded_usd: null,
+      recorded_brl: null,
+      average_run_cost_usd: null,
+      average_run_cost_brl: null,
+      average_run_duration_ms: null,
+      known_tokens_per_cycle: null,
+      top_10_token_share: null,
+    },
+    groups: {
+      conversations: [],
+      tasks: [],
+      providers: [],
+      agents: [],
+      models: [],
+      daily: [],
+      monthly: [],
+      annual: [],
+    },
+    // Exact totals deliberately remain unavailable: computing them would
+    // materialise the complete filtered JSONL population.
+    run_page: {
+      offset,
+      limit,
+      total: hasTelemetryFilters ? null : lifecycleCandidates.length,
+      has_more: hasTelemetryFilters ? page.has_more : offset + limit < lifecycleCandidates.length,
+    },
+  };
+}
+
+/** Left-join telemetry without changing lifecycle page cardinality or order. */
+export function mergeLifecycleRunPage(
+  page: readonly RunProjection[],
+  summaries: Parameters<typeof mergeManifestRuns>[1],
+): RunProjection[] {
+  const ids = new Set(page.map((run) => run.id));
+  const merged = mergeManifestRuns(
+    page,
+    summaries.filter((summary) => ids.has(summary.run_id)),
+  );
+  const byId = new Map(merged.map((run) => [run.id, run] as const));
+  return page.map((run) => byId.get(run.id) ?? run);
+}
+
+export interface CompactRunMetric {
+  id: string;
+  started_at: string;
+  finished_at: string | null;
+  task_id: string | null;
+  execution_id: string | null;
+  conversation_id: string | null;
+  agent: string | null;
+  agent_name: string | null;
+  provider: string | null;
+  model: string | null;
+  spec_id: string | null;
+  prd_id: string | null;
+  change_id: string | null;
+  phase: string | null;
+  parent_run_id: string | null;
+  status: string | null;
+  run_kind?: "run" | "subrun" | null;
+  duration_ms: number | null;
+  total_tokens: number | null;
+  cost: number | null;
+  currency: string | null;
+  events: number | null;
+}
+
+export function compactRunProjection(run: CompactRunMetric): RunProjection {
+  const empty = {
+    events: 0,
+    tokens: { input: null, cached_input: null, output: null, reasoning: null, total: null },
+    cost: { usd: null, brl: null },
+    coverage: { events: 0, tokens: 0, usd: 0, brl: 0 },
+  };
+  const metric = {
+    ...empty,
+    events: run.events ?? 0,
+    tokens: { ...empty.tokens, total: run.total_tokens },
+    cost: { usd: null, brl: run.currency === "BRL" ? run.cost : null },
+    coverage: {
+      events: run.events ?? 0,
+      tokens: run.total_tokens === null ? 0 : 1,
+      usd: 0,
+      brl: run.cost === null ? 0 : 1,
+    },
+  };
+  return {
+    id: run.id,
+    artifact_path: `.agents/records/runs/${run.id}`,
+    status:
+      run.status === "failed" || run.status === "cancelled" || run.status === "running"
+        ? run.status
+        : "completed",
+    phase: run.phase ?? "execution",
+    entrypoint: run.task_id === null ? "conversation" : "task",
+    work_type: "new",
+    run_role: run.run_kind === "subrun" ? "subagent" : "orchestrator",
+    run_kind: run.run_kind ?? "run",
+    run_purpose: "execution",
+    requires_finalizer: false,
+    parent_run_id: run.parent_run_id,
+    client: "unknown",
+    agent: run.agent ?? "unknown",
+    agent_name: run.agent_name ?? run.agent ?? "unknown",
+    provider: run.provider,
+    model: run.model ?? "unknown",
+    reasoning_effort: null,
+    effective_model: run.model,
+    effective_reasoning_effort: null,
+    effective_config_mixed: false,
+    call_count: null,
+    terminal_call_count: null,
+    failed_call_count: 0,
+    cancelled_call_count: 0,
+    conversation_id: run.conversation_id ?? run.id,
+    execution_id: run.execution_id,
+    task_id: run.task_id,
+    spec_id: run.spec_id,
+    prd_id: run.prd_id,
+    change_id: run.change_id,
+    started_at: run.started_at,
+    finished_at: run.finished_at,
+    duration_ms: run.duration_ms,
+    source_duration_ms: run.duration_ms,
+    usage: {
+      conversation: empty,
+      planning: empty,
+      execution: metric,
+      total: metric,
+      new_work: metric,
+      rework: empty,
+    },
+  };
+}
+
+async function manifestRunRange(
+  filesystem: WorkspaceFileSystem,
+  from: string | null,
+  to: string | null,
+): Promise<{ from: string; to: string }> {
+  if (from !== null && to !== null) return { from, to };
+  const summary = await filesystem
+    .readText(".agents/records/lifecycle/summary.json")
+    .then((value) => JSON.parse(value) as { periods?: { daily?: Record<string, unknown> } });
+  const days = Object.keys(summary.periods?.daily ?? {}).sort();
+  const first = days.at(0);
+  const last = days.at(-1);
+  // Empty lifecycle data has no Run page; constrain the probe to the current
+  // month rather than scanning millennia of absent telemetry directories.
+  const today = new Date().toISOString().slice(0, 10);
+  return {
+    from: normalizeRunRangeBoundary(from ?? first ?? today, "start"),
+    to: normalizeRunRangeBoundary(to ?? last ?? today, "end"),
+  };
+}
+
+export function runTimestampInRange(timestamp: string, from: string, to: string): boolean {
+  const value = Date.parse(timestamp);
+  const start = Date.parse(normalizeRunRangeBoundary(from, "start"));
+  const end = Date.parse(normalizeRunRangeBoundary(to, "end"));
+  return (
+    Number.isFinite(value) &&
+    Number.isFinite(start) &&
+    Number.isFinite(end) &&
+    value >= start &&
+    value <= end
+  );
+}
+
+function normalizeRunRangeBoundary(value: string, boundary: "start" | "end"): string {
+  if (/^\d{4}-\d{2}-\d{2}$/.test(value))
+    return `${value}T${boundary === "start" ? "00:00:00.000" : "23:59:59.999"}Z`;
+  return value;
+}
+
+/** Keeps Cost Run transport incremental without changing aggregate semantics. */
+export function pageCostRunRows(
+  projection: CostMonitorProjection,
+  offset: number,
+  limit: number,
+): CostMonitorProjection {
+  const safeOffset = Math.max(0, offset);
+  const safeLimit = Math.min(500, Math.max(1, limit));
+  return {
+    ...projection,
+    runs: projection.runs.slice(safeOffset, safeOffset + safeLimit),
+    run_page: {
+      offset: safeOffset,
+      limit: safeLimit,
+      total: projection.runs.length,
+      has_more: safeOffset + safeLimit < projection.runs.length,
+    },
+  };
+}
+
+/**
+ * The Runs endpoint advertises these dimensions as server-side filters. Apply
+ * them before offset pagination so the reported total and every page have the
+ * same population. Aggregate fields intentionally retain their full filtered
+ * projection semantics and are not derived from the transport page.
+ */
+export function filterCostRunRows(
+  projection: CostMonitorProjection,
+  filters: {
+    provider: readonly string[];
+    model: readonly string[];
+    agent: readonly string[];
+    phase: readonly string[];
+    status: readonly string[];
+  },
+): CostMonitorProjection {
+  const includes = (values: readonly string[], value: string) =>
+    values.length === 0 || values.includes(value);
+  const provider = (value: string | null) => {
+    const normalized = value?.trim().toLowerCase();
+    return !normalized || normalized === "unknown" || normalized === "codex"
+      ? "openai"
+      : normalized;
+  };
+  return {
+    ...projection,
+    runs: projection.runs.filter(
+      (run) =>
+        includes(filters.provider, provider(run.provider)) &&
+        includes(filters.model, run.model) &&
+        includes(filters.agent, run.agent_name) &&
+        includes(filters.phase, run.phase) &&
+        includes(filters.status, run.task_status),
+    ),
+  };
+}
+
+export async function readCurrentFxRate(filesystem: WorkspaceFileSystem) {
+  return new PricingRepository(filesystem).readLatestFxRate();
+}
+
+export function isUnfilteredCostRequest(context: Context): boolean {
+  return ["provider", "model", "agent", "phase", "status"].every(
+    (name) => (context.req.queries(name)?.length ?? 0) === 0,
+  );
+}

package/templates/.agents/dashboard/packages/local-runtime/src/server-settings.test.ts

@@ -18,7 +18,9 @@ describe("dashboard settings backend", () => {
     await writeFile(configPath, projectSource, "utf8");
 
     try {
-      const app = createDashboardApp(fixtureRoot, "test-session");
+      const app = createDashboardApp(fixtureRoot, "test-session", undefined, {
+        snapshotReadOnly: true,
+      });
       const unauthorized = await app.request("/api/v2/project-settings", { method: "PUT" });
       const settings = await app.request("/api/v2/project-settings", {
         headers: { "x-zaip-session": "test-session" },
@@ -26,7 +28,7 @@ describe("dashboard settings backend", () => {
       const payload = (await settings.json()) as {
         zaip?: { enabled: boolean };
         project: { id: string };
-        stack: { profile: string; overrides: Record<string, unknown> };
+        stack: { id: string; overrides: Record<string, unknown> };
         tracking: { currency: string };
       };
       const updated = await app.request("/api/v2/project-settings", {
@@ -68,6 +70,7 @@ describe("dashboard settings backend", () => {
       await expect(updated.json()).resolves.toMatchObject({
         zaip: { enabled: false },
         stack: {
+          id: "zaip-aios-stack",
           overrides: {
             languages: {
               frontend: ["TypeScript"],