@zaip-ai/cli 1.0.6 → 1.0.7

package/templates/.agents/dashboard/modules/operations/src/server/canonical-compat.ts

@@ -0,0 +1,176 @@
+import type { ScopedRun } from "./internal.js";
+
+export function observedSourceTiming(
+  record:
+    | {
+        occurred_at: string;
+        source_occurred_at?: string | undefined;
+        source_started_at?: string | undefined;
+        source_finished_at?: string | undefined;
+      }
+    | undefined,
+): {
+  source_started_at: string | null;
+  source_finished_at: string | null;
+  source_duration_ms: number | null;
+  capture_lag_ms: number | null;
+} {
+  const sourceStartedAt = record?.source_started_at ?? null;
+  const sourceFinishedAt = record?.source_finished_at ?? record?.source_occurred_at ?? null;
+  return {
+    source_started_at: sourceStartedAt,
+    source_finished_at: sourceFinishedAt,
+    source_duration_ms:
+      sourceStartedAt === null || sourceFinishedAt === null
+        ? null
+        : Math.max(0, Date.parse(sourceFinishedAt) - Date.parse(sourceStartedAt)),
+    capture_lag_ms:
+      sourceFinishedAt === null || record === undefined
+        ? null
+        : Math.max(0, Date.parse(record.occurred_at) - Date.parse(sourceFinishedAt)),
+  };
+}
+
+type SourceTimingRecord = {
+  occurred_at: string;
+  activity_kind?: string | undefined;
+  source_occurred_at?: string | null | undefined;
+  source_started_at?: string | undefined;
+  source_finished_at?: string | undefined;
+};
+
+/**
+ * Pricing or supersession records can remove a retrospective usage record from
+ * `effective_usage_records`.  Select the most recently recorded exact source
+ * interval from both views instead of treating a later non-timing record as
+ * evidence that the earlier observation disappeared.
+ */
+export function latestObservedSourceTiming(
+  runStartedAt: string,
+  _recordedFinishedAt: string | null,
+  effectiveRecords: readonly SourceTimingRecord[],
+  allRecords: readonly SourceTimingRecord[],
+) {
+  const startedAtMs = Date.parse(runStartedAt);
+  const atOrAfterRunStart = (value: string | null | undefined) => {
+    const timestamp = value === null || value === undefined ? Number.NaN : Date.parse(value);
+    return Number.isFinite(timestamp) && timestamp >= startedAtMs;
+  };
+  const candidates: SourceTimingRecord[] = [];
+  for (const record of [...effectiveRecords, ...allRecords]) {
+    const sourceStartedAt = record.source_started_at;
+    const sourceFinishedAt = record.source_finished_at;
+    if (
+      sourceStartedAt !== undefined &&
+      sourceFinishedAt !== undefined &&
+      atOrAfterRunStart(sourceStartedAt) &&
+      atOrAfterRunStart(sourceFinishedAt) &&
+      Date.parse(sourceFinishedAt) >= Date.parse(sourceStartedAt)
+    ) {
+      candidates.push({ ...record, source_finished_at: sourceFinishedAt });
+      continue;
+    }
+    // Exact retrospective reconciliation records report a source completion
+    // time. Their interval begins at the immutable Run start; never substitute
+    // a lifecycle end or an approximate timestamp.
+    if (
+      record.activity_kind === "retrospective_local_reconciliation" &&
+      typeof record.source_occurred_at === "string" &&
+      atOrAfterRunStart(record.source_occurred_at)
+    ) {
+      candidates.push({
+        ...record,
+        source_started_at: runStartedAt,
+        source_finished_at: record.source_occurred_at,
+      });
+    }
+  }
+  candidates.sort((left, right) => Date.parse(left.occurred_at) - Date.parse(right.occurred_at));
+  const selected = candidates.at(-1);
+  return selected === undefined
+    ? observedSourceTiming(undefined)
+    : observedSourceTiming({
+        occurred_at: selected.occurred_at,
+        source_occurred_at: selected.source_occurred_at ?? undefined,
+        source_started_at: selected.source_started_at,
+        source_finished_at: selected.source_finished_at,
+      });
+}
+
+export function createDescendantQueries(input: {
+  changes: readonly {
+    id: string;
+    source: { type: string; spec_id?: string | null; prd_id?: string };
+  }[];
+  tasks: readonly { id: string; change_id: string }[];
+  executions: readonly {
+    id: string;
+    origin: { type: string; spec_id?: string; prd_id?: string; conversation_id?: string };
+    dag: { nodes: Array<{ task_id: string }> };
+  }[];
+  prds: readonly { id: string; creation_run_id?: string | null }[];
+  specs: readonly { id: string; prd_id: string | null; creation_run_id?: string | null }[];
+  runs: readonly ScopedRun[];
+}) {
+  function collect(specIds: ReadonlySet<string>, prdId: string | null) {
+    const creationRunIds = new Set(
+      [
+        ...(prdId === null
+          ? []
+          : input.prds.filter((prd) => prd.id === prdId).map((prd) => prd.creation_run_id)),
+        ...input.specs.filter((spec) => specIds.has(spec.id)).map((spec) => spec.creation_run_id),
+      ].filter((runId): runId is string => runId !== null && runId !== undefined),
+    );
+    const changeIds = new Set(
+      input.changes
+        .filter(
+          (change) =>
+            (prdId !== null && change.source.type === "prd" && change.source.prd_id === prdId) ||
+            ((change.source.type === "spec" || change.source.type === "prd") &&
+              change.source.spec_id !== null &&
+              change.source.spec_id !== undefined &&
+              specIds.has(change.source.spec_id)),
+        )
+        .map((change) => change.id),
+    );
+    const taskIds = new Set(
+      input.tasks.filter((task) => changeIds.has(task.change_id)).map((task) => task.id),
+    );
+    const executionIds = new Set(
+      input.executions
+        .filter(
+          (execution) =>
+            (prdId !== null &&
+              execution.origin.type === "prd" &&
+              execution.origin.prd_id === prdId) ||
+            (execution.origin.type === "spec" &&
+              execution.origin.spec_id !== undefined &&
+              specIds.has(execution.origin.spec_id)) ||
+            execution.dag.nodes.some((node) => taskIds.has(node.task_id)),
+        )
+        .map((execution) => execution.id),
+    );
+    const runs = input.runs.filter((run) => {
+      const directlyLinked =
+        (run.fold.run.spec_id !== null && specIds.has(run.fold.run.spec_id)) ||
+        (run.fold.run.task_id !== null && taskIds.has(run.fold.run.task_id)) ||
+        creationRunIds.has(run.fold.run.run_id);
+      if (prdId === null) return directlyLinked;
+      return (
+        directlyLinked ||
+        run.fold.run.prd_id === prdId ||
+        (run.fold.run.execution_id !== null && executionIds.has(run.fold.run.execution_id))
+      );
+    });
+    return { changeIds, taskIds, executionIds, runs };
+  }
+
+  return {
+    forSpec: (specId: string) => collect(new Set([specId]), null),
+    forPrd: (prdId: string) =>
+      collect(
+        new Set(input.specs.filter((spec) => spec.prd_id === prdId).map((spec) => spec.id)),
+        prdId,
+      ),
+  };
+}

