@zaip-ai/cli 1.0.7 → 1.0.8

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

@@ -0,0 +1,609 @@
+import type { WorkspaceFileSystem, WorkspaceLayout } from "@zaip-ai/core";
+import {
+  type CompactMacroMetric,
+  LifecycleManifestStore,
+  type LifecycleManifestSummary,
+} from "@zaip-ai/lifecycle-manifests";
+import type {
+  OperationsProjection,
+  ProjectionTimeFilter,
+  UsageMetricProjection,
+  UsageProjection,
+} from "../contracts.js";
+import { LEGACY_EFFORT_DAILY_MS, saoPauloPeriodKey } from "../contracts.js";
+import { observedExecutionElapsedMs } from "../duration-population.js";
+import {
+  hybridDailyDuration,
+  normalizeDailyPeriods,
+  rootExecutionDurationByDay,
+} from "./daily-duration-projection.js";
+import { normalizeFilter } from "./filter.js";
+import {
+  aggregateDailyDetails,
+  aggregateOverviewPeriodMetrics,
+  dailyMacroProjection,
+  dailyTaskProjection,
+  dailyTopTasksFromRows,
+  taskCountsFromDailyRows,
+} from "./quick-daily-operations-projection.js";
+
+export type OverviewMetricRun = {
+  id: string;
+  started_at: string;
+  finished_at?: string | null;
+  phase?: string | null;
+  parent_run_id?: string | null;
+  duration_started_at?: string | null;
+  duration_ms: number | null;
+  total_tokens: number | null;
+  cost: number | null;
+};
+
+/** The shared quick/detail Run population: terminal time, then start time. */
+export function aggregateOverviewRunMetrics<T extends OverviewMetricRun>(
+  runs: readonly T[],
+  filter: ProjectionTimeFilter,
+  filterRuns = true,
+) {
+  const deduplicated = [...new Map(runs.map((run) => [run.id, run] as const)).values()];
+  const selected = filterRuns
+    ? deduplicated.filter((run) => inTimeWindow(run.finished_at ?? run.started_at, filter))
+    : deduplicated;
+  const roots = selected.filter((run) => run.phase === "execution" && run.parent_run_id == null);
+  const duration = hybridLegacyDurationMetric(roots, filter);
+  const knownSum = (values: readonly (number | null)[]) => {
+    const known = values.filter((value): value is number => value !== null);
+    // Compact manifests and folded Run records can arrive in different stable
+    // orders. Normalize binary floating-point noise at the metric boundary so
+    // the canonical numeric contract is byte-for-byte identical.
+    return known.length === 0
+      ? null
+      : Math.round(known.reduce((total, value) => total + value, 0) * 1_000_000_000) /
+          1_000_000_000;
+  };
+  const coverage = (values: readonly (number | null)[]) =>
+    values.length === 0 ? 1 : values.filter((value) => value !== null).length / values.length;
+  return {
+    duration_ms:
+      duration === undefined || duration.coverage_ratio === 0 ? null : duration.known_sum,
+    tokens: knownSum(selected.map((run) => run.total_tokens)),
+    cost_brl: knownSum(selected.map((run) => run.cost)),
+    coverage: {
+      duration: duration?.coverage_ratio ?? 1,
+      tokens: coverage(selected.map((run) => run.total_tokens)),
+      cost: coverage(selected.map((run) => run.cost)),
+    },
+    execution_day_count: new Set(
+      roots
+        .map((run) => saoPauloPeriodKey(run.duration_started_at ?? run.started_at, "day"))
+        .filter((day): day is string => day !== null),
+    ).size,
+  };
+}
+
+/**
+ * The legacy snapshot is a complete aggregate, never a synthesized Run.
+ * Coverage therefore describes only the observed root-execution population
+ * after the snapshot cutoff, including roots whose duration is unavailable.
+ */
+export function hybridLegacyDurationMetric<
+  T extends {
+    id: string;
+    started_at: string | null;
+    duration_started_at?: string | null;
+    duration_ms: number | null;
+    phase?: string | null;
+    parent_run_id?: string | null;
+  },
+>(
+  roots: readonly T[],
+  range: ProjectionTimeFilter,
+): { known_sum: number; unknown: number; complete: boolean; coverage_ratio: number } | undefined {
+  const rootsByDay = rootExecutionDurationByDay(roots);
+  const days = new Set([...Object.keys(LEGACY_EFFORT_DAILY_MS), ...rootsByDay.keys()]);
+  const values = [...days]
+    .filter((day) => inDurationDayRange(day, range))
+    .map((day) => hybridDailyDuration(day, { runs: 0 }, rootsByDay.get(day), true).value);
+  if (values.length === 0) return undefined;
+  const unknown = values.reduce((total, value) => total + value.unknown, 0);
+  const known = values.reduce((total, value) => total + value.known_sum, 0);
+  const eligible = [...rootsByDay]
+    .filter(([day]) => inDurationDayRange(day, range))
+    .reduce((total, [, value]) => total + value.population.eligible_runs, 0);
+  const covered = [...rootsByDay]
+    .filter(([day]) => inDurationDayRange(day, range))
+    .reduce((total, [, value]) => total + value.population.known_runs, 0);
+  return {
+    known_sum: known,
+    unknown,
+    complete: unknown === 0,
+    coverage_ratio: eligible === 0 ? 1 : covered / eligible,
+  };
+}
+
+function inDurationDayRange(day: string, range: ProjectionTimeFilter): boolean {
+  return (
+    (range.from === null || day >= range.from.slice(0, 10)) &&
+    (range.to === null || day <= range.to.slice(0, 10))
+  );
+}
+
+export async function buildQuickOperationsProjection(
+  filesystem: WorkspaceFileSystem,
+  layout: WorkspaceLayout,
+  filter: Partial<ProjectionTimeFilter> = {},
+  options: { includeBoardTasks?: boolean } = {},
+): Promise<OperationsProjection> {
+  if (layout.version === 1)
+    throw new Error("Operations projection requires a modern WorkspaceLayout");
+  const manifest = new LifecycleManifestStore(filesystem);
+  const normalizedFilter = normalizeFilter(filter);
+  const [overview, taskModels, specModels, prdModels] = await Promise.all([
+    manifest.readDailyReadModels("overview"),
+    manifest.readDailyReadModels("tasks"),
+    manifest.readDailyReadModels("specs"),
+    manifest.readDailyReadModels("prds"),
+  ]);
+  if (overview === null) throw new Error("Lifecycle daily overview is not initialized");
+  const selectedPeriods = Object.entries(overview.days)
+    .filter(([day]) => inDurationDayRange(day, normalizedFilter))
+    .map(([day, model]) => [day, model.overview] as const);
+  const metrics = aggregateOverviewPeriodMetrics(selectedPeriods, normalizedFilter);
+  const periodCounts = {
+    runs: selectedPeriods.reduce((total, [, period]) => total + period.runs, 0),
+  };
+  const unavailable = emptyUsageMetric();
+  const total = {
+    ...unavailable,
+    tokens: { ...unavailable.tokens, total: metrics.tokens },
+    cost: { ...unavailable.cost, brl: metrics.cost_brl },
+  };
+  const coverage = metrics.coverage;
+  const quickDailyPeriods = normalizeDailyPeriods(selectedPeriods, metrics.duration_ms ?? 0);
+  const tasks = aggregateDailyDetails(taskModels, normalizedFilter);
+  const prdRows = aggregateDailyDetails(prdModels, normalizedFilter);
+  const specRows = aggregateDailyDetails(specModels, normalizedFilter);
+  const taskWindowCounts = taskCountsFromDailyRows(tasks);
+  const statusCounts = taskWindowCounts.statuses;
+  const riskCounts = taskWindowCounts.risks;
+  const tasksBySpec = new Map<string, number>();
+  for (const task of tasks)
+    if (task.parent_id !== null)
+      tasksBySpec.set(task.parent_id, (tasksBySpec.get(task.parent_id) ?? 0) + 1);
+  const specsByPrd = new Map(specRows.map((spec) => [spec.id, spec.parent_id] as const));
+  const prds = prdRows.map((row) =>
+    dailyMacroProjection(
+      row,
+      "prd",
+      tasks.filter((task) => task.parent_id === row.id).length +
+        [...tasksBySpec]
+          .filter(([specId]) => specsByPrd.get(specId) === row.id)
+          .reduce((total, [, count]) => total + count, 0),
+    ),
+  );
+  const specs = specRows.map((row) =>
+    dailyMacroProjection(row, "spec", tasksBySpec.get(row.id) ?? 0),
+  );
+  const topTasks = dailyTopTasksFromRows(tasks);
+  return {
+    schema_version: 2,
+    layout_version: layout.version,
+    readonly: true,
+    source: ".agents/records",
+    filters: normalizedFilter,
+    summary: {
+      prd_count: prds.length,
+      spec_count: specs.length,
+      execution_count: 0,
+      task_count: taskWindowCounts.total,
+      run_count: periodCounts.runs,
+      overview_metrics: {
+        duration_ms: metrics.duration_ms,
+        execution_day_count: metrics.execution_day_count,
+        tokens: metrics.tokens,
+        cost_brl: metrics.cost_brl,
+        prd_count: prds.length,
+        spec_count: specs.length,
+        selected_counts: { prds: prds.length, specs: specs.length },
+        // Count, status, and risk deliberately share taskCountsInWindow.
+        // `period.tasks` remains available in daily rows as tasksCreated,
+        // which has a different time semantic.
+        task_count: taskWindowCounts.total,
+        completed_prd_count: prds.filter((macro) => macro.work_status === "completed").length,
+        completed_spec_count: specs.filter((macro) => macro.work_status === "completed").length,
+        completed_task_count: statusCounts.completed ?? 0,
+        task_status_counts: statusCounts,
+        task_risk_counts: riskCounts,
+        top_tasks: topTasks,
+        latest_task_created_at:
+          tasks
+            .map((task) => task.occurred_at)
+            .sort()
+            .at(-1) ?? null,
+        coverage: {
+          duration: coverage.duration,
+          tokens: coverage.tokens,
+          cost: coverage.cost,
+        },
+        data_source: "lifecycle_manifest_summary",
+        partial: true,
+      },
+      decisions: { human: 0, agent: 0 },
+      source_latest_at: overview.source_latest_at,
+      quality: {
+        completed_tasks: 0,
+        task_completion_rate: 0,
+        terminal_runs: 0,
+        successful_runs: 0,
+        terminal_success_rate: 0,
+        rework_rate: 0,
+      },
+      reconciliation: {
+        phase_tokens_match_total: false,
+        phase_usd_match_total: false,
+        phase_brl_match_total: false,
+        origin_tokens_match_total: false,
+      },
+      usage: usageProjection(unavailable, total),
+      periods: { daily: quickDailyPeriods },
+    },
+    origins: {
+      conversation: usageProjection(unavailable, unavailable),
+      task: usageProjection(unavailable, unavailable),
+      spec: usageProjection(unavailable, unavailable),
+      prd: usageProjection(unavailable, unavailable),
+    },
+    prds,
+    specs,
+    // The quick overview keeps cards out of its first-fold payload.  The
+    // paginated board route opts into compact Task cards from the same daily
+    // read model, without reading execution or telemetry records.
+    tasks: options.includeBoardTasks ? tasks.map(dailyTaskProjection) : [],
+    changes: [],
+    executions: [],
+    runs: [],
+    decisions: [],
+    evidences: [],
+    validations: [],
+  };
+}
+
+export function withExecutionDurations(
+  periods: ReturnType<typeof manifestDailyPeriods>,
+  runs: NonNullable<LifecycleManifestSummary["run_metrics"]>,
+) {
+  return Object.fromEntries(
+    periods.map(([day, period]) => {
+      // `hybridLegacyDurationMetric` splits observed intervals at the Sao
+      // Paulo day boundary and unions overlaps. It also keeps the immutable
+      // pre-cutoff baseline separate from Run attribution.
+      const duration = hybridLegacyDurationMetric(runs.filter(isRootExecutionRun), {
+        from: day,
+        to: day,
+      });
+      return [
+        day,
+        {
+          ...period,
+          ...(duration === undefined ? {} : { duration }),
+        },
+      ];
+    }),
+  );
+}
+
+export function taskCountsInWindow(
+  tasks: readonly {
+    status: string | null;
+    risk: string | null;
+    updated_at: string;
+    finished_at?: string | null;
+    data?: Record<string, unknown> | null;
+  }[],
+  filter: ProjectionTimeFilter,
+): { total: number; statuses: Record<string, number>; risks: Record<string, number> } {
+  const statuses: Record<string, number> = {};
+  const risks: Record<string, number> = {};
+  let total = 0;
+  for (const task of tasks) {
+    const finished =
+      task.finished_at ??
+      (typeof task.data?.finished_at === "string" ? task.data.finished_at : null);
+    const timestamp = finished ?? task.updated_at;
+    if (!inTimeWindow(timestamp, filter)) continue;
+    total += 1;
+    const status = task.status ?? "unclassified";
+    const risk = task.risk ?? "unclassified";
+    statuses[status] = (statuses[status] ?? 0) + 1;
+    risks[risk] = (risks[risk] ?? 0) + 1;
+  }
+  return { total, statuses, risks };
+}
+
+function inTimeWindow(timestamp: string, filter: ProjectionTimeFilter): boolean {
+  const normalized = new Date(timestamp).toISOString();
+  return (
+    (filter.from === null || normalized >= filter.from) &&
+    (filter.to === null || normalized <= filter.to)
+  );
+}
+
+export function aggregateTopTasks(
+  runs: NonNullable<LifecycleManifestSummary["run_metrics"]>,
+  canonicalTaskIds: ReadonlySet<string>,
+): NonNullable<NonNullable<OperationsProjection["summary"]["overview_metrics"]>["top_tasks"]> {
+  const tasks = new Map<
+    string,
+    NonNullable<
+      NonNullable<OperationsProjection["summary"]["overview_metrics"]>["top_tasks"]
+    >[number] & {
+      total_tokens: number;
+      cost_brl: number;
+      runs: NonNullable<LifecycleManifestSummary["run_metrics"]>;
+    }
+  >();
+  for (const run of runs) {
+    if (run.task_id === null || !canonicalTaskIds.has(run.task_id)) continue;
+    const current = tasks.get(run.task_id) ?? {
+      task_id: run.task_id,
+      duration_ms: 0,
+      total_tokens: 0,
+      cost_brl: 0,
+      run_count: 0,
+      runs: [],
+    };
+    // Rankings use observed processing time only. Lifecycle wall-clock time
+    // can overlap across Runs and must remain a distinct diagnostic metric.
+    current.runs.push(run);
+    current.total_tokens += run.total_tokens ?? 0;
+    current.cost_brl += run.cost ?? 0;
+    current.run_count += 1;
+    tasks.set(run.task_id, current);
+  }
+  return [...tasks.values()]
+    .map(({ runs: taskRuns, ...task }) => ({
+      ...task,
+      duration_ms: observedExecutionElapsedMs(taskRuns) ?? 0,
+    }))
+    .sort(
+      (left, right) =>
+        right.duration_ms - left.duration_ms || left.task_id.localeCompare(right.task_id),
+    )
+    .slice(0, 5);
+}
+
+function isRootExecutionRun(
+  run: NonNullable<LifecycleManifestSummary["run_metrics"]>[number],
+): boolean {
+  return run.phase === "execution" && run.parent_run_id == null;
+}
+
+export function manifestDailyPeriods(
+  summary: LifecycleManifestSummary,
+  from: string | null,
+  to: string | null,
+) {
+  const fromDay = from === null ? null : saoPauloPeriodKey(from, "day");
+  const toDay = to === null ? null : saoPauloPeriodKey(to, "day");
+  return Object.entries(finishDayPeriods(summary)).filter(
+    ([day]) => (fromDay === null || day >= fromDay) && (toDay === null || day <= toDay),
+  );
+}
+
+/**
+ * Lifecycle period counters predate the completed-Run calendar contract. When
+ * the compact Run index is complete, re-bucket Run accounting by terminal day
+ * while retaining entity-created counters from the durable period summary.
+ */
+function finishDayPeriods(
+  summary: LifecycleManifestSummary,
+): LifecycleManifestSummary["periods"]["daily"] {
+  const runs = [
+    ...new Map((summary.run_metrics ?? []).map((run) => [run.id, run] as const)).values(),
+  ];
+  const summarizedRuns = Object.values(summary.periods.daily).reduce(
+    (total, period) => total + period.runs,
+    0,
+  );
+  if (runs.length === 0 || runs.length !== summarizedRuns) return summary.periods.daily;
+
+  const byDay = new Map<string, typeof runs>();
+  for (const run of runs) {
+    const day = saoPauloPeriodKey(run.finished_at ?? run.started_at, "day");
+    if (day !== null) byDay.set(day, [...(byDay.get(day) ?? []), run]);
+  }
+  const days = new Set([...Object.keys(summary.periods.daily), ...byDay.keys()]);
+  return Object.fromEntries(
+    [...days].map((day) => {
+      const period = summary.periods.daily[day] ?? emptyManifestPeriod(summary.usage.cost.currency);
+      const dayRuns = byDay.get(day) ?? [];
+      return [
+        day,
+        {
+          ...period,
+          runs: dayRuns.length,
+          usage: {
+            ...period.usage,
+            total_tokens: knownRunMetric(dayRuns.map((run) => run.total_tokens)),
+            cost: {
+              ...knownRunMetric(dayRuns.map((run) => run.cost)),
+              currency: period.usage.cost.currency ?? summary.usage.cost.currency,
+            },
+          },
+          events: knownRunMetric(dayRuns.map((run) => run.events)),
+        },
+      ];
+    }),
+  );
+}
+
+function knownRunMetric(values: readonly (number | null)[]) {
+  const known = values.filter((value): value is number => value !== null);
+  const unknown = values.length - known.length;
+  return {
+    known_sum: known.reduce((total, value) => total + value, 0),
+    unknown,
+    complete: unknown === 0,
+    coverage_ratio: values.length === 0 ? 1 : known.length / values.length,
+  };
+}
+
+function emptyManifestPeriod(
+  currency: string | null,
+): LifecycleManifestSummary["periods"]["daily"][string] {
+  const empty = knownRunMetric([]);
+  return {
+    prds: 0,
+    specs: 0,
+    tasks: 0,
+    validations: 0,
+    evidences: 0,
+    runs: 0,
+    usage: {
+      input_tokens: empty,
+      output_tokens: empty,
+      total_tokens: empty,
+      cost: { ...empty, currency },
+    },
+    events: empty,
+  };
+}
+
+export function summaryTopTasks(
+  summary: LifecycleManifestSummary,
+  filter: ProjectionTimeFilter,
+  canonicalTaskIds: ReadonlySet<string>,
+): NonNullable<NonNullable<OperationsProjection["summary"]["overview_metrics"]>["top_tasks"]> {
+  // A per-day Top 5 is not compositional: a Task that finishes sixth every
+  // day can be first over a selected week. Re-rank the compact Run metrics
+  // after applying the same finished-or-started window as detail projection.
+  return aggregateTopTasks(
+    (summary.run_metrics ?? []).filter((run) =>
+      inTimeWindow(run.finished_at ?? run.started_at, filter),
+    ),
+    canonicalTaskIds,
+  );
+}
+
+export function macroInWindow(macro: CompactMacroMetric, filter: ProjectionTimeFilter): boolean {
+  return inTimeWindow(macro.updated_at, filter);
+}
+
+function availableKnownSum(value: { known_sum: number; unknown: number }): number | null {
+  return value.known_sum === 0 && value.unknown > 0 ? null : value.known_sum;
+}
+
+function compactMacroProjection(metric: CompactMacroMetric): OperationsProjection["prds"][number] {
+  const unavailable = emptyUsageMetric();
+  const total: UsageMetricProjection = {
+    ...unavailable,
+    tokens: { ...unavailable.tokens, total: metric.total_tokens },
+    cost: { ...unavailable.cost, brl: metric.cost },
+  };
+  return {
+    id: metric.id,
+    title: metric.title,
+    created_at: metric.created_at,
+    updated_at: metric.updated_at,
+    kind: metric.kind,
+    parent_id: metric.parent_id,
+    artifact_path: "",
+    lifecycle_status: metric.lifecycle_status,
+    work_status: metric.work_status,
+    execution_ids: [],
+    task_ids: [],
+    planned_tasks: [],
+    canonical_run_ids: metric.canonical_run_ids,
+    run_ids: metric.canonical_run_ids,
+    root_execution_run_ids: metric.root_execution_run_ids,
+    execution_count: 0,
+    task_count: metric.task_count,
+    run_count: metric.run_count,
+    duration_ms: metric.observed_root_duration_ms,
+    observed_root_duration_ms: metric.observed_root_duration_ms,
+    observed_lifecycle_duration_ms: metric.observed_lifecycle_duration_ms,
+    duration_coverage: metric.duration_coverage,
+    duration_provenance: metric.duration_provenance,
+    lifecycle_duration_coverage: metric.lifecycle_duration_coverage,
+    lifecycle_duration_provenance: metric.lifecycle_duration_provenance,
+    decisions: { human: 0, agent: 0 },
+    rework_run_count: metric.rework_run_count,
+    quality: {
+      completed_tasks: 0,
+      task_completion_rate: 0,
+      terminal_runs: 0,
+      successful_runs: 0,
+      terminal_success_rate: 0,
+      rework_rate: metric.run_count === 0 ? 0 : metric.rework_run_count / metric.run_count,
+    },
+    usage: usageProjection(unavailable, total),
+  };
+}
+
+function emptyUsageMetric(): UsageMetricProjection {
+  return {
+    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 },
+  };
+}
+
+function usageProjection(
+  unavailable: UsageMetricProjection,
+  total: UsageMetricProjection,
+): UsageProjection {
+  return {
+    conversation: unavailable,
+    planning: unavailable,
+    execution: unavailable,
+    total,
+    new_work: unavailable,
+    rework: unavailable,
+  };
+}
+
+/** Derive bounded-period coverage from the same dated Runs used by the overview. */
+export function coverageFromRuns(
+  runs: readonly Pick<
+    NonNullable<LifecycleManifestSummary["run_metrics"]>[number],
+    "duration_ms" | "total_tokens" | "cost"
+  >[],
+): { duration: number; tokens: number; cost: number } {
+  const ratio = (known: number) => (runs.length === 0 ? 1 : known / runs.length);
+  return {
+    duration: ratio(runs.filter((run) => run.duration_ms !== null).length),
+    tokens: ratio(runs.filter((run) => run.total_tokens !== null).length),
+    cost: ratio(runs.filter((run) => run.cost !== null).length),
+  };
+}
+
+function aggregateManifestPeriodUsage(
+  summary: LifecycleManifestSummary,
+  from: string | null,
+  to: string | null,
+): LifecycleManifestSummary["usage"] {
+  const periods = manifestDailyPeriods(summary, from, to);
+  const aggregate = (key: keyof LifecycleManifestSummary["usage"]) => {
+    const values = periods.map(([, period]) => period.usage[key]);
+    const runs = periods.reduce((total, [, period]) => total + period.runs, 0);
+    return {
+      known_sum: values.reduce((total, value) => total + value.known_sum, 0),
+      unknown: values.reduce((total, value) => total + value.unknown, 0),
+      complete: values.every((value) => value.complete),
+      coverage_ratio:
+        runs === 0
+          ? 1
+          : periods.reduce(
+              (total, [, period]) => total + period.runs * period.usage[key].coverage_ratio,
+              0,
+            ) / runs,
+    };
+  };
+  return {
+    input_tokens: aggregate("input_tokens"),
+    output_tokens: aggregate("output_tokens"),
+    total_tokens: aggregate("total_tokens"),
+    cost: { ...aggregate("cost"), currency: summary.usage.cost.currency },
+  } as LifecycleManifestSummary["usage"];
+}

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

