@cosmicdrift/kumiko-samples 0.391.1 → 0.392.1

package/packages/bundled-features/src/inbound-provider-imap/sent-folder.ts

@@ -0,0 +1,49 @@
+// Stores the copy of a sent mail in the mailbox's sent folder, so the customer finds the reply in
+// their own mail client. Best effort: the mail is already out, a failed copy is only logged.
+
+import { createFallbackLogger } from "@cosmicdrift/kumiko-framework/logging";
+import type { ImapFlow } from "imapflow";
+import type { ImapCredentialDocument } from "./credential-document.ts";
+import { createImapClient, imapMailHostGuard } from "./imap-client.ts";
+
+const log = createFallbackLogger("inbound-provider-imap");
+
+const SENT_SPECIAL_USE = "\\Sent";
+const SENT_FALLBACK_PATHS = ["Sent", "Gesendet", "INBOX.Sent"];
+
+type ListedMailbox = { readonly path: string; readonly specialUse?: string };
+
+export function pickSentMailboxPath(mailboxes: readonly ListedMailbox[]): string | undefined {
+  const flagged = mailboxes.find((mailbox) => mailbox.specialUse === SENT_SPECIAL_USE);
+  if (flagged) return flagged.path;
+  for (const name of SENT_FALLBACK_PATHS) {
+    const match = mailboxes.find((mailbox) => mailbox.path.toLowerCase() === name.toLowerCase());
+    if (match) return match.path;
+  }
+  return undefined;
+}
+
+export async function appendToSentFolder(
+  doc: ImapCredentialDocument,
+  raw: Buffer,
+  accountId: string,
+): Promise<void> {
+  let client: ImapFlow | undefined;
+  try {
+    client = await createImapClient(doc, imapMailHostGuard());
+    await client.connect();
+    const path = pickSentMailboxPath(await client.list());
+    if (!path) {
+      log.warn("mailbox has no sent folder, sent copy not stored", { accountId });
+      return;
+    }
+    await client.append(path, raw, ["\\Seen"]);
+  } catch (err) {
+    log.warn("storing the sent copy failed", {
+      accountId,
+      reason: err instanceof Error ? err.message : String(err),
+    });
+  } finally {
+    await client?.logout().catch(() => {});
+  }
+}

package/packages/bundled-features/src/inbound-provider-imap/smtp-client.ts