package/templates/.agents/dashboard/modules/operations/src/server/canonical-run-projection.ts

@@ -0,0 +1,140 @@
+import {
+  effectiveRunV2Kind,
+  effectiveRunV2Purpose,
+  effectiveRunV2Role,
+  type RunV2Fold,
+  runV2RequiresFinalizer,
+} from "@zaip-ai/decisions";
+import type { OperationsProjection } from "../contracts.js";
+import { latestObservedSourceTiming } from "./canonical-compat.js";
+import type { ScopedRun } from "./internal.js";
+import { usageProjection } from "./usage.js";
+
+export function projectCanonicalRun(run: ScopedRun): OperationsProjection["runs"][number] {
+  const finishedAt = run.fold.finished?.occurred_at ?? null;
+  const runtime = run.fold.effective_usage_records.findLast((record) => record.runtime)?.runtime;
+  const observedRuntime = run.fold.effective_usage_records.at(-1);
+  const sourceTiming = latestObservedSourceTiming(
+    run.fold.run.occurred_at,
+    finishedAt,
+    run.fold.effective_usage_records,
+    run.fold.records,
+  );
+  return {
+    id: run.fold.run.run_id,
+    artifact_path: run.artifactPath,
+    status: run.fold.status,
+    phase: run.fold.records.findLast((record) => "phase" in record)?.phase ?? run.fold.run.phase,
+    entrypoint: run.fold.run.entrypoint,
+    work_type: run.fold.run.work_type,
+    run_role: effectiveRunV2Role(run.fold.run),
+    run_kind: effectiveRunV2Kind(run.fold.run),
+    run_purpose: effectiveRunV2Purpose(run.fold.run),
+    requires_finalizer: runV2RequiresFinalizer(run.fold.run),
+    parent_run_id: run.fold.run.parent_run_id,
+    client: run.fold.run.client,
+    agent: run.fold.run.agent,
+    agent_name: canonicalAgentName(run.fold.run.agent, run.fold.run.agent_name),
+    provider: observedRuntime?.provider ?? run.fold.run.provider,
+    model: run.fold.run.model,
+    reasoning_effort:
+      run.fold.run.reasoning_effort ??
+      run.fold.model_selection_records[0]?.requested.reasoning_effort ??
+      null,
+    ...effectiveConfiguration(run.fold),
+    ...callSummary(run.fold),
+    service_tier: runtime?.service_tier ?? null,
+    conversation_id: run.fold.run.conversation_id,
+    execution_id: run.fold.run.execution_id,
+    task_id: run.fold.run.task_id,
+    spec_id: run.fold.run.spec_id,
+    prd_id: run.fold.run.prd_id,
+    change_id: run.fold.run.change_id,
+    started_at: run.fold.run.occurred_at,
+    finished_at: finishedAt,
+    duration_ms: effectiveOperationsDurationMs(sourceTiming.source_duration_ms),
+    ...sourceTiming,
+    pricing_segments: run.fold.effective_usage_records.map((record) => ({
+      phase: record.phase,
+      provider: record.provider,
+      model: record.model,
+      service_tier: record.runtime?.service_tier ?? runtime?.service_tier ?? null,
+      input_tokens: record.tokens.input,
+      cached_input_tokens: record.tokens.cached_input,
+      output_tokens: record.tokens.output,
+      reasoning_tokens: record.tokens.reasoning,
+      total_tokens: record.tokens.total,
+      recorded_usd: record.cost.usd,
+      recorded_brl: record.cost.brl,
+      recorded_fx_rate: record.cost.fx_rate ?? null,
+    })),
+    usage: usageProjection([run]),
+  };
+}
+
+function canonicalAgentName(agent: string, agentName: string | null | undefined): string {
+  if (agent === "codex") return "codex";
+  const value = agentName ?? agent;
+  return value.startsWith("agent-") ? `zaip-agent-${value.slice("agent-".length)}` : value;
+}
+
+function effectiveConfiguration(fold: RunV2Fold): {
+  effective_model: string | null;
+  effective_reasoning_effort: string | null;
+  effective_config_mixed: boolean;
+} {
+  const models = new Set(
+    [
+      ...fold.provider_invocation_records.map((record) => record.effective.model),
+      ...fold.effective_usage_records.map((record) => record.model),
+    ].filter((value): value is string => value !== null),
+  );
+  const efforts = new Set(
+    [
+      ...fold.provider_invocation_records.map((record) => record.effective.reasoning_effort),
+      ...fold.effective_usage_records.map((record) => record.runtime?.reasoning_effort ?? null),
+    ].filter((value): value is string => value !== null),
+  );
+  return {
+    effective_model: models.size === 1 ? ([...models][0] ?? null) : null,
+    effective_reasoning_effort: efforts.size === 1 ? ([...efforts][0] ?? null) : null,
+    effective_config_mixed: models.size > 1 || efforts.size > 1,
+  };
+}
+
+function callSummary(fold: RunV2Fold): {
+  call_count: number | null;
+  terminal_call_count: number | null;
+  failed_call_count: number | null;
+  cancelled_call_count: number | null;
+} {
+  const ids = new Set([
+    ...fold.model_selection_records.map((record) => record.invocation_id),
+    ...fold.provider_invocation_records.map((record) => record.invocation_id),
+  ]);
+  if (ids.size === 0) {
+    return {
+      call_count: null,
+      terminal_call_count: null,
+      failed_call_count: null,
+      cancelled_call_count: null,
+    };
+  }
+  return {
+    call_count: ids.size,
+    terminal_call_count: fold.provider_invocation_records.length,
+    failed_call_count: fold.provider_invocation_records.filter(
+      (record) => record.status === "failed",
+    ).length,
+    cancelled_call_count: fold.provider_invocation_records.filter(
+      (record) => record.status === "cancelled",
+    ).length,
+  };
+}
+
+export function effectiveOperationsDurationMs(
+  sourceDurationMs: number | null,
+  _lifecycleDurationMs?: number | null,
+): number | null {
+  return sourceDurationMs !== null && sourceDurationMs > 0 ? sourceDurationMs : null;
+}