@@ -19,17 +19,20 @@ export async function readScopedRuns(
   const runs = (
     await mapLimited<string, ScopedRun | null>(paths, 32, async (path) => {
       const fold = foldRunV2Records(parseRunV2JsonLines(await filesystem.readText(path)));
-      const records = fold.records.filter((record) => inWindow(record.occurred_at, filter));
-      if ((filter.from !== null || filter.to !== null) && records.length === 0) return null;
+      // Operations assigns a completed Run to its terminal instant, matching
+      // the compact manifest and the client-side period contract. Once the
+      // Run is selected, retain all of its settled usage rather than slicing
+      // individual capture records into a different population.
+      const periodTimestamp = fold.finished?.occurred_at ?? fold.run.occurred_at;
+      if ((filter.from !== null || filter.to !== null) && !inWindow(periodTimestamp, filter))
+        return null;
       const scoped: ScopedRun = {
         fold,
         artifactPath: path,
         cost: {
           run: fold.run,
-          records,
-          effective_usage_records: fold.effective_usage_records.filter((record) =>
-            inWindow(record.occurred_at, filter),
-          ),
+          records: fold.records,
+          effective_usage_records: fold.effective_usage_records,
         },
       };
       return scoped;
@@ -52,20 +55,16 @@ export async function mapLimited<T, R>(
   return results;
 }
 
-/** Avoid opening every historical Run file for a bounded dashboard period. */
+/**
+ * A Run is filed under its start month but belongs to Operations by terminal
+ * capture when complete. A bounded start-month scan drops start-before,
+ * finish-inside Runs, so detail must inspect the complete Run index before
+ * applying the shared terminal-time predicate. Quick cards remain snapshot
+ * backed and do not pay this cost.
+ */
 export function runSearchRoots(root: string, filter: ProjectionTimeFilter): string[] {
-  if (filter.from === null || filter.to === null) return [root];
-  const months = new Set<string>();
-  const cursor = new Date(filter.from);
-  const end = new Date(filter.to);
-  cursor.setUTCDate(1);
-  while (cursor <= end) {
-    months.add(
-      `${root}/${cursor.getUTCFullYear()}/${String(cursor.getUTCMonth() + 1).padStart(2, "0")}`,
-    );
-    cursor.setUTCMonth(cursor.getUTCMonth() + 1);
-  }
-  return [...months];
+  void filter;
+  return [root];
 }
 
 function inWindow(timestamp: string, filter: ProjectionTimeFilter): boolean {