@zaip-ai/cli 1.3.7 → 1.4.1

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

@@ -163,6 +163,54 @@ describe("project settings persistence", () => {
     expect(architecture).toContain("- TypeScript");
   });
 
+  it("persists observability and on-demand testing components without requiring local detection", async () => {
+    const { filesystem } = await fixtureProject();
+    const current = await readProjectSettings(filesystem);
+    await filesystem.writeTextAtomic(
+      PROJECT_CONFIG_PATH,
+      serializeYaml({
+        ...current,
+        stack: {
+          ...current.stack,
+          overrides: { ...current.stack.overrides, components: { future_tool: { enabled: true } } },
+        },
+      }),
+    );
+    const updated = await persistProjectSettings(filesystem, {
+      ...current,
+      stack: {
+        ...current.stack,
+        overrides: {
+          components: {
+            prometheus: {
+              name: "Prometheus",
+              version: "3.6.0",
+              reference: "docker:prom/prometheus",
+            },
+            grafana: {
+              name: "Grafana",
+              version: "",
+              reference: "docker:grafana/grafana",
+            },
+            k6: { name: "k6", version: "1.1.0", reference: "docker:grafana/k6" },
+            autocannon: { name: "autocannon", version: "", reference: "npm:autocannon" },
+          },
+        },
+      },
+    });
+
+    expect(updated.stack.overrides.components).toMatchObject({
+      prometheus: { name: "Prometheus", version: "3.6.0" },
+      grafana: { name: "Grafana", version: "" },
+      k6: { name: "k6", version: "1.1.0" },
+      autocannon: { name: "autocannon", version: "" },
+      future_tool: { enabled: true },
+    });
+    await expect(filesystem.readText(SOFTWARE_ARCHITECTURE_PATH)).resolves.toContain(
+      "| Coleta de métricas | Prometheus | 3.6.0 | docker:prom/prometheus |",
+    );
+  });
+
   it("rejects invalid settings before touching the project file", async () => {
     const { configPath, filesystem } = await fixtureProject();
     const original = await readFile(configPath, "utf8");
@@ -359,7 +407,7 @@ describe("project settings persistence", () => {
         expect.objectContaining({ id: "skills", value: 2 }),
         expect.objectContaining({ id: "rules", value: 2 }),
         expect.objectContaining({ id: "hooks", value: 3 }),
-        expect.objectContaining({ id: "database", value: "Ativo" }),
+        expect.objectContaining({ id: "database", value: "Inativo" }),
       ],
       stack_components: [
         expect.objectContaining({
@@ -375,6 +423,11 @@ describe("project settings persistence", () => {
         expect.objectContaining({ name: "BullMQ", verification: "unavailable" }),
         expect.objectContaining({ name: "Hono", verification: "unavailable" }),
         expect.objectContaining({ name: "React", verification: "unavailable" }),
+        expect.objectContaining({ name: "Git", configured_version: "latest" }),
+        expect.objectContaining({
+          name: "Terraform",
+          configured_version: "1.16.1",
+        }),
       ],
       areas: expect.arrayContaining([
         expect.objectContaining({
@@ -424,4 +477,193 @@ describe("project settings persistence", () => {
       "growth_strategy",
     ]);
   });
+
+  it("reports the project-local installed version separately from configured stack versions", async () => {
+    const { filesystem } = await fixtureProject();
+    const current = await readProjectSettings(filesystem);
+    await filesystem.writeTextAtomic(
+      PROJECT_CONFIG_PATH,
+      serializeYaml({
+        ...current,
+        stack: {
+          ...current.stack,
+          overrides: {
+            ...current.stack.overrides,
+            components: { backend_api: { name: "Hono", version: "4.12.34" } },
+          },
+        },
+      }),
+    );
+    await filesystem.writeTextAtomic(
+      ".agents/dashboard/stack-dependencies.json",
+      JSON.stringify({
+        schema_version: 1,
+        node: "22.16.0",
+        packages: [
+          { name: "typescript", version: "7.0.2", development: true },
+          { name: "redis", version: "6.2.1", development: false },
+          { name: "hono", version: "4.12.33", development: false },
+        ],
+      }),
+    );
+    await mkdir(join(filesystem.root, "node_modules", "hono"), { recursive: true });
+    await writeFile(
+      join(filesystem.root, "node_modules", "hono", "package.json"),
+      JSON.stringify({ name: "hono", version: "4.12.35", main: "index.js" }),
+      "utf8",
+    );
+    await writeFile(
+      join(filesystem.root, "node_modules", "hono", "index.js"),
+      "export {};",
+      "utf8",
+    );
+
+    const overview = await readProjectOverview(filesystem);
+
+    expect(overview.stack_components).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          name: "Hono",
+          version: "4.12.35",
+          configured_version: "4.12.34",
+          source: "node_modules/hono/package.json",
+          installation: "installed",
+          verification: "exact",
+        }),
+        expect.objectContaining({
+          name: "TypeScript",
+          version: null,
+          configured_version: "7.0.2",
+          installation: "missing",
+          verification: "unavailable",
+        }),
+        expect.objectContaining({
+          name: "Redis",
+          version: null,
+          configured_version: "6.2.1",
+          installation: "missing",
+          verification: "unavailable",
+        }),
+      ]),
+    );
+  });
+
+  it("only reports Hono and React as bundled when their dashboard artifacts exist", async () => {
+    const { filesystem } = await fixtureProject();
+    await filesystem.writeTextAtomic(
+      ".agents/dashboard/stack-dependencies.json",
+      JSON.stringify({
+        schema_version: 1,
+        node: "22.16.0",
+        packages: [
+          { name: "hono", version: "4.12.34", development: false },
+          { name: "react", version: "19.2.7", development: false },
+        ],
+      }),
+    );
+    const absent = await readProjectOverview(filesystem);
+    expect(absent.stack_components).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ name: "Hono", installation: "missing", version: null }),
+        expect.objectContaining({ name: "React", installation: "missing", version: null }),
+      ]),
+    );
+
+    await filesystem.writeTextAtomic(
+      ".agents/dashboard/packages/local-runtime/server.mjs",
+      "/* bundled runtime */",
+    );
+    await filesystem.writeTextAtomic(
+      ".agents/dashboard/apps/frontend/dist/assets/index.js",
+      "/* bundled frontend */",
+    );
+    const bundled = await readProjectOverview(filesystem);
+    expect(bundled.stack_components).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          name: "Hono",
+          version: null,
+          configured_version: "4.12.34",
+          installation: "bundled",
+          verification: "unavailable",
+          source: ".agents/dashboard/packages/local-runtime/server.mjs",
+        }),
+        expect.objectContaining({
+          name: "React",
+          version: null,
+          configured_version: "19.2.7",
+          installation: "bundled",
+          verification: "unavailable",
+          source: ".agents/dashboard/apps/frontend/dist",
+        }),
+      ]),
+    );
+  });
+
+  it("reads pnpm workspace manifests and validates their entrypoints", async () => {
+    const { filesystem } = await fixtureProject();
+    for (const [name, version, directory] of [
+      ["hono", "4.12.35", ".agents/dashboard/packages/local-runtime/node_modules/hono"],
+      ["react", "19.2.6", ".agents/dashboard/apps/frontend/node_modules/react"],
+    ]) {
+      await filesystem.writeTextAtomic(
+        `${directory}/package.json`,
+        JSON.stringify({ name, version, main: "index.js" }),
+      );
+      await filesystem.writeTextAtomic(`${directory}/index.js`, "export {};");
+      const overview = await readProjectOverview(filesystem);
+      expect(
+        overview.stack_components.find((item) => item.name.toLowerCase() === name),
+      ).toMatchObject({
+        version,
+        source: `${directory}/package.json`,
+        verification: "exact",
+        installation: "installed",
+      });
+      await filesystem.writeTextAtomic(
+        `${directory}/package.json`,
+        JSON.stringify({ name, version, main: "missing.js" }),
+      );
+      const incomplete = await readProjectOverview(filesystem);
+      expect(
+        incomplete.stack_components.find((item) => item.name.toLowerCase() === name),
+      ).toMatchObject({
+        version: null,
+        verification: "unavailable",
+      });
+    }
+  });
+
+  it("does not accept a local package without its matching identity and entrypoint", async () => {
+    const { filesystem } = await fixtureProject();
+    await mkdir(join(filesystem.root, "node_modules", "hono"), { recursive: true });
+    await writeFile(
+      join(filesystem.root, "node_modules", "hono", "package.json"),
+      JSON.stringify({ name: "not-hono", version: "4.12.35", main: "index.js" }),
+      "utf8",
+    );
+    await writeFile(
+      join(filesystem.root, "node_modules", "hono", "index.js"),
+      "export {};",
+      "utf8",
+    );
+
+    const mismatched = await readProjectOverview(filesystem);
+    expect(mismatched.stack_components).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ name: "Hono", installation: "missing", version: null }),
+      ]),
+    );
+
+    await filesystem.writeTextAtomic(
+      "node_modules/hono/package.json",
+      JSON.stringify({ name: "hono", version: "4.12.35", main: "missing.js" }),
+    );
+    const incomplete = await readProjectOverview(filesystem);
+    expect(incomplete.stack_components).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ name: "Hono", installation: "missing", version: null }),
+      ]),
+    );
+  });
 });

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