@@ -0,0 +1,135 @@
+// nodemailer wiring for sending from a connected mailbox: one short-lived, non-pooled connection
+// per call, TLS enforced (implicit on 465, STARTTLS otherwise), pinned to the address the mail host guard approved.
+
+import {
+  BlockedHostError,
+  type MailConnectTarget,
+  resolveMailConnectTarget,
+} from "@cosmicdrift/kumiko-bundled-features/foundation-shared";
+import { createFallbackLogger } from "@cosmicdrift/kumiko-framework/logging";
+import { errorCodeOf, propertyOf } from "@cosmicdrift/kumiko-types/type-guards";
+import { createTransport, type Transporter } from "nodemailer";
+import { imapMailHostGuard } from "./imap-client.ts";
+
+const log = createFallbackLogger("inbound-provider-imap");
+
+export const SMTP_IMPLICIT_TLS_PORT = 465;
+
+// nodemailer's defaults wait minutes; the connect form holds a request open meanwhile.
+const CONNECTION_TIMEOUT_MS = 10_000;
+const GREETING_TIMEOUT_MS = 10_000;
+const SOCKET_TIMEOUT_MS = 30_000;
+
+export type SmtpLogin = {
+  readonly host: string;
+  readonly port: number;
+  readonly user: string;
+  readonly password: string;
+};
+
+export type SmtpFailure =
+  | "hostUnreachable"
+  | "loginRejected"
+  | "tlsFailed"
+  | "connectFailed"
+  | "rejected";
+
+// Carries only the category and the library code: the raw error holds the host and the server
+// response, which stay in the server log.
+export class SmtpFailureError extends Error {
+  readonly failure: SmtpFailure;
+  constructor(failure: SmtpFailure, detail: string) {
+    super(`SMTP ${failure}: ${detail}`);
+    this.name = "SmtpFailureError";
+    this.failure = failure;
+  }
+}
+
+const LOGIN_CODES = ["EAUTH", "ENOAUTH"];
+const CONNECTION_CODES = ["ECONNECTION", "ETIMEDOUT", "ESOCKET", "EDNS", "EPROXY"];
+const TLS_CODE = /^(ETLS|ERR_SSL|ERR_TLS)|CERT|SELF_SIGNED|UNABLE_TO_VERIFY/;
+
+// nodemailer wraps a TLS handshake error as ESOCKET and keeps the TLS code as originalCode.
+function isTlsFailure(code: string, originalCode: unknown): boolean {
+  return TLS_CODE.test(code) || (typeof originalCode === "string" && TLS_CODE.test(originalCode));
+}
+
+export function classifySmtpError(err: unknown): SmtpFailure {
+  const code = errorCodeOf(err) ?? "";
+  if (LOGIN_CODES.includes(code)) return "loginRejected";
+  if (isTlsFailure(code, propertyOf(err, "originalCode"))) return "tlsFailed";
+  if (CONNECTION_CODES.includes(code)) return "connectFailed";
+  if (typeof propertyOf(err, "responseCode") === "number") return "rejected";
+  return "connectFailed";
+}
+
+export function smtpTransportOptions(login: SmtpLogin, target: MailConnectTarget) {
+  return {
+    host: target.host,
+    port: login.port,
+    secure: login.port === SMTP_IMPLICIT_TLS_PORT,
+    // Without it nodemailer sends AUTH in clear text when the server offers no STARTTLS.
+    ...(login.port !== SMTP_IMPLICIT_TLS_PORT && { requireTLS: true }),
+    ...(target.servername && { servername: target.servername }),
+    auth: { user: login.user, pass: login.password },
+    connectionTimeout: CONNECTION_TIMEOUT_MS,
+    greetingTimeout: GREETING_TIMEOUT_MS,
+    socketTimeout: SOCKET_TIMEOUT_MS,
+    // The message is composed by us; nothing in it may make nodemailer read files or URLs.
+    disableFileAccess: true,
+    disableUrlAccess: true,
+    logger: false,
+    debug: false,
+  } as const;
+}
+
+async function openSmtpTransport(login: SmtpLogin): Promise<Transporter> {
+  let target: MailConnectTarget;
+  try {
+    target = await resolveMailConnectTarget(login.host, imapMailHostGuard());
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    const blocked = err instanceof BlockedHostError;
+    log.warn(blocked ? "rejected blocked smtp host" : "smtp host resolution failed", {
+      host: login.host,
+      reason,
+    });
+    throw new SmtpFailureError("hostUnreachable", blocked ? "blocked" : "unresolved");
+  }
+  return createTransport(smtpTransportOptions(login, target));
+}
+
+// No error message in the log: a server's reply to a failed AUTH can echo the user name.
+function smtpFailureOf(err: unknown, host: string): SmtpFailureError {
+  const failure = classifySmtpError(err);
+  const code = errorCodeOf(err) ?? "unknown";
+  const responseCode = propertyOf(err, "responseCode");
+  log.warn("smtp call failed", { host, failure, code, responseCode });
+  return new SmtpFailureError(failure, code);
+}
+
+export async function verifySmtpLogin(login: SmtpLogin): Promise<void> {
+  const transport = await openSmtpTransport(login);
+  try {
+    await transport.verify();
+  } catch (err) {
+    throw smtpFailureOf(err, login.host);
+  } finally {
+    transport.close();
+  }
+}
+
+export async function sendRawViaSmtp(
+  login: SmtpLogin,
+  envelope: { readonly from: string; readonly to: readonly string[] },
+  raw: Buffer,
+): Promise<void> {
+  const transport = await openSmtpTransport(login);
+  try {
+    await transport.sendMail({ envelope: { from: envelope.from, to: [...envelope.to] }, raw });
+  } catch (err) {
+    throw smtpFailureOf(err, login.host);
+  } finally {
+    transport.close();
+  }
+}

package/packages/bundled-features/src/legal-pages/README.md

