@schlenkr/ragents 0.1.0 → 0.1.2

package/plugins/ragents.reference/run-scripts/conversation-circle/src/server.ts

@@ -58,25 +58,19 @@ export default defineActor(contract, {
     }
 
     await context.functions.canvas_layout_replace({
-      nodes: [
-        { entity: "shape:thema" },
-        { id: "runde", group: "circle", label: "Runde", frame: true },
-        { entity: participants[0]!, parent: "runde" },
-        { entity: participants[1]!, parent: "runde" },
-        { entity: participants[2]!, parent: "runde" },
-      ],
-      shapes: [{ id: "thema", kind: "diamond", text: topic }],
-      lines: [
-        { from: participants[0]!, to: participants[1]!, arrow: "end", label: "gibt weiter" },
-        { from: participants[1]!, to: participants[2]!, arrow: "end", label: "gibt weiter" },
-        { from: participants[2]!, to: participants[0]!, arrow: "end", label: "gibt weiter" },
-        { from: "shape:thema", to: participants[0]!, style: "dashed", label: "Auftakt" },
-      ],
+      root: {
+        direction: "vertical",
+        weights: [1, 1],
+        children: [
+          { entity: participants[0]! },
+          { direction: "horizontal", weights: [1, 1], children: [{ entity: participants[1]! }, { entity: participants[2]! }] },
+        ],
+      },
     });
 
     await context.functions.actor_input({
       actor: "@coordinator",
-      content: `Die Runde steht: ${participants.join(", ")} sind aufgestellt, die Fläche ist gestaltet. Thema: "${topic}". `
+      content: `Die Runde steht: ${participants.join(", ")} sind aufgestellt, die Fläche ist aufgeteilt. Thema: "${topic}". `
         + `Führe genau ${rounds} Gesprächsrunden durch: in jeder Runde ${participants.join(", ")} in dieser Reihenfolge. `
         + "Jeder erhält die bisherigen Beiträge. Ändere die Fläche nicht. "
         + "Fasse das Gespräch am Ende in drei Sätzen zusammen.",

package/plugins/ragents.reference/run-scripts/conversation-circle/tests/program.test.ts

@@ -8,9 +8,11 @@ test("Thema und Rundenzahl steuern Teilnehmer, Fläche und Auftrag", async () =>
   await program.onInput!(startInput({ topic: "Teamfrühstück", rounds: 3 }), context);
   assert.deepEqual(calls.filter((call) => call.name === "agent_spawn").map((call) => (call.input as { handle: string }).handle), ["mira", "jon", "ada"]);
   assert.deepEqual(calls.find((call) => call.name === "run_configure")?.input, { title: "Gesprächsrunde: Teamfrühstück" });
-  const layout = calls.find((call) => call.name === "canvas_layout_replace")?.input as { shapes: { text: string }[]; lines: unknown[] };
-  assert.equal(layout.shapes[0].text, "Teamfrühstück");
-  assert.equal(layout.lines.length, 4);
+  const layout = calls.find((call) => call.name === "canvas_layout_replace")?.input as { root: unknown };
+  assert.deepEqual(layout.root, { direction: "vertical", weights: [1, 1], children: [
+    { entity: "@mira" },
+    { direction: "horizontal", weights: [1, 1], children: [{ entity: "@jon" }, { entity: "@ada" }] },
+  ] });
   assert.match(JSON.stringify(calls.at(-1)), /genau 3 Gesprächsrunden/);
   assert.deepEqual(context.state.read(), { built: true });
   const completedCalls = calls.length;

package/plugins/ragents.reference/run-scripts/learning-afternoon/package.json

@@ -5,6 +5,6 @@
   "ragents": {
     "title": "Lernnachmittag",
     "backend": "src/server.ts",
-    "views": [{ "id": "main", "client": "src/client.tsx", "width": 620, "height": 550 }]
+    "views": [{ "id": "main", "client": "src/client.tsx" }]
   }
 }

package/plugins/ragents.reference/run-scripts/learning-afternoon/src/server.ts

@@ -38,6 +38,13 @@ const contract = {
 const startMarker = "START_LEARNING_AFTERNOON";
 
 
+type Tile = { entity: string } | { direction: "vertical"; weights: [number, number]; children: [Tile, Tile] };
+
+function stackedTiles(entities: string[]): Tile {
+  const [first, ...rest] = entities;
+  return rest.length === 0 ? { entity: first! } : { direction: "vertical", weights: [1, rest.length], children: [{ entity: first! }, stackedTiles(rest)] };
+}
+
 function boardWith(helpers: HelperState[]): LearningState {
   const working = helpers.some((helper) => helper.status === "working");
   return { phase: working ? "working" : helpers.some((helper) => helper.status === "error") ? "error" : "complete", helpers };
@@ -65,10 +72,13 @@ export default defineActor(contract, {
         const actor = await context.functions.agent_spawn({ handle: `learning-${helper.id}`, displayName: helper.label, profile: profile.name, prompt, tools: [] });
         return { ...helper, actorId: actor.id };
       }));
-      await context.functions.canvas_layout_replace({ nodes: [
-        ...helpers.map((helper) => ({ entity: `@learning-${helper.id}` })),
-        { entity: `app:@${context.actor.handle}/main` },
-      ] });
+      await context.functions.canvas_layout_replace({
+        root: {
+          direction: "horizontal",
+          weights: [1, 1],
+          children: [{ entity: `app:@${context.actor.handle}/main` }, stackedTiles(helpers.map((helper) => `@learning-${helper.id}`))],
+        },
+      });
       await context.functions.run_configure({ title: learningWorkflow.title, primaryActor: `@${context.actor.handle}` });
       context.state.replace({ board: { phase: "ready", helpers } });
       return;

package/plugins/ragents.reference/run-scripts/word-game/src/server.ts

@@ -37,7 +37,7 @@ export default defineActor(contract, {
     try {
       if (!state.status) {
         await context.functions.run_configure({ title: "Wortspiel", primaryActor: context.actor.id });
-        await context.functions.canvas_layout_replace({ nodes: [{ entity: `app:@${context.actor.handle}/main`, width: 640, height: 700 }] });
+        await context.functions.canvas_layout_replace({ root: { entity: `app:@${context.actor.handle}/main` } });
         const start = payloadOf(JSON.parse(input.content));
         if (start.input !== null || !start.options || typeof start.options !== "object" || Array.isArray(start.options)
           || Object.keys(start).some((key) => key !== "input" && key !== "options")) {

package/plugins/ragents.reference/skills/210-moderator-handover/SKILL.md

@@ -6,7 +6,7 @@ title: "Gespräch an einen Moderator übergeben"
 description: "Zeigt die Übergabe eines laufenden Chats an einen anderen Primary-Actor. Der Moderator übernimmt als direkter Ansprechpartner und hält den Aufgabenfortschritt fest."
 category: "Zusammenarbeit"
 order: 210
-tags: "Rückfragen, To-dos, Anwendungsfall, Konzeptdemo, Agententeams, Primary-Actor, Canvas-Layout"
+tags: "Rückfragen, To-dos, Anwendungsfall, Konzeptdemo, Agententeams, Primary-Actor"
 ---
 
 Ich hätte gern einen Workshop für einen ruhigeren Arbeitstag: Ein Planer bringt zwei Ideen mit, ein skeptischer Gast prüft die Nachteile. Ein Moderator übernimmt die Runde und spricht danach direkt mit mir im Chat, damit ich einen Vorschlag auswählen kann. Zeig die drei auf der Fläche und übergib das Gespräch wirklich an den Moderator. Seine Aufgabenliste zeigt den Fortschritt.

package/plugins/ragents.reference/walkthroughs.ts

@@ -2,25 +2,25 @@ export const referenceWalkthroughs = [
   {
     id: "mini-app-owner-inspector",
     title: "Den Helfer hinter einer Mini-App öffnen",
-    description: "Die Mini-App bleibt auf der Fläche; ihr Besitzer ist auch ohne zusätzliche Karte erreichbar.",
-    tags: ["Anwendungsfall", "Konzeptdemo", "Persönliche Canvas-Ansicht"],
+    description: "Die Mini-App bleibt als Kachel sichtbar; ihr Besitzer ist auch ohne eigene Kachel erreichbar.",
+    tags: ["Anwendungsfall", "Konzeptdemo", "Kachelfläche"],
     steps: [
-      "Im Profil core Sammelboard einrichten öffnen und den Leitfaden abschließen. Erwartung: Die Liste steht auf dem Canvas; die Karte ihres Besitzers ist in der Standardansicht ausgeblendet.",
-      "Unten Actors öffnen und den Namen des Listenbesitzers wählen. Erwartung: Rechts öffnen sich dessen Chat und Details, ohne eine zusätzliche Karte einzublenden.",
-      "In der Actorliste die Canvas-Sichtbarkeit dieses Actors einschalten. Erwartung: Seine Karte erscheint zusätzlich; die Mini-App bleibt bedienbar und behält ihre Einträge.",
-      "Die Karte wieder ausblenden und die App erneut bedienen. Erwartung: Actor und Funktionen arbeiten weiter. Unter Ansicht hebt Ansicht zurücksetzen die persönliche Einzelentscheidung wieder auf.",
+      "Im Profil core Sammelboard einrichten öffnen und den Leitfaden abschließen. Erwartung: Die Liste steht als Kachel auf der Fläche; ihr Besitzer hat keine eigene Kachel.",
+      "In der Kopfzeile Actors öffnen und den Namen des Listenbesitzers wählen. Erwartung: Rechts öffnen sich dessen Chat und Details, ohne die Kachelaufteilung zu ändern.",
+      "Den Besitzer aus der Kopfzeile auf die Kachel der Liste ziehen und rechts andocken. Erwartung: Seine Kachel erscheint neben der Liste; die Mini-App bleibt bedienbar und behält ihre Einträge.",
+      "Die neue Kachel über das Kreuz in ihrer Kopfzeile wieder entfernen und die App erneut bedienen. Erwartung: Actor und Funktionen arbeiten weiter; sein Name bleibt in der Kopfzeile erreichbar.",
     ],
   },
   {
-    id: "personal-conversation-canvas",
-    title: "Eine Gesprächsrunde übersichtlicher anzeigen",
-    description: "Actor-Karten und Verbindungen lassen sich persönlich ausblenden, ohne den Gesprächsaufbau zu verändern.",
-    tags: ["Anwendungsfall", "Konzeptdemo", "Persönliche Canvas-Ansicht"],
+    id: "personal-tile-arrangement",
+    title: "Eine Gesprächsrunde anders aufteilen",
+    description: "Kacheln lassen sich persönlich umstellen und wieder auf die Programmvorgabe zurücksetzen.",
+    tags: ["Anwendungsfall", "Konzeptdemo", "Kachelfläche"],
     steps: [
-      "Im Profil core den Skill-Einstieg Eine Gesprächsrunde auf der Fläche anordnen ausführen und den Aufbau abwarten. Die sichtbaren Karten und Verbindungen ansehen.",
-      "Unter Actors einen Gesprächspartner vom Canvas ausblenden. Erwartung: Seine Karte und ihre Verbindungen verschwinden; sein Name in der Liste öffnet weiterhin den Inspector. Die übrigen Beteiligten arbeiten weiter.",
-      "Unter Ansicht Verbindungen anzeigen ausschalten und denselben Run im selben Browser neu laden. Erwartung: Die persönliche Auswahl bleibt erhalten; die Actors und das gespeicherte Layout sind unverändert.",
-      "Unter Ansicht Ansicht zurücksetzen wählen. Erwartung: Verbindungen und gewöhnliche Actor-Karten erscheinen wieder; Actors mit eigener Mini-App bleiben nach der Standardvorgabe ausgeblendet. Bei einem gestoppten Actor bleiben sein Name und sein Verlauf in der Liste erreichbar.",
+      "Im Profil core den Einstieg Gesprächsrunde einrichten ausführen und den Aufbau abwarten. Die vom Run gesetzte Aufteilung ansehen.",
+      "Eine Kachel an ihrer Kopfzeile fassen und am oberen Rand einer anderen Kachel andocken. Erwartung: Die Aufteilung ändert sich sofort; alle Gesprächspartner arbeiten weiter.",
+      "Die Trennlinie zwischen zwei Kacheln verschieben und denselben Run im selben Browser neu laden. Erwartung: Die persönliche Aufteilung bleibt erhalten; die Actors und die Programmanordnung sind unverändert.",
+      "In der Statusleiste Programmvorgabe übernehmen wählen. Erwartung: Die Fläche zeigt wieder die Aufteilung des Runs; der Knopf verschwindet, bis wieder eine eigene Änderung vorliegt.",
     ],
   },
   {

package/plugins/ragents.workspace/client/workspace-client.ts

@@ -37,6 +37,8 @@ export interface WorkspaceClientExecution {
 }
 
 export interface WorkspaceClientOptions {
+  /** Die Host-Wurzel dieses Rechners, aus der die Sprachserver aufgelöst werden; sie kann erst später entstehen. */
+  hostRoot: () => string | undefined;
   onExecuted?: (execution: WorkspaceClientExecution) => void;
 }
 
@@ -75,7 +77,7 @@ export class WorkspaceClient {
   constructor(
     private readonly transport: WorkspaceClientTransport,
     identity: WorkspaceClientIdentity,
-    private readonly options: WorkspaceClientOptions = {},
+    private readonly options: WorkspaceClientOptions,
   ) {
     this.#identity = { ...identity, folders: [...identity.folders] };
     this.#executor = new SandboxWorkspaceExecutor({
@@ -198,6 +200,7 @@ export class WorkspaceClient {
       root: await realPathOf(cwd),
       home: { home: homedir() },
       logDirectory: join(tmpdir(), "ragents-workspace-logs", input.runId),
+      hostRoot: this.options.hostRoot(),
       additions: input.env,
     }));
     const startedAt = Date.now();

package/scripts/agent/agent-cli.ts

@@ -1,13 +1,14 @@
+// Der Hook löst @aicontainer/* auch für eine Profildatei außerhalb des Hosts auf; im Paket gibt es dort kein node_modules.
+import "../../apps/server/src/host-resolution.ts";
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { closeSync, mkdirSync, openSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { fileURLToPath } from "node:url";
 import { coreContracts } from "../../apps/server/src/api/contracts.ts";
 import { profileFileName } from "../../apps/server/src/config-file.ts";
-import { isEnvironmentReference } from "../../apps/server/src/config-definition.ts";
-import { defaultDataDirectory } from "../../apps/server/src/data-directory.ts";
 import { hostRoot } from "../../apps/server/src/host-version.ts";
+import { readProfileTarget, type ProfileTarget } from "../../apps/server/src/profile-target.ts";
 import { RpcClient } from "../../apps/web/src/rpc/client.ts";
 import { WORKSPACE_BINDING_OPTION_ID } from "../../plugins/ragents.workspace/contract.ts";
 import { JournalReader, journalLines, readJournal, RUN_ID_PATTERN, type JournalEvent } from "./journal.ts";
@@ -33,7 +34,8 @@ export const usage = (): string => `Verwendung: ragents <befehl> [argumente]
 Vorgabeprofil ist ${DEFAULT_PROFILE}. Exit-Code: 0 fertig, 2 abgebrochen, 1 fehlgeschlagen oder
 Verbindungsproblem. Die letzte Zeile auf stdout ist "run: <id>". Die Adresse kommt aus
 <Datenordner>/host.json, sonst aus RAGENTS_URL, sonst aus host.PORT des Profils; RAGENTS_TOKEN
-geht als Bearer-Token mit, falls das Profil eine Anmeldung verlangt.`;
+geht als Bearer-Token mit, falls das Profil eine Anmeldung verlangt. Der so gestartete Host baut
+die Oberfläche nicht - ein Agent braucht sie nicht; mit Oberfläche startet ragents start <profil>.`;
 
 export type AgentCommand =
   | { readonly kind: "run"; readonly profile: string; readonly folder: string; readonly text: string; readonly entry: string | undefined; readonly json: boolean }
@@ -123,14 +125,6 @@ export const parseArguments = (argv: readonly string[]): AgentCommand => {
   throw new Error(command ? `Unbekannter Befehl: ${command}\n\n${usage()}` : usage());
 };
 
-export interface ProfileTarget {
-  readonly profile: string;
-  readonly profileFile: string;
-  readonly port: number;
-  readonly dataDirectory: string;
-  readonly baseUrl: string;
-}
-
 export interface HostRecord {
   readonly profile: string;
   readonly url: string;
@@ -155,17 +149,8 @@ export const writeHostRecord = (dataDirectory: string, record: HostRecord): void
   writeFileSync(hostRecordFile(dataDirectory), `${JSON.stringify(record, null, 2)}\n`);
 };
 
-export const loadProfile = async (profile: string, root = hostRoot()): Promise<ProfileTarget> => {
-  const profileFile = path.join(root, profileFileName(profile));
-  if (!existsSync(profileFile)) throw new Error(`Die Profildatei fehlt: ${profileFile}`);
-  const module = await import(pathToFileURL(profileFile).href) as { config: { host: { PORT?: number; DATA_DIR?: unknown } } };
-  const port = Number(process.env.PORT || module.config.host.PORT);
-  if (!Number.isInteger(port) || port < 1 || port > 65535) throw new Error(`host.PORT des Profils ${profile} ist keine gültige Portnummer.`);
-  const configured = module.config.host.DATA_DIR;
-  const fromFile = isEnvironmentReference(configured) ? process.env[configured.name] : typeof configured === "string" ? configured : undefined;
-  const dataDirectory = path.resolve(process.env.DATA_DIR ?? fromFile ?? defaultDataDirectory(profile));
-  return { profile, profileFile, port, dataDirectory, baseUrl: `http://localhost:${port}` };
-};
+export const loadProfile = (profile: string, root = hostRoot()): Promise<ProfileTarget> =>
+  readProfileTarget(profile, path.join(root, profileFileName(profile)));
 
 /** pnpm und der bin-Befehl führen dieses Skript mit dem Arbeitsverzeichnis apps/server aus; ein relativer Ordner gilt trotzdem ab dem Aufrufer. */
 export const callerDirectory = (): string => process.env.RAGENTS_CWD ?? process.env.INIT_CWD ?? process.cwd();

package/scripts/package/build-package.ts

@@ -39,12 +39,17 @@ const ROOT_FILE_SOURCES = new Set(PACKAGE_ROOT_FILES.map(([source]) => source));
 
 const skippedInPackage = (relative: string): boolean => SKIPPED_IN_PACKAGE.test(relative) || ROOT_FILE_SOURCES.has(relative);
 
-/** Was der Host zur Laufzeit lädt: Server, Engine, Plugins, Profile und die Skripte hinter den Unterbefehlen. */
+/** Was der Host zur Laufzeit lädt: Server, Engine, Plugins, Profile, den Web-Build und die Skripte hinter den Unterbefehlen. */
 export const packageContents = (root = repositoryRoot): readonly string[] => [
   "apps/server/package.json",
+  "apps/server/tsconfig.json",
   "apps/server/src",
   "apps/server/agent-home/settings.json",
   "apps/web/package.json",
+  "apps/web/tsconfig.json",
+  "apps/web/vite.config.ts",
+  "apps/web/index.html",
+  "apps/web/column.html",
   "apps/web/src",
   ...readdirSync(path.join(root, "packages"), { withFileTypes: true })
     .filter((entry) => entry.isDirectory())
@@ -58,10 +63,10 @@ export const packageContents = (root = repositoryRoot): readonly string[] => [
   "scripts/workspace-client",
 ];
 
-/** Was der Host ausführt oder in eine Mini-App bündelt; die web-Ordner der Plugins baut der zentrale Server. */
-const SCANNED = ["apps/server/src", "apps/web/src", "packages", "plugins", "scripts"];
+/** Was der Host ausführt, in eine Mini-App bündelt oder beim Start in sein Web baut. */
+const SCANNED = ["apps/server/src", "apps/web", "packages", "plugins", "scripts"];
 const PACKAGE_NAME_PATTERN = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
-const SCAN_SKIPPED = new Set(["web", "node_modules", "dist"]);
+const SCAN_SKIPPED = new Set(["node_modules", "dist"]);
 const SCANNED_EXTENSIONS = new Set([".ts", ".tsx", ".mts", ".mjs", ".js", ".css"]);
 const IMPORT_PATTERN = /\b(?:from|import|require(?:\.resolve)?)\s*\(?\s*["']([^"'\n]+)["']/g;
 
@@ -114,10 +119,18 @@ const packageNameOf = (specifier: string): string | undefined => {
   return PACKAGE_NAME_PATTERN.test(name) ? name : undefined;
 };
 
-/** Die Pakete, die der ausgeführte Teil des Pakets wirklich importiert, plus die zur Laufzeit verlinkten Bibliotheken. */
+const declaredWebDependencies = (packageDirectory: string): readonly string[] => {
+  const file = path.join(packageDirectory, "apps/web/package.json");
+  const declared = (JSON.parse(readFileSync(file, "utf8")) as { dependencies?: Record<string, string> }).dependencies ?? {};
+  return Object.keys(declared);
+};
+
+/** Die Pakete, die der ausgeführte Teil des Pakets wirklich importiert, plus die zur Laufzeit verlinkten Bibliotheken
+ * und die, die das Web des Hosts den web-Hälften fremder Plugins anbietet. */
 export const requiredPackages = (packageDirectory: string): ReadonlyMap<string, string> => {
   const sources = new Map<string, string>();
   for (const name of runtimeLibraries) sources.set(name, "plugins/ragents.actor-programs (verlinkt zur Laufzeit)");
+  for (const name of declaredWebDependencies(packageDirectory)) sources.set(name, "apps/web/package.json (für die web-Hälften der Plugins)");
   for (const folder of scanRoots(packageDirectory)) {
     for (const file of scannedFiles(folder)) {
       const content = readFileSync(file, "utf8");

package/scripts/package/publish-package.ts

@@ -1,6 +1,7 @@
 import { spawnSync } from "node:child_process";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { compareVersions, nextVersion, readVersion, versionLine, writeHostPackageVersion, writeVersion } from "../publish-version.ts";
 import { buildPackage, PACKAGE_FOLDER, PACKAGE_NAME } from "./build-package.ts";
 
 const repositoryRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
@@ -8,7 +9,8 @@ const repositoryRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url))
 const usage = `Verwendung: pnpm publish:package [--dry-run]
 Baut das Paket ${PACKAGE_NAME} und veröffentlicht es auf npm. Der Token kommt aus der
 Umgebungsvariable npm_key. --dry-run reicht npm den Probelauf durch und veröffentlicht nichts.
-Die Fassung steht in der package.json der Wurzel und wird von Hand erhöht.`;
+Die Fassung steht in der package.json der Wurzel; das Skript zählt vor dem Bauen die letzte Stelle
+über die zuletzt veröffentlichte hoch, im Probelauf nur in der Ausgabe.`;
 
 const REGISTRY_TOKEN_KEY = "npm_config_//registry.npmjs.org/:_authToken";
 
@@ -52,6 +54,10 @@ export const publishedVersions = (name: string, npm: NpmRunner): readonly string
   return typeof parsed === "string" ? [parsed] : parsed;
 };
 
+/** Die höchste Fassung, die auf npm liegt; ein dort unbekanntes Paket hat keine. */
+export const latestPublishedVersion = (npm: NpmRunner = runNpm, name = PACKAGE_NAME): string | undefined =>
+  [...publishedVersions(name, npm)].sort(compareVersions).at(-1);
+
 export interface PublishPlan {
   readonly name: string;
   readonly version: string;
@@ -59,13 +65,13 @@ export interface PublishPlan {
 }
 
 /** Was vor einem Publish stimmen muss: das gebaute Manifest und eine Fassung, die es auf npm noch nicht gibt. */
-export const publishPlan = (manifest: Record<string, unknown>, published: readonly string[]): PublishPlan => {
-  const { name, version } = manifest as { name?: unknown; version?: unknown };
+export const publishPlan = (manifest: Record<string, unknown>, published: readonly string[], version: string): PublishPlan => {
+  const { name } = manifest as { name?: unknown };
   const access = (manifest.publishConfig as { access?: unknown } | undefined)?.access;
   const hostVersion = (manifest.ragents as { hostVersion?: unknown } | undefined)?.hostVersion;
   if (name !== PACKAGE_NAME) throw new Error(`Das gebaute Paket heißt ${String(name)}, veröffentlicht wird ${PACKAGE_NAME}`);
   if (access !== "public") throw new Error(`${PACKAGE_NAME} hat einen Scope und braucht publishConfig.access "public", nicht ${JSON.stringify(access)}`);
-  if (typeof version !== "string" || !/^\d+\.\d+\.\d+(?:-[0-9a-z.-]+)?$/.test(version)) {
+  if (!/^\d+\.\d+\.\d+(?:-[0-9a-z.-]+)?$/.test(version)) {
     throw new Error(`Die Fassung ${JSON.stringify(version)} ist keine Fassung; sie steht als version in der package.json der Wurzel`);
   }
   if (typeof hostVersion !== "string" || !/^[0-9a-f]{40}$/.test(hostVersion)) {
@@ -80,6 +86,7 @@ export const publishPlan = (manifest: Record<string, unknown>, published: readon
 
 export interface PublishOptions {
   readonly directory: string;
+  readonly version: string;
   readonly token: string;
   readonly dryRun: boolean;
   readonly npm: NpmRunner;
@@ -92,7 +99,7 @@ const scopeAdvice = (output: string): string => /Scope not found/i.test(output)
     + "auf npmjs.com anlegen bzw. den Token für den Scope freigeben."
   : "";
 
-/** Veröffentlicht den gebauten Ordner und nennt danach die Fassung, die npm ausliefert. */
+/** Veröffentlicht den gebauten Ordner; der Exit 0 von npm publish ist die Bestätigung. */
 export const publishDirectory = (options: PublishOptions): void => {
   const hide = redacting(options.token);
   const published = options.npm(["publish", "--access", "public", ...options.dryRun ? ["--dry-run"] : []], { cwd: options.directory, token: options.token });
@@ -103,9 +110,7 @@ export const publishDirectory = (options: PublishOptions): void => {
     options.log("== Probelauf: nichts veröffentlicht");
     return;
   }
-  const view = options.npm(["view", PACKAGE_NAME, "version"], { cwd: repositoryRoot });
-  if (view.status !== 0) throw new Error(`npm view ${PACKAGE_NAME} version endete mit Code ${view.status}: ${hide(oneLine(view.stderr))}`);
-  options.log(`== Auf npm steht jetzt ${PACKAGE_NAME}@${view.stdout.trim()}`);
+  options.log(`== Veröffentlicht: ${PACKAGE_NAME}@${options.version}`);
 };
 
 const main = async (): Promise<void> => {
@@ -114,10 +119,19 @@ const main = async (): Promise<void> => {
   if (unknown.length) throw new Error(`Unbekanntes Argument: ${unknown.join(" ")}\n${usage}`);
   const token = process.env.npm_key;
   if (!token) throw new Error(`npm_key fehlt: der npm-Token mit Schreibrecht auf ${PACKAGE_NAME}.\n${usage}`);
+  const manifestFile = path.join(repositoryRoot, "package.json");
+  const published = publishedVersions(PACKAGE_NAME, runNpm);
+  const next = nextVersion(readVersion(manifestFile), published);
+  console.log(versionLine(next));
+  const extensionManifestFile = path.join(repositoryRoot, "apps", "vscode", "package.json");
+  if (!dryRun) {
+    writeVersion(manifestFile, next.version);
+    writeHostPackageVersion(extensionManifestFile, next.version);
+  }
   const built = await buildPackage(path.join(repositoryRoot, "dist", PACKAGE_FOLDER));
-  const plan = publishPlan(built.manifest, publishedVersions(PACKAGE_NAME, runNpm));
+  const plan = publishPlan(built.manifest, published, next.version);
   console.log(`== ${plan.name}@${plan.version} aus Host ${plan.hostVersion.slice(0, 12)}, ${built.fileCount} Dateien, ${(built.byteSize / 1024 / 1024).toFixed(1)} MB`);
-  publishDirectory({ directory: built.directory, token, dryRun, npm: runNpm, log: (line) => console.log(line) });
+  publishDirectory({ directory: built.directory, version: plan.version, token, dryRun, npm: runNpm, log: (line) => console.log(line) });
 };
 
 const moduleUrl: string | undefined = import.meta.url;

package/scripts/package/ragents.mjs

@@ -20,12 +20,13 @@ export const commands = {
 
 const usage = `Verwendung: ragents <befehl> [argumente]
 
-  run <ordner> "<auftrag>"         Host starten, Run auf dem Ordner anlegen und auf das Ende warten
+  run <ordner> "<auftrag>"         Host ohne Oberfläche starten, Run anlegen und auf das Ende warten
   send <run> "<text>"              Folgeauftrag im selben Run
   journal <run> [--tools]          Verlauf eines Runs lesen
   stop <run> | stop --host         laufenden Turn abbrechen oder den gemerkten Host beenden
   connect <server-url>             Client-Profil holen und den lokalen Server damit starten
-  start <profil>                   ein Profil des Pakets oder einen geholten Stand starten
+  start <profil|pfad>              ein Profil des Pakets, eine eigene Profildatei oder einen
+                                   geholten Stand starten; baut die Oberfläche bei Bedarf
   provision [<profil>|--workspace] Werkzeuge der Plugins holen
   workspace-client <server-url>    diesen Rechner als Arbeitsplatz anmelden
 `;

package/scripts/remote/connect.ts

@@ -8,6 +8,8 @@ import { fileURLToPath } from "node:url";
 import { extract as extractTar } from "tar";
 import { ragentsDataRoot } from "../../apps/server/src/data-directory.ts";
 import { hostRoot, readHostPackage, readHostVersion } from "../../apps/server/src/host-version.ts";
+import { readProfileTarget } from "../../apps/server/src/profile-target.ts";
+import { ensureWebBuild } from "../../apps/server/src/web-build.ts";
 import { RpcClient } from "../../apps/web/src/rpc/client.ts";
 import { profileDistributionContracts, type ClientProfileDescription } from "../../plugins/ragents.profile-distribution/contract.ts";
 
@@ -226,24 +228,33 @@ export interface StartedProfile {
   readonly profileFile: string;
   /** Nur bei einem geholten Stand gesetzt; ein Profil des Hosts nimmt die Vorgaben seiner eigenen Konfiguration. */
   readonly dataDirectory?: string;
+  /** Nur bei einem geholten Stand gesetzt; sonst baut der Start das Web des Profils selbst. */
   readonly webDirectory?: string;
   readonly port: number | undefined;
 }
 
-/** Provisioniert die Werkzeuge des Profils und startet den Server damit. */
+/** Provisioniert die Werkzeuge des Profils, baut sein Web falls nötig und startet den Server damit. */
 export const startProfile = async (started: StartedProfile): Promise<number> => {
+  const dataDirectory = started.dataDirectory ?? (await readProfileTarget(started.profile, started.profileFile)).dataDirectory;
   const env: NodeJS.ProcessEnv = {
     ...process.env,
     PRODUCT_PROFILE: started.profile,
     PRODUCT_PROFILE_FILE: started.profileFile,
-    ...(started.dataDirectory ? { DATA_DIR: started.dataDirectory } : {}),
-    ...(started.webDirectory ? { WEB_DIST_DIR: started.webDirectory } : {}),
+    DATA_DIR: dataDirectory,
   };
   console.log("== Werkzeuge provisionieren");
   const provisioned = await run(hostScript("scripts/provision/run-provision.ts"), env);
   if (provisioned !== 0) throw new Error(`Die Provisionierung endete mit Code ${provisioned}`);
-  console.log(started.webDirectory ? `== Server starten (Web ${started.webDirectory})` : "== Server starten");
-  return run(hostScript("apps/server/src/main.ts", started.port !== undefined ? ["--port", String(started.port)] : []), env);
+  const webDirectory = started.webDirectory ?? await ensureWebBuild({
+    root: hostRoot(),
+    profile: started.profile,
+    profileFile: started.profileFile,
+    dataDirectory,
+    environment: env,
+    log: (line) => console.log(line),
+  });
+  console.log(`== Server starten (Web ${webDirectory}, Daten ${dataDirectory})`);
+  return run(hostScript("apps/server/src/main.ts", started.port !== undefined ? ["--port", String(started.port)] : []), { ...env, WEB_DIST_DIR: webDirectory });
 };
 
 /** Startet einen Stand, den connect geholt hat, mit dem Web aus dem Cache. */

package/scripts/remote/start.ts

@@ -1,3 +1,5 @@
+// Der Hook löst @aicontainer/* auch für eine Profildatei außerhalb des Hosts auf; im Paket gibt es dort kein node_modules.
+import "../../apps/server/src/host-resolution.ts";
 import { statSync } from "node:fs";
 import { readFile, readdir } from "node:fs/promises";
 import path from "node:path";
@@ -5,14 +7,16 @@ import { fileURLToPath } from "node:url";
 import { profileFileName } from "../../apps/server/src/config-file.ts";
 import { ragentsDataRoot } from "../../apps/server/src/data-directory.ts";
 import { hostRoot } from "../../apps/server/src/host-version.ts";
+import { callerDirectory } from "../agent/agent-cli.ts";
 import { startCached, startProfile, type CachedProfile } from "./connect.ts";
 
-const usage = (): string => `Verwendung: ragents start <profil> [--port <n>]
-Startet ein Profil dieses Hosts (core, developer) oder einen Stand, den ragents connect schon
-geholt hat, ohne den Server zu fragen. Ein geholter Stand bringt sein Web aus demselben Cache
-mit. Ohne Argument nennt der Befehl die Profile im Cache.`;
+const usage = (): string => `Verwendung: ragents start <profil|pfad> [--port <n>]
+Startet ein Profil dieses Hosts (core, developer), eine eigene ragents.config.<profil>.ts an
+beliebiger Stelle oder einen Stand, den ragents connect schon geholt hat, ohne den Server zu
+fragen. Ein eigenes Profil bekommt sein Web beim Start gebaut, ein geholter Stand bringt es aus
+demselben Cache mit. Ohne Argument nennt der Befehl die Profile im Cache.`;
 
-export const parseArguments = (argv: readonly string[]): { profile: string; port: number | undefined } => {
+export const parseArguments = (argv: readonly string[]): { selection: string; port: number | undefined } => {
   let profile: string | undefined;
   let port: number | undefined;
   for (let index = 0; index < argv.length; index += 1) {
@@ -28,7 +32,7 @@ export const parseArguments = (argv: readonly string[]): { profile: string; port
     profile = argument;
   }
   if (!profile) throw new Error(`Der Profilname fehlt.\n${usage()}`);
-  return { profile, port };
+  return { selection: profile, port };
 };
 
 const directories = async (folder: string): Promise<readonly string[]> =>
@@ -60,22 +64,36 @@ export const selectCachedProfile = (cached: readonly CachedProfile[], profile: s
     + "nimm ragents connect <server-url>.");
 };
 
-/** Ein Profil, das neben dem Host liegt: im Checkout die Datei im Repo, im Paket die mitgelieferte. */
-export const hostProfileFile = (profile: string, root = hostRoot()): string | undefined => {
-  const file = path.join(root, profileFileName(profile));
-  return statSync(file, { throwIfNoEntry: false })?.isFile() ? file : undefined;
+const PROFILE_FILE = /^ragents\.config\.([a-z0-9]+(?:-[a-z0-9]+)*)\.ts$/;
+
+export interface LocalProfile {
+  readonly profile: string;
+  readonly profileFile: string;
+}
+
+/** Ein Profil ist ein Name neben dem Host (Checkout wie Paket) oder ein Pfad zu einer ragents.config.<profil>.ts an beliebiger Stelle. */
+export const localProfile = (selection: string, root = hostRoot(), caller = callerDirectory()): LocalProfile | undefined => {
+  if (!selection.includes("/") && !selection.endsWith(".ts")) {
+    const file = path.join(root, profileFileName(selection));
+    return statSync(file, { throwIfNoEntry: false })?.isFile() ? { profile: selection, profileFile: file } : undefined;
+  }
+  const profileFile = path.resolve(caller, selection);
+  const match = PROFILE_FILE.exec(path.basename(profileFile));
+  if (!match) throw new Error(`Eine Profildatei heißt ragents.config.<profil>.ts, nicht ${path.basename(profileFile)}`);
+  if (!statSync(profileFile, { throwIfNoEntry: false })?.isFile()) throw new Error(`Die Profildatei fehlt: ${profileFile}`);
+  return { profile: match[1]!, profileFile };
 };
 
 const main = async (): Promise<void> => {
   const arguments_ = parseArguments(process.argv.slice(2));
-  const own = hostProfileFile(arguments_.profile);
+  const own = localProfile(arguments_.selection);
   if (own) {
-    console.log(`== Profil ${arguments_.profile} dieses Hosts`);
-    console.log(`== Profildatei ${own}`);
-    process.exitCode = await startProfile({ profile: arguments_.profile, profileFile: own, port: arguments_.port });
+    console.log(`== Profil ${own.profile}`);
+    console.log(`== Profildatei ${own.profileFile}`);
+    process.exitCode = await startProfile({ profile: own.profile, profileFile: own.profileFile, port: arguments_.port });
     return;
   }
-  const cached = selectCachedProfile(await cachedProfiles(ragentsDataRoot()), arguments_.profile);
+  const cached = selectCachedProfile(await cachedProfiles(ragentsDataRoot()), arguments_.selection);
   console.log(`== Profil ${cached.profile} vom Server ${cached.serverUrl}, Stand ${cached.version.slice(0, 12)} (aus dem Cache)`);
   console.log(`== Profildatei ${cached.profileFile}`);
   console.log(`== Daten ${cached.dataDirectory}`);

package/scripts/workspace-client/run-workspace-client.ts

@@ -3,6 +3,7 @@ import { statSync } from "node:fs";
 import { hostname } from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { hostRoot } from "../../apps/server/src/host-version.ts";
 import { provisionWorkspace } from "../../apps/server/src/profile/provisioning.ts";
 import { workspaceClientTransport } from "../../plugins/ragents.workspace/client/transport.ts";
 import { WorkspaceClient } from "../../plugins/ragents.workspace/client/workspace-client.ts";
@@ -13,7 +14,7 @@ dieses Rechners aus - dasselbe, was die VS-Code-Erweiterung tut, nur ohne VS Cod
 gilt das aktuelle Verzeichnis. Jeder Werkzeugaufruf erscheint als eine Zeile auf stdout.
 Die Sprachserver holt der Start in den Werkzeugordner dieses Rechners (dasselbe wie
 pnpm provision --workspace); ROSLYN_LANGUAGE_SERVER und FSHARP_LANGUAGE_SERVER übersteuern ihn,
-TypeScript bringt der Executor mit. Das Skript läuft, bis es mit Strg-C beendet wird.`;
+TypeScript kommt aus dem Host-Ordner. Das Skript läuft, bis es mit Strg-C beendet wird.`;
 
 export interface WorkspaceClientArguments {
   readonly serverUrl: string;
@@ -71,6 +72,7 @@ const main = async (): Promise<void> => {
   };
   const transport = workspaceClientTransport(parsed.serverUrl, process.env.RAGENTS_TOKEN);
   const client = new WorkspaceClient(transport, identity, {
+    hostRoot,
     onExecuted: ({ runId, tool, durationMs, error }) =>
       console.log(`== ${runId.slice(0, 8)} ${tool} ${durationMs} ms ${error ?? "ok"}`),
   });

package/apps/web/src/MaterialSettings.tsx

@@ -1,40 +0,0 @@
-import { useEffect, useId, useState } from "react";
-import { useAccess } from "./AccessContext";
-import { DEFAULT_MATERIAL_SETTINGS, MATERIAL_SETTINGS_LIMITS, resetMaterialSettings, saveMaterialSettings, useMaterialSettings } from "./material-settings";
-import { Button, Input } from "./ui";
-
-const noteClasses = "text-sm leading-[1.6] text-muted-foreground";
-
-export function MaterialSettings() {
-  const { settings, error } = useMaterialSettings();
-  const writable = useAccess().can("settings.write");
-  const prefix = useId();
-  const [steps, setSteps] = useState(String(settings.steps));
-  useEffect(() => { setSteps(String(settings.steps)); }, [settings]);
-  const valid = (text: string, min: number, max: number) => text.trim() !== "" && Number.isInteger(Number(text)) && Number(text) >= min && Number(text) <= max;
-  const stepsValid = valid(steps, MATERIAL_SETTINGS_LIMITS.minSteps, MATERIAL_SETTINGS_LIMITS.maxSteps);
-  const changeSteps = (value: string) => {
-    if (!writable) return;
-    setSteps(value);
-    if (valid(value, MATERIAL_SETTINGS_LIMITS.minSteps, MATERIAL_SETTINGS_LIMITS.maxSteps)) saveMaterialSettings({ ...settings, steps: Number(value) });
-  };
-  return <div className="flex min-w-0 max-w-[680px] flex-col gap-5">
-    <p className={noteClasses}>Schichtwerk mit matten Flächen und gestapelter Tiefe. Änderungen gelten sofort für alle Runs und werden in diesem Browser gespeichert.</p>
-    <div className="flex flex-col gap-2">
-      <label className="text-sm font-semibold text-foreground" id={`${prefix}-steps-label`} htmlFor={`${prefix}-steps`}>Tiefenstufen</label>
-      <div className="flex min-w-0 items-center gap-5">
-        <input className="w-0 min-w-0 flex-1 accent-primary" aria-labelledby={`${prefix}-steps-label`} disabled={!writable} type="range" min={MATERIAL_SETTINGS_LIMITS.minSteps} max={MATERIAL_SETTINGS_LIMITS.maxSteps} step="1" value={settings.steps} onChange={(event) => changeSteps(event.target.value)} />
-        <Input className="w-[84px] flex-none" id={`${prefix}-steps`} aria-invalid={!stepsValid} aria-describedby={`${prefix}-steps-note`} disabled={!writable} type="number" min={MATERIAL_SETTINGS_LIMITS.minSteps} max={MATERIAL_SETTINGS_LIMITS.maxSteps} step="1" value={steps} onChange={(event) => changeSteps(event.target.value)} />
-      </div>
-      <p id={`${prefix}-steps-note`} className={stepsValid ? noteClasses : "text-sm leading-[1.6] text-destructive"}>{stepsValid ? `0 ist flach, bis zu 5 gleich tiefe Stufen. Standard: ${DEFAULT_MATERIAL_SETTINGS.steps}.` : "Bitte eine ganze Zahl von 0 bis 5 eingeben."}</p>
-    </div>
-    <div><Button variant="outline" disabled={!writable} onClick={() => {
-      if (!writable) return;
-      if (resetMaterialSettings()) {
-        setSteps(String(DEFAULT_MATERIAL_SETTINGS.steps));
-      }
-    }}>Auf Standard zurücksetzen</Button></div>
-    {!writable && <p className={noteClasses}>Die Materialeinstellungen sind mit deinen Rechten nur lesbar.</p>}
-    {error && <p className="text-sm leading-[1.6] text-destructive" role="alert">{error}</p>}
-  </div>;
-}