@schlenkr/ragents 0.1.0 → 0.1.2

package/packages/workspace-executor/src/language-server/host.ts

@@ -2,7 +2,7 @@ import { realpath, stat } from "node:fs/promises";
 import path from "node:path";
 import type { WorkspaceProcessContext } from "../context.js";
 import { runManagedProcess } from "../managed-process.js";
-import type { LanguageServerDiagnostic, LanguageServerSnapshot } from "./contract.js";
+import type { LanguageServerDiagnostic, LanguageServerInstanceSnapshot, LanguageServerSnapshot } from "./contract.js";
 import { diagnosticEntries, formatDiagnostics } from "./diagnostics.js";
 import { LanguageServerSession, withTimeout, type LanguageServerLaunch } from "./session.js";
 import { allowedWorkspacePath, containsWorkspacePath, expandWorkspaceAlias, resolvedWorkspacePath } from "../paths.js";
@@ -13,6 +13,7 @@ export interface LanguageServerAdapter {
   languages: Readonly<Record<string, string>>;
   rootDescription: string;
   resolveRoot: (workspaceRoot: string, root: string) => Promise<string>;
+  rootDirectory: (root: string) => string;
   launch: (context: WorkspaceProcessContext, root: string) => Promise<LanguageServerLaunch>;
   open: (session: LanguageServerSession, root: string, timeoutMs: number) => Promise<string>;
 }
