@cosmicdrift/kumiko-bundled-features 0.390.0 → 0.391.0

package/dist/{user-data-rights/lib → mail-foundation}/mail-transport-resolver.js

@@ -5,8 +5,8 @@
 // the HTTP dispatcher), so the resolver builds a per-tenant accessor from it.
 // Without that bridge createTransportForTenant throws "ctx.config is missing"
 // in the worker lane (the prod-bug class the file-provider resolver already fixed).
-import { createTransportForTenant } from "@cosmicdrift/kumiko-bundled-features/mail-foundation";
-import { createConfigAccessor } from "../../config/index.js";
+import { createConfigAccessor } from "../config/index.js";
+import { createTransportForTenant } from "./feature.js";
 export function makeTenantMailTransportResolver(ctx) {
     return async (tenantId) => {
         if (!ctx.configResolver) {

package/dist/mail-foundation/probe.d.ts

@@ -0,0 +1,2 @@
+import { type FeatureRegistrar } from "@cosmicdrift/kumiko-framework/engine";
+export declare function registerMailProbe(r: FeatureRegistrar<"mail-foundation">): void;

package/dist/mail-foundation/probe.js

@@ -0,0 +1,66 @@
+import { createSystemUser, ProbeFailure, SETTINGS_HUB_FEATURE, } from "@cosmicdrift/kumiko-framework/engine";
+import { UnconfiguredError } from "@cosmicdrift/kumiko-framework/errors";
+import { HostResolutionError } from "@cosmicdrift/kumiko-framework/http";
+import { createConfigAccessor } from "../config/index.js";
+import { tenantMailTransport } from "./feature.js";
+import { MAIL_PROBE_KEYS } from "./i18n.js";
+const PROBE_SUBJECT = "Kumiko system check";
+const PROBE_TEXT = "This message was sent by the system check. No action is needed.";
+const MAIL_SETTINGS_SCREEN_QN = `${SETTINGS_HUB_FEATURE}:screen:mail-foundation-tenant`;
+// The raw error stays in the server log: it can name hosts, users or the recipient.
+function probeFailure(ctx, error, key) {
+    ctx.obs.log.warn("mail probe failed", {
+        error: error instanceof Error ? error.message : String(error),
+    });
+    return new ProbeFailure({ key });
+}
+function transportFailureKey(error) {
+    if (error instanceof HostResolutionError)
+        return MAIL_PROBE_KEYS.hostNotFound;
+    return error instanceof UnconfiguredError
+        ? MAIL_PROBE_KEYS.setupIncomplete
+        : MAIL_PROBE_KEYS.setupFailed;
+}
+// The mail goes to whoever started the check; the address never appears in the stored result.
+export function registerMailProbe(r) {
+    r.probe({
+        name: "send-test-mail",
+        scope: "tenant",
+        cost: "free",
+        area: MAIL_PROBE_KEYS.area,
+        label: MAIL_PROBE_KEYS.label,
+        fixScreen: MAIL_SETTINGS_SCREEN_QN,
+        run: async (ctx) => {
+            const { configResolver, secrets } = ctx.services;
+            if (!configResolver) {
+                return { status: "skipped", message: { key: MAIL_PROBE_KEYS.notConfigured } };
+            }
+            const config = createConfigAccessor(ctx.registry, configResolver, ctx.tenantId, createSystemUser(ctx.tenantId).id, ctx.db);
+            const transport = await tenantMailTransport({
+                tenantId: ctx.tenantId,
+                config,
+                registry: ctx.registry,
+                secrets,
+            }).catch((error) => {
+                throw probeFailure(ctx, error, transportFailureKey(error));
+            });
+            if (transport === null) {
+                return { status: "skipped", message: { key: MAIL_PROBE_KEYS.notConfigured } };
+            }
+            if (ctx.triggeredByEmail === undefined) {
+                return { status: "skipped", message: { key: MAIL_PROBE_KEYS.noRecipient } };
+            }
+            await transport
+                .send({
+                to: ctx.triggeredByEmail,
+                subject: PROBE_SUBJECT,
+                text: PROBE_TEXT,
+                html: `<p>${PROBE_TEXT}</p>`,
+            })
+                .catch((error) => {
+                throw probeFailure(ctx, error, MAIL_PROBE_KEYS.sendRejected);
+            });
+            return { status: "ok", message: { key: MAIL_PROBE_KEYS.accepted } };
+        },
+    });
+}

package/dist/readiness/built-in-probes.d.ts

@@ -0,0 +1,11 @@
+import type { FeatureRegistrar } from "@cosmicdrift/kumiko-framework/engine";
+export declare const BuiltInProbeKeys: {
+    readonly areaInfrastructure: "readiness.area.infrastructure";
+    readonly databaseLabel: "readiness.probe.database.label";
+    readonly databaseOk: "readiness.probe.database.ok";
+    readonly cacheLabel: "readiness.probe.cache.label";
+    readonly cacheOk: "readiness.probe.cache.ok";
+    readonly searchLabel: "readiness.probe.search.label";
+    readonly searchOk: "readiness.probe.search.ok";
+};
+export declare function registerBuiltInProbes(r: FeatureRegistrar<"readiness">): void;

package/dist/readiness/built-in-probes.js

@@ -0,0 +1,55 @@
+import { ProbeTextKeys } from "./constants.js";
+import { probeRunsTable } from "./schema/probe-run.js";
+export const BuiltInProbeKeys = {
+    areaInfrastructure: "readiness.area.infrastructure",
+    databaseLabel: "readiness.probe.database.label",
+    databaseOk: "readiness.probe.database.ok",
+    cacheLabel: "readiness.probe.cache.label",
+    cacheOk: "readiness.probe.cache.ok",
+    searchLabel: "readiness.probe.search.label",
+    searchOk: "readiness.probe.search.ok",
+};
+export function registerBuiltInProbes(r) {
+    r.probe({
+        name: "database",
+        scope: "system",
+        cost: "free",
+        area: BuiltInProbeKeys.areaInfrastructure,
+        label: BuiltInProbeKeys.databaseLabel,
+        run: async (ctx) => {
+            await ctx.db.fetchOne(probeRunsTable, { id: ctx.probeRunId });
+            return { status: "ok", message: { key: BuiltInProbeKeys.databaseOk } };
+        },
+    });
+    r.probe({
+        name: "cache",
+        scope: "system",
+        cost: "free",
+        area: BuiltInProbeKeys.areaInfrastructure,
+        label: BuiltInProbeKeys.cacheLabel,
+        run: async (ctx) => {
+            const { redis } = ctx.services;
+            if (!redis)
+                return { status: "skipped", message: { key: ProbeTextKeys.notConfigured } };
+            const reply = await redis.ping();
+            if (reply !== "PONG")
+                throw new Error(`unexpected PING reply: ${reply}`);
+            return { status: "ok", message: { key: BuiltInProbeKeys.cacheOk } };
+        },
+    });
+    r.probe({
+        name: "search",
+        scope: "system",
+        cost: "free",
+        area: BuiltInProbeKeys.areaInfrastructure,
+        label: BuiltInProbeKeys.searchLabel,
+        run: async (ctx) => {
+            const { searchAdapter } = ctx.services;
+            if (!searchAdapter) {
+                return { status: "skipped", message: { key: ProbeTextKeys.notConfigured } };
+            }
+            await searchAdapter.search(ctx.tenantId, "readiness-probe", { limit: 1 });
+            return { status: "ok", message: { key: BuiltInProbeKeys.searchOk } };
+        },
+    });
+}

package/dist/readiness/collect-probes.d.ts

@@ -0,0 +1,9 @@
+import type { ProbeDefinition, Registry } from "@cosmicdrift/kumiko-framework/engine";
+export type CollectProbesOptions = {
+    readonly includeSystemProbes: boolean;
+    readonly enabledFeatures: ReadonlySet<string> | undefined;
+};
+export declare function collectProbes(registry: Registry, options: CollectProbesOptions): readonly ProbeDefinition[];
+export declare function hasPaidProbes(registry: Registry, options: CollectProbesOptions): boolean;
+export declare function probeTimeoutMs(probe: ProbeDefinition): number;
+export declare function staleRunAfterMs(registry: Registry): number;

package/dist/readiness/collect-probes.js

@@ -0,0 +1,30 @@
+import { DEFAULT_PROBE_TIMEOUT_MS, MIN_STALE_RUN_AFTER_MS, STALE_RUN_TIMEOUT_FACTOR, } from "./constants.js";
+export function collectProbes(registry, options) {
+    const collected = [];
+    for (const feature of registry.features.values()) {
+        if (options.enabledFeatures !== undefined && !options.enabledFeatures.has(feature.name)) {
+            continue;
+        }
+        for (const probe of Object.values(feature.probes ?? {})) {
+            if (probe.scope === "system" && !options.includeSystemProbes)
+                continue;
+            collected.push(probe);
+        }
+    }
+    return collected;
+}
+export function hasPaidProbes(registry, options) {
+    return collectProbes(registry, options).some((probe) => probe.cost === "paid");
+}
+export function probeTimeoutMs(probe) {
+    return probe.timeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
+}
+export function staleRunAfterMs(registry) {
+    let longestTimeoutMs = 0;
+    for (const feature of registry.features.values()) {
+        for (const probe of Object.values(feature.probes ?? {})) {
+            longestTimeoutMs = Math.max(longestTimeoutMs, probeTimeoutMs(probe));
+        }
+    }
+    return Math.max(MIN_STALE_RUN_AFTER_MS, longestTimeoutMs * STALE_RUN_TIMEOUT_FACTOR);
+}

package/dist/readiness/constants.d.ts

@@ -1,4 +1,23 @@
 export declare const READINESS_FEATURE: "readiness";
 export declare const ReadinessQueries: {
     readonly status: "readiness:query:status";
+    readonly latestResults: "readiness:query:probe-run:latest-results";
+    readonly latestSummary: "readiness:query:probe-run:latest-summary";
+    readonly runList: "readiness:query:probe-run:list";
+    readonly runDetail: "readiness:query:probe-run:detail";
+    readonly runResults: "readiness:query:probe-run:results";
+};
+export declare const ReadinessWrites: {
+    readonly runProbes: "readiness:write:run-probes";
+};
+export declare const DEFAULT_PROBE_TIMEOUT_MS = 10000;
+export declare const MIN_STALE_RUN_AFTER_MS: number;
+export declare const STALE_RUN_TIMEOUT_FACTOR = 3;
+export declare const ProbeTextKeys: {
+    readonly paidNotRequested: "readiness.probe.paid-not-requested";
+    readonly noTargets: "readiness.probe.no-targets";
+    readonly timeout: "readiness.probe.timeout";
+    readonly failed: "readiness.probe.failed";
+    readonly runCrashed: "readiness.probe.run-crashed";
+    readonly notConfigured: "readiness.probe.not-configured";
 };

package/dist/readiness/constants.js

@@ -3,4 +3,25 @@ export const READINESS_FEATURE = "readiness";
 // Qualified query handler names (QN format: scope:type:name)
 export const ReadinessQueries = {
     status: "readiness:query:status",
+    latestResults: "readiness:query:probe-run:latest-results",
+    latestSummary: "readiness:query:probe-run:latest-summary",
+    runList: "readiness:query:probe-run:list",
+    runDetail: "readiness:query:probe-run:detail",
+    runResults: "readiness:query:probe-run:results",
+};
+export const ReadinessWrites = {
+    runProbes: "readiness:write:run-probes",
+};
+export const DEFAULT_PROBE_TIMEOUT_MS = 10_000;
+// An active run older than this is treated as dead (worker crash) and may be replaced.
+export const MIN_STALE_RUN_AFTER_MS = 10 * 60_000;
+export const STALE_RUN_TIMEOUT_FACTOR = 3;
+// Translation keys of the runner's own result texts.
+export const ProbeTextKeys = {
+    paidNotRequested: "readiness.probe.paid-not-requested",
+    noTargets: "readiness.probe.no-targets",
+    timeout: "readiness.probe.timeout",
+    failed: "readiness.probe.failed",
+    runCrashed: "readiness.probe.run-crashed",
+    notConfigured: "readiness.probe.not-configured",
 };

package/dist/readiness/execute-probes.d.ts

@@ -0,0 +1,3 @@
+import { type ProbeContext, type ProbeDefinition } from "@cosmicdrift/kumiko-framework/engine";
+import type { ProbeResultRow } from "./schema/probe-run.ts";
+export declare function executeProbes(ctx: ProbeContext, probes: readonly ProbeDefinition[], includePaid: boolean): Promise<readonly ProbeResultRow[]>;

package/dist/readiness/execute-probes.js

@@ -0,0 +1,80 @@
+import { runWithTimeout } from "@cosmicdrift/kumiko-framework/api";
+import { ProbeFailure, } from "@cosmicdrift/kumiko-framework/engine";
+import { probeTimeoutMs } from "./collect-probes.js";
+import { ProbeTextKeys } from "./constants.js";
+function baseRow(probe, target) {
+    return {
+        probe: probe.qualifiedName,
+        scope: probe.scope,
+        area: probe.area,
+        label: target ? target.label : { key: probe.label },
+        ...(target && { targetId: target.id }),
+        ...(target?.ownerUserId !== undefined && { ownerUserId: target.ownerUserId }),
+        ...(probe.fixScreen !== undefined && { fixScreen: probe.fixScreen }),
+    };
+}
+function rowOf(probe, target, outcome) {
+    return { ...baseRow(probe, target), ...outcome };
+}
+// Raw error messages can carry secrets or addresses, so only ProbeFailure texts reach the run.
+function failureText(ctx, probe, failure) {
+    if (failure.timedOut) {
+        return { key: ProbeTextKeys.timeout, params: { seconds: probeTimeoutMs(probe) / 1000 } };
+    }
+    if (failure.error instanceof ProbeFailure)
+        return failure.error.text;
+    ctx.obs.log.warn("readiness probe failed", {
+        probe: probe.qualifiedName,
+        error: failure.error instanceof Error ? failure.error.message : String(failure.error),
+    });
+    return { key: ProbeTextKeys.failed };
+}
+async function runOne(ctx, probe, target) {
+    const result = await runWithTimeout(() => probe.run(ctx, target), probeTimeoutMs(probe));
+    if (result.ok) {
+        // A skipped probe did not run, so its row shows no duration like the runner's own skips.
+        return rowOf(probe, target, {
+            status: result.value.status,
+            durationMs: result.value.status === "skipped" ? null : result.latencyMs,
+            message: result.value.message,
+        });
+    }
+    return rowOf(probe, target, {
+        status: "failed",
+        durationMs: result.latencyMs,
+        message: failureText(ctx, probe, result),
+    });
+}
+function skippedRow(probe, messageKey) {
+    return rowOf(probe, undefined, {
+        status: "skipped",
+        durationMs: null,
+        message: { key: messageKey },
+    });
+}
+async function runProbe(ctx, probe, includePaid) {
+    if (probe.cost === "paid" && !includePaid) {
+        return [skippedRow(probe, ProbeTextKeys.paidNotRequested)];
+    }
+    const { targets } = probe;
+    if (targets === undefined)
+        return [await runOne(ctx, probe, undefined)];
+    const resolved = await runWithTimeout(() => targets(ctx), probeTimeoutMs(probe));
+    if (!resolved.ok) {
+        return [
+            rowOf(probe, undefined, {
+                status: "failed",
+                durationMs: resolved.latencyMs,
+                message: failureText(ctx, probe, resolved),
+            }),
+        ];
+    }
+    const ownTargets = resolved.value.filter((target) => target.ownerUserId === undefined || target.ownerUserId === ctx.triggeredByUserId);
+    if (ownTargets.length === 0)
+        return [skippedRow(probe, ProbeTextKeys.noTargets)];
+    return Promise.all(ownTargets.map((target) => runOne(ctx, probe, target)));
+}
+export async function executeProbes(ctx, probes, includePaid) {
+    const perProbe = await Promise.all(probes.map((probe) => runProbe(ctx, probe, includePaid)));
+    return perProbe.flat();
+}

package/dist/readiness/feature.d.ts

@@ -1,7 +1,20 @@
-export declare function createReadinessFeature(): import("@cosmicdrift/kumiko-types/feature").FeatureDefinition & {
+export interface ReadinessNavOptions {
+    readonly order?: number;
+    readonly parent?: string;
+    readonly workspaces?: readonly string[];
+}
+export interface ReadinessFeatureOptions {
+    readonly nav?: ReadinessNavOptions;
+}
+export declare function createReadinessFeature(options?: ReadinessFeatureOptions): import("@cosmicdrift/kumiko-types/feature").FeatureDefinition & {
     readonly exports: {
         queries: {
             status: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            latestResults: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            latestSummary: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            runList: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            runDetail: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
+            runResults: import("@cosmicdrift/kumiko-types/handlers").HandlerRef;
         };
     };
 };

package/dist/readiness/feature.js

@@ -8,10 +8,25 @@
 // query may roll up missing config + missing required secrets + a single
 // `ready` boolean — the settings-checklist call for admin UIs.
 import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
+import { registerBuiltInProbes } from "./built-in-probes.js";
+import { ReadinessWrites } from "./constants.js";
+import { latestResultsQuery } from "./handlers/latest-results.query.js";
+import { latestSummaryQuery } from "./handlers/latest-summary.query.js";
+import { runDetailQuery } from "./handlers/run-detail.query.js";
+import { runListQuery } from "./handlers/run-list.query.js";
+import { runProbesWrite } from "./handlers/run-probes.write.js";
+import { runResultsQuery } from "./handlers/run-results.query.js";
 import { statusQuery } from "./handlers/status.query.js";
-export function createReadinessFeature() {
+import { READINESS_I18N } from "./i18n.js";
+import { validateProbeTranslations } from "./probe-boot-check.js";
+import { runProbesJob } from "./run-probes-job.js";
+import { probeRunEntity } from "./schema/probe-run.js";
+import { SYSTEM_CHECK_NAV_LABEL, SYSTEM_CHECK_SCREEN_ID, SYSTEM_CHECK_SCREEN_QN, systemCheckRunScreen, systemCheckScreen, } from "./screens.js";
+const DEFAULT_NAV_ORDER = 90;
+export function createReadinessFeature(options = {}) {
+    const { nav } = options;
     return defineFeature("readiness", (r) => {
-        r.describe("One-call tenant-onboarding probe: `readiness:query:status` rolls up every config key and secret declared `required: true` across all mounted features and reports which still lack a usable value for the calling tenant, plus a single `ready` boolean. Provider-features under an `r.extensionSelector`-declared extension point count only while their provider is the selected one — a tenant on the inmemory mail transport is not blocked by unset SMTP keys. Mount it (together with `config` and `secrets`) when an admin UI needs a settings checklist before the first mail-send or file-write; the per-concern lists stay available via `config:query:readiness` and `secrets:query:list`.");
+        r.describe("One-call tenant-onboarding probe: `readiness:query:status` rolls up every config key and secret declared `required: true` across all mounted features and reports which still lack a usable value for the calling tenant, plus a single `ready` boolean. Provider-features under an `r.extensionSelector`-declared extension point count only while their provider is the selected one — a tenant on the inmemory mail transport is not blocked by unset SMTP keys. Mount it (together with `config` and `secrets`) when an admin UI needs a settings checklist before the first mail-send or file-write; the per-concern lists stay available via `config:query:readiness` and `secrets:query:list`. `readiness:write:run-probes` runs the live probes features register with `r.probe` (mail, files, mailboxes, PDF service and more) as a job; the system-check screen shows the latest run and the history once `nav` is passed.");
         r.uiHints({
             displayLabel: "Readiness · Onboarding Probe",
             category: "operations",
@@ -19,9 +34,57 @@ export function createReadinessFeature() {
         });
         r.requires({ features: ["config"] });
         r.requires({ features: ["secrets"] });
+        r.optionalRequires("user");
+        r.adoptsBundledLists();
+        r.translations({ keys: READINESS_I18N });
+        r.entity({ name: "probe-run", ...probeRunEntity });
+        r.writeHandler(runProbesWrite);
+        r.job({
+            name: "run-probes",
+            trigger: { on: ReadinessWrites.runProbes },
+            runIn: "worker",
+            retries: 0,
+            escapeHatch: {
+                reason: "looks up the run starter's address via the system-only user auth lookup",
+                grants: ["systemIdentity"],
+            },
+            // Inline so the feature-AST reader can parse the job; the logic lives in run-probes-job.ts.
+            handler: (payload, ctx) => runProbesJob(payload, ctx),
+        });
+        registerBuiltInProbes(r);
+        r.bootCheck(({ features }) => validateProbeTranslations(features));
+        r.screen(systemCheckScreen(nav === undefined));
+        r.screen(systemCheckRunScreen);
+        if (nav !== undefined) {
+            // Explicit property assignments: the feature-AST parser reads neither `??`, shorthand
+            // properties nor a conditional spread, and the boot validator treats `parent: undefined`
+            // as a top-level entry.
+            const { order: navOrder = DEFAULT_NAV_ORDER, parent: navParent, workspaces: navWorkspaces, } = nav;
+            r.nav({
+                id: SYSTEM_CHECK_SCREEN_ID,
+                label: SYSTEM_CHECK_NAV_LABEL,
+                icon: "shield-check",
+                screen: SYSTEM_CHECK_SCREEN_QN,
+                order: navOrder,
+                parent: navParent,
+                workspaces: navWorkspaces,
+            });
+        }
         const queries = {
             status: r.queryHandler(statusQuery),
+            latestResults: r.queryHandler(latestResultsQuery),
+            latestSummary: r.queryHandler(latestSummaryQuery),
+            runList: r.queryHandler(runListQuery),
+            runDetail: r.queryHandler(runDetailQuery),
+            runResults: r.queryHandler(runResultsQuery),
         };
         return { queries };
-    }, { dedupeOptions: {} });
+    }, {
+        dedupeOptions: {
+            hasNav: nav !== undefined,
+            navOrder: nav?.order ?? DEFAULT_NAV_ORDER,
+            navParent: nav?.parent ?? "",
+            navWorkspaces: nav?.workspaces?.join(",") ?? "",
+        },
+    });
 }

package/dist/readiness/handlers/latest-results.query.d.ts

@@ -0,0 +1,5 @@
+import * as z from "zod";
+export declare const latestResultsQuery: import("@cosmicdrift/kumiko-types/define-handler").QueryHandlerDefinition<"probe-run:latest-results", z.ZodObject<{}, z.core.$strip>, {
+    rows: readonly import("../visible-results.ts").VisibleProbeResult[];
+    nextCursor: null;
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

package/dist/readiness/handlers/latest-results.query.js

@@ -0,0 +1,13 @@
+import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
+import * as z from "zod";
+import { fetchLatestRun, viewRun } from "../run-view.js";
+export const latestResultsQuery = defineQueryHandler({
+    name: "probe-run:latest-results",
+    schema: z.object({}),
+    access: { roles: ["TenantAdmin", "SystemAdmin"] },
+    description: "Returns the per-probe results of the tenant's latest system-check run (finished or still running) that the caller may see: system probes only for SystemAdmin, personal mailboxes only for their owner. Empty rows while the run is still working or when no run exists.",
+    handler: async (query, ctx) => {
+        const latest = await fetchLatestRun(ctx.db);
+        return { rows: latest ? viewRun(latest, query.user).results : [], nextCursor: null };
+    },
+});

package/dist/readiness/handlers/latest-summary.query.d.ts

@@ -0,0 +1,39 @@
+import * as z from "zod";
+export declare const SUMMARY_TEXT_KEY = "readiness.summary.ok-of-total";
+export declare const SUMMARY_RUNNING_TEXT_KEY = "readiness.summary.running";
+export declare const SUMMARY_NO_RUN_TEXT_KEY = "readiness.summary.no-run";
+export declare const latestSummaryQuery: import("@cosmicdrift/kumiko-types/define-handler").QueryHandlerDefinition<"probe-run:latest-summary", z.ZodObject<{}, z.core.$strip>, {
+    okCount: number;
+    failedCount: number;
+    skippedCount: number;
+    totalCount: number;
+    id: string;
+    runId: null;
+    hasPaidProbes: boolean;
+    text: {
+        i18nKey: string;
+        i18nParams?: undefined;
+    };
+} | {
+    okCount: number;
+    failedCount: number;
+    skippedCount: number;
+    totalCount: number;
+    id: string;
+    runId: string;
+    hasPaidProbes: boolean;
+    requestedAt: string;
+    status: string;
+    outcome: import("../visible-results.ts").RunOutcome;
+    tone: "default" | "negative" | "positive";
+    text: {
+        i18nKey: string;
+        i18nParams?: undefined;
+    } | {
+        i18nKey: string;
+        i18nParams: {
+            ok: number;
+            total: number;
+        };
+    };
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

package/dist/readiness/handlers/latest-summary.query.js

@@ -0,0 +1,49 @@
+import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
+import * as z from "zod";
+import { hasPaidProbes } from "../collect-probes.js";
+import { fetchLatestRun, viewRun } from "../run-view.js";
+import { countResults } from "../visible-results.js";
+import { toneOf } from "./run-tone.js";
+export const SUMMARY_TEXT_KEY = "readiness.summary.ok-of-total";
+export const SUMMARY_RUNNING_TEXT_KEY = "readiness.summary.running";
+export const SUMMARY_NO_RUN_TEXT_KEY = "readiness.summary.no-run";
+export const latestSummaryQuery = defineQueryHandler({
+    name: "probe-run:latest-summary",
+    schema: z.object({}),
+    access: { roles: ["TenantAdmin", "SystemAdmin"] },
+    description: "Returns the one-line summary of the tenant's latest system-check run (when it started, how many of the checks the caller may see passed, a tone and a ready-made translatable text) and whether the caller's check has paid probes. Zero counts and runId null when no run exists yet.",
+    handler: async (query, ctx) => {
+        const paid = hasPaidProbes(ctx.registry, {
+            includeSystemProbes: query.user.roles.includes("SystemAdmin"),
+            enabledFeatures: ctx.services.effectiveFeatures?.(query.user.tenantId),
+        });
+        const latest = await fetchLatestRun(ctx.db);
+        if (!latest) {
+            return {
+                // The system-check screen's record id only gates its sections; their queries ignore it.
+                id: query.user.tenantId,
+                runId: null,
+                hasPaidProbes: paid,
+                ...countResults([]),
+                text: { i18nKey: SUMMARY_NO_RUN_TEXT_KEY },
+            };
+        }
+        const { counts, outcome } = viewRun(latest, query.user);
+        return {
+            id: latest.id,
+            runId: latest.id,
+            hasPaidProbes: paid,
+            requestedAt: latest.requestedAt.toString(),
+            status: latest.status,
+            ...counts,
+            outcome,
+            tone: toneOf(outcome),
+            text: outcome === "running"
+                ? { i18nKey: SUMMARY_RUNNING_TEXT_KEY }
+                : {
+                    i18nKey: SUMMARY_TEXT_KEY,
+                    i18nParams: { ok: counts.okCount, total: counts.totalCount },
+                },
+        };
+    },
+});

package/dist/readiness/handlers/run-detail.query.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod";
+export declare const runDetailQuery: import("@cosmicdrift/kumiko-types/define-handler").QueryHandlerDefinition<"probe-run:detail", z.ZodObject<{
+    runId: z.ZodUUID;
+}, z.core.$strip>, {
+    okCount: number;
+    failedCount: number;
+    skippedCount: number;
+    totalCount: number;
+    id: string;
+    status: string;
+    requestedAt: string;
+    startedAt: string | null;
+    finishedAt: string | null;
+    triggeredByUserId: string;
+    durationMs: number | null;
+    outcome: import("../visible-results.ts").RunOutcome;
+    tone: "default" | "negative" | "positive";
+}, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;

package/dist/readiness/handlers/run-detail.query.js

@@ -0,0 +1,30 @@
+import { defineQueryHandler } from "@cosmicdrift/kumiko-framework/engine";
+import { NotFoundError } from "@cosmicdrift/kumiko-framework/errors";
+import * as z from "zod";
+import { viewRun } from "../run-view.js";
+import { probeRunsTable } from "../schema/probe-run.js";
+import { toneOf } from "./run-tone.js";
+export const runDetailQuery = defineQueryHandler({
+    name: "probe-run:detail",
+    schema: z.object({ runId: z.uuid() }),
+    access: { roles: ["TenantAdmin", "SystemAdmin"] },
+    description: "Returns the header of one system-check run of the caller's tenant: status, timing, starter and the outcome counts of the results the caller may see.",
+    handler: async (query, ctx) => {
+        const run = await ctx.db.fetchOne(probeRunsTable, { id: query.payload.runId });
+        if (!run)
+            throw new NotFoundError("probe-run", query.payload.runId);
+        const { counts, outcome } = viewRun(run, query.user);
+        return {
+            id: run.id,
+            status: run.status,
+            requestedAt: run.requestedAt.toString(),
+            startedAt: run.startedAt?.toString() ?? null,
+            finishedAt: run.finishedAt?.toString() ?? null,
+            triggeredByUserId: run.triggeredByUserId,
+            durationMs: run.durationMs,
+            ...counts,
+            outcome,
+            tone: toneOf(outcome),
+        };
+    },
+});

package/dist/readiness/handlers/run-list.query.d.ts

@@ -0,0 +1,24 @@
+export declare const runListQuery: import("@cosmicdrift/kumiko-types/define-handler").QueryHandlerDefinition<"probe-run:list", import("zod").ZodObject<{
+    limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+    offset: import("zod").ZodOptional<import("zod").ZodNumber>;
+    search: import("zod").ZodOptional<import("zod").ZodString>;
+    sort: import("zod").ZodOptional<import("zod").ZodEnum<{
+        requestedAt: "requestedAt";
+    }>>;
+    sortDirection: import("zod").ZodOptional<import("zod").ZodEnum<{
+        asc: "asc";
+        desc: "desc";
+    }>>;
+    totalCount: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    cursor: import("zod").ZodOptional<import("zod").ZodNever>;
+}, import("zod/v4/core").$strip>, import("@cosmicdrift/kumiko-types/cursor-types").CursorResult<{
+    id: string;
+    requestedAt: string;
+    triggeredByUserId: string;
+    triggeredByName: string;
+    status: string;
+    okCount: number;
+    failedCount: number;
+    durationMs: number | null;
+    outcome: import("../visible-results.ts").RunOutcome;
+}>, import("@cosmicdrift/kumiko-types/event-type-map").KumikoEventTypeMap>;