@@ -1,3 +1,6 @@
+import { execFile } from "node:child_process";
+import { join } from "node:path";
+import { promisify } from "node:util";
 import {
   PROJECT_CONFIG_PATH,
   type ProjectConfig,
@@ -11,7 +14,9 @@ import {
 const AGENT_CATALOG_PATH = ".agents/config/agents/catalog.yaml";
 const CODEX_CONFIG_PATH = ".codex/config.toml";
 const FRAMEWORK_LOCK_PATH = ".agents/config/framework.lock.yaml";
-const SQLITE_READ_MODEL_PATH = ".local/dashboard-sqlite/read-model.sqlite";
+const SQLITE_READ_MODEL_PATH = ".local/sqlite/zaip-aios-dashboard.sqlite";
+const DASHBOARD_STACK_DEPENDENCIES_PATH = ".agents/dashboard/stack-dependencies.json";
+const exec = promisify(execFile);
 export const SOFTWARE_ARCHITECTURE_PATH = ".agents/architecture/software-architecture.md";
 
 export type ProjectOverview = {
@@ -24,8 +29,10 @@ export type ProjectOverview = {
   stack_components: Array<{
     name: string;
     version: string | null;
+    configured_version: string | null;
     source: string | null;
     verification: "exact" | "constraint" | "unavailable";
+    installation: "runtime" | "installed" | "missing" | "bundled";
   }>;
   areas: Array<{
     id:
@@ -142,63 +149,252 @@ async function countCodexHookEvents(filesystem: WorkspaceFileSystem): Promise<nu
 async function readVerifiedStackComponents(
   filesystem: WorkspaceFileSystem,
 ): Promise<ProjectOverview["stack_components"]> {
-  const [rootPackage, dashboardRuntime, dashboardFrontend] = await Promise.all([
-    readPackageJson(filesystem, "package.json"),
-    readPackageJson(filesystem, ".agents/dashboard/packages/local-runtime/package.json"),
-    readPackageJson(filesystem, ".agents/dashboard/apps/frontend/package.json"),
-  ]);
-  return [
-    component("Node.js", process.versions.node, `Runtime observado: ${process.execPath}`, "exact"),
-    component("TypeScript", packageVersion(rootPackage, "typescript"), "package.json", "exact"),
-    component("Vite", packageVersion(rootPackage, "vite"), "package.json", "exact"),
-    component("Astro", packageVersion(rootPackage, "astro"), "package.json", "exact"),
-    component("Redis", packageVersion(rootPackage, "redis"), "package.json", "exact"),
-    component("BullMQ", packageVersion(rootPackage, "bullmq"), "package.json", "exact"),
-    component(
-      "Hono",
-      packageVersion(dashboardRuntime, "hono"),
-      ".agents/dashboard/packages/local-runtime/package.json",
-      "exact",
+  const [project, fallback, bundledRuntime, bundledFrontend, git, terraform] = await Promise.all([
+    readProjectSettings(filesystem),
+    readDashboardStackDependencies(filesystem),
+    hasNonEmptyFile(filesystem, ".agents/dashboard/packages/local-runtime/server.mjs"),
+    hasBundledDashboardFrontend(filesystem),
+    executableComponent(
+      filesystem,
+      "Git",
+      ["--version"],
+      "git",
+      (output) => /^git version (.+)$/m.exec(output.trim())?.[1] ?? null,
     ),
-    component(
-      "React",
-      packageVersion(dashboardFrontend, "react"),
-      ".agents/dashboard/apps/frontend/package.json",
-      "exact",
+    executableComponent(filesystem, "Terraform", ["version", "-json"], "terraform", (output) => {
+      try {
+        const version = JSON.parse(output).terraform_version;
+        return typeof version === "string" ? version : null;
+      } catch {
+        return null;
+      }
+    }),
+  ]);
+  const configured = configuredStackVersions(project, fallback);
+  const packages = await Promise.all(
+    ["typescript", "vite", "astro", "redis", "bullmq", "hono", "react"].map((name) =>
+      readInstalledPackageVersion(filesystem, name),
     ),
+  );
+  const installed = new Map(packages.map((item) => [item.name, item]));
+  return [
+    runtimeComponent("Node.js", process.versions.node, configured.get("node")),
+    packageComponent("TypeScript", "typescript", configured.get("typescript"), installed),
+    packageComponent("Vite", "vite", configured.get("vite"), installed),
+    packageComponent("Astro", "astro", configured.get("astro"), installed),
+    packageComponent("Redis", "redis", configured.get("redis"), installed),
+    packageComponent("BullMQ", "bullmq", configured.get("bullmq"), installed),
+    packageComponent("Hono", "hono", configured.get("hono"), installed, bundledRuntime),
+    packageComponent("React", "react", configured.get("react"), installed, bundledFrontend),
+    git,
+    terraform,
   ];
 }
 
-type PackageJson = {
-  dependencies?: Record<string, string>;
-  devDependencies?: Record<string, string>;
-};
+type InstalledPackage = { name: string; version: string | null; source: string | null };
+type DashboardStackDependencies = { node: string | null; packages: Map<string, string> };
+
+async function readInstalledPackageVersion(
+  filesystem: WorkspaceFileSystem,
+  name: string,
+): Promise<InstalledPackage> {
+  const roots = ["node_modules"];
+  if (name === "hono") roots.push(".agents/dashboard/packages/local-runtime/node_modules");
+  if (name === "react") roots.push(".agents/dashboard/apps/frontend/node_modules");
+  for (const root of roots) {
+    try {
+      const source = `${root}/${name}/package.json`;
+      const value = recordValue(JSON.parse(await filesystem.readText(source)));
+      const version = stringValue(value.version);
+      const entrypoint = packageEntrypoint(value);
+      if (
+        value.name !== name ||
+        version === null ||
+        !/^\d+\.\d+\.\d+(?:-[\w.-]+)?(?:\+[\w.-]+)?$/.test(version) ||
+        entrypoint === null
+      )
+        continue;
+      await filesystem.readText(`${root}/${name}/${entrypoint}`);
+      return { name, version, source };
+    } catch {
+      // A pnpm workspace can install dependencies in the owning package only.
+    }
+  }
+  return { name, version: null, source: null };
+}
 
-async function readPackageJson(
+async function readDashboardStackDependencies(
   filesystem: WorkspaceFileSystem,
-  path: string,
-): Promise<PackageJson> {
+): Promise<DashboardStackDependencies> {
   try {
-    const value = JSON.parse(await filesystem.readText(path)) as unknown;
-    return typeof value === "object" && value !== null ? (value as PackageJson) : {};
+    const source = recordValue(
+      JSON.parse(await filesystem.readText(DASHBOARD_STACK_DEPENDENCIES_PATH)),
+    );
+    const packages = new Map<string, string>();
+    for (const item of Array.isArray(source.packages) ? source.packages : []) {
+      const definition = recordValue(item);
+      const name = stringValue(definition.name);
+      const version = stringValue(definition.version);
+      if (name !== null && version !== null) packages.set(name, version);
+    }
+    return { node: stringValue(source.node), packages };
   } catch {
-    return {};
+    return { node: null, packages: new Map() };
   }
 }
 
-function packageVersion(pkg: PackageJson, name: string): string | null {
-  return pkg.dependencies?.[name] ?? pkg.devDependencies?.[name] ?? null;
+function configuredStackVersions(
+  project: ProjectConfig,
+  fallback: DashboardStackDependencies,
+): Map<string, string> {
+  const components = recordValue(recordValue(project.stack.overrides).components);
+  const configured = new Map(fallback.packages);
+  if (fallback.node !== null) configured.set("node", fallback.node);
+  for (const [component, packageName] of Object.entries({
+    backend_runtime: "node",
+    primary_language: "typescript",
+    web_language: "typescript",
+    web_build: "vite",
+    site_framework: "astro",
+    cache_messaging: "redis",
+    async_queue: "bullmq",
+    backend_api: "hono",
+    web_framework: "react",
+  })) {
+    const version = stringValue(recordValue(components[component]).version);
+    if (version !== null) configured.set(packageName, version);
+  }
+  return configured;
 }
 
-function component(
+async function hasBundledDashboardFrontend(filesystem: WorkspaceFileSystem): Promise<boolean> {
+  try {
+    return (await filesystem.listFiles(".agents/dashboard/apps/frontend/dist", ".js")).length > 0;
+  } catch {
+    return false;
+  }
+}
+
+async function hasNonEmptyFile(filesystem: WorkspaceFileSystem, path: string): Promise<boolean> {
+  try {
+    return (await filesystem.readText(path)).trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+
+async function executableComponent(
+  filesystem: WorkspaceFileSystem,
+  name: string,
+  args: string[],
+  command: "git" | "terraform",
+  parse: (output: string) => string | null,
+): Promise<ProjectOverview["stack_components"][number]> {
+  const project = await readProjectSettings(filesystem);
+  const components = recordValue(recordValue(project.stack.overrides).components);
+  const configuredVersion =
+    command === "git"
+      ? "latest"
+      : (stringValue(recordValue(components.backend_infrastructure).version) ?? "1.16.1");
+  const safeTerraformVersion = /^\d+\.\d+\.\d+$/.test(configuredVersion)
+    ? configuredVersion
+    : "1.16.1";
+  const local =
+    command === "git"
+      ? ".local/git/cmd/git.exe"
+      : `.local/terraform/v${safeTerraformVersion}-${process.platform}-${process.arch}/${
+          process.platform === "win32" ? "terraform.exe" : "terraform"
+        }`;
+  const localPath = join(filesystem.root, local);
+  const executable = (await filesystem.exists(local)) ? localPath : command;
+  try {
+    const version = parse(
+      (await exec(executable, args, { timeout: 10_000, windowsHide: true })).stdout,
+    );
+    if (version === null) throw new Error("unsupported version output");
+    return {
+      name,
+      version,
+      configured_version: configuredVersion,
+      source: executable === command ? `Comando do workspace: ${command}` : local,
+      verification: "exact",
+      installation: executable === command ? "runtime" : "installed",
+    };
+  } catch {
+    return {
+      name,
+      version: null,
+      configured_version: configuredVersion,
+      source: null,
+      verification: "unavailable",
+      installation: "missing",
+    };
+  }
+}
+
+function runtimeComponent(
   name: string,
   version: string | null,
-  source: string,
-  verification: "exact" | "constraint",
+  configuredVersion: string | undefined,
 ): ProjectOverview["stack_components"][number] {
-  return version === null
-    ? { name, version: null, source: null, verification: "unavailable" }
-    : { name, version, source, verification };
+  return {
+    name,
+    version,
+    configured_version: configuredVersion ?? null,
+    source: `Runtime do Dashboard: ${process.execPath}`,
+    verification: "exact",
+    installation: "runtime",
+  };
+}
+
+function packageComponent(
+  name: string,
+  packageName: string,
+  configuredVersion: string | undefined,
+  installed: ReadonlyMap<string, InstalledPackage>,
+  bundled = false,
+): ProjectOverview["stack_components"][number] {
+  const actual = installed.get(packageName)?.version ?? null;
+  if (actual !== null)
+    return {
+      name,
+      version: actual,
+      configured_version: configuredVersion ?? null,
+      source: installed.get(packageName)?.source ?? null,
+      verification: "exact",
+      installation: "installed",
+    };
+  if (bundled)
+    return {
+      name,
+      version: null,
+      configured_version: configuredVersion ?? null,
+      source:
+        packageName === "hono"
+          ? ".agents/dashboard/packages/local-runtime/server.mjs"
+          : ".agents/dashboard/apps/frontend/dist",
+      verification: "unavailable",
+      installation: "bundled",
+    };
+  return {
+    name,
+    version: null,
+    configured_version: configuredVersion ?? null,
+    source: null,
+    verification: "unavailable",
+    installation: "missing",
+  };
+}
+
+function stringValue(value: unknown): string | null {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+
+function packageEntrypoint(pkg: Record<string, unknown>): string | null {
+  if (typeof pkg.bin === "string") return pkg.bin;
+  const bin = Object.values(recordValue(pkg.bin)).find((value) => typeof value === "string");
+  if (typeof bin === "string") return bin;
+  return stringValue(pkg.main);
 }
 
 export async function persistProjectSettings(
@@ -211,6 +407,8 @@ export async function persistProjectSettings(
   if (requested.tracking.storage_mode !== "tracked_sanitized") {
     throw new TypeError("This project requires Git-native tracked_sanitized storage.");
   }
+  const currentComponents = recordValue(current.stack.overrides.components);
+  const requestedComponents = recordValue(requested.stack.overrides.components);
   const candidate = parseProjectConfig({
     ...requested,
     clients: current.clients,
@@ -221,6 +419,9 @@ export async function persistProjectSettings(
       overrides: {
         ...current.stack.overrides,
         ...requested.stack.overrides,
+        ...(Object.keys(currentComponents).length > 0 || Object.keys(requestedComponents).length > 0
+          ? { components: { ...currentComponents, ...requestedComponents } }
+          : {}),
       },
     },
   });
@@ -250,6 +451,7 @@ const componentLabels: Record<string, string> = {
   cache_messaging: "Cache e mensageria",
   async_queue: "Filas e processamento assíncrono",
   backend_infrastructure: "Infraestrutura backend",
+  backend_hosting: "Hospedagem do backend",
   web_framework: "Framework do Web App",
   web_language: "Linguagem do Web App",
   web_build: "Build do Web App",
@@ -259,6 +461,14 @@ const componentLabels: Record<string, string> = {
   site_islands: "Componentes interativos",
   site_build: "Build do site",
   site_hosting: "Hospedagem do site",
+  prometheus: "Coleta de métricas",
+  grafana: "Dashboards",
+  uptime_kuma: "Monitoramento de disponibilidade",
+  cadvisor: "Métricas de containers",
+  node_exporter: "Métricas de host",
+  redis_exporter: "Métricas do Redis",
+  k6: "Teste de carga",
+  autocannon: "Teste HTTP de carga",
 };
 
 const architectureLabels: Record<string, string> = {
@@ -266,6 +476,7 @@ const architectureLabels: Record<string, string> = {
   backend_api_and_business_rules: "APIs e regras de negócio",
   backend_async_processing: "Filas e processamento assíncrono",
   backend_infrastructure: "Infraestrutura backend",
+  backend_hosting: "Hospedagem do backend",
 };
 
 export function renderSoftwareArchitecture(config: ProjectConfig): string {

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

@@ -0,0 +1,39 @@
+export const agentPortraitFiles: Record<string, string> = {
+  "agent-orchestrator": "1 - Dave - Product Owner.png",
+  "agent-builder": "2 - Rafa - Tech Lead.png",
+  "agent-task-executor": "3 - Leo - Software Engineer.png",
+  "agent-analyst": "4 - Bia - Product Manager.png",
+  "agent-finalizer": "5 - Gui - Quality Assurance Lead.png",
+  "agent-reviewer": "6 - Nanda - Principal Engineer.png",
+  "agent-integrator": "7 - Dani - Integration Engineer.png",
+  "agent-auditor": "8 - Ana - Quality Auditor.png",
+  "agent-text-summarizer": "9 - Lia - Technical Writer.png",
+  "agent-data-analyst": "10 - Gabi - Data Analyst.png",
+  "agent-refactoring-specialist": "11 - Tati - Refactoring Specialist.png",
+  "agent-frontend": "12 - Doug - Frontend Developer.png",
+  "agent-backend": "13 - Will - Backend Developer.png",
+  "agent-website-developer": "14 - Jonny - Website Developer.png",
+  "agent-designer": "15 - Manu - Product Designer.png",
+  "agent-cloud-engineer": "16 - Dan - Cloud Engineer.png",
+  "agent-security-auditor": "17 - Luis - Security Auditor.png",
+  "agent-marketing-analyst": "18 - Lucia - Marketing Analyst.png",
+};
+
+interface ActiveWorkItem {
+  kind: string;
+  id: string;
+  status: string | null;
+}
+
+export function openWorkIds(items: readonly ActiveWorkItem[]): string[] {
+  const kinds = new Set(["prd", "spec", "change", "task", "execution"]);
+  const statuses = new Set(["active", "executing", "verifying", "running", "paused"]);
+  return items
+    .filter(
+      (item) =>
+        kinds.has(item.kind) &&
+        (statuses.has(item.status ?? "") || (item.kind === "task" && item.status === "planned")),
+    )
+    .map((item) => item.id)
+    .sort();
+}