@@ -30,6 +31,7 @@ interface OpenServer {
 }
 
 interface ServerEntry {
+  runId: string;
   root: string;
   state: "opening" | "ready" | "failed";
   summary: string;
@@ -47,12 +49,23 @@ const GIT_TIMEOUT_MS = 30 * 1000;
 
 const messageOf = (error: unknown): string => error instanceof Error ? error.message : String(error);
 
-const git = async (context: WorkspaceProcessContext, tool: string, args: readonly string[]): Promise<string> => {
+const keyOf = (runId: string, root: string): string => `${runId}\n${root}`;
+
+const runOf = (key: string): string => key.slice(0, key.indexOf("\n"));
+
+const instanceCount = (count: number): string => `${count} offene Instanz${count === 1 ? "" : "en"}`;
+
+const git = async (
+  context: WorkspaceProcessContext,
+  directory: string,
+  tool: string,
+  args: readonly string[],
+): Promise<string> => {
   let output = "";
   const result = await runManagedProcess({
     command: "git",
     args: [...args],
-    cwd: context.root,
+    cwd: directory,
     env: context.env,
     uid: context.uid,
     gid: context.gid,
@@ -66,14 +79,15 @@ const git = async (context: WorkspaceProcessContext, tool: string, args: readonl
   return output;
 };
 
-/** Git nennt seine Pfade relativ zur Repo-Wurzel; `-- .` grenzt sie auf den Arbeitsbereich ein. */
+/** Git nennt seine Pfade relativ zur Repo-Wurzel; `-- .` grenzt sie auf die Wurzel der Instanz ein. */
 export const changedWorkspaceFiles = async (
   context: WorkspaceProcessContext,
+  directory: string,
   tool: string,
   handles: (filePath: string) => boolean,
 ): Promise<string[]> => {
-  const topLevel = (await git(context, tool, ["rev-parse", "--show-toplevel"])).trim();
-  const candidates = (await git(context, tool, ["status", "--porcelain", "--untracked-files=all", "--no-renames", "--", "."]))
+  const topLevel = (await git(context, directory, tool, ["rev-parse", "--show-toplevel"])).trim();
+  const candidates = (await git(context, directory, tool, ["status", "--porcelain", "--untracked-files=all", "--no-renames", "--", "."]))
     .split("\n")
     .filter((line) => line.length > 3 && line[1] !== "D" && line[0] !== "D")
     .map((line) => path.resolve(topLevel, line.slice(3)))
@@ -92,7 +106,7 @@ export class LanguageServerHost {
   readonly #openTimeoutMs: number;
   readonly #diagnosticsTimeoutMs: number;
   readonly #servers = new Map<string, ServerEntry>();
-  readonly #roots = new Map<string, string>();
+  readonly #roots = new Map<string, Set<string>>();
   readonly #lifetimes = new Map<string, object>();
   readonly #closing = new Map<string, Set<Promise<void>>>();
   readonly #idleTimers = new Map<string, NodeJS.Timeout>();
@@ -117,71 +131,163 @@ export class LanguageServerHost {
 
   async open(runId: string, root: string): Promise<string> {
     const lifetime = this.#lifetime(runId);
-    const previous = this.#servers.get(runId);
+    const { context, absoluteRoot } = await this.#prepare(runId, lifetime, root);
+    const current = this.#current(runId, absoluteRoot);
+    if (current && current.state !== "failed") {
+      const server = await current.pending!.catch(async (error: unknown) => {
+        await this.#recordFailure(runId, lifetime, absoluteRoot, error);
+        throw error;
+      });
+      this.#assertCurrent(current);
+      this.#touch(runId, absoluteRoot);
+      return this.#openMessage(runId, `${this.adapter.label} ist für ${absoluteRoot} bereits geöffnet: ${server.summary}`);
+    }
+    const server = await this.#start(runId, context, absoluteRoot);
+    this.#assertLifetime(runId, lifetime);
+    if (this.#servers.get(keyOf(runId, absoluteRoot))?.server !== server) throw this.#stopped();
+    return this.#openMessage(runId, `${server.summary} (Wurzel ${absoluteRoot})`);
+  }
+
+  async close(runId: string, root?: string): Promise<string> {
+    if (root === undefined) {
+      const roots = this.#openRoots(runId);
+      if (roots.length === 0) return `${this.adapter.label} ist in diesem Run nicht geöffnet`;
+      await Promise.all(roots.map((entry) => this.#closeInstance(runId, entry)));
+      const closed = roots.length === 1 ? "eine Instanz" : `${roots.length} Instanzen`;
+      return `${this.adapter.label}: ${closed} beendet; keine offene Instanz mehr in diesem Run`;
+    }
+    const context = await this.#contextFor(runId);
+    const chosen = await this.#known(runId, context, root);
+    await this.#closeInstance(runId, chosen);
+    return `${this.adapter.label} für ${chosen} beendet; ${instanceCount(this.#openRoots(runId).length)} in diesem Run`;
+  }
+
+  async snapshot(runId: string): Promise<LanguageServerSnapshot> {
+    const instances: LanguageServerInstanceSnapshot[] = [];
+    for (const root of this.#openRoots(runId)) {
+      const instance = await this.#instanceSnapshot(runId, root);
+      if (instance) instances.push(instance);
+    }
+    return { instances };
+  }
+
+  async diagnostics(
+    runId: string,
+    paths: readonly string[] | undefined,
+    includeWarnings: boolean,
+    root?: string,
+  ): Promise<string> {
+    const lifetime = this.#lifetime(runId);
+    const context = await this.#contextFor(runId);
+    this.#assertLifetime(runId, lifetime);
+    const roots = root === undefined ? this.#openRoots(runId) : [await this.#known(runId, context, root)];
+    if (roots.length === 0) throw new Error(`Kein ${this.adapter.label}-Server geöffnet; zuerst ${this.adapter.id}_open aufrufen`);
+    const results = paths === undefined || paths.length === 0
+      ? await this.#changed(runId, context, roots, includeWarnings)
+      : await this.#requested(runId, context, roots, paths, includeWarnings);
+    if (results.length === 0) return `Keine geänderten ${this.adapter.label}-Dateien in den geöffneten Wurzeln`;
+    return results.join("\n\n");
+  }
+
+  async annotate(runId: string, absolutePath: string): Promise<string | undefined> {
+    if (!this.handles(absolutePath) || this.#openRoots(runId).length === 0) return undefined;
+    try {
+      const lifetime = this.#lifetime(runId);
+      const context = await this.#contextFor(runId);
+      this.#assertLifetime(runId, lifetime);
+      const file = await allowedWorkspacePath(absolutePath, [context.root, ...context.additionalRoots ?? []]);
+      const chosen = this.#match(this.#openRoots(runId), file);
+      if (!chosen) return undefined;
+      const server = await this.#ensure(runId, context, chosen);
+      return await this.#format(context, server, file, false);
+    } catch (error) {
+      return `Diagnostik (${this.adapter.label}) fehlgeschlagen: ${messageOf(error)}`;
+    }
+  }
+
+  async stopSession(runId: string): Promise<void> {
+    this.#lifetimes.delete(runId);
+    const keys = new Set([
+      ...this.#openRoots(runId).map((root) => keyOf(runId, root)),
+      ...[...this.#servers.keys()].filter((key) => runOf(key) === runId),
+    ]);
+    this.#roots.delete(runId);
+    for (const key of keys) this.#seen.delete(key);
+    await Promise.all([...keys].map((key) => this.#close(key)));
+    await Promise.all(this.#closing.get(runId) ?? []);
+  }
+
+  async shutdown(): Promise<void> {
+    this.#closed = true;
+    const runs = new Set([
+      ...this.#lifetimes.keys(),
+      ...this.#roots.keys(),
+      ...[...this.#servers.keys()].map(runOf),
+      ...this.#closing.keys(),
+    ]);
+    const results = await Promise.allSettled([...runs].map((runId) => this.stopSession(runId)));
+    const failures = results
+      .filter((result): result is PromiseRejectedResult => result.status === "rejected")
+      .map((result) => result.reason);
+    if (failures.length > 0) throw new AggregateError(failures, `${this.adapter.label}-Shutdown fehlgeschlagen`);
+  }
+
+  async #prepare(
+    runId: string,
+    lifetime: object,
+    root: string,
+  ): Promise<{ context: WorkspaceProcessContext; absoluteRoot: string }> {
     let absoluteRoot = root;
     try {
       const context = await this.#contextFor(runId);
       this.#assertLifetime(runId, lifetime);
       const allowed = await Promise.all([context.root, ...context.additionalRoots ?? []].map(resolvedWorkspacePath));
       const requested = await allowedWorkspacePath(path.resolve(context.root, expandWorkspaceAlias(root, context.workspaceAliases ?? {})), allowed);
+      absoluteRoot = requested;
       const workspaceRoot = allowed.find((directory) => containsWorkspacePath(directory, requested))!;
       absoluteRoot = await this.adapter.resolveRoot(workspaceRoot, requested);
       this.#assertLifetime(runId, lifetime);
-      const current = this.#current(runId);
-      if (current && current.root === absoluteRoot && current.state !== "failed") {
-        const server = await current.pending!;
-        this.#assertCurrent(runId, current);
-        this.#touch(runId);
-        return `${this.adapter.label} ist bereits geöffnet: ${server.summary}`;
-      }
-      const server = await this.#start(runId, context, absoluteRoot);
-      this.#assertLifetime(runId, lifetime);
-      if (this.#servers.get(runId)?.server !== server) throw this.#stopped();
-      return server.summary;
+      return { context, absoluteRoot };
     } catch (error) {
-      if (this.#lifetimes.get(runId) === lifetime && this.#servers.get(runId) === previous && !this.#closed) {
-        const failed: ServerEntry = { root: absoluteRoot, state: "failed", summary: messageOf(error), controller: new AbortController() };
-        this.#servers.set(runId, failed);
-        this.#roots.set(runId, absoluteRoot);
-        this.#seen.delete(runId);
-        if (previous) await this.#dispose(runId, previous);
-      }
+      await this.#recordFailure(runId, lifetime, absoluteRoot, error);
       throw error;
     }
   }
 
-  async status(runId: string): Promise<string> {
-    const current = this.#current(runId);
-    if (current?.state === "opening") return current.summary;
-    if (current?.state === "failed") return `${this.adapter.label} konnte nicht geöffnet werden: ${current.summary}`;
-    if (current) return `${this.adapter.label} läuft: ${current.summary}`;
-    const root = this.#roots.get(runId);
-    return root
-      ? `${this.adapter.label} ist nach Leerlauf beendet und wird beim nächsten Zugriff für ${root} neu geladen`
-      : `${this.adapter.label} ist nicht geöffnet`;
+  async #recordFailure(runId: string, lifetime: object, root: string, error: unknown): Promise<void> {
+    if (this.#closed || this.#lifetimes.get(runId) !== lifetime) return;
+    const key = keyOf(runId, root);
+    const previous = this.#servers.get(key);
+    if (previous && previous.state !== "failed") return;
+    this.#servers.set(key, {
+      runId,
+      root,
+      state: "failed",
+      summary: messageOf(error),
+      controller: new AbortController(),
+    });
+    this.#remember(runId, root);
+    this.#seen.delete(key);
+    if (previous) await this.#dispose(previous);
   }
 
-  async snapshot(runId: string): Promise<LanguageServerSnapshot> {
-    const current = this.#current(runId);
-    if (current?.state === "opening" || current?.state === "failed") {
-      return { state: current.state, root: current.root, summary: current.summary, files: [] };
+  #openMessage(runId: string, text: string): string {
+    return `${text}; ${instanceCount(this.#openRoots(runId).length)} von ${this.adapter.label} in diesem Run`;
+  }
+
+  async #instanceSnapshot(runId: string, root: string): Promise<LanguageServerInstanceSnapshot | undefined> {
+    const entry = this.#current(runId, root);
+    if (entry?.state === "opening" || entry?.state === "failed") {
+      return { state: entry.state, root, summary: entry.summary, files: [] };
     }
-    const root = current?.root ?? this.#roots.get(runId);
-    const rootExists = !root || await this.#exists(root);
-    if (this.#servers.get(runId) !== current || this.#roots.get(runId) !== root) return this.snapshot(runId);
-    if (!rootExists) {
-      await this.stopSession(runId);
-      return { state: "closed", root: null, summary: null, files: [] };
+    if (!await this.#exists(root)) {
+      await this.#closeInstance(runId, root);
+      return undefined;
     }
-    const seen = this.#seen.get(runId);
+    const seen = this.#seen.get(keyOf(runId, root));
     const files = seen === undefined ? [] : await this.#existingFiles(runId, seen);
-    if (this.#servers.get(runId) !== current || this.#roots.get(runId) !== root) return this.snapshot(runId);
-    return {
-      state: current ? "ready" : root ? "suspended" : "closed",
-      root: root ?? null,
-      summary: current?.summary ?? null,
-      files,
-    };
+    if (!this.#roots.get(runId)?.has(root)) return undefined;
+    return { state: entry ? "ready" : "suspended", root, summary: entry?.summary ?? null, files };
   }
 
   async #exists(absolutePath: string): Promise<boolean> {
@@ -191,7 +297,7 @@ export class LanguageServerHost {
   async #existingFiles(
     runId: string,
     seen: ReadonlyMap<string, readonly LanguageServerDiagnostic[]>,
-  ): Promise<LanguageServerSnapshot["files"]> {
+  ): Promise<LanguageServerInstanceSnapshot["files"]> {
     const context = await this.#contextFor(runId);
     const entries = await Promise.all([...seen.entries()].map(async ([file, diagnostics]) =>
       await this.#exists(path.resolve(context.root, expandWorkspaceAlias(file, context.workspaceAliases ?? {}))) ? { path: file, diagnostics: [...diagnostics] } : null));
@@ -200,54 +306,61 @@ export class LanguageServerHost {
       .sort((left, right) => left.path.localeCompare(right.path, "de"));
   }
 
-  async diagnostics(runId: string, paths: readonly string[] | undefined, includeWarnings: boolean): Promise<string> {
-    const lifetime = this.#lifetime(runId);
-    const context = await this.#contextFor(runId);
-    this.#assertLifetime(runId, lifetime);
-    const server = await this.#ensure(runId, context);
-    const files = paths === undefined || paths.length === 0
-      ? await changedWorkspaceFiles(context, `${this.adapter.id}_diagnostics`, (file) => this.handles(file))
-      : await Promise.all(paths.map((requested) => allowedWorkspacePath(path.resolve(context.root, expandWorkspaceAlias(requested, context.workspaceAliases ?? {})), [context.root, ...context.additionalRoots ?? []])));
-    if (files.length === 0) return `Keine geänderten ${this.adapter.label}-Dateien im Arbeitsverzeichnis`;
+  async #changed(
+    runId: string,
+    context: WorkspaceProcessContext,
+    roots: readonly string[],
+    includeWarnings: boolean,
+  ): Promise<string[]> {
     const results: string[] = [];
-    for (const file of files) {
-      if (!this.handles(file)) {
-        throw new Error(`${path.relative(context.root, file)} hat keine ${this.adapter.label}-Endung (${Object.keys(this.adapter.languages).join(", ")})`);
-      }
-      results.push(await this.#format(context, server, file, includeWarnings));
+    for (const root of roots) {
+      const server = await this.#ensure(runId, context, root);
+      const files = await changedWorkspaceFiles(
+        context,
+        this.adapter.rootDirectory(root),
+        `${this.adapter.id}_diagnostics`,
+        (file) => this.handles(file),
+      );
+      for (const file of files) results.push(await this.#format(context, server, file, includeWarnings));
     }
-    return results.join("\n\n");
+    return results;
   }
 
-  async annotate(runId: string, absolutePath: string): Promise<string | undefined> {
-    if (!this.handles(absolutePath) || !this.#roots.has(runId)) return undefined;
-    try {
-      const lifetime = this.#lifetime(runId);
-      const context = await this.#contextFor(runId);
-      this.#assertLifetime(runId, lifetime);
-      const server = await this.#ensure(runId, context);
-      return await this.#format(context, server, absolutePath, false);
-    } catch (error) {
-      return `Diagnostik (${this.adapter.label}) fehlgeschlagen: ${messageOf(error)}`;
+  async #requested(
+    runId: string,
+    context: WorkspaceProcessContext,
+    roots: readonly string[],
+    paths: readonly string[],
+    includeWarnings: boolean,
+  ): Promise<string[]> {
+    const results: string[] = [];
+    for (const requested of paths) {
+      const file = await allowedWorkspacePath(path.resolve(context.root, expandWorkspaceAlias(requested, context.workspaceAliases ?? {})), [context.root, ...context.additionalRoots ?? []]);
+      if (!this.handles(file)) {
+        throw new Error(`${path.relative(context.root, file)} hat keine ${this.adapter.label}-Endung (${Object.keys(this.adapter.languages).join(", ")})`);
+      }
+      const chosen = this.#match(roots, file);
+      if (!chosen) {
+        throw new Error(`${path.relative(context.root, file)} liegt in keiner geöffneten ${this.adapter.label}-Wurzel; offen: ${roots.join(", ")}`);
+      }
+      results.push(await this.#format(context, await this.#ensure(runId, context, chosen), file, includeWarnings));
     }
+    return results;
   }
 
-  async stopSession(runId: string): Promise<void> {
-    this.#lifetimes.delete(runId);
-    this.#roots.delete(runId);
-    this.#seen.delete(runId);
-    await this.#close(runId);
-    await Promise.all(this.#closing.get(runId) ?? []);
+  #match(roots: readonly string[], file: string): string | undefined {
+    return [...roots]
+      .filter((root) => containsWorkspacePath(this.adapter.rootDirectory(root), file))
+      .sort((left, right) => this.adapter.rootDirectory(right).length - this.adapter.rootDirectory(left).length)[0];
   }
 
-  async shutdown(): Promise<void> {
-    this.#closed = true;
-    const runs = new Set([...this.#lifetimes.keys(), ...this.#roots.keys(), ...this.#servers.keys(), ...this.#closing.keys()]);
-    const results = await Promise.allSettled([...runs].map((runId) => this.stopSession(runId)));
-    const failures = results
-      .filter((result): result is PromiseRejectedResult => result.status === "rejected")
-      .map((result) => result.reason);
-    if (failures.length > 0) throw new AggregateError(failures, `${this.adapter.label}-Shutdown fehlgeschlagen`);
+  async #known(runId: string, context: WorkspaceProcessContext, root: string): Promise<string> {
+    const roots = this.#openRoots(runId);
+    if (roots.length === 0) throw new Error(`Kein ${this.adapter.label}-Server geöffnet; zuerst ${this.adapter.id}_open aufrufen`);
+    const requested = await resolvedWorkspacePath(path.resolve(context.root, expandWorkspaceAlias(root, context.workspaceAliases ?? {})));
+    const found = roots.find((open) => open === requested);
+    if (!found) throw new Error(`Für ${root} ist kein ${this.adapter.label}-Server geöffnet; offen: ${roots.join(", ")}`);
+    return found;
   }
 
   async #format(
@@ -256,61 +369,81 @@ export class LanguageServerHost {
     absolutePath: string,
     includeWarnings: boolean,
   ): Promise<string> {
-    this.#touch(context.runId);
+    this.#touch(context.runId, server.root);
+    const key = keyOf(context.runId, server.root);
     const checkedPath = await allowedWorkspacePath(absolutePath, [context.root, ...context.additionalRoots ?? []]);
     const diagnostics = await server.session.diagnosticsFor(await realpath(checkedPath), this.#diagnosticsTimeoutMs);
-    if (this.#servers.get(context.runId)?.server !== server) throw this.#stopped();
+    if (this.#servers.get(key)?.server !== server) throw this.#stopped();
     const alias = Object.entries(context.workspaceAliases ?? {}).find(([, root]) => containsWorkspacePath(root, checkedPath));
     const relativePath = alias ? `${alias[0]}/${path.relative(alias[1], checkedPath)}`
       : containsWorkspacePath(context.root, checkedPath) ? path.relative(context.root, checkedPath) : checkedPath;
-    const seen = this.#seen.get(context.runId) ?? new Map<string, readonly LanguageServerDiagnostic[]>();
+    const seen = this.#seen.get(key) ?? new Map<string, readonly LanguageServerDiagnostic[]>();
     seen.set(relativePath, diagnosticEntries(diagnostics));
-    this.#seen.set(context.runId, seen);
+    this.#seen.set(key, seen);
     return formatDiagnostics(this.adapter.label, relativePath, diagnostics, includeWarnings);
   }
 
-  #current(runId: string): ServerEntry | undefined {
-    const current = this.#servers.get(runId);
+  #openRoots(runId: string): string[] {
+    return [...this.#roots.get(runId) ?? []];
+  }
+
+  #remember(runId: string, root: string): void {
+    const roots = this.#roots.get(runId) ?? new Set<string>();
+    roots.add(root);
+    this.#roots.set(runId, roots);
+  }
+
+  async #closeInstance(runId: string, root: string): Promise<void> {
+    const roots = this.#roots.get(runId);
+    roots?.delete(root);
+    if (roots?.size === 0) this.#roots.delete(runId);
+    const key = keyOf(runId, root);
+    this.#seen.delete(key);
+    await this.#close(key);
+  }
+
+  #current(runId: string, root: string): ServerEntry | undefined {
+    const key = keyOf(runId, root);
+    const current = this.#servers.get(key);
     if (current?.server?.session.exited) {
-      this.#servers.delete(runId);
-      void this.#dispose(runId, current).catch((error) => console.error(`${this.adapter.label}: Bereinigung fehlgeschlagen: ${messageOf(error)}`));
+      this.#servers.delete(key);
+      void this.#dispose(current).catch((error) => console.error(`${this.adapter.label}: Bereinigung fehlgeschlagen: ${messageOf(error)}`));
       return undefined;
     }
     return current;
   }
 
-  async #ensure(runId: string, context: WorkspaceProcessContext): Promise<OpenServer> {
+  async #ensure(runId: string, context: WorkspaceProcessContext, root: string): Promise<OpenServer> {
     if (this.#closed) throw this.#stopped();
-    const current = this.#current(runId);
+    const current = this.#current(runId, root);
     if (current?.state === "failed") throw new Error(current.summary);
     if (current) {
       const server = await current.pending!;
-      this.#assertCurrent(runId, current);
+      this.#assertCurrent(current);
       return server;
     }
-    const root = this.#roots.get(runId);
-    if (!root) throw new Error(`Kein ${this.adapter.label}-Server geöffnet; zuerst ${this.adapter.id}_open aufrufen`);
     return this.#start(runId, context, root);
   }
 
   #start(runId: string, context: WorkspaceProcessContext, root: string): Promise<OpenServer> {
-    const previous = this.#servers.get(runId);
-    const closing = previous ? this.#dispose(runId, previous) : undefined;
+    const key = keyOf(runId, root);
+    const previous = this.#servers.get(key);
+    const closing = previous ? this.#dispose(previous) : undefined;
     const entry: ServerEntry = {
-      root, state: "opening", summary: `${this.adapter.label} lädt ${root}`, controller: new AbortController(),
+      runId, root, state: "opening", summary: `${this.adapter.label} lädt ${root}`, controller: new AbortController(),
     };
-    this.#servers.set(runId, entry);
-    this.#roots.set(runId, root);
-    this.#seen.delete(runId);
+    this.#servers.set(key, entry);
+    this.#remember(runId, root);
+    this.#seen.delete(key);
     entry.pending = (async (): Promise<OpenServer> => {
       try {
         await closing;
-        this.#assertCurrent(runId, entry);
+        this.#assertCurrent(entry);
         const launch = await this.adapter.launch(context, root);
-        this.#assertCurrent(runId, entry);
+        this.#assertCurrent(entry);
         entry.initializing = LanguageServerSession.start(launch, this.#openTimeoutMs);
         const session = await entry.initializing;
-        this.#assertCurrent(runId, entry);
+        this.#assertCurrent(entry);
         let aborted!: () => void;
         const cancelled = new Promise<never>((_resolve, reject) => {
           aborted = () => reject(entry.controller.signal.reason);
@@ -326,49 +459,49 @@ export class LanguageServerHost {
         } finally {
           entry.controller.signal.removeEventListener("abort", aborted);
         }
-        this.#assertCurrent(runId, entry);
+        this.#assertCurrent(entry);
         if (session.exited) throw new Error(`${this.adapter.label} wurde während des Ladens beendet`);
         const server = { root, session, summary };
         entry.server = server;
         entry.state = "ready";
         entry.summary = summary;
-        this.#touch(runId);
+        this.#touch(runId, root);
         return server;
       } catch (error) {
-        if (this.#servers.get(runId) === entry && !entry.controller.signal.aborted) {
+        if (this.#servers.get(key) === entry && !entry.controller.signal.aborted) {
           entry.state = "failed";
           entry.summary = messageOf(error);
         }
-        await this.#dispose(runId, entry);
+        await this.#dispose(entry);
         throw error;
       }
     })();
     return entry.pending;
   }
 
-  async #close(runId: string): Promise<void> {
-    const timer = this.#idleTimers.get(runId);
+  async #close(key: string): Promise<void> {
+    const timer = this.#idleTimers.get(key);
     if (timer) clearTimeout(timer);
-    this.#idleTimers.delete(runId);
-    const entry = this.#servers.get(runId);
+    this.#idleTimers.delete(key);
+    const entry = this.#servers.get(key);
     if (!entry) return;
-    this.#servers.delete(runId);
-    await this.#dispose(runId, entry);
+    this.#servers.delete(key);
+    await this.#dispose(entry);
   }
 
-  #dispose(runId: string, entry: ServerEntry): Promise<void> {
+  #dispose(entry: ServerEntry): Promise<void> {
     entry.controller.abort(this.#stopped());
     if (entry.closing) return entry.closing;
     entry.closing = (async () => {
       const session = await entry.initializing?.catch(() => undefined);
       await session?.shutdown();
     })();
-    const pending = this.#closing.get(runId) ?? new Set<Promise<void>>();
-    this.#closing.set(runId, pending);
+    const pending = this.#closing.get(entry.runId) ?? new Set<Promise<void>>();
+    this.#closing.set(entry.runId, pending);
     pending.add(entry.closing);
     const finished = () => {
       pending.delete(entry.closing!);
-      if (pending.size === 0 && this.#closing.get(runId) === pending) this.#closing.delete(runId);
+      if (pending.size === 0 && this.#closing.get(entry.runId) === pending) this.#closing.delete(entry.runId);
     };
     entry.closing.then(finished, finished);
     return entry.closing;
@@ -385,25 +518,29 @@ export class LanguageServerHost {
     if (this.#closed || this.#lifetimes.get(runId) !== lifetime) throw this.#stopped();
   }
 
-  #assertCurrent(runId: string, entry: ServerEntry): void {
-    if (this.#closed || entry.controller.signal.aborted || entry.server?.session.exited || this.#servers.get(runId) !== entry) throw this.#stopped();
+  #assertCurrent(entry: ServerEntry): void {
+    if (this.#closed
+      || entry.controller.signal.aborted
+      || entry.server?.session.exited
+      || this.#servers.get(keyOf(entry.runId, entry.root)) !== entry) throw this.#stopped();
   }
 
   #stopped(): Error {
     return new Error(`${this.adapter.label}-Start wurde beendet`);
   }
 
-  #touch(runId: string): void {
-    const entry = this.#servers.get(runId);
+  #touch(runId: string, root: string): void {
+    const key = keyOf(runId, root);
+    const entry = this.#servers.get(key);
     if (!entry || entry.state !== "ready") return;
-    const existing = this.#idleTimers.get(runId);
+    const existing = this.#idleTimers.get(key);
     if (existing) clearTimeout(existing);
     const timer = setTimeout(() => {
-      this.#idleTimers.delete(runId);
-      if (this.#servers.get(runId) !== entry) return;
-      void this.#close(runId).catch((error) => console.error(`${this.adapter.label}: Beenden nach Leerlauf fehlgeschlagen: ${messageOf(error)}`));
+      this.#idleTimers.delete(key);
+      if (this.#servers.get(key) !== entry) return;
+      void this.#close(key).catch((error) => console.error(`${this.adapter.label}: Beenden nach Leerlauf fehlgeschlagen: ${messageOf(error)}`));
     }, this.#idleMs);
     timer.unref();
-    this.#idleTimers.set(runId, timer);
+    this.#idleTimers.set(key, timer);
   }
 }

package/plugins/ragents.actor-programs/contract.ts

@@ -7,7 +7,7 @@ export const ACTOR_INVOCATIONS_STATE_ID = "ragents.actor-programs.invocations";
 export const ACTOR_SCRIPT_STATE_ID = "ragents.actor-programs.script";
 export const ACTOR_STATE_ID = "ragents.actor-state";
 
-export interface ActorViewPlacement { kind: "canvas"; anchorActorId: string; width: number; height: number; }
+export interface ActorViewPlacement { kind: "canvas"; anchorActorId: string; }
 export interface ActorViewDefinition {
   id: string;
   key: string;

package/plugins/ragents.actor-programs/prompt.hbs

@@ -29,7 +29,7 @@ one active program package; add further functions and views to that package.
 
 `package.json` contains `name`, `private: true`, `type: "module"` and `ragents` metadata:
 `title`, optional `description`, optional `backend`, and optional `views`. Each view has an
-`id`, `client`, optional `title`, `styles`, `width` and `height`. At least a backend or a view
+`id`, `client` and optional `title` and `styles`. At least a backend or a view
 is required. The host supplies the HTML root and fixed local dependencies.
 
 Import `defineActor` from `@ragents/server` and `Type` from `typebox`. Its contract contains
@@ -68,9 +68,9 @@ Use `FlowDiagram` for other graphs (star layout, fit, actions). Keep local IDs s
 See `controls`. For custom SVG use `SvgEdge`, Tailwind utilities, responsive `viewBox` and
 accessible descriptions.
 Address view visibility with `package-name/view-key`, `@handle/view-key` or a unique title;
-canvas nodes and lines use the same names with the `app:` prefix.
-The host controls resizing, collapse and full view. Views appear on the canvas; owner cards
-start hidden but remain in the Actors list. Personal actor visibility is separate from
+a tile uses the same names with the `app:` prefix.
+The host sizes the tile and offers the full view. Views appear as tiles; owner cards are not
+placed by themselves but stay in the Actors list. Personal actor visibility is separate from
 `actor_view_set_visibility` and cannot be changed by layouts.
 
 Tests call `program.functions.<name>(input, context)` or `program.onInput(input, context)`.

package/plugins/ragents.actor-programs/server/app-project.ts

@@ -78,8 +78,6 @@ export const appPackageSchema = Type.Object({
   views: Type.Optional(Type.Array(Type.Object({
     id: Type.String({ pattern: "^[a-z][a-z0-9-]{0,63}$" }), title: Type.Optional(Type.String({ minLength: 1 })),
     client: Type.String({ minLength: 1 }), styles: Type.Optional(Type.String()),
-    width: Type.Optional(Type.Integer({ minimum: 280, maximum: 960 })),
-    height: Type.Optional(Type.Integer({ minimum: 180, maximum: 720 })),
   }, { additionalProperties: false }))),
 }, { additionalProperties: false });
 export type AppPackage = Static<typeof appPackageSchema>;