@@ -251,10 +251,8 @@ import { legalContentSeed } from "@cosmicdrift/kumiko-bundled-features/legal-pag
 runProdApp({ /* ... */ seeds: [legalContentSeed({ blocks: legalContent })] });
 ```
 
-Templates for imprint + privacy policy: see
-[docs/plans/datenschutz/legal-artifacts.md](../../../../docs/plans/datenschutz/legal-artifacts.md)
-and vetted external generators (e-recht24.de,
-datenschutz-generator.de).
+Templates for imprint + privacy policy: use vetted external generators
+(e-recht24.de, datenschutz-generator.de).
 
 ---
 
@@ -290,11 +288,8 @@ and put your own routes in front.
 
 ## Architecture cross-refs
 
-- [docs/plans/datenschutz/](../../../../docs/plans/datenschutz/)
-  — consolidated privacy plan index
-- [docs/plans/datenschutz/legal-artifacts.md](../../../../docs/plans/datenschutz/legal-artifacts.md)
-  — templates + where-is-what for imprint/AVV/TOMs/RoPA
-- [docs/plans/datenschutz/compliance-as-product.md](../../../../docs/plans/datenschutz/compliance-as-product.md)
-  — roadmap for auto-generation (sub-processor list, TOMs, data-breach workflow)
+- Privacy planning (templates and where-is-what for imprint/AVV/TOMs/RoPA, plus the
+  roadmap for auto-generation of the sub-processor list, TOMs and data-breach
+  workflow) lives in the private platform repo.
 - [samples/recipes/legal-pages/](../../../../samples/recipes/legal-pages/)
   — live sample with both features wired up

package/packages/bundled-features/src/mail-foundation/changes.json

@@ -1,4 +1,10 @@
 [
+  {
+    "version": "0.392.0",
+    "type": "improvement",
+    "title": "The mail probe tests the platform sender",
+    "detail": "A tenant without its own mail provider now gets the test mail through the channel-email app transport, the sender its tenant-transport notifications fall back to. The probe reports mail-foundation.probe.send-test-mail.platform-accepted on success and mail-foundation.probe.platform-send-rejected when the platform server rejects it; it is skipped only when neither an own provider nor an app transport exists, and mail-foundation.probe.not-configured now reads \"No email sending set up\". New keys in all locale packages."
+  },
   {
     "version": "0.391.0",
     "type": "improvement",

package/packages/bundled-features/src/mail-foundation/i18n.ts

@@ -2,12 +2,14 @@ export const MAIL_PROBE_KEYS = {
   area: "mail-foundation.probe.area",
   label: "mail-foundation.probe.send-test-mail.label",
   accepted: "mail-foundation.probe.send-test-mail.accepted",
+  platformAccepted: "mail-foundation.probe.send-test-mail.platform-accepted",
   notConfigured: "mail-foundation.probe.not-configured",
   noRecipient: "mail-foundation.probe.no-recipient",
   hostNotFound: "mail-foundation.probe.host-not-found",
   setupIncomplete: "mail-foundation.probe.setup-incomplete",
   setupFailed: "mail-foundation.probe.setup-failed",
   sendRejected: "mail-foundation.probe.send-rejected",
+  platformSendRejected: "mail-foundation.probe.platform-send-rejected",
 } as const;
 
 export const MAIL_FOUNDATION_I18N = {
@@ -21,7 +23,10 @@ export const MAIL_FOUNDATION_I18N = {
   [MAIL_PROBE_KEYS.area]: { en: "Email" },
   [MAIL_PROBE_KEYS.label]: { en: "Test email to the person who started the check" },
   [MAIL_PROBE_KEYS.accepted]: { en: "Accepted by the mail server" },
-  [MAIL_PROBE_KEYS.notConfigured]: { en: "No own email sending set up" },
+  [MAIL_PROBE_KEYS.platformAccepted]: {
+    en: "Sent via the platform sender, accepted by its mail server",
+  },
+  [MAIL_PROBE_KEYS.notConfigured]: { en: "No email sending set up" },
   [MAIL_PROBE_KEYS.noRecipient]: {
     en: "No email address known for the person who started the check",
   },
@@ -33,4 +38,7 @@ export const MAIL_FOUNDATION_I18N = {
   [MAIL_PROBE_KEYS.sendRejected]: {
     en: "The mail server did not accept the test email, check address, port and login",
   },
+  [MAIL_PROBE_KEYS.platformSendRejected]: {
+    en: "The platform mail server did not accept the test email",
+  },
 } as const;

package/packages/bundled-features/src/mail-foundation/probe.ts

@@ -1,3 +1,7 @@
+import {
+  type EmailTransport,
+  findEmailAppTransport,
+} from "@cosmicdrift/kumiko-bundled-features/channel-email";
 import {
   createSystemUser,
   type FeatureRegistrar,
@@ -30,6 +34,36 @@ function transportFailureKey(error: unknown): string {
     : MAIL_PROBE_KEYS.setupFailed;
 }
 
+async function ownTenantTransport(ctx: ProbeContext): Promise<EmailTransport | null> {
+  const { configResolver, secrets } = ctx.services;
+  if (!configResolver) return null;
+  const config = createConfigAccessor(
+    ctx.registry,
+    configResolver,
+    ctx.tenantId,
+    createSystemUser(ctx.tenantId).id,
+    ctx.db,
+  );
+  return tenantMailTransport({
+    tenantId: ctx.tenantId,
+    config,
+    registry: ctx.registry,
+    secrets,
+  }).catch((error: unknown) => {
+    throw probeFailure(ctx, error, transportFailureKey(error));
+  });
+}
+
+// Same order as channel-email for tenant mails: the tenant's own provider, else the app sender.
+async function probeTransport(
+  ctx: ProbeContext,
+): Promise<{ readonly transport: EmailTransport; readonly viaPlatform: boolean } | null> {
+  const own = await ownTenantTransport(ctx);
+  if (own !== null) return { transport: own, viaPlatform: false };
+  const platform = findEmailAppTransport(ctx.registry);
+  return platform === null ? null : { transport: platform, viaPlatform: true };
+}
+
 // The mail goes to whoever started the check; the address never appears in the stored result.
 export function registerMailProbe(r: FeatureRegistrar<"mail-foundation">): void {
   r.probe({
@@ -40,31 +74,14 @@ export function registerMailProbe(r: FeatureRegistrar<"mail-foundation">): void
     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: unknown) => {
-        throw probeFailure(ctx, error, transportFailureKey(error));
-      });
-      if (transport === null) {
+      const resolved = await probeTransport(ctx);
+      if (resolved === null) {
         return { status: "skipped", message: { key: MAIL_PROBE_KEYS.notConfigured } };
       }
       if (ctx.triggeredByEmail === undefined) {
         return { status: "skipped", message: { key: MAIL_PROBE_KEYS.noRecipient } };
       }
+      const { transport, viaPlatform } = resolved;
       await transport
         .send({
           to: ctx.triggeredByEmail,
@@ -73,9 +90,13 @@ export function registerMailProbe(r: FeatureRegistrar<"mail-foundation">): void
           html: `<p>${PROBE_TEXT}</p>`,
         })
         .catch((error: unknown) => {
-          throw probeFailure(ctx, error, MAIL_PROBE_KEYS.sendRejected);
+          const key = viaPlatform
+            ? MAIL_PROBE_KEYS.platformSendRejected
+            : MAIL_PROBE_KEYS.sendRejected;
+          throw probeFailure(ctx, error, key);
         });
-      return { status: "ok", message: { key: MAIL_PROBE_KEYS.accepted } };
+      const accepted = viaPlatform ? MAIL_PROBE_KEYS.platformAccepted : MAIL_PROBE_KEYS.accepted;
+      return { status: "ok", message: { key: accepted } };
     },
   });
 }

package/packages/bundled-features/src/readiness/built-in-probes.ts

@@ -1,4 +1,8 @@
-import type { FeatureRegistrar, ProbeContext } from "@cosmicdrift/kumiko-framework/engine";
+import {
+  type FeatureRegistrar,
+  type ProbeContext,
+  ProbeFailure,
+} from "@cosmicdrift/kumiko-framework/engine";
 import { ProbeTextKeys } from "./constants.ts";
 import { probeRunsTable } from "./schema/probe-run.ts";
 
@@ -10,6 +14,7 @@ export const BuiltInProbeKeys = {
   cacheOk: "readiness.probe.cache.ok",
   searchLabel: "readiness.probe.search.label",
   searchOk: "readiness.probe.search.ok",
+  searchUnavailable: "readiness.probe.search.unavailable",
 } as const;
 
 export function registerBuiltInProbes(r: FeatureRegistrar<"readiness">): void {
@@ -51,7 +56,15 @@ export function registerBuiltInProbes(r: FeatureRegistrar<"readiness">): void {
       if (!searchAdapter) {
         return { status: "skipped", message: { key: ProbeTextKeys.notConfigured } };
       }
-      await searchAdapter.search(ctx.tenantId, "readiness-probe", { limit: 1 });
+      try {
+        await searchAdapter.search(ctx.tenantId, "readiness-probe", { limit: 1 });
+      } catch (error) {
+        // The raw error can name the search host, so it stays in the server log.
+        ctx.obs.log.warn("readiness search probe failed", {
+          error: error instanceof Error ? error.message : String(error),
+        });
+        throw new ProbeFailure({ key: BuiltInProbeKeys.searchUnavailable });
+      }
       return { status: "ok", message: { key: BuiltInProbeKeys.searchOk } };
     },
   });

package/packages/bundled-features/src/readiness/changes.json

@@ -1,4 +1,34 @@
 [
+  {
+    "version": "0.392.0",
+    "type": "improvement",
+    "title": "The paid run is a button next to Start check",
+    "detail": "The system check screen declares run-paid-check as an inline action, so \"Test AI extraction\" shows as a button beside \"Start check\" instead of in the \"More actions\" menu. It stays hidden while the app has no paid probes."
+  },
+  {
+    "version": "0.392.0",
+    "type": "improvement",
+    "title": "The readiness entry exports ProbeTextKeys",
+    "detail": "ProbeTextKeys comes from @cosmicdrift/kumiko-bundled-features/readiness next to ReadinessQueries and ReadinessWrites, so apps can name probe texts without a deep import."
+  },
+  {
+    "version": "0.392.0",
+    "type": "improvement",
+    "title": "The paid probe hint names the button",
+    "detail": "readiness.probe.paid-not-requested now reads \"Only via “Test AI extraction”\" (de „Nur über „KI-Auslesen testen““), the label of the button that starts the paid run."
+  },
+  {
+    "version": "0.392.0",
+    "type": "improvement",
+    "title": "The search probe fails with its own text",
+    "detail": "When the search service throws, the search probe fails with readiness.probe.search.unavailable (\"The search service does not answer\"). The raw error can name the search host, so it goes only to the server log. New key in all locale packages."
+  },
+  {
+    "version": "0.392.0",
+    "type": "improvement",
+    "title": "An empty latest run says why it is empty",
+    "detail": "The latest results and the run detail show \"The check is running. Results appear when it is done.\" while a run is running and \"There is nothing to check for this tenant.\" when a finished run has no rows the caller may see, and \"The run was stopped before it returned results.\" for an abandoned run. Without a run the old text stays. New keys readiness.screen.latest.running, readiness.screen.latest.nothing-to-check and readiness.screen.latest.abandoned in all locale packages."
+  },
   {
     "version": "0.391.0",
     "type": "improvement",

package/packages/bundled-features/src/readiness/constants.ts

@@ -15,6 +15,8 @@ export const ReadinessWrites = {
   runProbes: "readiness:write:run-probes",
 } as const;
 
+export const RUN_OUTCOME = { ok: "ok", failed: "failed", running: "running" } as const;
+
 export const DEFAULT_PROBE_TIMEOUT_MS = 10_000;
 
 // An active run older than this is treated as dead (worker crash) and may be replaced.

package/packages/bundled-features/src/readiness/i18n.ts

@@ -10,7 +10,8 @@ export const READINESS_I18N: Readonly<Record<string, LocalizedString>> = {
   "readiness.probe.cache.ok": { en: "Cache reachable" },
   "readiness.probe.search.label": { en: "Search" },
   "readiness.probe.search.ok": { en: "Search reachable" },
-  "readiness.probe.paid-not-requested": { en: "Not run, paid checks were not requested" },
+  "readiness.probe.search.unavailable": { en: "The search service does not answer" },
+  "readiness.probe.paid-not-requested": { en: "Only via “Test AI extraction”" },
   "readiness.probe.no-targets": { en: "Nothing to check" },
   "readiness.probe.timeout": { en: "No answer after {seconds} seconds" },
   "readiness.probe.failed": { en: "The check failed" },
@@ -29,6 +30,11 @@ export const READINESS_I18N: Readonly<Record<string, LocalizedString>> = {
     en: "Real calls against mail, storage, search and the other connected services. A failed row links to the screen that fixes it.",
   },
   "readiness.screen.latest.empty": { en: "No results yet. Start a check." },
+  "readiness.screen.latest.running": {
+    en: "The check is running. Results appear when it is done.",
+  },
+  "readiness.screen.latest.nothing-to-check": { en: "There is nothing to check for this tenant." },
+  "readiness.screen.latest.abandoned": { en: "The run was stopped before it returned results." },
   "readiness.screen.history.title": { en: "History" },
   "readiness.screen.history.description": {
     en: "Earlier runs, newest first. Open one to see its results.",

package/packages/bundled-features/src/readiness/index.ts

@@ -1,3 +1,8 @@
-export { READINESS_FEATURE, ReadinessQueries, ReadinessWrites } from "./constants.ts";
+export {
+  ProbeTextKeys,
+  READINESS_FEATURE,
+  ReadinessQueries,
+  ReadinessWrites,
+} from "./constants.ts";
 export { createReadinessFeature } from "./feature.ts";
 export type { ReadinessMissingSecret } from "./handlers/status.query.ts";

package/packages/bundled-features/src/readiness/screens.ts

@@ -4,7 +4,8 @@ import type {
   ProjectionDetailScreenDefinition,
   RowAction,
 } from "@cosmicdrift/kumiko-framework/ui-types";
-import { ReadinessQueries, ReadinessWrites } from "./constants.ts";
+import { ReadinessQueries, ReadinessWrites, RUN_OUTCOME } from "./constants.ts";
+import { PROBE_RUN_STATUS } from "./schema/probe-run.ts";
 
 export const SYSTEM_CHECK_SCREEN_ID = "system-check";
 export const SYSTEM_CHECK_RUN_SCREEN_ID = "system-check-run";
@@ -17,6 +18,9 @@ export const ScreenTextKeys = {
   latestTitle: "readiness.screen.latest.title",
   latestDescription: "readiness.screen.latest.description",
   latestEmpty: "readiness.screen.latest.empty",
+  latestRunning: "readiness.screen.latest.running",
+  latestNothingToCheck: "readiness.screen.latest.nothing-to-check",
+  latestAbandoned: "readiness.screen.latest.abandoned",
   historyTitle: "readiness.screen.history.title",
   historyDescription: "readiness.screen.history.description",
   historyEmpty: "readiness.screen.history.empty",
@@ -76,7 +80,24 @@ function resultsSection(
     title,
     query,
     columns: RESULT_COLUMNS,
-    emptyState: { title: ScreenTextKeys.latestEmpty },
+    emptyState: {
+      title: ScreenTextKeys.latestEmpty,
+      // A finished run without rows had nothing the caller may see, not "no run yet".
+      variants: [
+        {
+          when: { field: "outcome", eq: RUN_OUTCOME.running },
+          title: ScreenTextKeys.latestRunning,
+        },
+        {
+          when: { field: "outcome", eq: RUN_OUTCOME.ok },
+          title: ScreenTextKeys.latestNothingToCheck,
+        },
+        {
+          when: { field: "status", eq: PROBE_RUN_STATUS.Abandoned },
+          title: ScreenTextKeys.latestAbandoned,
+        },
+      ],
+    },
     ...extra,
   };
 }
@@ -121,6 +142,8 @@ export function systemCheckScreen(dormant: boolean): ProjectionDetailScreenDefin
     access: ACCESS,
     actions: RUN_ACTIONS,
     primaryAction: "run-check",
+    // The paid run is the only way to test AI extraction, so it must not hide in the menu.
+    inlineActions: ["run-paid-check"],
     metrics: RESULT_METRICS,
     metricsStyle: "tiles",
     layout: {

package/packages/bundled-features/src/readiness/visible-results.ts

@@ -1,5 +1,6 @@
 import type { SessionUser } from "@cosmicdrift/kumiko-framework/engine";
 import * as z from "zod";
+import type { RUN_OUTCOME } from "./constants.ts";
 import { PROBE_RUN_STATUS } from "./schema/probe-run.ts";
 
 const probeTextSchema = z.object({
@@ -38,7 +39,7 @@ export type VisibleProbeResult = Omit<StoredProbeResult, "label" | "message" | "
   readonly fixScreen?: string;
 };
 
-export type RunOutcome = "ok" | "failed" | "running";
+export type RunOutcome = (typeof RUN_OUTCOME)[keyof typeof RUN_OUTCOME];
 
 export type ResultCounts = {
   readonly okCount: number;

package/packages/bundled-features/src/renderer-foundation/README.md

@@ -1,8 +1,6 @@
 # renderer-foundation
 
-Plugin-Foundation für Renderer (HTML-Mail, PDF, Image). Plugins (`renderer-mail-html`, `renderer-puppeteer-client`) registrieren sich via `r.useExtension("renderer", "<name>", { kinds, render })`.
-
-**Plan-Doc:** [`kumiko-platform/docs/plans/features/renderer-foundation.md`](../../../../../../kumiko-platform/docs/plans/features/renderer-foundation.md)
+Plugin foundation for renderers (HTML email, PDF, image). Plugins (`renderer-mail-html`, `renderer-puppeteer-client`) register via `r.useExtension("renderer", "<name>", { kinds, render })`.
 
 ## Mount
 
@@ -17,7 +15,7 @@ const features = [
   createTemplateResolverFeature(),
   createRendererFoundationFeature(),
   createRendererMailHtmlFeature(), // Plugin: kind "mail"
-  // weitere Plugins...
+  // more plugins...
 ];
 
 const app = createKumikoApp({
@@ -30,7 +28,7 @@ const app = createKumikoApp({
 });
 ```
 
