@schlenkr/ragents 0.1.4 → 0.1.6

package/bundles/ragents.workspace/server/index.js

@@ -0,0 +1,1049 @@
+import { createRequire as __ragentsCreateRequire } from "node:module";
+const require = __ragentsCreateRequire(import.meta.url);
+
+// server/index.ts
+import path3 from "node:path";
+import { DomainError as DomainError4 } from "@ragents/engine";
+import { documentStoreToken } from "@ragents/host/ragents/document-store.js";
+import { workspaceResolverToken, workspaceRuntimeToken } from "@ragents/host/ragents/workspace-runtime.js";
+import { sandboxServicesToken } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
+import {
+  hostAddressToken,
+  runtimeProviderToken,
+  runGuardToken,
+  runWorkspaceProviderToken,
+  workspaceGuardToken
+} from "@ragents/host/ragents/host-services.js";
+import { pluginAsset } from "@ragents/host/plugin-support/plugin-folder.js";
+import { ServerProcessSandbox } from "@ragents/host/plugin-support/process-sandbox.js";
+import { boundToTools as boundToTools2, handlebarsPrompt } from "@ragents/host/plugin-support/prompt.js";
+
+// server/shell-platform.ts
+import { shellPlatformText } from "@ragents/workspace-executor";
+import { boundToTools } from "@ragents/host/plugin-support/prompt.js";
+var shellPlatformChapter = (platform) => `## Shell platform
+
+${shellPlatformText(platform)}`;
+var shellPlatformPrompt = (id, order, chapterFor) => boundToTools({
+  id,
+  order,
+  delivery: "initial",
+  render: () => shellPlatformChapter(process.platform),
+  ...chapterFor ? { renderForRun: chapterFor } : {}
+}, "bash");
+
+// server/workspace-tool-naming.ts
+var workspaceToolTable = {
+  manual: { read: [], write: [], execute: [] },
+  script: { read: [], write: [], execute: [] },
+  agent: { read: ["read"], write: ["edit", "write"], execute: ["bash"] }
+};
+var sandboxToolNaming = {
+  agentToolNames: (driver) => workspaceToolTable[driver]
+};
+var agentWorkspaceToolNames = [
+  ...workspaceToolTable.agent.read,
+  ...workspaceToolTable.agent.write,
+  ...workspaceToolTable.agent.execute
+];
+
+// server/index.ts
+import { startOptionScope } from "@ragents/host/ragents/start-option-state.js";
+
+// contract.ts
+import { Type } from "typebox";
+import { openJson } from "@ragents/engine/src/http/contracts";
+import { defineChannel, defineOperation } from "@ragents/engine/src/rpc/contract";
+var WORKSPACE_BINDING_OPTION_ID = "ragents.workspace.binding";
+var WORKSPACE_METADATA_ID = "ragents.workspace";
+var freshServerBinding = () => ({ machine: "server", folder: "fresh" });
+var WORKSPACE_CLIENT_ID_PATTERN = /^[A-Za-z0-9_-]{8,64}$/;
+var clientId = Type.String({ pattern: "^[A-Za-z0-9_-]{8,64}$", description: "Stabile Kennung des Arbeitsplatzes" });
+var executorVersion = Type.String({ minLength: 1, maxLength: 64, description: "Stand des Executors, den der Arbeitsplatz mitbringt" });
+var clientDescription = {
+  label: Type.String({ minLength: 1, maxLength: 120 }),
+  hostname: Type.String({ minLength: 1 }),
+  platform: Type.String({ minLength: 1 }),
+  folders: Type.Array(Type.String({ minLength: 1 }), { maxItems: 32 }),
+  runsDirectory: Type.String({ minLength: 1, description: "Absoluter Ordner, unter dem der Arbeitsplatz die neuen Ordner je Run anlegt" })
+};
+var clientInfoSchema = Type.Object({
+  id: Type.String(),
+  ...clientDescription
+}, { additionalProperties: false });
+var absolutePath = Type.String({ minLength: 1, description: "Absoluter Pfad im gebundenen Ordner" });
+var WORKSPACE_CLIENT_STOP_OPERATION = "stop";
+var workspaceClientContracts = {
+  execute: defineOperation({
+    id: "ragents.workspace.client.execute",
+    description: "Eine Operation des Executors auf dem Arbeitsplatz ausf\xFChren, etwa ein Werkzeug, eine Dateiabfrage oder die Prozessanzeige; das Ergebnis ist ihr Wert, Fortschritt ihr JSON-Wert. stop gibt frei, was der Arbeitsplatz f\xFCr den Run h\xE4lt.",
+    implementedBy: "client",
+    input: Type.Object({
+      runId: Type.String({ minLength: 1, maxLength: 64, description: "Kennung des Runs" }),
+      operation: Type.String({ minLength: 1, maxLength: 64, description: "Name der Operation, etwa read, bash, roslyn_open, files.list oder stop" }),
+      toolCallId: Type.Optional(Type.String({ minLength: 1, maxLength: 200, description: "Nur bei einem Werkzeugaufruf des Modells" })),
+      cwd: absolutePath,
+      env: Type.Record(Type.String(), Type.String(), { description: "Was der Server beitr\xE4gt: Run-Marker und Git-Regeln der Sandbox" }),
+      input: Type.Unknown({ description: "Die Eingabe der Operation" })
+    }, { additionalProperties: false }),
+    result: Type.Object({ value: Type.Unknown() }, { additionalProperties: false })
+  })
+};
+var browseTarget = {
+  runId: Type.String({ minLength: 1, maxLength: 64, description: "Kennung des Runs" }),
+  root: Type.Union([Type.Literal("workspace"), Type.Literal("files")]),
+  path: Type.String({ description: "Pfad unterhalb der Wurzel; leer ist die Wurzel selbst" })
+};
+var workspaceContracts = {
+  browse: {
+    list: defineOperation({
+      id: "ragents.workspace.browse.list",
+      description: "Ein Verzeichnis im Arbeitsverzeichnis oder in der Dateiablage eines Runs auflisten.",
+      rights: ["runs.read", "runs.inspect"],
+      input: Type.Object(browseTarget, { additionalProperties: false }),
+      result: openJson("BrowseListing")
+    }),
+    preview: defineOperation({
+      id: "ragents.workspace.browse.preview",
+      description: "Eine Datei als Text vorschauen; zu gro\xDFe und bin\xE4re Dateien nennen stattdessen den Grund.",
+      rights: ["runs.read", "runs.inspect"],
+      input: Type.Object(browseTarget, { additionalProperties: false }),
+      result: openJson("BrowsePreview")
+    })
+  },
+  channels: {
+    browse: defineChannel({
+      id: "ragents.workspace.browse",
+      description: "Meldet jede \xC4nderung unterhalb der beobachteten Wurzel eines Runs.",
+      rights: ["runs.read", "runs.inspect"],
+      params: Type.Object({ runId: browseTarget.runId, root: browseTarget.root }, { additionalProperties: false }),
+      message: Type.Object({ changed: Type.Literal(true) }, { additionalProperties: false })
+    })
+  },
+  clients: {
+    list: defineOperation({
+      id: "ragents.workspace.clients.list",
+      description: "Die angemeldeten Arbeitspl\xE4tze des Aufrufers; fremde erscheinen auch mit runs.read.all nicht.",
+      rights: ["runs.read"],
+      input: Type.Object({}, { additionalProperties: false }),
+      result: Type.Array(clientInfoSchema)
+    }),
+    register: defineOperation({
+      id: "ragents.workspace.clients.register",
+      description: "Einen Arbeitsplatz anmelden oder seine Ordner erneuern; die Verbindung dieser Anfrage wird sein R\xFCckweg und braucht einen Ereignisstrom.",
+      rights: ["runs.write"],
+      input: Type.Object({ id: clientId, ...clientDescription, executor: executorVersion }, { additionalProperties: false }),
+      result: clientInfoSchema
+    }),
+    unregister: defineOperation({
+      id: "ragents.workspace.clients.unregister",
+      description: "Einen eigenen Arbeitsplatz abmelden; offene Auftr\xE4ge scheitern.",
+      rights: ["runs.write"],
+      input: Type.Object({ id: clientId }, { additionalProperties: false }),
+      result: Type.Null()
+    })
+  }
+};
+var isRecord = (value) => typeof value === "object" && value !== null;
+var hasExactly = (value, keys) => Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+var isMachine = (value) => value === "server" || isRecord(value) && hasExactly(value, ["client", "label"]) && typeof value.client === "string" && WORKSPACE_CLIENT_ID_PATTERN.test(value.client) && typeof value.label === "string";
+var isFolder = (value) => {
+  if (value === "fresh") return true;
+  if (!isRecord(value) || typeof value.path !== "string" || value.path.length === 0) return false;
+  return hasExactly(value, ["path"]) || hasExactly(value, ["path", "fresh"]) && value.fresh === true;
+};
+var isWorkspaceBinding = (value) => isRecord(value) && hasExactly(value, ["machine", "folder"]) && isMachine(value.machine) && isFolder(value.folder) && !(value.machine === "server" && typeof value.folder === "object" && "fresh" in value.folder);
+var isFreshFolder = (folder) => folder === "fresh" || "fresh" in folder;
+var fromKind = (value) => {
+  switch (value.kind) {
+    case "fresh":
+      return hasExactly(value, ["kind"]) ? freshServerBinding() : void 0;
+    case "path":
+      return hasExactly(value, ["kind", "path"]) ? { machine: "server", folder: { path: value.path } } : void 0;
+    case "client":
+      return hasExactly(value, ["kind", "client", "label", "path"]) ? { machine: { client: value.client, label: value.label }, folder: { path: value.path } } : void 0;
+    default:
+      return void 0;
+  }
+};
+var storedWorkspaceBinding = (value) => {
+  if (isWorkspaceBinding(value)) return value;
+  const mapped = isRecord(value) && Object.hasOwn(value, "kind") ? fromKind(value) : void 0;
+  return isWorkspaceBinding(mapped) ? mapped : void 0;
+};
+var FRESH_WORKSPACE_LABEL = "Leerer Ordner je Run";
+var freshLabelOf = (binding, labels) => (binding.machine === "server" ? labels.server : labels.client) ?? FRESH_WORKSPACE_LABEL;
+var workspaceBindingSummary = (binding, labels) => {
+  const { machine, folder } = binding;
+  const fresh = freshLabelOf(binding, labels);
+  const where = folder === "fresh" ? fresh : "fresh" in folder ? `${folder.path} (${fresh})` : folder.path;
+  return machine === "server" ? where : `${machine.label}: ${where}`;
+};
+
+// server/binding.ts
+import { statSync } from "node:fs";
+import path from "node:path";
+import { Type as Type2 } from "typebox";
+import { DomainError } from "@ragents/engine";
+import { storedStartOption } from "@ragents/host/ragents/start-option-state.js";
+var machineSchema = Type2.Union([
+  Type2.Literal("server"),
+  Type2.Object({ client: Type2.String({ minLength: 8, maxLength: 64 }), label: Type2.String() }, { additionalProperties: false })
+]);
+var folderSchema = Type2.Union([
+  Type2.Literal("fresh"),
+  Type2.Object({ path: Type2.String({ minLength: 1 }), fresh: Type2.Optional(Type2.Literal(true)) }, { additionalProperties: false })
+]);
+var bindingSchema = Type2.Object({ machine: machineSchema, folder: folderSchema }, { additionalProperties: false });
+var insideFolder = (folder, candidate) => {
+  const separator = folder.includes("\\") ? "\\" : "/";
+  const root = folder.endsWith(separator) ? folder.slice(0, -separator.length) : folder;
+  return candidate === root || candidate.startsWith(root + separator);
+};
+var workstationRunFolder = (runsDirectory, runId) => {
+  const separator = runsDirectory.includes("\\") ? "\\" : "/";
+  const root = runsDirectory.endsWith(separator) ? runsDirectory.slice(0, -separator.length) : runsDirectory;
+  return `${root}${separator}${runId}`;
+};
+var bindingOf = (state) => {
+  const stored = storedStartOption(state, WORKSPACE_BINDING_OPTION_ID);
+  if (stored === void 0) return freshServerBinding();
+  const binding = storedWorkspaceBinding(stored);
+  if (!binding || binding.machine !== "server" && binding.folder === "fresh") {
+    throw new Error(`Die gespeicherte Arbeitsbereich-Bindung ist ung\xFCltig: ${JSON.stringify(stored)}`);
+  }
+  return binding;
+};
+var isWorkstationBinding = (binding) => binding.machine !== "server" && binding.folder !== "fresh";
+var workspaceOwnerOf = (state) => state?.ownerUserId ?? null;
+var boundServerDirectory = (state) => {
+  const { machine, folder } = bindingOf(state);
+  return machine === "server" && folder !== "fresh" ? folder.path : null;
+};
+var serverDirectoryFolder = (directory) => {
+  if (!path.isAbsolute(directory)) throw new DomainError("workspace-path-relative", "Der Ordner muss ein absoluter Pfad sein.", 400);
+  const resolved = path.resolve(directory);
+  if (!statSync(resolved, { throwIfNoEntry: false })?.isDirectory()) {
+    throw new DomainError("workspace-path-missing", `Der Ordner ${resolved} existiert auf dem Server nicht.`, 400);
+  }
+  return { path: resolved };
+};
+var executorShellChapter = (registry, owner, binding) => {
+  const { machine } = binding;
+  if (machine === "server") return shellPlatformChapter(process.platform);
+  const client = registry.info(owner, machine.client);
+  return client ? shellPlatformChapter(client.platform) : `## Shell platform
+
+The workstation ${machine.label} that holds this project is not registered right now, so the platform of its shell is unknown; the workspace tools fail until it connects again.`;
+};
+var workspaceLocation = (binding, location) => binding.machine === "server" ? location : `Arbeitsplatz ${binding.machine.label}: ${location}`;
+var freshLabels = (contribution) => ({
+  server: contribution?.kind?.label ?? FRESH_WORKSPACE_LABEL,
+  client: contribution ? contribution.workstation?.label ?? null : FRESH_WORKSPACE_LABEL
+});
+var sessionMetadataOf = (state, contribution) => {
+  const binding = bindingOf(state);
+  return { binding, summary: workspaceBindingSummary(binding, freshLabels(contribution)) };
+};
+var unsupported = (message) => new DomainError("workspace-binding-unsupported", message, 400);
+var workstationBinding = (client, folder, runId, labels) => {
+  const machine = { client: client.id, label: client.label };
+  if (isFreshFolder(folder)) {
+    if (labels.client === null) {
+      throw unsupported(`Einen neuen Ordner je Run gibt es hier nur auf dem Server (${labels.server}); w\xE4hle dort einen oder einen vorhandenen Ordner des Arbeitsplatzes.`);
+    }
+    return { machine, folder: { path: workstationRunFolder(client.runsDirectory, runId), fresh: true } };
+  }
+  if (!client.folders.some((offered) => insideFolder(offered, folder.path))) {
+    throw new DomainError("workspace-client-folder", `Der Arbeitsplatz ${client.label} bietet den Ordner ${folder.path} nicht an.`, 400);
+  }
+  return { machine, folder: { path: folder.path } };
+};
+var workspaceBindingOption = (registry, contribution) => ({
+  id: WORKSPACE_BINDING_OPTION_ID,
+  schema: bindingSchema,
+  selectable: () => true,
+  defaultValue: () => freshServerBinding(),
+  accept: (value, { runId, userId }) => {
+    if (!isWorkspaceBinding(value)) throw new DomainError("workspace-binding-invalid", "Die Arbeitsbereich-Bindung hat kein g\xFCltiges Format.", 400);
+    const labels = freshLabels(contribution());
+    const { machine, folder } = value;
+    if (machine === "server") {
+      if (folder === "fresh") return freshServerBinding();
+      if ("fresh" in folder) throw new DomainError("workspace-binding-invalid", "Einen neuen Ordner je Run legt auf dem Server der Host an; er hat keinen gew\xE4hlten Pfad.", 400);
+      if (!(contribution()?.kind?.serverFolders ?? true)) {
+        throw unsupported(`Ein vorhandener Ordner auf dem Serverrechner ist hier keine Bindung; w\xE4hle ${labels.server} oder einen Arbeitsplatz.`);
+      }
+      return { machine, folder: serverDirectoryFolder(folder.path) };
+    }
+    const client = registry.info(userId, machine.client);
+    if (!client) throw new DomainError("workspace-client-disconnected", `Der Arbeitsplatz ${machine.label || machine.client} ist nicht verbunden.`, 409);
+    return workstationBinding(client, folder, runId, labels);
+  },
+  describe: (_value, { userId }) => {
+    const presentation = {
+      kind: "workspace-binding",
+      clients: registry.list(userId),
+      fresh: freshLabels(contribution()),
+      serverFolders: contribution()?.kind?.serverFolders ?? true
+    };
+    return presentation;
+  },
+  ownerOnly: (value) => {
+    const binding = storedWorkspaceBinding(value);
+    return binding !== void 0 && binding.machine !== "server";
+  }
+});
+
+// server/browse-route.ts
+import {
+  implement,
+  implementChannel
+} from "@ragents/engine";
+import {
+  FILE_OPERATIONS,
+  listDirectory,
+  readTextFile,
+  watchDirectory
+} from "@ragents/workspace-executor";
+import { withDomainCause } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
+var onServer = async (operation) => {
+  try {
+    return await operation();
+  } catch (error) {
+    throw withDomainCause(error);
+  }
+};
+var listingOf = async (options, runId, root, target) => {
+  if (root === "files") {
+    const listing2 = await onServer(async () => listDirectory(await options.documentsFor(runId), target));
+    return { root, ...listing2 };
+  }
+  const listing = await options.execute(runId, FILE_OPERATIONS.list, { path: target });
+  return { root, ...listing, location: options.locationOf(runId, listing.location) };
+};
+var previewOf = async (options, runId, root, target) => {
+  const text = root === "files" ? await onServer(async () => readTextFile(await options.documentsFor(runId), target)) : await options.execute(runId, FILE_OPERATIONS.read, { path: target });
+  return { root, ...text };
+};
+var ensureRoot = (options, access, runId, root) => {
+  if (root === "workspace") options.ensureWorkspaceAccess(access, runId);
+  else options.ensureSession(runId);
+};
+var createBrowseMethods = (options) => [
+  implement(workspaceContracts.browse.list, ({ runId, root, path: target }, { access }) => {
+    ensureRoot(options, access, runId, root);
+    return listingOf(options, runId, root, target);
+  }),
+  implement(workspaceContracts.browse.preview, ({ runId, root, path: target }, { access }) => {
+    ensureRoot(options, access, runId, root);
+    return previewOf(options, runId, root, target);
+  })
+];
+var WATCH_RETRY_MS = 5e3;
+var watchWorkspace = (options, runId, changed) => new Promise((ready, failed) => {
+  const controller = new AbortController();
+  let opened = false;
+  let retry;
+  const stop = () => {
+    controller.abort();
+    clearTimeout(retry);
+  };
+  const start = () => {
+    let watching = false;
+    const ended = (error) => {
+      if (controller.signal.aborted) return;
+      if (!opened) {
+        failed(error ?? new Error("Die Beobachtung des Arbeitsbereichs endete, bevor sie stand"));
+        return;
+      }
+      if (watching) changed();
+      retry = setTimeout(start, WATCH_RETRY_MS);
+    };
+    options.execute(runId, FILE_OPERATIONS.watch, {}, {
+      signal: controller.signal,
+      untilAborted: true,
+      onProgress: (value) => {
+        if (value.kind === "changed") changed();
+        else if (!watching) {
+          watching = true;
+          if (opened) changed();
+          else {
+            opened = true;
+            ready(stop);
+          }
+        }
+      }
+    }).then(() => ended(), ended);
+  };
+  start();
+});
+var createBrowseChannel = (options) => implementChannel(workspaceContracts.channels.browse, async ({ runId, root }, emit, { access }) => {
+  ensureRoot(options, access, runId, root);
+  const changed = () => emit({ changed: true });
+  if (root === "workspace") return watchWorkspace(options, runId, changed);
+  return onServer(async () => watchDirectory(await options.documentsFor(runId), { onChange: changed, onError: changed }));
+});
+
+// server/clients.ts
+import {
+  DomainError as DomainError2,
+  RPC_ERROR_CODES,
+  RpcError,
+  implement as implement2
+} from "@ragents/engine";
+import {
+  WORKSPACE_EXECUTOR_VERSION,
+  sandboxRunEnvironment
+} from "@ragents/workspace-executor";
+var CLIENT_TIMEOUT_MS = 15 * 60 * 1e3;
+var CLEANUP_TIMEOUT_MS = 1e4;
+var STOP_RETRY_MS = 3e4;
+var ownerOf = (access) => access.user?.id ?? null;
+var timeoutFor = (options) => {
+  if (options.untilAborted) return {};
+  if (options.whenReachable) return { timeoutMs: CLEANUP_TIMEOUT_MS };
+  return { timeoutMs: CLIENT_TIMEOUT_MS + (options.durationMs ?? 0) };
+};
+var disconnected = (label, detail) => new DomainError2("workspace-client-disconnected", `Der Arbeitsplatz ${label} hat die Verbindung verloren: ${detail}`, 409);
+var withClientCause = (cause, label) => {
+  if (!(cause instanceof RpcError)) return cause;
+  if (cause.code === RPC_ERROR_CODES.connectionClosed) return disconnected(label, cause.message);
+  if (cause.code === RPC_ERROR_CODES.timeout) {
+    return new DomainError2("workspace-client-timeout", `Der Arbeitsplatz ${label} hat nicht geantwortet: ${cause.message}`, 504);
+  }
+  if (cause.code === RPC_ERROR_CODES.application && cause.domainCode !== void 0 && cause.status !== void 0) {
+    return new DomainError2(cause.domainCode, cause.message, cause.status);
+  }
+  return cause;
+};
+var unreached = (cause) => cause instanceof DomainError2 && (cause.code === "workspace-client-disconnected" || cause.code === "workspace-client-timeout");
+var messageOf = (cause) => cause instanceof Error ? cause.message : String(cause);
+var keyOf = (owner, id) => JSON.stringify([owner, id]);
+var assertMayRegister = (access, local) => {
+  if (local || access.enabled && access.user !== null) return;
+  throw new DomainError2(
+    "workspace-client-login-required",
+    "Dieser Server kennt keine Benutzeranmeldung; einen Arbeitsplatz nimmt er deshalb nur \xFCber eine Loopback-Verbindung an (etwa http://127.0.0.1 auf seinem eigenen Rechner). \xDCber das Netz braucht ein Arbeitsplatz ein Profil mit Benutzern.",
+    403
+  );
+};
+var WorkspaceClientRegistry = class {
+  #clients = /* @__PURE__ */ new Map();
+  /** Stopps, die den Arbeitsplatz noch nicht erreicht haben, je Arbeitsplatz und Run mit dem Ordner der Bindung. */
+  #pendingStops = /* @__PURE__ */ new Map();
+  #stopRetries = /* @__PURE__ */ new Map();
+  async register(id, description, executor, connection) {
+    if (connection.streamless) {
+      throw new DomainError2("stream-required", "Die Anmeldung eines Arbeitsplatzes braucht einen Ereignisstrom.", 409);
+    }
+    if (executor !== WORKSPACE_EXECUTOR_VERSION) {
+      throw new DomainError2(
+        "workspace-executor-version",
+        `Der Arbeitsplatz ${description.label} bringt den Executor ${executor} mit, der Server verlangt ${WORKSPACE_EXECUTOR_VERSION}.`,
+        409
+      );
+    }
+    const owner = connection.userId;
+    const key = keyOf(owner, id);
+    const previous = this.#clients.get(key);
+    previous?.release();
+    const info = { ...description, id };
+    const renewed = previous?.connection === connection;
+    const entry = {
+      info,
+      owner,
+      connection,
+      release: connection.onClose(() => this.#disconnected(key, connection)),
+      calls: renewed ? previous.calls : /* @__PURE__ */ new Set(),
+      stops: renewed ? previous.stops : /* @__PURE__ */ new Map()
+    };
+    this.#clients.set(key, entry);
+    if (previous && !renewed) this.#abandon(previous);
+    this.#deliverPendingStops(key);
+    return info;
+  }
+  /** Nur die Verbindung, die den Eintrag hält, meldet ihn ab; eine Abmeldung ohne Eintrag ist nach einer Trennung kein Fehler. */
+  unregister(owner, id, connection) {
+    const key = keyOf(owner, id);
+    const entry = this.#clients.get(key);
+    if (entry?.connection !== connection) return;
+    this.#remove(key, entry);
+  }
+  list(owner) {
+    return [...this.#clients.values()].filter((entry) => entry.owner === owner).map((entry) => entry.info);
+  }
+  info(owner, id) {
+    return this.#clients.get(keyOf(owner, id))?.info;
+  }
+  /** Die Runs, deren Stopp diesen Arbeitsplatz noch nicht erreicht hat. */
+  pendingStops(owner, id) {
+    return this.#pendingRuns(keyOf(owner, id));
+  }
+  /** Der Executor eines gebundenen Runs: dieselbe Schnittstelle wie im Server, nur über die Verbindung des Arbeitsplatzes seines Besitzers. */
+  executorFor(owner, id, label, cwd) {
+    const key = keyOf(owner, id);
+    const call = async (runId, operation, input, options) => {
+      if (options.untilAborted && !options.signal) throw new Error(`Die Operation ${operation} l\xE4uft bis zum Abbruch und braucht daf\xFCr ein Abbruchsignal`);
+      if (this.#pendingStops.get(key)?.has(runId)) {
+        if (options.whenReachable) return null;
+        if (this.#clients.has(key)) await this.#deliverStop(key, runId);
+      }
+      const entry = this.#clients.get(key);
+      if (!entry) {
+        if (options.whenReachable) return null;
+        throw new DomainError2("workspace-client-disconnected", `Der Arbeitsplatz ${label} ist nicht verbunden.`, 409);
+      }
+      try {
+        return await this.#send(entry, runId, operation, input, cwd, options);
+      } catch (cause) {
+        if (options.whenReachable && unreached(cause)) return null;
+        throw cause;
+      }
+    };
+    return {
+      version: WORKSPACE_EXECUTOR_VERSION,
+      execute: (runId, operation, input, options = {}) => call(runId, operation, input, options),
+      stopRun: async (runId) => {
+        this.#pendingStopsOf(key).set(runId, cwd);
+        await this.#deliverStop(key, runId);
+      },
+      shutdown: async () => void 0
+    };
+  }
+  shutdown() {
+    for (const entry of this.#clients.values()) {
+      entry.release();
+      this.#abandon(entry);
+    }
+    this.#clients.clear();
+    for (const timer of this.#stopRetries.values()) clearTimeout(timer);
+    this.#stopRetries.clear();
+    this.#pendingStops.clear();
+  }
+  /** Ein getrennter Arbeitsplatz verlässt die Registry; eine spätere Anmeldung über eine neue Verbindung bleibt stehen. */
+  #disconnected(key, connection) {
+    const entry = this.#clients.get(key);
+    if (entry?.connection !== connection) return;
+    this.#remove(key, entry);
+  }
+  #remove(key, entry) {
+    entry.release();
+    this.#clients.delete(key);
+    this.#abandon(entry);
+  }
+  /** Eine Verbindung, die niemand mehr hält, bekommt keine Antworten mehr zugestellt; ihre offenen Aufrufe scheitern sofort. */
+  #abandon(entry) {
+    for (const controller of entry.calls) controller.abort();
+    entry.calls.clear();
+  }
+  async #send(entry, runId, operation, input, cwd, options) {
+    const label = entry.info.label;
+    const abandoned = new AbortController();
+    entry.calls.add(abandoned);
+    const signal = options.signal ? AbortSignal.any([options.signal, abandoned.signal]) : abandoned.signal;
+    try {
+      const { value } = await Promise.race([
+        entry.connection.call(
+          workspaceClientContracts.execute,
+          {
+            runId,
+            operation,
+            ...options.toolCallId ? { toolCallId: options.toolCallId } : {},
+            cwd,
+            env: sandboxRunEnvironment(runId),
+            input
+          },
+          {
+            signal,
+            ...timeoutFor(options),
+            ...options.onProgress ? { onProgress: options.onProgress } : {}
+          }
+        ),
+        new Promise((_settle, fail) => abandoned.signal.addEventListener("abort", () => fail(disconnected(label, "eine neue Verbindung hat die Anmeldung abgel\xF6st")), { once: true }))
+      ]);
+      return value;
+    } catch (cause) {
+      throw withClientCause(cause, label);
+    } finally {
+      entry.calls.delete(abandoned);
+    }
+  }
+  #pendingStopsOf(key) {
+    const known = this.#pendingStops.get(key);
+    if (known) return known;
+    const created = /* @__PURE__ */ new Map();
+    this.#pendingStops.set(key, created);
+    return created;
+  }
+  /** Stellt einen ausstehenden Stopp zu; erreicht er den Arbeitsplatz nicht, bleibt er ausstehend, und die nächste Anmeldung holt ihn nach. */
+  #deliverStop(key, runId) {
+    const entry = this.#clients.get(key);
+    const cwd = this.#pendingStops.get(key)?.get(runId);
+    if (cwd === void 0) return Promise.resolve();
+    if (!entry) {
+      console.warn(`Der Stopp des Runs ${runId} erreicht seinen Arbeitsplatz erst bei dessen n\xE4chster Anmeldung.`);
+      return Promise.resolve();
+    }
+    const running = entry.stops.get(runId);
+    if (running) return running;
+    const delivery = this.#send(entry, runId, WORKSPACE_CLIENT_STOP_OPERATION, null, cwd, { whenReachable: true }).then(() => this.#stopDelivered(key, runId, cwd), (cause) => {
+      if (!unreached(cause)) {
+        this.#stopDelivered(key, runId, cwd);
+        throw cause;
+      }
+      console.warn(`Der Stopp des Runs ${runId} hat den Arbeitsplatz ${entry.info.label} nicht erreicht und bleibt ausstehend: ${messageOf(cause)}`);
+      this.#retryStops(key);
+    }).finally(() => entry.stops.delete(runId));
+    entry.stops.set(runId, delivery);
+    return delivery;
+  }
+  #stopDelivered(key, runId, cwd) {
+    const pending = this.#pendingStops.get(key);
+    if (pending?.get(runId) === cwd) pending.delete(runId);
+    if (pending?.size === 0) this.#pendingStops.delete(key);
+  }
+  #deliverPendingStops(key) {
+    for (const runId of this.#pendingRuns(key)) {
+      void this.#deliverStop(key, runId).catch((cause) => console.warn(`Der nachgeholte Stopp des Runs ${runId} ist gescheitert: ${messageOf(cause)}`));
+    }
+  }
+  #pendingRuns(key) {
+    return [...this.#pendingStops.get(key)?.keys() ?? []];
+  }
+  /** Ein Arbeitsplatz, der angemeldet bleibt, aber nicht antwortet, bekommt seine ausstehenden Stopps später noch einmal. */
+  #retryStops(key) {
+    if (this.#stopRetries.has(key)) return;
+    const timer = setTimeout(() => {
+      this.#stopRetries.delete(key);
+      if (this.#clients.has(key)) this.#deliverPendingStops(key);
+    }, STOP_RETRY_MS);
+    timer.unref();
+    this.#stopRetries.set(key, timer);
+  }
+};
+var clientMethods = (registry) => [
+  implement2(workspaceContracts.clients.list, (_input, { access }) => registry.list(ownerOf(access))),
+  implement2(workspaceContracts.clients.register, ({ id, executor, ...description }, { access, connection, local }) => {
+    assertMayRegister(access, local);
+    return registry.register(id, description, executor, connection);
+  }),
+  implement2(workspaceContracts.clients.unregister, ({ id }, { access, connection }) => {
+    registry.unregister(ownerOf(access), id, connection);
+    return null;
+  })
+];
+
+// server/config.ts
+import { declaredEnvironment } from "@ragents/host/plugin-support/plugin-config.js";
+import { PROCESS_SANDBOX_DEFAULT_NETWORK } from "@ragents/host/plugin-support/process-sandbox.js";
+var workspaceConfigDescriptors = [
+  { key: "PROCESS_SANDBOX", source: "environment" },
+  { key: "PROCESS_SANDBOX_NETWORK", source: "environment" },
+  { key: "RAGENTS_BASH", source: "environment" }
+];
+var env = declaredEnvironment(workspaceConfigDescriptors);
+var processSandboxSetting = () => {
+  const mode = env.optional("PROCESS_SANDBOX") ?? "on";
+  if (mode !== "on" && mode !== "off") {
+    throw new Error(`PROCESS_SANDBOX in der Sektion ragents.workspace ist "on" oder "off", nicht "${mode}"`);
+  }
+  const network = env.optional("PROCESS_SANDBOX_NETWORK") === void 0 ? PROCESS_SANDBOX_DEFAULT_NETWORK : env.list("PROCESS_SANDBOX_NETWORK");
+  return { enabled: mode === "on", network };
+};
+var bashSetting = () => env.optional("RAGENTS_BASH") || void 0;
+
+// server/runtime.ts
+import { mkdir, realpath } from "node:fs/promises";
+import path2 from "node:path";
+import { DomainError as DomainError3 } from "@ragents/engine";
+import {
+  RUN_FOLDER_OPERATIONS
+} from "@ragents/workspace-executor";
+import { storedStartOption as storedStartOption2 } from "@ragents/host/ragents/start-option-state.js";
+import { WorkspaceSandboxHost } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
+var runNotStarted = () => new DomainError3(
+  "run-not-started",
+  "Der Run ist noch nicht gestartet; das Arbeitsverzeichnis entsteht mit der ersten Nachricht.",
+  409
+);
+var lookAround = "Look around in it before you say anything about the project.";
+var serverProjectDescription = (cwd) => [
+  "# Working directory",
+  "",
+  `Your working directory is \`${cwd}\` on the server: the project folder the user picked.`,
+  `It is a real project. Work inside it, keep its structure, and never delete or reorganize files unless you are asked to. ${lookAround}`
+].join("\n");
+var clientProjectDescription = (projectPath, label) => [
+  "# Working directory",
+  "",
+  `Your working directory is the project folder \`${projectPath}\` on the workstation "${label}", not on the server.`,
+  "Every workspace tool runs there, and a relative path refers to that folder.",
+  `It is a real project. Keep its structure, and never delete or reorganize files unless you are asked to. ${lookAround}`
+].join("\n");
+var freshWorkstationDescription = (folderPath, label) => [
+  "# Working directory",
+  "",
+  `Your working directory is \`${folderPath}\` on the workstation "${label}", not on the server: a folder of this run alone.`,
+  "Every workspace tool runs there, and a relative path refers to that folder.",
+  "It starts empty unless the profile prepared content in it. Look around in it before you say anything about what is already there."
+].join("\n");
+var freshDescription = (cwd) => [
+  "# Working directory",
+  "",
+  `Your working directory is \`${cwd}\`, a private folder of this conversation on the server.`,
+  "No other conversation sees it, and it starts empty unless the profile prepared content in it.",
+  "Look around in it before you say anything about what is already there."
+].join("\n");
+var listed = (entries) => entries.length === 1 ? entries[0] : `${entries.slice(0, -1).join(", ")} and ${entries.at(-1)}`;
+var rootList = (roots) => listed(roots.map((root) => `\`${root.alias}\` (${root.writable ? "read and write" : "read only"})`));
+var variableList = (roots) => listed(roots.flatMap((root) => root.environmentVariable === void 0 ? [] : [`\`$${root.environmentVariable}\` for \`${root.alias}\``]));
+var hasVariables = (roots) => roots.some((root) => root.environmentVariable !== void 0);
+var serverRootsDescription = (roots) => [
+  "## Roots besides the working directory",
+  "",
+  `This run also reaches ${rootList(roots)}. File tools and language servers take a path that starts with the alias, such as \`${roots[0].alias}/<path>\`; \`bash\` runs in such a root with that path as \`cwd\`.` + (hasVariables(roots) ? ` \`bash\` also has ${variableList(roots)}.` : "")
+].join("\n");
+var workstationRootsDescription = (roots) => [
+  "## Roots on the server",
+  "",
+  `This run also reaches roots on the server: ${rootList(roots)}. File tools and language servers reach them from the workstation as well: pass a path that starts with the alias, such as \`${roots[0].alias}/<path>\`. \`bash\` runs on the workstation; with a \`cwd\` that starts with an alias it runs on the server instead and sees only the server` + (hasVariables(roots) ? `, and only that bash has ${variableList(roots)}` : "") + ". One call reaches one machine: never combine a path with an alias and a path in the working directory in one call."
+].join("\n");
+var RunWorkspaceRuntime = class {
+  sandbox;
+  toolNaming = sandboxToolNaming;
+  transfer;
+  #options;
+  #nugetCacheDirectory;
+  /** Die neuen Ordner auf Arbeitsplätzen, die in diesem Serverlauf schon angelegt oder in Arbeit sind. */
+  #preparations = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.#options = options;
+    this.transfer = {
+      boundDirectory: (runId) => boundServerDirectory(options.runState(runId)),
+      assertDirectory: (directory) => void serverDirectoryFolder(directory),
+      rebind: (runId, directory) => options.storeBinding(runId, { machine: "server", folder: serverDirectoryFolder(directory) })
+    };
+    this.#nugetCacheDirectory = path2.join(options.globalDirectory, "nuget-cache");
+    this.sandbox = new WorkspaceSandboxHost({
+      contributorName: "ragents.workspace.sandbox",
+      workspaceFor: options.sessionWorkspaceFor,
+      identFor: () => Promise.resolve(void 0),
+      skillPaths: options.skillPaths,
+      storageRootFor: options.storageRootFor,
+      homeFor: (runId) => this.#homeFor(runId),
+      executorFor: (runId) => Promise.resolve(this.#executorFor(runId)),
+      serverDirectoryFor: (runId) => this.#serverDirectoryFor(runId),
+      ...options.processSandbox ? { processSandbox: options.processSandbox } : {},
+      ...options.bash === void 0 ? {} : { bash: options.bash }
+    });
+  }
+  /** Arbeit eines Runs, die auf dem Server läuft, während sein Arbeitsbereich auf einem Arbeitsplatz liegt. */
+  async #serverDirectoryFor(runId) {
+    const directory = this.#options.sessionDirectory(runId, "server");
+    await mkdir(directory, { recursive: true });
+    return realpath(directory);
+  }
+  async #homeFor(runId) {
+    const home = this.#options.sessionDirectory(runId, "home");
+    await mkdir(home, { recursive: true });
+    await mkdir(this.#nugetCacheDirectory, { recursive: true });
+    return { home, nugetPackages: this.#nugetCacheDirectory };
+  }
+  /** Auf einem Arbeitsplatz führt dessen Executor im Namen des Run-Eigentümers aus, sonst der des Servers. */
+  #executorFor(runId) {
+    const state = this.#options.runState(runId);
+    const binding = bindingOf(state);
+    if (!isWorkstationBinding(binding)) return void 0;
+    const { machine, folder } = binding;
+    const executor = this.#options.clients.executorFor(workspaceOwnerOf(state), machine.client, machine.label, folder.path);
+    return "fresh" in folder ? this.#preparing(state, binding, executor) : executor;
+  }
+  /** Vor dem ersten Auftrag eines Runs legt der Arbeitsplatz dessen neuen Ordner an; Aufräumen legt nie einen an. */
+  #preparing(state, binding, executor) {
+    return {
+      ...executor,
+      execute: async (runId, operation, input, options = {}) => {
+        if (!options.whenReachable) await this.#prepared(runId, state, binding, executor);
+        return executor.execute(runId, operation, input, options);
+      }
+    };
+  }
+  #prepared(runId, state, binding, executor) {
+    const known = this.#preparations.get(runId);
+    if (known) return known;
+    const preparation = this.#prepare(runId, state, binding, executor).catch((error) => {
+      this.#preparations.delete(runId);
+      throw error;
+    });
+    this.#preparations.set(runId, preparation);
+    return preparation;
+  }
+  /** Nur ein eben angelegter Ordner bekommt die Schritte des Beitrags; scheitert einer, verschwindet er wieder, und der nächste Auftrag beginnt neu. */
+  async #prepare(runId, state, binding, executor) {
+    const { created } = await executor.execute(runId, RUN_FOLDER_OPERATIONS.create, null);
+    const steps = created ? this.#contribution()?.workstation?.prepare(this.#workstationContext(runId, state, binding)) ?? [] : [];
+    try {
+      await this.#runSteps(runId, executor, steps);
+    } catch (error) {
+      await executor.execute(runId, RUN_FOLDER_OPERATIONS.remove, null, { whenReachable: true });
+      throw error;
+    }
+  }
+  async #runSteps(runId, executor, steps, options = {}) {
+    for (const step of steps) await executor.execute(runId, step.operation, step.input, options);
+  }
+  #workstationContext(runId, state, binding) {
+    const contribution = this.#contribution();
+    return {
+      runId,
+      path: binding.folder.path,
+      label: binding.machine.label,
+      choice: contribution && state ? this.#choiceFor(state, contribution) : null
+    };
+  }
+  async resolve(runId, emitSystem) {
+    const state = this.#options.runState(runId);
+    if (!state) throw runNotStarted();
+    const binding = bindingOf(state);
+    const { folder } = binding;
+    const onWorkstation = isWorkstationBinding(binding);
+    const workspace = onWorkstation ? this.#workstation(runId, state, binding, emitSystem) : isFreshFolder(folder) ? await this.#fresh(runId, state, emitSystem) : this.#bound(folder, emitSystem);
+    return this.#withRoots(workspace, onWorkstation);
+  }
+  /** Was der Prompt über Wurzeln sagt, hängt an der Maschine des Runs: nur eine Bash auf dem Server kennt ihre Variablen. */
+  async #withRoots(workspace, onWorkstation) {
+    const roots = await this.sandbox.serverRoots();
+    if (roots.length === 0) return workspace;
+    const described = onWorkstation ? workstationRootsDescription(roots) : serverRootsDescription(roots);
+    return { ...workspace, description: [workspace.description, described].filter(Boolean).join("\n\n") };
+  }
+  placementOf(runId) {
+    const { machine, folder } = bindingOf(this.#options.runState(runId));
+    const placement = {
+      machine: machine === "server" ? "server" : "client",
+      folder: isFreshFolder(folder) ? "fresh" : "existing"
+    };
+    const contribution = this.#contribution();
+    const contributed = placement.folder === "fresh" && (placement.machine === "server" || contribution?.workstation !== void 0);
+    const kind = contributed ? contribution?.kind?.id : void 0;
+    return kind === void 0 ? placement : { ...placement, kind };
+  }
+  async #fresh(runId, state, emitSystem) {
+    const resolver = this.#options.resolver();
+    const directory = resolver?.kind ? this.#options.sessionDirectory(runId, "workspace") : await this.#sessionWorkspace(runId);
+    if (!resolver) return this.#directory(directory, freshDescription(directory));
+    const { cwd, description, currentRoot, runOperation, ...rest } = await resolver.resolve({
+      runId,
+      directory,
+      choice: this.#choiceFor(state, resolver),
+      emitSystem
+    });
+    const resolved = path2.resolve(cwd);
+    return {
+      ...this.#directory(resolved, description ?? freshDescription(resolved)),
+      ...rest,
+      ...currentRoot ? { currentRoot } : {},
+      ...runOperation ? { runOperation } : {}
+    };
+  }
+  #bound(folder, emitSystem) {
+    const cwd = path2.resolve(folder.path);
+    const existing = async () => {
+      try {
+        return await realpath(cwd);
+      } catch {
+        throw new DomainError3("workspace-path-missing", `Der gebundene Ordner ${cwd} existiert auf dem Server nicht mehr.`, 409);
+      }
+    };
+    emitSystem(`Arbeitsbereich: ${cwd} (Projektordner auf dem Server)`);
+    return {
+      cwd,
+      description: serverProjectDescription(cwd),
+      currentRoot: existing,
+      runOperation: (operation) => operation()
+    };
+  }
+  /** Der Arbeitsbereich liegt auf dem Arbeitsplatz; der Server kennt nur seinen Pfad, und jeder lokale Griff darauf scheitert laut. */
+  #workstation(runId, state, binding, emitSystem) {
+    const { machine: { label }, folder } = binding;
+    const fresh = "fresh" in folder;
+    const workstation = this.#contribution()?.workstation;
+    emitSystem(fresh ? `Arbeitsbereich: ${folder.path} (${workstation?.label ?? FRESH_WORKSPACE_LABEL} auf dem Arbeitsplatz ${label})` : `Arbeitsbereich: ${folder.path} (Projektordner auf dem Arbeitsplatz ${label})`);
+    const remote = () => Promise.reject(new Error(
+      `Der Arbeitsbereich ${folder.path} liegt auf dem Arbeitsplatz ${label}, nicht auf dem Server; er ist nur \xFCber den Executor des Runs (SandboxServices.execute) erreichbar.`
+    ));
+    const description = !fresh ? clientProjectDescription(folder.path, label) : workstation?.description?.(this.#workstationContext(runId, state, binding)) ?? freshWorkstationDescription(folder.path, label);
+    return {
+      cwd: folder.path,
+      description,
+      currentRoot: remote,
+      runOperation: (operation) => operation()
+    };
+  }
+  async #sessionWorkspace(runId) {
+    const directory = this.#options.sessionDirectory(runId, "workspace");
+    await mkdir(directory, { recursive: true });
+    return directory;
+  }
+  #directory(cwd, description, extraEnv) {
+    return {
+      cwd,
+      description,
+      ...extraEnv ? { extraEnv } : {},
+      currentRoot: () => realpath(cwd),
+      runOperation: (operation) => operation()
+    };
+  }
+  #choiceFor(state, resolver) {
+    if (resolver.optionId === void 0) return null;
+    const choice = storedStartOption2(state, resolver.optionId);
+    if (choice === void 0) {
+      throw new Error(`Die Startoption ${resolver.optionId} des Workspace-Resolvers ist im Run nicht gespeichert`);
+    }
+    return choice;
+  }
+  describe() {
+    return {
+      mode: "per-run",
+      directoryPattern: this.#contribution()?.kind?.directoryPattern ?? path2.join(this.#options.sessionsDirectoryPattern, "workspace")
+    };
+  }
+  #contribution() {
+    return this.#options.resolver();
+  }
+  /** Auf dem Server gehört ein neuer Ordner samt Stopp und Löschen dem Beitrag; auf einem Arbeitsplatz räumt ihn der Host weg. */
+  #serverContributionFor(runId) {
+    const { machine, folder } = bindingOf(this.#options.runState(runId));
+    return machine === "server" && isFreshFolder(folder) ? this.#contribution() : void 0;
+  }
+  /** Ist der Arbeitsplatz nicht erreichbar, bleibt der Ordner dort mit Hinweis liegen; der Run ist trotzdem gelöscht. */
+  async #removeWorkstationFolder(runId) {
+    this.#preparations.delete(runId);
+    const state = this.#options.runState(runId);
+    const binding = bindingOf(state);
+    if (!isWorkstationBinding(binding) || !("fresh" in binding.folder)) return;
+    const { machine, folder } = binding;
+    const executor = this.#options.clients.executorFor(workspaceOwnerOf(state), machine.client, machine.label, folder.path);
+    const steps = this.#contribution()?.workstation?.release?.(this.#workstationContext(runId, state, binding)) ?? [];
+    await this.#runSteps(runId, executor, steps, { whenReachable: true });
+    if (await executor.execute(runId, RUN_FOLDER_OPERATIONS.remove, null, { whenReachable: true }) !== null) return;
+    console.warn(`Der Ordner ${folder.path} des Runs ${runId} bleibt auf dem Arbeitsplatz ${machine.label}, weil er nicht erreichbar war.`);
+  }
+  async deleteSession(runId) {
+    const contribution = this.#serverContributionFor(runId);
+    await this.stopSession(runId);
+    await this.#removeWorkstationFolder(runId);
+    await contribution?.deleteSession?.(runId);
+  }
+  stopSession(runId) {
+    const contribution = this.#serverContributionFor(runId);
+    const sandbox = () => this.sandbox.shutdown(runId);
+    return contribution?.stopSession ? contribution.stopSession(runId, sandbox) : sandbox();
+  }
+  async shutdown() {
+    await this.sandbox.shutdownAll();
+    this.#options.clients.shutdown();
+  }
+};
+
+// server/index.ts
+var warnWithoutSandbox = () => {
+  console.warn('Prozess-Sandbox ausgeschaltet (PROCESS_SANDBOX: "off" in der Sektion ragents.workspace): Prozesse der Runs laufen auf dem Server ohne Sandbox.');
+};
+var ragentsWorkspacePlugin = (skillPaths) => ({
+  manifest: { id: "ragents.workspace" },
+  register: (host) => {
+    const sessionWorkspaceFor = host.service(runWorkspaceProviderToken);
+    const orchestration = host.service(runtimeProviderToken);
+    const runState = (runId) => {
+      try {
+        return orchestration().state(runId);
+      } catch (error) {
+        if (error instanceof DomainError4 && error.code === "run-not-found") return null;
+        throw error;
+      }
+    };
+    const documentsFor = (runId) => host.optionalService(documentStoreToken)?.directoryFor(runId) ?? Promise.resolve(void 0);
+    const documentsRoot = async (runId) => {
+      const directory = await documentsFor(runId);
+      if (!directory) throw new Error("In diesem Profil gibt es keine Dateiablage; das Plugin ragents.documents fehlt");
+      return directory;
+    };
+    const clients = new WorkspaceClientRegistry();
+    const contribution = () => host.optionalService(workspaceResolverToken);
+    host.config(...workspaceConfigDescriptors);
+    const sandboxSetting = processSandboxSetting();
+    const processSandbox = sandboxSetting.enabled ? new ServerProcessSandbox({
+      network: sandboxSetting.network,
+      serverAddress: host.service(hostAddressToken)(),
+      dataDirectory: path3.dirname(host.storage.sessionsRoot)
+    }) : void 0;
+    const bash = bashSetting();
+    const runtime = new RunWorkspaceRuntime({
+      clients,
+      ...processSandbox ? { processSandbox } : {},
+      ...bash === void 0 ? {} : { bash },
+      globalDirectory: host.storage.root(),
+      sessionDirectory: (runId, ...segments) => host.storage.session(runId, ...segments),
+      storageRootFor: (runId) => path3.join(host.storage.sessionsRoot, runId),
+      sessionsDirectoryPattern: path3.join(host.storage.sessionsRoot, "{runId}", "plugins", host.manifest.id),
+      sessionWorkspaceFor,
+      skillPaths,
+      resolver: contribution,
+      runState,
+      storeBinding: (runId, binding) => {
+        const state = orchestration().state(runId);
+        orchestration().replacePluginState(
+          { actorId: state.ownerId, commandId: `workspace-binding:${runId}:${state.revision}` },
+          runId,
+          { pluginId: WORKSPACE_BINDING_OPTION_ID, scope: startOptionScope, state: binding }
+        );
+      }
+    });
+    host.provide(workspaceRuntimeToken, runtime);
+    host.provide(sandboxServicesToken, runtime.sandbox);
+    host.functions(runtime.sandbox.workspaceTools());
+    const rules = handlebarsPrompt("ragents.workspace.prompt", 100, pluginAsset("ragents.workspace", "prompt.hbs"));
+    host.prompts(
+      boundToTools2({
+        ...rules,
+        delivery: "initial",
+        // Die Regeln gelten für die Arbeitsbereiche des Hosts; eine beigesteuerte Art beschreibt ihre eigenen.
+        render: (context) => contribution()?.kind ? "" : rules.render(context)
+      }, ...agentWorkspaceToolNames),
+      shellPlatformPrompt("ragents.workspace.shell.prompt", 102, (runId) => {
+        const state = runState(runId);
+        return executorShellChapter(clients, workspaceOwnerOf(state), bindingOf(state));
+      })
+    );
+    const browseOptions = {
+      ensureSession: host.service(runGuardToken),
+      ensureWorkspaceAccess: host.service(workspaceGuardToken),
+      execute: runtime.sandbox.execute.bind(runtime.sandbox),
+      documentsFor: documentsRoot,
+      locationOf: (runId, location) => workspaceLocation(bindingOf(runState(runId)), location)
+    };
+    host.methods(...createBrowseMethods(browseOptions), ...clientMethods(clients));
+    host.channels(createBrowseChannel(browseOptions));
+    host.startOptions(workspaceBindingOption(clients, contribution));
+    host.sessionMetadata({ id: WORKSPACE_METADATA_ID, describe: ({ runId }) => sessionMetadataOf(runState(runId), contribution()) });
+    host.lifecycle({
+      id: "ragents.workspace.lifecycle",
+      initialize: () => processSandbox ? processSandbox.start() : warnWithoutSandbox(),
+      stopSession: ({ runId }) => runtime.stopSession(runId),
+      deleteSession: ({ runId }) => runtime.deleteSession(runId),
+      shutdown: async () => {
+        await runtime.shutdown();
+        await processSandbox?.stop();
+      }
+    });
+  }
+});
+var plugin = {
+  create: (host) => ragentsWorkspacePlugin(() => host.skills.global())
+};
+export {
+  plugin
+};
+//# sourceMappingURL=index.js.map