@schlenkr/ragents 0.1.4 → 0.1.6

package/packages/ragents/src/plugin-host.ts

@@ -1,11 +1,13 @@
 import path from "node:path";
 import type { IncomingMessage, ServerResponse } from "node:http";
-import type { InlineExtension } from "@aicontainer/agent";
+import type { InlineExtension } from "@ragents/agent";
+import { agentHookExtension } from "./drivers/agent-hooks.ts";
 import { Value } from "typebox/value";
-import { canStartEntry, defaultHttpRights, unrestrictedAccess, type AccessContext } from "./access.ts";
+import { canStartEntry, defaultHttpRights, isAccessRight, unrestrictedAccess, type AccessContext } from "./access.ts";
+import { DomainError } from "./runtime/domain-error.ts";
 import { assertJsonValue, type JsonValue } from "./domain/json.ts";
 import { canonicalHash } from "./runtime/canonical-hash.ts";
-import { schemaComplaints } from "./agents/toolset.ts";
+import { schemaComplaints } from "./domain/schema-errors.ts";
 import type { AgentProfile, CatalogModel } from "./agents/catalog.ts";
 import type { ToolContributor } from "./agents/plugins.ts";
 import { describeToolAvailability, type RunFunction } from "./agents/tools.ts";
@@ -18,7 +20,6 @@ import type {
   RegisteredOperationDescriptor,
   AgentContribution,
   AgentContributionContext,
-  AgentToolDescriptor,
   PluginConfigDescriptor,
   PluginManifest,
   PluginRegistration,
@@ -29,7 +30,7 @@ import type {
   ProfileContribution,
   PromptContribution,
   PromptRenderContext,
-  PublicAgentExtensionContribution,
+  PublicAgentHookContribution,
   PublicPluginConfigDescriptor,
   PublicPluginManifest,
   PublicPluginProfile,
@@ -42,6 +43,8 @@ import type {
   ServiceToken,
   RegisteredStartOption,
   SessionLifecycleContribution,
+  SessionMetadata,
+  SessionStartedContext,
   SessionMetadataContribution,
   SkillContribution,
   RunScriptPackage,
@@ -187,8 +190,7 @@ export class OperationContributionRegistry {
     assertJsonValue(input, `Operation ${id} input`);
 
     if (!Value.Check(operation.schema, input)) {
-      const first = [...Value.Errors(operation.schema, input)].at(0);
-      throw new Error(`Ungültige Eingabe für Operation ${id}: ${first?.message ?? "Schema nicht erfüllt"}`);
+      throw new Error(`Ungültige Eingabe für Operation ${id}: ${schemaComplaints(operation.schema, input)}`);
     }
 
     if (context.principal.kind === "operator") {
@@ -209,97 +211,38 @@ export class OperationContributionRegistry {
     context.signal.throwIfAborted();
     const result = await operation.execute(context, input);
     if (!Value.Check(operation.resultSchema, result)) {
-      const first = [...Value.Errors(operation.resultSchema, result)].at(0);
-      throw new Error(`Ungültiges Ergebnis von Operation ${id}: ${first?.message ?? "Schema nicht erfüllt"}`);
+      throw new Error(`Ungültiges Ergebnis von Operation ${id}: ${schemaComplaints(operation.resultSchema, result, "result")}`);
     }
     assertJsonValue(result, `Operation ${id} output`);
     return result;
   }
 }
 
-const namedExtension = (extension: InlineExtension): string | undefined =>
-  typeof extension === "function" ? undefined : extension.name;
-
-const extensionFactoryName = (extension: InlineExtension): string | null => {
-  if (typeof extension !== "function") return extension.name;
-  return extension.name || null;
-};
-
 export class AgentContributionRegistry {
   readonly #contributions = new ContributionRegistry<AgentContribution>("Agent-Beitrag");
-  readonly #toolOwners = new Map<string, string>();
 
   register(owner: string, contributions: readonly AgentContribution[]): void {
-    const names = new Set<string>();
     for (const contribution of contributions) {
-      if (contribution.tools.length > 0 && (contribution.global?.length ?? 0) === 0 && !contribution.resolve) {
-        throw new Error(`Agent-Beitrag ${contribution.id} deklariert Werkzeuge, aber keine Extension-Factory`);
-      }
-      for (const tool of contribution.tools) {
-        if (!tool.name.trim() || !tool.description.trim() || !tool.availabilityDetail.trim()) {
-          throw new Error(`Agent-Beitrag ${contribution.id} hat einen unvollständigen Werkzeug-Descriptor`);
-        }
-        if (names.has(tool.name)) {
-          throw new Error(`Agent-Werkzeug ${tool.name} ist innerhalb der Registrierung mehrfach deklariert`);
-        }
-        const existing = this.#toolOwners.get(tool.name);
-        if (existing) throw new Error(`Agent-Werkzeug ${tool.name} wird bereits von ${existing} deklariert`);
-        names.add(tool.name);
+      if (!contribution.beforeModelCall && !contribution.afterToolCall) {
+        throw new Error(`Agent-Beitrag ${contribution.id} hat keinen Hook`);
       }
     }
     this.#contributions.register(owner, contributions);
-    for (const name of names) this.#toolOwners.set(name, owner);
   }
 
-  global(): readonly InlineExtension[] {
-    return this.#unique(this.#contributions.entries().flatMap(({ value }) => value.global ?? []));
+  resolve(context: AgentContributionContext): readonly InlineExtension[] {
+    return this.#contributions.entries().map(({ value }) => agentHookExtension(value, context));
   }
 
-  async resolve(context: AgentContributionContext): Promise<readonly InlineExtension[]> {
-    const contextual = await Promise.all(this.#contributions.entries().map(async ({ value }) =>
-      value.resolve ? await value.resolve(context) : []));
-    return this.#unique([...this.global(), ...contextual.flat()]);
-  }
-
-  describe(): readonly PublicAgentExtensionContribution[] {
+  describe(): readonly PublicAgentHookContribution[] {
     return this.#contributions.entries().map(({ owner, value }) => ({
       id: value.id,
       owner,
       kind: "plugin" as const,
-      factories: (value.global ?? []).map((extension) => ({
-        name: extensionFactoryName(extension),
-        scope: "global" as const,
-      })),
-      resolvesPerAgent: Boolean(value.resolve),
+      factories: [{ name: value.id, scope: "per-agent" as const }],
+      resolvesPerAgent: true as const,
     }));
   }
-
-  describeTools(): readonly PublicToolDescriptor[] {
-    return this.#contributions.entries().flatMap(({ owner, value }) =>
-      value.tools.map((tool) => ({
-        id: `agent-extension:${owner}:${value.id}:${tool.name}`,
-        owner,
-        source: value.id,
-        kind: "agent-extension" as const,
-        ...tool,
-        nativeTool: true,
-      })));
-  }
-
-  tools(): readonly AgentToolDescriptor[] {
-    return this.#contributions.entries().flatMap(({ value }) => value.tools);
-  }
-
-  #unique(extensions: readonly InlineExtension[]): readonly InlineExtension[] {
-    const names = new Set<string>();
-    for (const extension of extensions) {
-      const name = namedExtension(extension);
-      if (!name) continue;
-      if (names.has(name)) throw new Error(`Agent-Extension ${name} ist mehrfach registriert`);
-      names.add(name);
-    }
-    return extensions;
-  }
 }
 
 export class ToolContributionRegistry {
@@ -419,6 +362,15 @@ export class SkillContributionRegistry {
     return this.resolve(undefined);
   }
 
+  /** Ein Skillname bestimmt seinen Skill im ganzen Profil, auch über Zielgruppen hinweg; zwei Ordner gleichen Namens scheitern beim Start. */
+  async assertUniqueNames(): Promise<void> {
+    const paths = await this.global();
+    for (const name of new Set(paths.map(skillNameOf))) {
+      const named = paths.filter((entry) => skillNameOf(entry) === name);
+      if (named.length > 1) throw new Error(`Der Skillname ${name} ist im Profil mehrfach vergeben: ${named.join(", ")}`);
+    }
+  }
+
   async resolve(context: AgentContributionContext | undefined): Promise<readonly string[]> {
     const paths = (await this.describe(context)).flatMap((entry) => entry.paths);
     const unique = new Set(paths);
@@ -445,7 +397,7 @@ const SCRIPT_HANDLE = /^[a-z0-9][a-z0-9-]*$/;
 
 const requireText = (entry: { id: unknown }, value: unknown, field: string): void => {
   if (typeof value !== "string" || !value.trim()) {
-    throw new Error(`Einstieg ${String(entry.id)} hat kein gültiges ${field}`);
+    throw new Error(`Vorlage ${String(entry.id)} hat kein gültiges ${field}`);
   }
 };
 
@@ -475,7 +427,7 @@ const validateProgramFiles = (entry: StartEntryContribution, files: unknown): vo
 
 const validateScriptPackage = (entry: StartEntryContribution, script: unknown): void => {
   if (typeof script !== "object" || script === null)
-    throw new Error(`Einstieg ${entry.id} hat kein Run-Script-Paket`);
+    throw new Error(`Vorlage ${entry.id} hat kein Run-Script-Paket`);
   assertKnownFields(entry, script, ["handle", "coordinator", "files", "programs"], "Run-Script");
   const value = script as Record<string, unknown>;
   if (typeof value.handle !== "string" || !SCRIPT_HANDLE.test(value.handle))
@@ -496,52 +448,68 @@ const validateScriptPackage = (entry: StartEntryContribution, script: unknown):
   }
 };
 
+const validateFixedStartOptions = (entry: StartEntryContribution): void => {
+  const fixed: unknown = entry.fixedStartOptions;
+  if (fixed === undefined) return;
+  if (typeof fixed !== "object" || fixed === null || Array.isArray(fixed) || Object.keys(fixed).length === 0) {
+    throw new Error(`Vorlage ${entry.id}: fixedStartOptions muss mindestens eine Startoption auf einen Wert festlegen`);
+  }
+  for (const [optionId, value] of Object.entries(fixed)) {
+    if (!START_OPTION_ID.test(optionId)) throw new Error(`Vorlage ${entry.id} legt die ungültige Startoption-Id ${optionId} fest`);
+    assertJsonValue(value, `Vorlage ${entry.id}: fixedStartOptions.${optionId}`);
+  }
+};
+
 const validateStartEntry = (entry: StartEntryContribution): void => {
-  const base = ["id", "title", "description", "order", "guide", "tags", "action"];
+  const base = ["id", "title", "description", "order", "guide", "tags", "fixedStartOptions", "action"];
   for (const field of ["id", "title", "description"] as const) requireText(entry, entry[field], field);
   if (entry.order !== undefined && (typeof entry.order !== "number" || !Number.isFinite(entry.order))) {
-    throw new Error(`Einstieg ${entry.id} hat keine gültige Ordnungszahl`);
+    throw new Error(`Vorlage ${entry.id} hat keine gültige Ordnungszahl`);
   }
   if (entry.guide !== undefined && (typeof entry.guide !== "string" || !GUIDE_ID.test(entry.guide))) {
-    throw new Error(`Einstieg ${entry.id} nennt keine gültige Leitfaden-Kennung: ${String(entry.guide)}`);
+    throw new Error(`Vorlage ${entry.id} nennt keine gültige Leitfaden-Kennung: ${String(entry.guide)}`);
   }
   if (entry.tags !== undefined && (!Array.isArray(entry.tags)
     || entry.tags.some((tag) => typeof tag !== "string" || !tag.trim() || tag !== tag.trim())
     || new Set(entry.tags).size !== entry.tags.length)) {
-    throw new Error(`Einstieg ${entry.id}: tags müssen eindeutige, nicht leere Schlagworte sein`);
+    throw new Error(`Vorlage ${entry.id}: tags müssen eindeutige, nicht leere Schlagworte sein`);
   }
+  validateFixedStartOptions(entry);
   switch (entry.action) {
     case "skill":
-      assertKnownFields(entry, entry, [...base, "skill", "prompt", "category"], "Einstieg");
+      assertKnownFields(entry, entry, [...base, "skill", "prompt", "category"], "Vorlage");
       requireText(entry, entry.category, "category");
-      if (entry.category !== entry.category.trim()) throw new Error(`Einstieg ${entry.id}: category muss ein einzelner nicht leerer Text sein`);
+      if (entry.category !== entry.category.trim()) throw new Error(`Vorlage ${entry.id}: category muss ein einzelner nicht leerer Text sein`);
       requireText(entry, entry.prompt, "prompt");
       requireText(entry, entry.skill, "skill");
       if (!SKILL_NAME.test(entry.skill)) {
-        throw new Error(`Einstieg ${entry.id} nennt keinen gültigen Skill-Namen: ${entry.skill}`);
+        throw new Error(`Vorlage ${entry.id} nennt keinen gültigen Skill-Namen: ${entry.skill}`);
       }
       return;
     case "script":
-      assertKnownFields(entry, entry, [...base, "script", "category"], "Einstieg");
+      assertKnownFields(entry, entry, [...base, "script", "category"], "Vorlage");
       if (entry.category !== undefined && (typeof entry.category !== "string" || !entry.category.trim() || entry.category !== entry.category.trim())) {
-        throw new Error(`Einstieg ${entry.id}: category muss ein einzelner nicht leerer Text sein`);
+        throw new Error(`Vorlage ${entry.id}: category muss ein einzelner nicht leerer Text sein`);
       }
       validateScriptPackage(entry, entry.script);
       return;
     default:
       throw new Error(
-        `Einstieg ${String((entry as { id: unknown }).id)} hat die unbekannte Aktion ${String((entry as { action: unknown }).action)}; `
+        `Vorlage ${String((entry as { id: unknown }).id)} hat die unbekannte Aktion ${String((entry as { action: unknown }).action)}; `
         + "gültig sind skill und script",
       );
   }
 };
 
+/** Der Name eines Skills ist der Name seines Ordners. */
+const skillNameOf = (directory: string): string => directory.split(/[\\/]/).filter(Boolean).at(-1) ?? "";
+
 const byOrderThenId = (left: { order?: number; id: string }, right: { order?: number; id: string }): number =>
   (left.order ?? 0) - (right.order ?? 0) || left.id.localeCompare(right.id);
 
 /** Skills with a start prompt and executable run scripts share one registry. */
 export class StartEntryContributionRegistry {
-  readonly #entries = new ContributionRegistry<StartEntryContribution>("Einstieg");
+  readonly #entries = new ContributionRegistry<StartEntryContribution>("Vorlage");
 
   register(owner: string, entries: readonly StartEntryContribution[]): void {
     for (const entry of entries) validateStartEntry(entry);
@@ -549,11 +517,22 @@ export class StartEntryContributionRegistry {
   }
 
   assertSkillsKnown(skills: readonly PublicSkillContribution[]): void {
-    const names = new Set(skills.flatMap((skill) =>
-      skill.paths.map((entry) => entry.split(/[\\/]/).filter(Boolean).at(-1) ?? "")));
+    const names = new Set(skills.flatMap((skill) => skill.paths.map(skillNameOf)));
     for (const { owner, value } of this.#entries.entries()) {
       if (value.action === "skill" && !names.has(value.skill)) {
-        throw new Error(`Einstieg ${value.id} von ${owner} verweist auf den unbekannten Skill ${value.skill}`);
+        throw new Error(`Vorlage ${value.id} von ${owner} verweist auf den unbekannten Skill ${value.skill}`);
+      }
+    }
+  }
+
+  /** Jede festgelegte Startoption muss registriert sein und ihr Wert ihrem Schema genügen; ob er angenommen wird, entscheidet erst der Start. */
+  assertFixedStartOptionsKnown(startOptions: StartOptionContributionRegistry): void {
+    for (const { owner, value } of this.#entries.entries()) {
+      for (const [optionId, fixed] of Object.entries(value.fixedStartOptions ?? {})) {
+        if (!startOptions.entry(optionId)) {
+          throw new Error(`Vorlage ${value.id} von ${owner} legt die nicht registrierte Startoption ${optionId} fest`);
+        }
+        startOptions.assertValue(optionId, fixed, `festgelegter Wert der Vorlage ${value.id}`);
       }
     }
   }
@@ -570,6 +549,7 @@ export class StartEntryContributionRegistry {
           ...(value.order !== undefined ? { order: value.order } : {}),
           ...(value.guide !== undefined ? { guide: value.guide } : {}),
           ...(value.tags !== undefined ? { tags: [...value.tags] } : {}),
+          ...(value.fixedStartOptions !== undefined ? { fixedStartOptions: structuredClone(value.fixedStartOptions) } : {}),
         };
         switch (value.action) {
           case "skill":
@@ -581,11 +561,16 @@ export class StartEntryContributionRegistry {
       .sort(byOrderThenId);
   }
 
-  /** The run script behind a script entry; undefined for unknown ids and entries of another action. */
+  /** Eine Vorlage, wie das Web sie sieht; undefined für eine unbekannte Kennung. */
+  entry(entryId: string): PublicStartEntry | undefined {
+    return this.describe().find((candidate) => candidate.id === entryId);
+  }
+
+  /** The run script behind a script template; undefined for unknown ids and templates of another action. */
   scriptPackage(entryId: string): (RunScriptPackage & { entry: PublicStartEntry }) | undefined {
     const found = this.#entries.entries().find(({ value }) => value.id === entryId);
     if (!found || found.value.action !== "script") return undefined;
-    const entry = this.describe().find((candidate) => candidate.id === entryId);
+    const entry = this.entry(entryId);
     if (!entry) return undefined;
     return { ...found.value.script, entry };
   }
@@ -681,6 +666,10 @@ export class LifecycleContributionRegistry {
     for (const { value } of this.#lifecycle.entries()) await value.prepareSession?.({ runId });
   }
 
+  async sessionStarted(runId: string, startEntry: SessionStartedContext["startEntry"]): Promise<void> {
+    for (const { value } of this.#lifecycle.entries()) await value.sessionStarted?.({ runId, startEntry });
+  }
+
   beginStopSession(runId: string): PluginStopOperation {
     return this.#beginStopPhase(runId, "stopSession");
   }
@@ -829,19 +818,36 @@ export class LifecycleContributionRegistry {
   }
 }
 
+const WORKSPACE_NOT_ACCESSIBLE = "Der Arbeitsbereich dieses Runs ist für diesen Zugang nicht erreichbar.";
+
 export class SessionMetadataContributionRegistry {
-  readonly #metadata = new ContributionRegistry<SessionMetadataContribution>("Session-Metadaten-Beitrag");
+  readonly #metadata = new ContributionRegistry<SessionMetadataContribution>("Run-Metadaten-Beitrag");
 
   register(owner: string, contributions: readonly SessionMetadataContribution[]): void {
     this.#metadata.register(owner, contributions);
   }
 
-  async describe(runId: string): Promise<Readonly<Record<string, unknown>>> {
-    const entries = await Promise.all(this.#metadata.entries().map(async ({ value }) => [
-      value.id,
-      await value.describe({ runId }),
-    ] as const));
-    return Object.fromEntries(entries);
+  /** Alle Beiträge zugleich; wer nicht innerhalb von `timeoutMs` antwortet oder scheitert, verliert nur seinen Wert und nennt den Grund. */
+  async describe(runId: string, workspaceAccessible: boolean, timeoutMs: number): Promise<SessionMetadata> {
+    type Outcome = { readonly id: string; readonly value: unknown } | { readonly id: string; readonly reason: string };
+    const outcomes = await Promise.all(this.#metadata.entries().map(async ({ value }): Promise<Outcome> => {
+      if (value.requiresWorkspace === true && !workspaceAccessible) return { id: value.id, reason: WORKSPACE_NOT_ACCESSIBLE };
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      const silent = new Promise<never>((_resolve, reject) => {
+        timer = setTimeout(() => reject(new Error(`keine Antwort nach ${timeoutMs} ms`)), timeoutMs);
+      });
+      try {
+        return { id: value.id, value: await Promise.race([Promise.resolve().then(() => value.describe({ runId })), silent]) };
+      } catch (error) {
+        return { id: value.id, reason: error instanceof Error ? error.message : String(error) };
+      } finally {
+        clearTimeout(timer);
+      }
+    }));
+    return {
+      values: Object.fromEntries(outcomes.flatMap((outcome) => "value" in outcome ? [[outcome.id, outcome.value] as const] : [])),
+      unavailable: Object.fromEntries(outcomes.flatMap((outcome) => "reason" in outcome ? [[outcome.id, outcome.reason] as const] : [])),
+    };
   }
 }
 
@@ -857,6 +863,15 @@ export class StartOptionContributionRegistry {
       for (const name of ["selectable", "defaultValue", "accept", "describe"] as const) {
         if (typeof contribution[name] !== "function") throw new Error(`Startoption ${contribution.id} hat kein ${name}`);
       }
+      if (contribution.ownerOnly !== undefined && typeof contribution.ownerOnly !== "function") {
+        throw new Error(`Startoption ${contribution.id} hat ein ungültiges ownerOnly`);
+      }
+      if (contribution.rights !== undefined && (!Array.isArray(contribution.rights) || !contribution.rights.every(isAccessRight))) {
+        throw new Error(`Startoption ${contribution.id} hat ungültige rights`);
+      }
+      if (contribution.changeable !== undefined && typeof contribution.changeable !== "boolean") {
+        throw new Error(`Startoption ${contribution.id} hat ein ungültiges changeable`);
+      }
     }
     this.#options.register(owner, contributions);
   }
@@ -874,6 +889,16 @@ export class StartOptionContributionRegistry {
     return this.#options.entries().map(({ owner, value }) => ({ id: value.id, owner }));
   }
 
+  /** Das erste Recht der Option, das dem Zugang fehlt; eine unbekannte Option verlangt keins. */
+  missingRight(id: string, access: Pick<AccessContext, "can">): string | undefined {
+    return this.entry(id)?.option.rights?.find((right) => !access.can(right));
+  }
+
+  assertRights(id: string, access: Pick<AccessContext, "can">): void {
+    const missing = this.missingRight(id, access);
+    if (missing) throw new DomainError("access-denied", `Das Recht ${missing} fehlt für die Startoption ${id}.`, 403);
+  }
+
   defaultValue(id: string, context: StartOptionContext): JsonValue {
     const { option } = this.#require(id);
     const value = option.defaultValue(context);
@@ -890,6 +915,11 @@ export class StartOptionContributionRegistry {
     return accepted;
   }
 
+  /** Prüft einen Wert gegen das Schema der Option, ohne ihn anzunehmen. */
+  assertValue(id: string, value: unknown, label: string): void {
+    this.#check(this.#require(id).option, value, label);
+  }
+
   #require(id: string): RegisteredStartOption {
     const entry = this.entry(id);
     if (!entry) throw new Error(`Startoption ${id} ist nicht registriert`);
@@ -898,8 +928,7 @@ export class StartOptionContributionRegistry {
 
   #check(option: StartOptionContribution, value: unknown, label: string): void {
     if (Value.Check(option.schema, value)) return;
-    const first = [...Value.Errors(option.schema, value)].at(0);
-    throw new Error(`Ungültiger ${label} für Startoption ${option.id}: ${first?.message ?? "Schema nicht erfüllt"}`);
+    throw new Error(`Ungültiger ${label} für Startoption ${option.id}: ${schemaComplaints(option.schema, value, "value")}`);
   }
 }
 
@@ -972,7 +1001,7 @@ export class StorageRegistry {
       modes: this.#modes,
       root: (...segments: string[]) => joinSafe(path.join(this.#dataDirectory, pluginDirectory), segments),
       session: (runId: string, ...segments: string[]) => {
-        if (!RUN_ID.test(runId)) throw new Error(`Ungültige Session-Id: ${runId}`);
+        if (!RUN_ID.test(runId)) throw new Error(`Ungültige Run-ID: ${runId}`);
         return joinSafe(path.join(this.#dataDirectory, "sessions", runId, pluginDirectory), segments);
       },
     });
@@ -1029,6 +1058,8 @@ export interface PluginHostOptions {
   product: ProductDescriptor;
   dataDirectory: string;
   storageModes: PluginStorageModes;
+  /** The entry a new run takes by default; must be registered by a plugin of the profile. */
+  defaultStartEntry?: string;
 }
 
 const HOST_OWNER = "host";
@@ -1051,6 +1082,7 @@ export class PluginHost {
   readonly config = new ConfigContributionRegistry();
   readonly storage: StorageRegistry;
   readonly #product: ProductDescriptor;
+  readonly #defaultStartEntry: string | undefined;
   readonly #services = new ServiceRegistry();
   readonly #clientConfig = new ClientConfigRegistry();
   readonly #manifests: PluginManifest[] = [];
@@ -1058,6 +1090,7 @@ export class PluginHost {
 
   constructor(options: PluginHostOptions) {
     this.#product = Object.freeze({ ...options.product });
+    this.#defaultStartEntry = options.defaultStartEntry;
     this.storage = new StorageRegistry(options.dataDirectory, options.storageModes);
   }
 
@@ -1113,26 +1146,39 @@ export class PluginHost {
         if (position >= index) throw new Error(`Plugin ${dependency} muss vor ${manifest.id} registriert werden`);
       }
     }
+    this.startEntries.assertFixedStartOptionsKnown(this.startOptions);
+    const defaultStartEntry = this.#defaultStartEntry;
+    if (defaultStartEntry !== undefined) {
+      const entries = this.startEntries.describe().map((entry) => entry.id);
+      if (!entries.includes(defaultStartEntry)) {
+        throw new Error(`defaultStartEntry ${defaultStartEntry} ist keine registrierte Vorlage; `
+          + (entries.length > 0 ? `registriert sind ${entries.join(", ")}` : "kein Plugin dieses Profils registriert Vorlagen"));
+      }
+    }
     this.#sealed = true;
   }
 
   async initialize(): Promise<void> {
     this.seal();
     this.startEntries.assertSkillsKnown(await this.skills.describe(undefined));
+    await this.skills.assertUniqueNames();
     await this.lifecycle.initialize();
   }
 
   publicProfile(access: AccessContext = unrestrictedAccess): PublicPluginProfile {
     this.seal();
+    const startEntries = this.startEntries.describe().filter((entry) => canStartEntry(access, entry.id)
+      && (entry.action === "script" || access.can("runs.create")));
+    const defaultStartEntry = this.#defaultStartEntry;
     return {
       product: this.#product,
-      startEntries: this.startEntries.describe().filter((entry) => canStartEntry(access, entry.id)
-        && (entry.action === "script" || access.can("runs.create"))),
+      startEntries,
+      ...(defaultStartEntry !== undefined && startEntries.some((entry) => entry.id === defaultStartEntry) ? { defaultStartEntry } : {}),
       plugins: this.#manifests.map((manifest) => {
         const config = this.#mergedClientConfig(manifest);
         return {
           id: manifest.id,
-          web: manifest.web === true,
+          ...(manifest.web ? { web: manifest.web } : {}),
           ...(config ? { config } : {}),
         };
       }),