-## Konsumtion
+## Consumption
 
 ```typescript
 import { requireRendererFoundation } from "@cosmicdrift/kumiko-bundled-features/renderer-foundation";
@@ -49,18 +47,18 @@ async function sendMail(ctx, tenantId) {
 }
 ```
 
-Plugins ohne Service-Deps ignorieren den zweiten `ctx`-Parameter.
+Plugins without service dependencies ignore the second `ctx` parameter.
 
-Mails einer `r.notification` rendert die Delivery selbst: `template` + `meta` an der Notification werden beim Boot gesät (`seedNotificationTemplates`) und über kind `"mail"` gerendert. Ohne `template` + `meta` scheitert der Versand über den Email-Channel.
+Emails from an `r.notification` are rendered by the delivery itself: `template` and `meta` on the notification are seeded at boot (`seedNotificationTemplates`) and rendered with kind `"mail"`. Without `template` and `meta`, sending through the email channel fails.
 
-## Plugin-Auswahl-Reihenfolge
+## Plugin Selection Order
 
-1. Tenant-Override (Config-Key `rendererPluginByKind`, z.B. `{ "mail": "mail-html" }`)
-2. `DEFAULT_PLUGIN_BY_KIND` aus constants
-3. Erstes Plugin im Pool das das kind bedient
-4. `RendererError("no_plugin_for_kind")` wenn nichts passt
+1. Tenant override (config key `rendererPluginByKind`, for example `{ "mail": "mail-html" }`)
+2. `DEFAULT_PLUGIN_BY_KIND` from constants
+3. First plugin in the pool that handles the kind
+4. `RendererError("no_plugin_for_kind")` if nothing matches
 
