@zaip-ai/cli 1.0.7 → 1.3.0

package/templates/.agents/dashboard/packages/local-runtime/scripts/test-sqlite-read-model.mjs

@@ -0,0 +1,589 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, rm, utimes, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { join, resolve } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { fixture } from "./source-size-runtime-scripts/sqlite-read-model-fixture.mjs";
+
+const root = resolve(import.meta.dirname, "../../../../..");
+const sqliteTestTempRoot = resolve(root, ".tmp", "sqlite-read-model-tests");
+async function createSqliteTestDirectory(prefix) {
+  await mkdir(sqliteTestTempRoot, { recursive: true });
+  return mkdtemp(join(sqliteTestTempRoot, prefix));
+}
+const require = createRequire(resolve(root, "package.json"));
+const { build } = require("esbuild");
+
+/** Bundle only the read-model entry: importing server.cjs constructs the default
+ * app and opens the canonical DB, which makes a second rebuild EBUSY on Windows. */
+async function loadReadModelRuntime() {
+  const directory = await createSqliteTestDirectory("bundle-");
+  const outfile = join(directory, "sqlite-read-model.cjs");
+  await build({
+    entryPoints: [
+      resolve(root, ".agents/dashboard/packages/local-runtime/src/sqlite-read-model.ts"),
+    ],
+    outfile,
+    bundle: true,
+    platform: "node",
+    format: "cjs",
+    target: "node22",
+    alias: {
+      "@zaip-ai/core": resolve(root, "packages/core/src/index.ts"),
+      "@zaip-ai/costs": resolve(root, "packages/costs/src/index.ts"),
+    },
+  });
+  return { runtime: require(outfile), directory };
+}
+
+async function loadCostAdapterRuntime() {
+  const directory = await createSqliteTestDirectory("adapter-");
+  const outfile = join(directory, "sqlite-cost-adapters.cjs");
+  await build({
+    entryPoints: [resolve(root, ".agents/dashboard/apps/frontend/src/sqlite-cost-adapters.ts")],
+    outfile,
+    bundle: true,
+    platform: "node",
+    format: "cjs",
+    target: "node22",
+  });
+  return { runtime: require(outfile), directory };
+}
+
+async function verify(runtime, rootPath, intervals) {
+  await runtime.rebuildSqliteReadModel(rootPath);
+  const filesystem = new runtime.SqliteReadModelFileSystem(rootPath);
+  try {
+    for (const [from, to] of intervals) {
+      const aggregate = filesystem.firstFoldAggregate({ from, to });
+      if (rootPath.includes("zaip-dashboard-sqlite-parity-") && from === null && to === null)
+        assert.deepEqual(aggregate, {
+          days: 4,
+          total_run_count: 5,
+          agent_invocation_count: 3,
+          llm_call_count: 6,
+          duration_ms: 600,
+          total_tokens: 45,
+          cost_brl: 30,
+          execution_day_count: 3,
+        });
+    }
+    if (rootPath.includes("zaip-dashboard-sqlite-parity-")) {
+      const database = new DatabaseSync(process.env.ZAIP_SQLITE_DB_PATH, { readOnly: true });
+      try {
+        const schema = runtime.validateSqliteReadModelSchema(process.env.ZAIP_SQLITE_DB_PATH);
+        assert.deepEqual(schema, {
+          schemaVersion: "59",
+          tableCount: 5,
+          viewCount: 107,
+          indexCount: 15,
+        });
+        const objects = new Map(
+          database
+            .prepare("SELECT name, type FROM sqlite_master WHERE type IN ('table', 'view')")
+            .all()
+            .map((row) => [row.name, row.type]),
+        );
+        const names = new Set(objects.keys());
+        for (const name of [
+          "zaip_aios_activities",
+          "agent_runs",
+          "root_runs",
+          "sub_runs",
+          "overview",
+          "overview_daily",
+          "overview_monthly",
+          "overview_annual",
+          "task_summary",
+          "task_summary_daily",
+          "spec_summary",
+          "spec_summary_daily",
+          "prd_summary",
+          "prd_summary_daily",
+          "task_status_daily",
+          "task_risk_daily",
+          "tasks",
+          "specs",
+          "prds",
+          "executions",
+          "conversations",
+          "decisions",
+          "changes",
+          "work_items",
+          "cost_monitor_group_daily",
+          "cost_monitor_daily",
+          "cost_monitor_agent_invocations",
+          "operations_work_list",
+          "operations_agent_invocations",
+          "first_fold_overview",
+          "first_fold_task",
+          "first_fold_spec",
+          "first_fold_prd",
+        ])
+          assert.ok(
+            name === "zaip_aios_activities" ? names.has(name) : names.has(`zaip_vw_${name}`),
+            `missing ${name}`,
+          );
+        assert.equal(names.has("zaip_vw_sub_runs"), true);
+        for (const name of [
+          "canonical_artifacts",
+          "invocations",
+          "invocation_usage",
+          "work_items",
+          "daily_aggregate_cache",
+          "daily_aggregates",
+          "overview",
+          "overview_daily",
+          "overview_monthly",
+          "overview_annual",
+          "operations_overview",
+          "cost_monitor_overview",
+          "cost_monitor_group_daily_cache",
+          "cost_monitor_group_daily",
+          "task_summary",
+          "spec_summary",
+          "prd_summary",
+        ])
+          assert.equal(objects.get(`zaip_vw_${name}`), "view", `${name} must be a prefixed view`);
+        assert.equal(
+          [...objects.entries()].filter(
+            ([name, type]) => type === "view" && !name.startsWith("zaip_vw_"),
+          ).length,
+          0,
+          "all persisted views must use zaip_vw_",
+        );
+        assert.equal(
+          [...objects.entries()].filter(
+            ([name, type]) => type === "view" && name.startsWith("zaip_vw_vw_"),
+          ).length,
+          0,
+          "view prefix must not be duplicated",
+        );
+        assert.deepEqual(
+          [...objects.entries()]
+            .filter(([, type]) => type === "table")
+            .map(([name]) => name)
+            .sort(),
+          [
+            "cost_invocation_dimension_facts",
+            "zaip_aios_activities",
+            "zaip_dim_llm_model",
+            "zaip_dim_provider",
+            "zaip_dim_zaip_agent",
+          ],
+        );
+        const fact = database
+          .prepare(
+            "SELECT activity_source_kind, agent_run_role, llm_call_count, provider, model, zaip_agent_persona, zaip_agent_job FROM zaip_aios_activities WHERE agent_run_id = ?",
+          )
+          .get("AINV-edge");
+        assert.deepEqual(
+          { ...fact },
+          {
+            activity_source_kind: "agent_run",
+            agent_run_role: "root",
+            llm_call_count: 2,
+            provider: "openai",
+            model: "mixed",
+            zaip_agent_persona: "ana",
+            zaip_agent_job: "quality_engineer",
+          },
+        );
+        assert.equal(
+          database
+            .prepare(
+              "SELECT COUNT(*) AS count FROM zaip_aios_activities WHERE payload_type IS NULL",
+            )
+            .get().count,
+          3,
+        );
+        assert.equal(
+          database
+            .prepare(
+              "SELECT COUNT(*) AS count FROM zaip_aios_activities WHERE payload_type IS NULL AND total_tokens IS NULL",
+            )
+            .get().count,
+          0,
+        );
+        assert.equal(
+          database
+            .prepare(
+              "SELECT value FROM zaip_vw_read_model_metadata WHERE key='canonical_run_count'",
+            )
+            .get().value,
+          "5",
+        );
+        assert.equal(
+          database
+            .prepare(
+              "SELECT value FROM zaip_vw_read_model_metadata WHERE key='unassisted_activity_count'",
+            )
+            .get().value,
+          "0",
+        );
+        assert.equal(
+          database
+            .prepare(
+              "SELECT value FROM zaip_vw_read_model_metadata WHERE key='excluded_unknown_token_run_count'",
+            )
+            .get().value,
+          "2",
+        );
+        assert.equal(
+          database
+            .prepare(
+              "SELECT COUNT(*) AS count FROM zaip_vw_files WHERE path LIKE '.agents/records/lifecycle/%'",
+            )
+            .get().count,
+          0,
+        );
+        assert.equal(
+          database
+            .prepare("SELECT llm_call_count FROM zaip_vw_daily_aggregates WHERE day = ?")
+            .get("2026-07-31").llm_call_count,
+          2,
+        );
+        assert.equal(
+          database
+            .prepare(
+              "SELECT llm_call_count FROM zaip_vw_overview WHERE period_kind = 'month' AND period_key = '2026-08'",
+            )
+            .get().llm_call_count,
+          4,
+        );
+        const dictionary = await readFile(
+          join(root, ".agents/dashboard/DATA-DICTIONARY.md"),
+          "utf8",
+        );
+        const headings = [...dictionary.matchAll(/^### `([^`]+)`\r?$/gm)];
+        const sections = new Map(
+          headings.map((heading, index) => [
+            heading[1],
+            dictionary.slice(
+              heading.index,
+              index + 1 < headings.length ? headings[index + 1].index : dictionary.length,
+            ),
+          ]),
+        );
+        for (const { name, type } of database
+          .prepare(
+            "SELECT name, type FROM sqlite_master WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%'",
+          )
+          .all()) {
+          const section = sections.get(
+            name.startsWith("zaip_vw_") ? name.slice("zaip_vw_".length) : name,
+          );
+          assert.ok(section, `DATA-DICTIONARY.md must document ${type} ${name}`);
+        }
+      } finally {
+        database.close();
+      }
+      assert.equal(
+        filesystem.invocationTotals({ from: "2026-07-31T00:00:00Z", to: "2026-07-31T23:59:59Z" })
+          .invocation_count,
+        1,
+      );
+      assert.equal(
+        filesystem.invocationCostRows({
+          from: "2026-07-31",
+          to: "2026-07-31",
+          providers: ["openai"],
+        }).length,
+        1,
+      );
+      const row = filesystem.invocationCostRows({ from: "2026-07-31", to: "2026-07-31" })[0];
+      assert.equal(row.provider, "mixed");
+      assert.equal(row.model, "mixed");
+      assert.equal(row.input_tokens, 7);
+      assert.equal(row.cached_input_tokens, 1);
+      assert.equal(row.output_tokens, 3);
+      assert.equal(row.reasoning_tokens, 4);
+      assert.equal(row.total_tokens, 15);
+      assert.equal(row.cost_brl, 10);
+      assert.equal(
+        filesystem
+          .invocationCostRows({ from: "2026-08-15", to: "2026-08-15" })
+          .find((value) => value.agent_invocation_id === "AINV-unavailable"),
+        undefined,
+      );
+      const augustMonthly = filesystem.viewPage("cost_monitor_monthly", {
+        from: "2026-08-11",
+        to: "2026-08-31",
+      });
+      assert.equal(augustMonthly.total_count, 1);
+      assert.equal(augustMonthly.rows[0].period_key, "2026-08");
+      assert.equal(augustMonthly.rows[0].invocation_count, 1);
+      assert.equal(augustMonthly.rows[0].total_duration, 300);
+      assert.equal(augustMonthly.rows[0].total_tokens, 15);
+      assert.equal(augustMonthly.rows[0].total_cost_brl, 10);
+      const augustAnnual = filesystem.viewPage("cost_monitor_annual", {
+        from: "2026-08-11",
+        to: "2026-08-31",
+      });
+      assert.equal(augustAnnual.total_count, 1);
+      assert.equal(augustAnnual.rows[0].period_key, "2026");
+      assert.equal(augustAnnual.rows[0].invocation_count, 1);
+      assert.equal(augustAnnual.rows[0].total_duration, 300);
+      assert.equal(augustAnnual.rows[0].total_tokens, 15);
+      assert.equal(augustAnnual.rows[0].total_cost_brl, 10);
+      // This fixture spans the Sao Paulo months 2026-07 and 2026-08.
+      const monthly2026 = filesystem
+        .viewPage("cost_monitor_monthly", { limit: 50, offset: 0 })
+        .rows.filter((row) => String(row.key ?? row.period_key).startsWith("2026-"));
+      const annual2026 = filesystem.viewPage("cost_monitor_annual", { limit: 50, offset: 0 });
+      assert.equal(monthly2026.length >= 2, true);
+      assert.equal(annual2026.total_count, 1);
+      assert.equal(annual2026.rows[0].key ?? annual2026.rows[0].period_key, "2026");
+      for (const metric of [
+        "prd_count",
+        "spec_count",
+        "task_count",
+        "validation_count",
+        "evidence_count",
+        "total_run_count",
+        "total_duration",
+        "total_tokens",
+        "total_cost_usd",
+        "total_cost_brl",
+      ]) {
+        const sum = monthly2026.reduce((total, row) => total + Number(row[metric] ?? 0), 0);
+        assert.equal(
+          Number(annual2026.rows[0][metric] ?? 0),
+          sum,
+          `annual ${metric} must equal the monthly sum`,
+        );
+      }
+      const completedAugust = filesystem.viewPage("cost_monitor_monthly", {
+        from: "2026-08-11",
+        to: "2026-08-31",
+        status: "completed",
+      });
+      assert.equal(completedAugust.total_count, 1);
+      assert.equal(completedAugust.rows[0].invocation_count, 1);
+      assert.equal(completedAugust.rows[0].total_duration, 300);
+      const failedAugust = filesystem.viewPage("cost_monitor_monthly", {
+        from: "2026-08-11",
+        to: "2026-08-31",
+        status: "failed",
+        agent: "agent-b",
+        phase: "conversation",
+      });
+      assert.equal(failedAugust.total_count, 1);
+      assert.equal(failedAugust.rows[0].invocation_count, 0);
+      assert.equal(failedAugust.rows[0].total_run_count, 0);
+      assert.equal(failedAugust.rows[0].total_duration, null);
+      const filteredAnnual = filesystem.viewPage("cost_monitor_annual", {
+        from: "2026-08-11",
+        to: "2026-08-31",
+        query: "AINV-aug-inside",
+        provider: "openai",
+        model: "a",
+        agent: "agent-a",
+        phase: "execution",
+        status: "completed",
+      });
+      assert.equal(filteredAnnual.total_count, 1);
+      assert.equal(filteredAnnual.rows[0].invocation_count, 1);
+      assert.equal(filteredAnnual.rows[0].total_duration, 300);
+      const filteredCalls = filesystem.viewPage("cost_monitor_agent_invocations", {
+        from: "2026-07-31",
+        to: "2026-07-31",
+        query: "edge",
+        agent: "agent-a",
+        phase: "execution",
+        status: "completed",
+      });
+      assert.equal(filteredCalls.total_count, 1);
+      assert.equal(filteredCalls.rows[0].agent_invocation_id, "AINV-edge");
+      assert.equal(
+        filesystem.viewPage("cost_monitor_agent_invocations", {
+          from: "2026-07-31",
+          to: "2026-07-31",
+          status: "failed",
+        }).total_count,
+        0,
+      );
+      const operationCalls = filesystem.viewPage("operations_agent_invocations", {
+        query: "edge",
+        status: "completed",
+        agent: "agent-a",
+        phase: "execution",
+      });
+      assert.equal(operationCalls.total_count, 1);
+      const operationExecutions = filesystem.viewPage("operations_executions", {
+        query: "EXEC-a",
+        status: "completed",
+      });
+      assert.equal(operationExecutions.total_count, 1);
+      assert.equal(
+        filesystem.viewPage("operations_changes", { query: "edge", status: "active" }).total_count,
+        0,
+      );
+      assert.equal(
+        filesystem.viewPage("operations_decisions", { query: "edge", status: "accepted" })
+          .total_count,
+        0,
+      );
+      assert.equal(
+        filesystem.viewPage("cost_monitor_monthly", {
+          from: "2026-08-11",
+          to: "2026-08-31",
+          query: "AINV-unavailable",
+        }).total_count,
+        0,
+      );
+      for (const groupedView of ["cost_monitor_providers", "cost_monitor_models"]) {
+        const grouped = filesystem.viewPage(groupedView, {
+          from: "2026-07-31",
+          to: "2026-07-31",
+          provider: "openai",
+          model: "a",
+          agent: "agent-a",
+          phase: "execution",
+          status: "completed",
+          limit: 50,
+        });
+        const mixed = grouped.rows.find((row) => row.key === "mixed");
+        assert.ok(mixed);
+        assert.equal(mixed.total_duration, 100);
+      }
+      const agentGroups = filesystem.viewPage("cost_monitor_zaip_agents", {
+        from: "2026-07-31",
+        to: "2026-07-31",
+        provider: "openai",
+        model: "a",
+        phase: "execution",
+        status: "completed",
+      });
+      assert.equal(agentGroups.total_count, 1);
+      assert.equal(agentGroups.rows[0].key, "agent-a");
+      assert.equal(agentGroups.rows[0].invocation_count, 1);
+      const overview = filesystem.overviewPage("day", 0, 50);
+      assert.equal(overview.total, 4);
+      assert.equal(
+        overview.rows.reduce((count, value) => count + Number(value.invocation_count), 0),
+        3,
+      );
+      for (const view of Object.keys(runtime.sqliteViewMetadata))
+        assert.ok(filesystem.viewPage(view, { limit: 1 }).rows.length <= 1, `view page ${view}`);
+      assert.equal(filesystem.viewPage("first_fold_top_tasks", {}).limit, 5);
+      assert.equal(filesystem.viewPage("cost_monitor_agent_invocations", {}).limit, 100);
+      const planDatabase = new DatabaseSync(process.env.ZAIP_SQLITE_DB_PATH, { readOnly: true });
+      try {
+        const plan = planDatabase
+          .prepare(
+            "EXPLAIN QUERY PLAN SELECT agent_run_id FROM zaip_aios_activities WHERE activity_source_kind=? AND occurred_day_sp>=? AND occurred_day_sp<=?",
+          )
+          .all("agent_run", "2026-07-31", "2026-08-31");
+        assert.match(plan.map((value) => value.detail).join(" "), /zaip_activities_agent_run/);
+      } finally {
+        planDatabase.close();
+      }
+    }
+  } finally {
+    try {
+      filesystem.close();
+    } catch {
+      /* fixture may already be closed */
+    }
+  }
+}
+
+const canonicalDb = process.env.ZAIP_SQLITE_DB_PATH;
+const runtimeBundle = await loadReadModelRuntime();
+const adapterBundle = await loadCostAdapterRuntime();
+const canonicalTestDirectory = await createSqliteTestDirectory("canonical-");
+try {
+  assert.equal(
+    adapterBundle.runtime.costGroupDuration({ cost_monitor_total_duration: null }),
+    null,
+  );
+  assert.equal(
+    adapterBundle.runtime.costGroupDuration({
+      total_duration: null,
+      cost_monitor_total_duration: 999,
+    }),
+    null,
+  );
+  assert.deepEqual(adapterBundle.runtime.legacyKnownMetric(null), {
+    known_sum: 0,
+    unknown: 1,
+    complete: false,
+    coverage_ratio: 0,
+  });
+  assert.deepEqual(adapterBundle.runtime.legacyKnownMetric(0), {
+    known_sum: 0,
+    unknown: 0,
+    complete: true,
+    coverage_ratio: 1,
+  });
+  process.env.ZAIP_SQLITE_DB_PATH = join(canonicalTestDirectory, "read-model.sqlite");
+  await verify(runtimeBundle.runtime, root, [[null, null]]);
+  const liveDatabase = new DatabaseSync(process.env.ZAIP_SQLITE_DB_PATH, { readOnly: true });
+  try {
+    const daily = liveDatabase
+      .prepare(
+        "SELECT day, total_duration FROM zaip_vw_daily_aggregates WHERE day IN ('2026-07-22', '2026-07-23') ORDER BY day",
+      )
+      .all();
+    const byDay = new Map(daily.map((row) => [row.day, row.total_duration]));
+    assert.ok(
+      (byDay.get("2026-07-22") ?? 0) >= 100 * 60_000,
+      "2026-07-22 must retain roughly 103 measurable minutes",
+    );
+    assert.ok(
+      (byDay.get("2026-07-22") ?? 0) <= 106 * 60_000,
+      "2026-07-22 must not exceed its reconciled interval union",
+    );
+    assert.ok(
+      (byDay.get("2026-07-23") ?? 0) >= 61 * 60_000,
+      "2026-07-23 must retain at least 61 measurable minutes",
+    );
+    assert.equal(
+      liveDatabase
+        .prepare(
+          "SELECT COUNT(*) AS count FROM zaip_vw_daily_aggregates WHERE total_duration > 86400000",
+        )
+        .get().count,
+      0,
+      "daily duration must not exceed 24 hours",
+    );
+    process.stdout.write(`SQLite live daily durations: ${JSON.stringify(daily)}\n`);
+  } finally {
+    liveDatabase.close();
+  }
+  const temp = await fixture(createSqliteTestDirectory);
+  try {
+    process.env.ZAIP_SQLITE_DB_PATH = join(temp, ".local/dashboard-sqlite/read-model.sqlite");
+    const nested = join(temp, ".agents/records/tasks/nested/task.md");
+    await mkdir(resolve(nested, ".."), { recursive: true });
+    await writeFile(nested, "# before\n");
+    await runtimeBundle.runtime.rebuildSqliteReadModel(temp);
+    await writeFile(nested, "# after\n");
+    const changedAt = new Date(Date.now() + 2_000);
+    await utimes(nested, changedAt, changedAt);
+    await runtimeBundle.runtime.rebuildSqliteReadModel(temp);
+    const changed = new runtimeBundle.runtime.SqliteReadModelFileSystem(temp);
+    try {
+      assert.match(await changed.readText(".agents/records/tasks/nested/task.md"), /after/);
+    } finally {
+      changed.close();
+    }
+    await verify(runtimeBundle.runtime, temp, [
+      [null, null],
+      ["2026-08-15", "2026-08-15"],
+      ["2026-08-16", "2026-08-16"],
+    ]);
+  } finally {
+    await rm(temp, { recursive: true, force: true });
+  }
+  process.stdout.write(
+    "SQLite daily aggregate parity passed: canonical all-time/ranges plus known-zero and all-unknown/null fixture.\n",
+  );
+} finally {
+  await rm(runtimeBundle.directory, { recursive: true, force: true });
+  await rm(adapterBundle.directory, { recursive: true, force: true });
+  await rm(canonicalTestDirectory, { recursive: true, force: true });
+  if (canonicalDb === undefined) delete process.env.ZAIP_SQLITE_DB_PATH;
+  else process.env.ZAIP_SQLITE_DB_PATH = canonicalDb;
+}

package/templates/.agents/dashboard/packages/local-runtime/scripts/test-unix-launchers.mjs

@@ -0,0 +1,53 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+
+const workspaceRoot = resolve(import.meta.dirname, "../../../../..");
+const launchers = [
+  ".agents/dashboard/zaip-dashboard-linux.sh",
+  ".agents/dashboard/zaip-dashboard-mac.command",
+];
+
+const stagedModes = new Map(
+  execFileSync("git", ["ls-files", "--stage", "--", ...launchers], {
+    cwd: workspaceRoot,
+    encoding: "utf8",
+  })
+    .trim()
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      const [mode, , , path] = line.split(/\s+/, 4);
+      return [path, mode];
+    }),
+);
+
+for (const launcher of launchers) {
+  const source = await readFile(resolve(workspaceRoot, launcher), "utf8");
+  assert.ok(source.startsWith("#!/usr/bin/env sh"), `${launcher} must be a POSIX shell launcher`);
+  assert.equal(stagedModes.get(launcher), "100755", `${launcher} must be versioned as executable`);
+}
+
+const linuxLauncher = await readFile(resolve(workspaceRoot, launchers[0]), "utf8");
+assert.match(linuxLauncher, /command -v node/, "Linux launcher must resolve Node from PATH");
+assert.match(linuxLauncher, /ZAIP_NODE/, "Linux launcher must allow an explicit Node executable");
+assert.match(
+  linuxLauncher,
+  /Node\.js 22 ou superior/,
+  "Linux launcher must report an actionable Node version failure",
+);
+assert.match(linuxLauncher, /node:sqlite/, "Linux launcher must verify node:sqlite");
+assert.match(
+  linuxLauncher,
+  /exec "\$node_bin" "\$runtime" "\$@"/,
+  "Linux launcher must preserve arguments and runtime exit code",
+);
+
+const macLauncher = await readFile(resolve(workspaceRoot, launchers[1]), "utf8");
+assert.match(
+  macLauncher,
+  /exec .*zaip-dashboard-linux\.sh.*"\$@"/,
+  "macOS launcher must delegate and preserve arguments/exit code",
+);
+process.stdout.write("Unix dashboard launcher contract passed.\n");