package/templates/.agents/dashboard/modules/operations/src/server/execution-relationship-counts.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, it } from "vitest";
+import { executionRelationshipCounts } from "./execution-relationship-counts.js";
+
+describe("executionRelationshipCounts", () => {
+  it("counts linked agent calls, Tasks, SPECs and PRDs with zero for missing links", () => {
+    const counts = executionRelationshipCounts(
+      {
+        id: "EXEC-1",
+        origin: { type: "task", task_id: "TASK-1" },
+        dag: {
+          nodes: [
+            { task_id: "TASK-1", change_id: "CHG-1", depends_on: [] },
+            { task_id: "TASK-2", change_id: "CHG-2", depends_on: [] },
+          ],
+          topological_order: ["TASK-1", "TASK-2"],
+        },
+      },
+      {
+        runs: [
+          {
+            agent: "agent-orchestrator",
+            call_count: 2,
+            duration_ms: 60_000,
+            execution_id: "EXEC-1",
+            parent_run_id: null,
+            run_purpose: "orchestration",
+            status: "completed",
+            task_id: "TASK-1",
+          },
+          {
+            agent: "agent-finalizer",
+            call_count: 1,
+            duration_ms: 30_000,
+            execution_id: null,
+            parent_run_id: "RUN-PARENT",
+            run_purpose: "finalization",
+            status: "completed",
+            task_id: "TASK-2",
+          },
+          {
+            agent: "agent-builder",
+            call_count: null,
+            duration_ms: 20_000,
+            execution_id: "EXEC-OTHER",
+            parent_run_id: null,
+            run_purpose: "execution",
+            status: "completed",
+            task_id: "TASK-OTHER",
+          },
+        ],
+        tasks: [
+          { id: "TASK-1", change_id: "CHG-1" },
+          { id: "TASK-2", change_id: "CHG-2" },
+        ],
+        changes: [
+          { id: "CHG-1", source: { type: "task" } },
+          { id: "CHG-2", source: { type: "spec", spec_id: "SPEC-1" } },
+        ],
+        specs: [{ id: "SPEC-1", prd_id: "PRD-1" }],
+      },
+    );
+
+    expect(counts).toEqual({
+      agent_call_count: 2,
+      duration_ms: 60_000,
+      finalizer_run_count: 1,
+      finalized_task_count: 1,
+      llm_call_count: 3,
+      llm_call_count_complete: true,
+      orchestrator_run_count: 1,
+      prd_count: 1,
+      spec_count: 1,
+      subagent_run_count: 1,
+      task_count: 2,
+    });
+  });
+
+  it("keeps every count at zero when an Execution has no linked work", () => {
+    expect(
+      executionRelationshipCounts(
+        {
+          id: "EXEC-EMPTY",
+          origin: { type: "task", task_id: "TASK-MISSING" },
+          dag: { nodes: [], topological_order: [] },
+        },
+        { runs: [], tasks: [], changes: [], specs: [] },
+      ),
+    ).toEqual({
+      agent_call_count: 0,
+      duration_ms: null,
+      finalizer_run_count: 0,
+      finalized_task_count: 0,
+      llm_call_count: 0,
+      llm_call_count_complete: true,
+      orchestrator_run_count: 0,
+      prd_count: 0,
+      spec_count: 0,
+      subagent_run_count: 0,
+      task_count: 0,
+    });
+  });
+
+  it("uses the canonical root Run interval when analytical duration is unavailable", () => {
+    const counts = executionRelationshipCounts(
+      {
+        id: "EXEC-LIFECYCLE",
+        origin: { type: "task", task_id: "TASK-1" },
+        dag: {
+          nodes: [{ task_id: "TASK-1", change_id: "CHG-1", depends_on: [] }],
+          topological_order: ["TASK-1"],
+        },
+      },
+      {
+        runs: [
+          {
+            agent: "agent-orchestrator",
+            call_count: 1,
+            duration_ms: null,
+            execution_id: "EXEC-LIFECYCLE",
+            finished_at: "2026-07-28T10:11:00.000Z",
+            parent_run_id: null,
+            run_purpose: "orchestration",
+            source_duration_ms: null,
+            started_at: "2026-07-28T10:00:00.000Z",
+            status: "completed",
+            task_id: "TASK-1",
+          },
+        ],
+        tasks: [{ id: "TASK-1", change_id: "CHG-1" }],
+        changes: [{ id: "CHG-1", source: { type: "task" } }],
+        specs: [],
+      },
+    );
+
+    expect(counts.duration_ms).toBe(11 * 60_000);
+  });
+});