-## Eigenes Plugin schreiben
+## Writing a Custom Plugin
 
 ```typescript
 import { defineFeature } from "@cosmicdrift/kumiko-framework/engine";
@@ -69,19 +67,19 @@ export const myRendererFeature = defineFeature("renderer-myown", (r) => {
   r.requires({ features: ["renderer-foundation"] });
   r.useExtension("renderer", "myown", {
     kinds: ["document-pdf"],
-    // ctx ist optional — nur nehmen wenn Service-Access nötig
+    // ctx is optional, only use it when service access is required
     render: async (req, ctx) => {
-      // ctx.db, ctx.registry, ctx.tenantId verfügbar
-      // eigene PDF-Logik
+      // ctx.db, ctx.registry, ctx.tenantId available
+      // custom PDF logic
       return { kind: "document-pdf", pdfBytes: ..., pageCount: 1, sizeBytes: ... };
     },
   });
 });
 ```
 
-## Out-of-Scope
+## Out of Scope
 
-- Template-Storage (kommt aus `template-resolver`)
-- Resource-URL-Substitution (Caller-Verantwortung: signed-URL vs. data-URI je nach kind)
-- Template-Authoring-UI — `designer`-Bundle (geplant)
-- Mail-Versand — `delivery` + `mail-transport-smtp`
+- Template storage (provided by `template-resolver`)
+- Resource URL substitution (caller's responsibility: signed URL versus data URI depending on the kind)
+- Template authoring UI, `designer` bundle (planned)
+- Email delivery, `delivery` + `mail-transport-smtp`