@zaip-ai/cli 3.2.0 → 3.4.0

package/templates/.agents/dashboard/packages/local-runtime/src/active-codex-telemetry.test.ts

@@ -0,0 +1,95 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+
+import { captureActiveCodexTelemetry } from "./active-codex-telemetry.js";
+
+const roots: string[] = [];
+
+afterEach(async () => {
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
+});
+
+describe("active Codex telemetry capture", () => {
+  it("reports an idle capture explicitly instead of treating it as an opaque success", async () => {
+    const root = await runtimeFixture(
+      "process.stdout.write(JSON.stringify({ telemetry: { mode: 'active_exact_session', captured: [] } }, null, 2));\n",
+    );
+
+    await expect(captureActiveCodexTelemetry(root)).resolves.toMatchObject({
+      captured_runs: 0,
+      captured_segments: 0,
+      manifest_state: "initialized",
+      skipped_reason: "no_active_runs",
+      last_capture_at: expect.any(String),
+    });
+  });
+
+  it("returns a typed manifest condition when the lifecycle has not been initialized", async () => {
+    const root = await runtimeFixture(
+      "process.stderr.write('Lifecycle manifest is not initialized'); process.exitCode = 1;\n",
+    );
+
+    await expect(captureActiveCodexTelemetry(root)).resolves.toMatchObject({
+      captured_runs: 0,
+      captured_segments: 0,
+      manifest_state: "missing",
+      skipped_reason: "manifest_uninitialized",
+    });
+  });
+  it("does not accept CLI idle success as proof of initialized lifecycle", async () => {
+    const root = await runtimeFixture(
+      "process.stdout.write(JSON.stringify({ telemetry: { captured: [] } }));",
+    );
+    await rm(join(root, ".agents/records/lifecycle"), { recursive: true });
+    await expect(captureActiveCodexTelemetry(root)).resolves.toMatchObject({
+      manifest_state: "missing",
+      skipped_reason: "manifest_uninitialized",
+    });
+  });
+  it("preserves unavailable segment cardinality for a captured Run", async () => {
+    const root = await runtimeFixture(
+      "process.stdout.write(JSON.stringify({ telemetry: { captured: [{captured:true}] } }, null, 2));",
+    );
+    await expect(captureActiveCodexTelemetry(root)).resolves.toMatchObject({
+      captured_runs: 1,
+      captured_segments: null,
+      skipped_reason: null,
+    });
+  });
+  it("rejects malformed successful command output", async () => {
+    const root = await runtimeFixture(
+      "process.stdout.write(JSON.stringify({ error: 'unavailable' }));",
+    );
+    await expect(captureActiveCodexTelemetry(root)).rejects.toThrow("Invalid capture telemetry");
+  });
+});
+
+async function runtimeFixture(script: string): Promise<string> {
+  const root = await mkdtemp(join(tmpdir(), "zaip-active-telemetry-"));
+  roots.push(root);
+  const runtime = join(root, ".agents", "runtime", "bin");
+  await mkdir(runtime, { recursive: true });
+  await writeFile(join(runtime, "zaip.mjs"), script, "utf8");
+  if (!script.includes("not initialized")) {
+    const lifecycle = join(root, ".agents/records/lifecycle");
+    await mkdir(lifecycle, { recursive: true });
+    await writeFile(
+      join(lifecycle, "manifest.json"),
+      JSON.stringify({ schema_version: 1, updated_at: "2026-09-16T00:00:00Z", offsets: {} }),
+    );
+    await writeFile(
+      join(lifecycle, "summary.json"),
+      JSON.stringify({
+        schema_version: 1,
+        updated_at: "2026-09-16T00:00:00Z",
+        counts: { total: 0, by_kind: {}, by_status: {} },
+        freshness: {},
+        usage: {},
+        periods: {},
+      }),
+    );
+  }
+  return root;
+}

package/templates/.agents/dashboard/packages/local-runtime/src/active-codex-telemetry.ts

@@ -1,25 +1,115 @@
 import { execFile } from "node:child_process";
 import { resolve } from "node:path";
 import { promisify } from "node:util";
+import { WorkspaceFileSystem } from "@zaip-ai/core";
+import { lifecycleManifestState } from "./server-lifecycle-diagnostics.js";
 
 const execFileAsync = promisify(execFile);
 