package/templates/.agents/dashboard/modules/operations/src/server/execution-relationship-counts.ts

@@ -0,0 +1,121 @@
+import type { ExecutionProjection, RunProjection } from "../contracts.js";
+
+export interface ExecutionRelationshipCounts {
+  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 function executionRelationshipCounts(
+  execution: {
+    id: string;
+    origin: ExecutionProjection["origin"];
+    dag: ExecutionProjection["dag"];
+  },
+  input: {
+    runs: readonly (Pick<
+      RunProjection,
+      | "agent"
+      | "call_count"
+      | "duration_ms"
+      | "execution_id"
+      | "parent_run_id"
+      | "run_purpose"
+      | "status"
+      | "task_id"
+    > &
+      Partial<Pick<RunProjection, "finished_at" | "source_duration_ms" | "started_at">>)[];
+    tasks: readonly { id: string; change_id: string }[];
+    changes: readonly {
+      id: string;
+      source: { type: string; spec_id?: string | null; prd_id?: string };
+    }[];
+    specs: readonly { id: string; prd_id?: string | null; parent_id?: string | null }[];
+  },
+): ExecutionRelationshipCounts {
+  const taskIds = new Set(execution.dag.nodes.map((node) => node.task_id));
+  const changesById = new Map(input.changes.map((change) => [change.id, change] as const));
+  const specsById = new Map(input.specs.map((spec) => [spec.id, spec] as const));
+  const specIds = new Set<string>();
+  const prdIds = new Set<string>();
+  const includeSpec = (specId: string) => {
+    specIds.add(specId);
+    const spec = specsById.get(specId);
+    const prdId = spec?.prd_id ?? spec?.parent_id ?? null;
+    if (prdId !== null) prdIds.add(prdId);
+  };
+
+  if (execution.origin.type === "spec") includeSpec(execution.origin.spec_id);
+  if (execution.origin.type === "prd") prdIds.add(execution.origin.prd_id);
+
+  for (const task of input.tasks) {
+    if (!taskIds.has(task.id)) continue;
+    const source = changesById.get(task.change_id)?.source;
+    if (!source) continue;
+    if ((source.type === "spec" || source.type === "prd") && source.spec_id) {
+      includeSpec(source.spec_id);
+    }
+    if (source.type === "prd" && source.prd_id) prdIds.add(source.prd_id);
+  }
+
+  const relatedRuns = input.runs.filter(
+    (run) =>
+      run.execution_id === execution.id || (run.task_id !== null && taskIds.has(run.task_id)),
+  );
+  const knownCalls = relatedRuns.flatMap((run) =>
+    run.call_count === null ? [] : [run.call_count],
+  );
+  const finalizerRuns = relatedRuns.filter(
+    (run) =>
+      run.run_purpose === "finalization" ||
+      run.agent === "agent-finalizer" ||
+      run.agent === "agent-task-finalizer",
+  );
+  const finalizedTaskIds = new Set(
+    finalizerRuns.flatMap((run) =>
+      run.status === "completed" && run.task_id !== null ? [run.task_id] : [],
+    ),
+  );
+  return {
+    agent_call_count: relatedRuns.length,
+    orchestrator_run_count: relatedRuns.filter((run) => run.parent_run_id === null).length,
+    subagent_run_count: relatedRuns.filter((run) => run.parent_run_id !== null).length,
+    finalizer_run_count: finalizerRuns.length,
+    finalized_task_count: finalizedTaskIds.size,
+    llm_call_count: knownCalls.reduce((sum, count) => sum + count, 0),
+    llm_call_count_complete: knownCalls.length === relatedRuns.length,
+    task_count: taskIds.size,
+    spec_count: specIds.size,
+    prd_count: prdIds.size,
+    // Execution elapsed time is wall time from root Runs. Sub-Run durations are
+    // agent effort and can overlap, so summing them inflates elapsed time.
+    duration_ms: sumOperationalDurations(relatedRuns.filter((run) => run.parent_run_id === null)),
+  };
+}
+
+function sumOperationalDurations(
+  runs: readonly (Pick<RunProjection, "duration_ms"> &
+    Partial<Pick<RunProjection, "finished_at" | "source_duration_ms" | "started_at">>)[],
+): number | null {
+  const durations = runs.flatMap((run) => {
+    if (typeof run.source_duration_ms === "number" && run.source_duration_ms > 0) {
+      return [run.source_duration_ms];
+    }
+    if (typeof run.duration_ms === "number" && run.duration_ms > 0) return [run.duration_ms];
+    if (run.finished_at == null || run.started_at == null) return [];
+    const started = Date.parse(run.started_at);
+    const finished = Date.parse(run.finished_at);
+    return Number.isFinite(started) && Number.isFinite(finished) && finished >= started
+      ? [finished - started]
+      : [];
+  });
+  return durations.length === 0 ? null : durations.reduce((sum, duration) => sum + duration, 0);
+}

package/templates/.agents/dashboard/modules/operations/src/server/filter.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import { normalizeFilter } from "./filter.js";
+
+describe("operations time filter", () => {
+  it("normalizes valid ISO timestamps", () => {
+    expect(
+      normalizeFilter({
+        from: "2026-07-13T01:00:00-03:00",
+        to: "2026-07-13T02:00:00-03:00",
+      }),
+    ).toEqual({
+      from: "2026-07-13T04:00:00.000Z",
+      to: "2026-07-13T05:00:00.000Z",
+    });
+  });
+
+  it("treats a date-only to bound as the end of that UTC day", () => {
+    expect(normalizeFilter({ from: "2026-07-27", to: "2026-07-27" })).toEqual({
+      from: "2026-07-27T00:00:00.000Z",
+      to: "2026-07-27T23:59:59.999Z",
+    });
+  });
+
+  it("rejects invalid and reversed windows", () => {
+    expect(() => normalizeFilter({ from: "not-a-date" })).toThrow("from must be an ISO");
+    expect(() =>
+      normalizeFilter({
+        from: "2026-07-13T05:00:00.000Z",
+        to: "2026-07-13T04:00:00.000Z",
+      }),
+    ).toThrow("from must not be after to");
+  });
+});

package/templates/.agents/dashboard/modules/operations/src/server/filter.ts

@@ -0,0 +1,17 @@
+import type { ProjectionTimeFilter } from "../contracts.js";
+
+export function normalizeFilter(filter: Partial<ProjectionTimeFilter>): ProjectionTimeFilter {
+  const from = normalizeTimestamp(filter.from ?? null, "from");
+  const to = normalizeTimestamp(filter.to ?? null, "to");
+  if (from !== null && to !== null && from > to) throw new Error("from must not be after to");
+  return { from, to };
+}
+
+function normalizeTimestamp(value: string | null, name: string): string | null {
+  if (value === null || value.length === 0) return null;
+  const timestamp =
+    name === "to" && /^\d{4}-\d{2}-\d{2}$/.test(value) ? `${value}T23:59:59.999Z` : value;
+  const time = Date.parse(timestamp);
+  if (Number.isNaN(time)) throw new Error(`${name} must be an ISO timestamp`);
+  return new Date(time).toISOString();
+}

package/templates/.agents/dashboard/modules/operations/src/server/index.ts

@@ -0,0 +1,2 @@
+export * from "./build-operations-projection.js";
+export * from "./read-task-detail.js";

package/templates/.agents/dashboard/modules/operations/src/server/internal.ts

@@ -0,0 +1,8 @@
+import type { RunCostInputV2 } from "@zaip-ai/costs";
+import type { RunV2Fold } from "@zaip-ai/decisions";
+
+export interface ScopedRun {
+  fold: RunV2Fold;
+  cost: RunCostInputV2;
+  artifactPath: string;
+}