+export type ActiveCodexTelemetryCapture = {
+  captured_runs: number;
+  /** The active CLI reports whether a Run changed, not its segment cardinality. */
+  captured_segments: number | null;
+  manifest_state: "initialized" | "missing" | "invalid";
+  skipped_reason:
+    | "manifest_uninitialized"
+    | "manifest_invalid"
+    | "no_active_runs"
+    | "no_new_segments"
+    | null;
+  last_capture_at: string;
+};
+
 /**
  * Captures only active Runs whose persisted Codex correlation names a concrete
  * turn. The CLI reuses source segment and loop keys as its durable cursor;
  * this never reconciles or changes a Run lifecycle.
  */
-export async function captureActiveCodexTelemetry(workspaceRoot: string): Promise<void> {
+export async function captureActiveCodexTelemetry(
+  workspaceRoot: string,
+): Promise<ActiveCodexTelemetryCapture> {
+  // The CLI intentionally treats an absent active-work index as an empty pass.
+  // Validate the canonical manifest first so that exit 0 cannot mask missing lifecycle.
+  const manifestState = await lifecycleManifestState(new WorkspaceFileSystem(workspaceRoot));
+  if (manifestState !== "initialized")
+    return {
+      captured_runs: 0,
+      captured_segments: 0,
+      manifest_state: manifestState,
+      skipped_reason: manifestState === "missing" ? "manifest_uninitialized" : "manifest_invalid",
+      last_capture_at: new Date().toISOString(),
+    };
   const cliPath = resolve(workspaceRoot, ".agents", "runtime", "bin", "zaip.mjs");
-  await execFileAsync(
-    process.execPath,
-    [cliPath, "run", "usage", "--active", "--limit", "1", "--disable-codex-raw", "--json"],
-    {
-      cwd: workspaceRoot,
-      encoding: "utf8",
-      windowsHide: true,
-      timeout: 55_000,
-      maxBuffer: 1_024 * 1_024,
-    },
-  );
+  try {
+    const outcome = await execFileAsync(
+      process.execPath,
+      [cliPath, "run", "usage", "--active", "--limit", "1", "--disable-codex-raw", "--json"],
+      {
+        cwd: workspaceRoot,
+        encoding: "utf8",
+        windowsHide: true,
+        timeout: 55_000,
+        maxBuffer: 1_024 * 1_024,
+      },
+    );
+    const payload = parseJsonResult(outcome.stdout);
+    const captured = readCaptured(payload);
+    const capturedRuns = captured.filter((item) => item.captured).length;
+    return {
+      captured_runs: capturedRuns,
+      // Zero is factual for an idle pass. A non-idle pass has no segment count
+      // in the CLI contract, so retain unavailable rather than inventing one.
+      captured_segments: capturedRuns === 0 ? 0 : null,
+      manifest_state: "initialized",
+      skipped_reason:
+        captured.length === 0 ? "no_active_runs" : capturedRuns === 0 ? "no_new_segments" : null,
+      last_capture_at: new Date().toISOString(),
+    };
+  } catch (error) {
+    if (isManifestUninitialized(error)) {
+      return {
+        captured_runs: 0,
+        captured_segments: 0,
+        manifest_state: "missing",
+        skipped_reason: "manifest_uninitialized",
+        last_capture_at: new Date().toISOString(),
+      };
+    }
+    throw error;
+  }
+}
+
+function parseJsonResult(stdout: string): unknown {
+  if (!stdout.trim()) throw new Error("Active telemetry capture returned no JSON result");
+  try {
+    return JSON.parse(stdout.trim()) as unknown;
+  } catch {
+    throw new Error("Active telemetry capture returned invalid JSON");
+  }
+}
+
+function readCaptured(payload: unknown): Array<{ captured: boolean }> {
+  if (typeof payload !== "object" || payload === null) throw new Error("Invalid capture payload");
+  const telemetry = (payload as { telemetry?: unknown }).telemetry;
+  if (typeof telemetry !== "object" || telemetry === null)
+    throw new Error("Invalid capture telemetry");
+  const captured = (telemetry as { captured?: unknown }).captured;
+  if (!Array.isArray(captured)) throw new Error("Invalid capture entries");
+  return captured.map((item) => {
+    if (
+      typeof item !== "object" ||
+      item === null ||
+      typeof (item as { captured?: unknown }).captured !== "boolean"
+    )
+      throw new Error("Invalid capture entry");
+    return { captured: (item as { captured: boolean }).captured };
+  });
+}
+
+function isManifestUninitialized(error: unknown): boolean {
+  const details =
+    error instanceof Error
+      ? `${error.message}\n${"stdout" in error ? String(error.stdout ?? "") : ""}\n${"stderr" in error ? String(error.stderr ?? "") : ""}`
+      : String(error);
+  return details.includes("Lifecycle manifest is not initialized");
 }

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { boardPage } from "./server-board.js";
+import { boardPage, boardStage } from "./server-board.js";
 
 describe("boardPage", () => {
   it("returns only the bounded entity page without Run-derived enrichment", () => {
@@ -126,6 +126,80 @@ describe("boardPage", () => {
     expect(page.total).toBe(2);
     expect(page.tasks.map((task) => task.id)).toEqual([linked.id, standalone.id]);
   });
+
+  it.each([
+    ["definition", "PRD-1"],
+    ["planning", "SPEC-1"],
+    ["ready", "TASK-READY"],
+    ["executing", "TASK-EXECUTING"],
+    ["verifying", "TASK-VERIFYING"],
+    ["completed", "TASK-COMPLETED"],
+    ["blocked", "TASK-BLOCKED"],
+    ["cancelled", "TASK-CANCELLED"],
+    ["failed", "TASK-FAILED"],
+  ] as const)("keeps the %s status page discriminated by canonical work state", (stage, id) => {
+    const tasks = [
+      "ready",
+      "executing",
+      "verifying",
+      "completed",
+      "blocked",
+      "cancelled",
+      "failed",
+    ].map((status) => ({
+      id: `TASK-${status.toUpperCase()}`,
+      title: status,
+      status: status === "ready" ? "planned" : status,
+      spec_id: "SPEC-1",
+      updated_at: "2026-09-16T10:00:00.000Z",
+    }));
+    const projection = {
+      changes: [],
+      tasks,
+      prds: [{ ...macro("PRD-1", "prd", []), lifecycle_status: "draft" }],
+      specs: [{ ...macro("SPEC-1", "spec", []), lifecycle_status: "draft" }],
+    } as unknown as Parameters<typeof boardPage>[0];
+    const page = boardPage(projection, boardStage(stage), 0, 10, [], {
+      query: "",
+      status: "",
+      risk: "",
+      origin: "",
+      kind: "",
+    });
+    const returnedIds = [...page.prds, ...page.specs, ...page.tasks].map((row) => row.id);
+    expect(returnedIds).toEqual([id]);
+  });
+
+  it.each([
+    ["prd", "draft", "definition"],
+    ["spec", "draft", "planning"],
+    ["prd", "ready", "ready"],
+    ["spec", "active", "executing"],
+    ["prd", "verifying", "verifying"],
+    ["spec", "delivered", "completed"],
+    ["prd", "blocked", "blocked"],
+    ["spec", "cancelled", "cancelled"],
+    ["prd", "failed", "failed"],
+  ] as const)("uses the canonical %s %s status on its %s board page", (kind, lifecycleStatus, stage) => {
+    const macroRow = {
+      ...macro(`${kind.toUpperCase()}-1`, kind, []),
+      lifecycle_status: lifecycleStatus,
+    };
+    const projection = {
+      changes: [],
+      tasks: [],
+      prds: kind === "prd" ? [macroRow] : [],
+      specs: kind === "spec" ? [macroRow] : [],
+    } as unknown as Parameters<typeof boardPage>[0];
+    const page = boardPage(projection, boardStage(stage), 0, 10, [], {
+      query: "",
+      status: "",
+      risk: "",
+      origin: "",
+      kind: "",
+    });
+    expect([...page.prds, ...page.specs].map((row) => row.id)).toEqual([macroRow.id]);
+  });
 });
 
 function macro(id: string, kind: "prd" | "spec", taskIds: string[]) {

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

@@ -34,6 +34,7 @@ export function registerCostsRoutes(app: Hono, dependencies: DashboardRouteConte
         const aggregateStartedAt = performance.now();
         const [source, rate] = await Promise.all([
           firstFoldCostSource(filesystem, {
+            query: context.req.query("query") ?? "",
             from,
             to,
             providers: queryValues(context, "provider"),
@@ -46,6 +47,15 @@ export function registerCostsRoutes(app: Hono, dependencies: DashboardRouteConte
             prds: queryValues(context, "prd"),
             executions: queryValues(context, "execution"),
             changes: queryValues(context, "change"),
+            priorities: queryValues(context, "priority"),
+            risks: queryValues(context, "risk"),
+            origins: queryValues(context, "origin"),
+            workTypes: [
+              ...new Set([
+                ...queryValues(context, "workType"),
+                ...queryValues(context, "work_type"),
+              ]),
+            ],
           }),
           currency === "BRL" ? readCurrentFxRate(filesystem) : Promise.resolve(null),
         ]);

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

@@ -0,0 +1,50 @@
+import type { WorkspaceFileSystem } from "@zaip-ai/core";
+
+export type LifecycleManifestState = "initialized" | "missing" | "invalid";
+const record = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+const timestamp = (value: unknown) =>
+  typeof value === "string" && Number.isFinite(Date.parse(value));
+
+/** Read lifecycle health from canonical records, never from the SQLite snapshot. */
+export async function lifecycleManifestState(
+  filesystem: WorkspaceFileSystem,
+): Promise<LifecycleManifestState> {
+  const root = ".agents/records/lifecycle";
+  const [manifestExists, summaryExists] = await Promise.all([
+    filesystem.exists(`${root}/manifest.json`),
+    filesystem.exists(`${root}/summary.json`),
+  ]);
+  if (!manifestExists && !summaryExists) return "missing";
+  if (!manifestExists || !summaryExists) return "invalid";
+  try {
+    const [manifest, summary] = await Promise.all([
+      filesystem.readText(`${root}/manifest.json`).then((value) => JSON.parse(value) as unknown),
+      filesystem.readText(`${root}/summary.json`).then((value) => JSON.parse(value) as unknown),
+    ]);
+    if (
+      !record(manifest) ||
+      manifest.schema_version !== 1 ||
+      !timestamp(manifest.updated_at) ||
+      !record(manifest.offsets) ||
+      !Object.values(manifest.offsets).every(
+        (value) => Number.isSafeInteger(value) && Number(value) >= 0,
+      ) ||
+      !record(summary) ||
+      summary.schema_version !== 1 ||
+      !timestamp(summary.updated_at) ||
+      !record(summary.counts) ||
+      !Number.isSafeInteger(summary.counts.total) ||
+      Number(summary.counts.total) < 0 ||
+      !record(summary.counts.by_kind) ||
+      !record(summary.counts.by_status) ||
+      !record(summary.freshness) ||
+      !record(summary.usage) ||
+      !record(summary.periods)
+    )
+      return "invalid";
+    return "initialized";
+  } catch {
+    return "invalid";
+  }
+}

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

@@ -0,0 +1,165 @@
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { expect, it, vi } from "vitest";
+import { createDashboardApp } from "./server.js";
+import { requireV2Layout } from "./server-http-contracts.js";
+import { buildFirstFoldQuickProjection } from "./server-read-projections.js";
+import { rebuildSqliteReadModel, SqliteReadModelFileSystem } from "./sqlite-read-model.js";
+
+it("keeps draft and ready SPEC/PRD cards, stages and classification consistent in compact and full responses", async () => {
+  const parent = resolve(import.meta.dirname, "../../../../../../.local/sqlite/tests");
+  await mkdir(parent, { recursive: true });
+  const root = await mkdtemp(join(parent, "macro-population-"));
+  let filesystem: SqliteReadModelFileSystem | undefined;
+  try {
+    await mkdir(join(root, ".agents/config"), { recursive: true });
+    await writeFile(
+      join(root, ".agents/config/project.yaml"),
+      "schema_version: 1\nzaip:\n  enabled: true\nproject:\n  id: macro-test\n  name: macro-test\n  timezone: UTC\nstack:\n  id: zaip-aios-stack\n  overrides: {}\nclients:\n  codex: true\n  claude: true\ntracking:\n  enabled: true\n  currency: BRL\n  storage_mode: tracked_sanitized\n",
+    );
+    await writeFile(
+      join(root, ".agents/config/framework.lock.yaml"),
+      "lock_version: 1\nframework:\n  version: 3.4.0\n  distribution_sha256: null\nlayout:\n  version: 3\nresolved_profile:\n  id: null\n  sha256: null\nmanaged_files: {}\n",
+    );
+    const record = async (kind: string, id: string, status: string, extra = "") => {
+      const directory = join(root, ".agents/records", kind, "2026/09");
+      await mkdir(directory, { recursive: true });
+      await writeFile(
+        join(directory, id + ".md"),
+        `---\nid: ${id}\ntitle: ${id}\nstatus: ${status}\ncreated_at: 2026-09-01T12:00:00.000Z\n${extra}---\n`,
+      );
+    };
+    for (const state of ["draft", "ready", "active", "active-completed"]) {
+      await record(
+        "specs",
+        "SPEC-MACRO",
+        state.startsWith("active") ? "active" : state,
+        "prd_id: PRD-MACRO\n",
+      );
+      await record("prds", "PRD-MACRO", state.startsWith("active") ? "active" : state);
+      if (state === "ready" || state.startsWith("active")) {
+        await record(
+          "tasks",
+          "TASK-MACRO",
+          state === "active-completed"
+            ? "completed"
+            : state.startsWith("active")
+              ? "verifying"
+              : "planned",
+          "change_id: CHG-MACRO\nrisk: standard\n",
+        );
+        const changes = join(root, ".agents/records/changes/2026/09/CHG-MACRO");
+        await mkdir(changes, { recursive: true });
+        await writeFile(
+          join(changes, "change.md"),
+          "---\nid: CHG-MACRO\ntitle: Macro delivery\nstatus: planned\ncreated_at: 2026-09-01T12:00:00.000Z\nsource:\n  type: spec\n  spec_id: SPEC-MACRO\ntask_ids: [TASK-MACRO]\n---\n",
+        );
+      }
+      await rebuildSqliteReadModel(root);
+      filesystem = new SqliteReadModelFileSystem(root);
+      const app = createDashboardApp(root, "fixture-only", undefined, {
+        filesystem,
+        watchSources: false,
+      });
+      const fullRead = vi.spyOn(filesystem, "firstFoldAllTime");
+      const entityRead = vi.spyOn(filesystem, "canonicalWorkPage");
+      const compact = await buildFirstFoldQuickProjection(
+        filesystem,
+        await requireV2Layout(filesystem),
+        { from: null, to: null },
+      );
+      expect(compact.summary.overview_metrics?.macro_metrics?.specs.status_counts).toMatchObject({
+        [state.startsWith("active") ? "verifying" : state === "ready" ? "ready" : "planning"]: 1,
+      });
+      expect(fullRead).not.toHaveBeenCalled();
+      expect(entityRead).not.toHaveBeenCalled();
+      for (const query of [
+        "scope=quick",
+        "scope=overview",
+        "scope=quick&from=2026-09-01&to=2026-09-30",
+      ]) {
+        const response = await app.request("/api/v2/operations?" + query, {
+          headers: { "x-zaip-session": "fixture-only" },
+        });
+        expect(response.status, await response.clone().text()).toBe(200);
+        const data = (await response.json()) as any;
+        const overview = data.summary.overview_metrics;
+        expect(overview.spec_count).toBe(1);
+        expect(overview.prd_count).toBe(1);
+        expect(overview.task_count).toBe(state === "draft" ? 0 : 1);
+        for (const [kind, draftStage] of [
+          ["specs", "planning"],
+          ["prds", "definition"],
+        ] as const) {
+          const metric = overview.macro_metrics[kind];
+          expect(metric.entity_count).toBe(1);
+          expect(metric.status_counts).toMatchObject({
+            [state.startsWith("active") ? "verifying" : state === "ready" ? "ready" : draftStage]:
+              1,
+          });
+          expect(metric.classification_counts).toMatchObject({
+            [state === "draft" ? "empty" : "structured"]: 1,
+          });
+          for (const counts of [metric.status_counts, metric.classification_counts]) {
+            expect(
+              Object.values(counts).reduce((sum: number, value) => sum + Number(value), 0),
+            ).toBe(1);
+          }
+          expect(metric.total_tokens).toBeNull();
+          expect(metric.total_cost_brl).toBeNull();
+        }
+        if (query === "scope=quick") {
+          expect(data.tasks).toEqual([]);
+        }
+      }
+      const boardResponse = await app.request(
+        "/api/v2/operations?scope=board&stage=" +
+          (state.startsWith("active") ? "verifying" : state === "ready" ? "ready" : "planning"),
+        { headers: { "x-zaip-session": "fixture-only" } },
+      );
+      expect(boardResponse.status).toBe(200);
+      const board = (await boardResponse.json()) as any;
+      expect(board.specs[0]).toMatchObject({
+        task_count: state === "draft" ? 0 : 1,
+        task_ids: state === "draft" ? [] : ["TASK-MACRO"],
+      });
+      if (state === "ready" || state.startsWith("active")) {
+        expect(board.prds[0]).toMatchObject({ task_count: 1, task_ids: ["TASK-MACRO"] });
+        if (state !== "active-completed")
+          expect(board.tasks[0]).toMatchObject({ spec_id: "SPEC-MACRO", origin: "spec" });
+        for (const kind of ["spec", "prd"]) {
+          const response = await app.request(
+            "/api/v2/operations?scope=classification&kind=" + kind + "&classification=structured",
+            { headers: { "x-zaip-session": "fixture-only" } },
+          );
+          const classified = (await response.json()) as any;
+          expect(classified.total).toBe(1);
+        }
+      }
+      const stage = state.startsWith("active")
+        ? "verifying"
+        : state === "ready"
+          ? "ready"
+          : "planning";
+      const listResponse = await app.request(
+        "/api/v2/sqlite-views?view=operations_work_list&status=" + stage,
+        { headers: { "x-zaip-session": "fixture-only" } },
+      );
+      expect(listResponse.status).toBe(200);
+      const list = (await listResponse.json()) as any;
+      expect(list.rows.some((row: any) => row.id === "SPEC-MACRO" && row.stage === stage)).toBe(
+        true,
+      );
+      if (state.startsWith("active"))
+        expect(
+          list.rows.some((row: any) => row.id === "PRD-MACRO" && row.stage === "verifying"),
+        ).toBe(true);
+      filesystem.close();
+      filesystem = undefined;
+    }
+  } finally {
+    vi.restoreAllMocks();
+    filesystem?.close();
+    await rm(root, { recursive: true, force: true });
+  }
+});

package/templates/.agents/dashboard/packages/local-runtime/src/server-operations-page-filters.ts

@@ -0,0 +1,65 @@
+import type { Context } from "hono";
+import type { OperationsCompactRun } from "./server-operations-pages.js";
+
+interface OperationsPageFilterValues {
+  query: string;
+  status: string;
+  risk: string;
+}
+
+export function operationsPageFilters(context: Context): OperationsPageFilterValues {
+  return {
+    query: (context.req.query("query") ?? "").trim().toLocaleLowerCase(),
+    status: (context.req.query("status") ?? "").trim(),
+    risk: (context.req.query("risk") ?? "").trim(),
+  };
+}
+
+export function filterOperationsMetricRows(
+  rows: readonly OperationsCompactRun[],
+  filters: OperationsPageFilterValues,
+): OperationsCompactRun[] {
+  return rows.filter((row) => {
+    if (filters.status && row.status !== filters.status) return false;
+    if (!filters.query) return true;
+    return [
+      row.id,
+      row.task_id,
+      row.execution_id,
+      row.conversation_id,
+      row.parent_run_id,
+      row.run_kind,
+      row.phase,
+      row.agent,
+    ].some(
+      (value) => typeof value === "string" && value.toLocaleLowerCase().includes(filters.query),
+    );
+  });
+}
+
+export function filterLifecyclePageRows(
+  rows: readonly Record<string, unknown>[],
+  filters: OperationsPageFilterValues,
+): Record<string, unknown>[] {
+  return rows.filter((row) => {
+    if (filters.status && row.status !== filters.status) return false;
+    if (filters.risk && row.risk !== filters.risk) return false;
+    if (!filters.query) return true;
+    return [
+      row.id,
+      row.title,
+      row.status,
+      row.risk,
+      row.source,
+      row.origin,
+      row.scope_type,
+      row.scope_id,
+    ]
+      .flatMap((value) =>
+        typeof value === "object" && value !== null ? Object.values(value) : [value],
+      )
+      .some(
+        (value) => typeof value === "string" && value.toLocaleLowerCase().includes(filters.query),
+      );
+  });
+}