@schlenkr/ragents 0.1.8 → 0.1.10

package/packages/workspace-executor/src/contributions.ts

@@ -0,0 +1,150 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { WorkspaceOperationError } from "./errors.js";
+import type { LanguageServerAdapter } from "./language-server/host.js";
+import { resolveRootDirectory, resolveRootFile } from "./language-server/roots.js";
+import type { WorkspaceModuleFactory } from "./module.js";
+import { RUN_MARKER_ENV } from "./run-marker.js";
+import { safeProcessEnvironment } from "./safe-environment.js";
+
+/** Wo ein Bundle seinen Beitrag zum Executor trägt: eine in sich geschlossene Datei, die jeder Node-Prozess ohne Host-Auflösung lädt. */
+export const EXECUTOR_CONTRIBUTION_FILE = "executor/index.mjs";
+
+/** Was der Executor einer Maschine einem Beitrag über sie sagt; ein Beitrag importiert vom Host nur Typen, alles andere kommt hierüber. */
+export interface WorkspaceExecutorMachine {
+  /** Der Werkzeugordner des Plugins auf dieser Maschine, wohin seine Provisionierung lädt. */
+  readonly toolsDirectory: string;
+  /** Eine Datei aus einem Paket in den node_modules des Hosts dieser Maschine; ohne Host oder Paket scheitert der Aufruf mit Ursache. */
+  readonly hostPackageFile: (hostRoot: string | undefined, specifier: string) => string;
+  /** Eine Datei mit einer der Endungen im Arbeitsbereich, aufgelöst und geprüft. */
+  readonly resolveRootFile: (workspaceRoot: string, requested: string, extensions: readonly string[]) => Promise<string>;
+  /** Ein Ordner im Arbeitsbereich, aufgelöst und geprüft. */
+  readonly resolveRootDirectory: (workspaceRoot: string, requested: string) => Promise<string>;
+  /** Ein fachlicher Fehler einer Operation mit Kennung und Status; beim Aufrufer kommt er als derselbe Fehler an wie einer des Executors. */
+  readonly operationError: (code: string, message: string, status: number) => Error;
+  /** Die Umgebung eines Prozesses, den ein Beitrag selbst startet: die sichere Auswahl dieser Maschine, ihr HOME und der Marker des Runs für die Prozessanzeige. */
+  readonly processEnvironment: (runId: string) => NodeJS.ProcessEnv;
+}
+
+/** Was ein Beitrag dem Executor einer Maschine hinzufügt. */
+export interface WorkspaceExecutorParts {
+  readonly languageServers?: readonly LanguageServerAdapter[];
+  /** Module mit eigenen Operationen; jede Operation gehört genau einem Modul. */
+  readonly modules?: readonly WorkspaceModuleFactory[];
+}
+
+/** Was ein Plugin-Bundle als `executor` exportiert; es läuft in jedem Executor, im Server wie auf jedem Arbeitsplatz, und berührt beim Bauen weder Platte noch Netz. */
+export type WorkspaceExecutorContribution = (machine: WorkspaceExecutorMachine) => WorkspaceExecutorParts;
+
+/** Wessen Beitrag in welchem Stand; Server und Arbeitsplatz verlangen dieselben. */
+export interface ExecutorContributionStand {
+  readonly plugin: string;
+  /** SHA-256 der Datei des Beitrags. */
+  readonly stand: string;
+}
+
+export interface LoadedExecutorContribution extends ExecutorContributionStand {
+  readonly contribution: WorkspaceExecutorContribution;
+}
+
+/** Ein Beitrag, gebaut für diese Maschine. */
+export interface PreparedExecutorContribution extends ExecutorContributionStand {
+  readonly parts: WorkspaceExecutorParts;
+}
+
+const LANGUAGE_SERVER_ID = /^[a-z][a-z0-9]{0,39}$/;
+const PART_KEYS = new Set(["languageServers", "modules"]);
+
+const messageOf = (cause: unknown): string => cause instanceof Error ? cause.message : String(cause);
+
+/** Der Paketname eines Bezeichners wie acme-server/lib/cli.mjs oder @scope/name/datei. */
+const packageOf = (specifier: string): string =>
+  specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/");
+
+const hostPackageFile = (hostRoot: string | undefined, specifier: string): string => {
+  if (!hostRoot) {
+    throw new Error(`Auf diesem Rechner ist kein Host bekannt, aus dem sich ${packageOf(specifier)} auflösen ließe. Ein Arbeitsplatz `
+      + "bekommt ihn mit der ersten Verbindung zu einem verteilenden Server oder über die Einstellung ragents.hostPath");
+  }
+  try {
+    return createRequire(path.join(hostRoot, "package.json")).resolve(specifier);
+  } catch (cause) {
+    throw new Error(`${packageOf(specifier)} liegt nicht im Host ${hostRoot}: ${messageOf(cause)}`);
+  }
+};
+
+export const executorMachine = (toolsDirectory: string): WorkspaceExecutorMachine => ({
+  toolsDirectory,
+  hostPackageFile,
+  resolveRootFile,
+  resolveRootDirectory,
+  operationError: (code, message, status) => new WorkspaceOperationError(code, message, status),
+  processEnvironment: (runId) => ({ ...safeProcessEnvironment(process.env), HOME: homedir(), [RUN_MARKER_ENV]: runId }),
+});
+
+/** Lädt die Datei eines Beitrags, mit `expected` nur in diesem Stand; der Stand steht in ihrer Adresse, damit ein neu gebauter Beitrag nie aus dem Modulcache kommt. */
+export const loadExecutorContribution = async (plugin: string, file: string, expected?: string): Promise<LoadedExecutorContribution> => {
+  const content = await readFile(file).catch((cause: unknown) => {
+    throw new Error(`Der Executor-Beitrag von ${plugin} fehlt unter ${file}: ${messageOf(cause)}`);
+  });
+  const stand = createHash("sha256").update(content).digest("hex");
+  if (expected !== undefined && stand !== expected) {
+    throw new Error(`Der Executor-Beitrag von ${plugin} unter ${file} hat den Stand ${stand.slice(0, 12)}, verlangt ist ${expected.slice(0, 12)}`);
+  }
+  const exported = await import(`${pathToFileURL(file).href}?stand=${stand}`).catch((cause: unknown) => {
+    throw new Error(`Der Executor-Beitrag von ${plugin} (${file}) lädt nicht: ${messageOf(cause)}`, { cause });
+  }) as Readonly<Record<string, unknown>>;
+  const contribution = exported.executor;
+  if (typeof contribution !== "function") {
+    throw new Error(`Das Bundle ${plugin} exportiert in ${file} keinen gültigen Executor-Beitrag; erwartet wird `
+      + "\"export const executor: WorkspaceExecutorContribution\" als Funktion der Maschine");
+  }
+  return { plugin, stand, contribution: contribution as WorkspaceExecutorContribution };
+};
+
+const isRecord = (value: unknown): value is Readonly<Record<string, unknown>> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const isStringList = (value: unknown): value is readonly string[] =>
+  Array.isArray(value) && value.every((entry) => typeof entry === "string");
+
+/** Was an einem Sprachserver fehlt oder die falsche Form hat; leer, wenn er taugt. */
+const adapterProblems = (value: Readonly<Record<string, unknown>>): readonly string[] => [
+  ...typeof value.id === "string" && LANGUAGE_SERVER_ID.test(value.id) ? [] : ["id aus Kleinbuchstaben und Ziffern"],
+  ...typeof value.label === "string" ? [] : ["label"],
+  ...isRecord(value.languages) && Object.values(value.languages).every((entry) => typeof entry === "string") ? [] : ["languages"],
+  ...typeof value.rootDescription === "string" ? [] : ["rootDescription"],
+  ...value.solutionExtensions === undefined || isStringList(value.solutionExtensions) ? [] : ["solutionExtensions"],
+  ...(["resolveRoot", "rootDirectory", "launch", "open"] as const).filter((name) => typeof value[name] !== "function"),
+];
+
+/** Baut einen geladenen Beitrag für diese Maschine und prüft, was er liefert; eine falsche Form ist ein Fehler mit Ursache. */
+export const prepareExecutorContribution = (loaded: LoadedExecutorContribution, toolsDirectory: string): PreparedExecutorContribution => {
+  const invalid = (detail: string): Error => new Error(`Der Executor-Beitrag von ${loaded.plugin} ist ungültig: ${detail}`);
+  const parts = ((): unknown => {
+    try {
+      return loaded.contribution(executorMachine(toolsDirectory));
+    } catch (cause) {
+      throw invalid(`die Funktion wirft: ${messageOf(cause)}`);
+    }
+  })();
+  if (!isRecord(parts)) throw invalid("die Funktion liefert kein Objekt");
+  const unknown = Object.keys(parts).filter((key) => !PART_KEYS.has(key));
+  if (unknown.length > 0) throw invalid(`unbekannte Teile ${unknown.join(", ")}; erlaubt sind ${[...PART_KEYS].join(", ")}`);
+  const modules = parts.modules;
+  if (modules !== undefined && (!Array.isArray(modules) || !modules.every((module) => typeof module === "function"))) {
+    throw invalid("modules ist keine Liste von Modulfabriken");
+  }
+  const servers = parts.languageServers;
+  if (servers !== undefined && !Array.isArray(servers)) throw invalid("languageServers ist keine Liste");
+  for (const [index, server] of (servers ?? []).entries()) {
+    if (!isRecord(server)) throw invalid(`der Sprachserver ${index + 1} ist kein Objekt`);
+    const problems = adapterProblems(server);
+    if (problems.length > 0) throw invalid(`der Sprachserver ${index + 1} braucht ${problems.join(", ")}`);
+  }
+  return { plugin: loaded.plugin, stand: loaded.stand, parts: parts as WorkspaceExecutorParts };
+};

package/packages/workspace-executor/src/executor.ts

@@ -4,7 +4,7 @@ import type { WorkspaceExecutorModule, WorkspaceModuleFactory, WorkspaceOperatio
 import { NO_ROOTS, type OperationFootprint } from "./paths.js";
 
 /** Der Stand des Executors; Server und Arbeitsplatz müssen denselben tragen. */
-export const WORKSPACE_EXECUTOR_VERSION = "5";
+export const WORKSPACE_EXECUTOR_VERSION = "7";
 
 export interface WorkspaceExecuteOptions {
   toolCallId?: string;

package/packages/workspace-executor/src/index.ts

@@ -18,6 +18,18 @@ export {
   type WorkspaceModuleFactory,
 } from "./module.js";
 export { workspaceExecutorModules, type WorkspaceExecutorModuleOptions } from "./modules.js";
+export {
+  EXECUTOR_CONTRIBUTION_FILE,
+  executorMachine,
+  loadExecutorContribution,
+  prepareExecutorContribution,
+  type ExecutorContributionStand,
+  type LoadedExecutorContribution,
+  type PreparedExecutorContribution,
+  type WorkspaceExecutorContribution,
+  type WorkspaceExecutorMachine,
+  type WorkspaceExecutorParts,
+} from "./contributions.js";
 export { RUN_FOLDER_OPERATIONS, runFolderModule, type RunFolderCreated } from "./run-folders.js";
 export {
   FILE_OPERATIONS,
@@ -37,18 +49,6 @@ export {
   type CommandResult,
   type CommandRunInput,
 } from "./commands.js";
-export {
-  BROWSER_EXECUTABLE_VARIABLE,
-  BROWSER_OPERATIONS,
-  type BrowserCheck,
-  type BrowserCheckResult,
-  type BrowserPageState,
-  type BrowserSnapshot,
-  type BrowserStep,
-  type BrowserTarget,
-  type BrowserViewport,
-} from "./browser/contract.js";
-export { browserModule, type BrowserModuleOptions } from "./browser/module.js";
 export { processGroupExists, runManagedProcess, startManagedService, type ManagedService } from "./managed-process.js";
 export {
   containsWorkspacePath,
@@ -81,15 +81,16 @@ export { labelOf, runProcessesFrom } from "./processes/snapshot.js";
 export { RunProcessTerminator } from "./processes/terminator.js";
 export { RUN_MARKER_ENV } from "./run-marker.js";
 export { editorFreeEnvironment, inheritedProcessEnvironment, safeProcessEnvironment } from "./safe-environment.js";
-export { bashLaunch, type BashLaunch } from "./bash-launch.js";
+export { bashLaunch, ripgrepAvailable, type BashLaunch, type BashPrograms } from "./bash-launch.js";
 export { createSandboxTools, sandboxToolsModule, withAnnotation, type SeenFile } from "./sandbox-tools.js";
 export { type SessionIdent } from "./session-ident.js";
-export { shellPlatformText } from "./shell-platform.js";
-export { ragentsDataRoot, workspaceDataDirectory } from "./tools.js";
+export { shellPlatformText, type ShellTools } from "./shell-platform.js";
+export { hostDataDirectory, pluginToolsDirectory, ragentsDataRoot, workspaceDataDirectory } from "./tools.js";
 export {
   LanguageServerHost,
   changedWorkspaceFiles,
   type LanguageServerAdapter,
+  type LanguageServerDescription,
   type LanguageServerHostOptions,
 } from "./language-server/host.js";
 export {
@@ -112,7 +113,3 @@ export {
 } from "./language-server/module.js";
 export { resolveRootDirectory } from "./language-server/roots.js";
 export { LanguageServerSession, withTimeout } from "./language-server/session.js";
-export { solutionProjects } from "./language-server/solution.js";
-export { fsharpAdapter, FSHARP_SERVER_FILE, FSHARP_SERVER_VARIABLE } from "./language-server/adapters/fsharp.js";
-export { roslynAdapter, ROSLYN_SERVER_FILE, ROSLYN_SERVER_VARIABLE } from "./language-server/adapters/roslyn.js";
-export { typescriptAdapter } from "./language-server/adapters/typescript.js";

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

@@ -27,6 +27,9 @@ export interface LanguageServerAdapter {
   open: (session: LanguageServerSession, root: string, timeoutMs: number) => Promise<string>;
 }
 
+/** Was der Server über einen Sprachserver wissen muss, um Werkzeuge und Reiter zu beschreiben; gestartet wird er nur im Executor. */
+export type LanguageServerDescription = Pick<LanguageServerAdapter, "id" | "label" | "languages" | "rootDescription" | "solutionExtensions">;
+
 export interface LanguageServerHostOptions {
   idleMs?: number;
   openTimeoutMs?: number;

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

@@ -1,5 +1,5 @@
 import { WorkspaceOperationError } from "../errors.js";
-import type { WorkspaceModuleFactory, WorkspaceOperation } from "../module.js";
+import type { WorkspaceExecutorModule, WorkspaceModuleFactory, WorkspaceModuleHost, WorkspaceOperation } from "../module.js";
 import { rootsOfFields, type OperationFootprint } from "../paths.js";
 import { LanguageServerHost, type LanguageServerAdapter, type LanguageServerHostOptions } from "./host.js";
 
@@ -89,7 +89,17 @@ const footprintsOf = (server: LanguageServerHost): Array<readonly [string, (inpu
 export const languageServerModule = (
   adapters: readonly LanguageServerAdapter[],
   options: LanguageServerHostOptions = {},
-): WorkspaceModuleFactory => (host) => {
+): WorkspaceModuleFactory => {
+  const duplicate = adapters.find((adapter, index) => adapters.findIndex((other) => other.id === adapter.id) !== index);
+  if (duplicate) throw new Error(`Der Sprachserver ${duplicate.id} kommt im Executor zweimal vor; seine Operationen gehören genau einem Beitrag`);
+  return (host) => languageServersOn(host, adapters, options);
+};
+
+const languageServersOn = (
+  host: WorkspaceModuleHost,
+  adapters: readonly LanguageServerAdapter[],
+  options: LanguageServerHostOptions,
+): WorkspaceExecutorModule => {
   const servers = adapters.map((adapter) => new LanguageServerHost(adapter, host.contextFor, options));
   return {
     operations: Object.fromEntries(servers.flatMap(operationsOf)),

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

@@ -22,8 +22,3 @@ export const resolveRootDirectory = async (workspaceRoot: string, requested: str
   if (!info?.isDirectory()) throw new Error(`${requested} ist kein Verzeichnis im Arbeitsverzeichnis`);
   return absolute;
 };
-
-export const dotnetCommand = (server: string, args: readonly string[]): { command: string; args: string[] } =>
-  server.toLowerCase().endsWith(".dll")
-    ? { command: "dotnet", args: [server, ...args] }
-    : { command: server, args: [...args] };

package/packages/workspace-executor/src/managed-process.ts

@@ -2,6 +2,7 @@ import { execFile, spawn, type ChildProcess } from "node:child_process";
 import { readdir, readFile } from "node:fs/promises";
 import type { Writable } from "node:stream";
 import { killProcessTree } from "@ragents/agent";
+import { bashLaunch } from "./bash-launch.js";
 
 const PROCESS_GROUP_JOIN_TIMEOUT_MS = 5_000;
 const PROCESS_GROUP_POLL_MS = 25;
@@ -77,6 +78,33 @@ export const stopProcessTree = (pid: number): void => {
   if (processExists(pid)) killProcessTree(pid);
 };
 
+/** Markiert unter Windows die Prozesse eines bash-Aufrufs: MSYS hängt die Kinder der Bash nicht an deren Windows-Prozessbaum, taskkill /T erreicht sie nicht. */
+export const MSYS_CALL_ENV = "RAGENTS_BASH_CALL";
+
+/** Die Windows-Kennungen aller MSYS-Prozesse in den Prozessgruppen, in denen ein Prozess die Markierung trägt, auch nach dem Ende der Bash selbst. */
+const msysGroupScript = (marker: string): string => [
+  "groups=' '",
+  `for d in /proc/[0-9]*; do tr '\\0' '\\n' < "$d/environ" 2>/dev/null | grep -qxF '${MSYS_CALL_ENV}=${marker}' && groups="$groups$(cat "$d/pgid") "; done`,
+  `for d in /proc/[0-9]*; do case "$groups" in *" $(cat "$d/pgid" 2>/dev/null) "*) cat "$d/winpid" 2>/dev/null;; esac; done`,
+].join("\n");
+
+const execFileText = (file: string, args: readonly string[], env?: NodeJS.ProcessEnv): Promise<{ stdout: string; error: Error | null }> =>
+  new Promise((resolve) => {
+    execFile(file, [...args], { env, windowsHide: true, timeout: 15_000 }, (error, stdout) => resolve({ stdout, error }));
+  });
+
+/** Beendet unter Windows alles, was ein bash-Aufruf mit dieser Markierung gestartet hat, samt den nativen Bäumen darunter. */
+export const stopMsysCall = async (bash: string, env: NodeJS.ProcessEnv, marker: string): Promise<void> => {
+  const launch = bashLaunch({ bash, rg: undefined }, msysGroupScript(marker), env, "win32");
+  const listing = await execFileText(launch.command, launch.args, launch.env);
+  if (listing.error) throw new Error(`Die Prozesse des bash-Aufrufs ließen sich nicht ermitteln: ${listing.error.message}`);
+  const winpids = [...new Set(listing.stdout.split(/\s+/).filter((pid) => /^\d+$/.test(pid)))];
+  if (winpids.length === 0) return;
+  await execFileText("taskkill", ["/F", "/T", ...winpids.flatMap((pid) => ["/PID", pid])]);
+  const alive = winpids.filter((pid) => processExists(Number(pid)));
+  if (alive.length > 0) throw new Error(`Die Prozesse ${alive.join(", ")} des bash-Aufrufs laufen nach taskkill weiter`);
+};
+
 const darwinProcessGroupExists = (pid: number): Promise<boolean> =>
   new Promise((resolve, reject) => {
     execFile("/bin/ps", ["-axo", "pgid=,stat="], { timeout: 5_000, maxBuffer: 4 * 1024 * 1024 }, (error, stdout) => {

package/packages/workspace-executor/src/modules.ts

@@ -1,7 +1,6 @@
-import { browserModule } from "./browser/module.js";
 import { commandModule } from "./commands.js";
+import type { WorkspaceExecutorParts } from "./contributions.js";
 import { fileModule } from "./files.js";
-import { workspaceLanguageServers } from "./language-server/adapters/index.js";
 import { languageServerModule } from "./language-server/module.js";
 import type { WorkspaceModuleFactory } from "./module.js";
 import { processModule } from "./processes/module.js";
@@ -11,15 +10,17 @@ import { sandboxToolsModule } from "./sandbox-tools.js";
 export interface WorkspaceExecutorModuleOptions {
   /** Der neue Ordner eines Runs auf dieser Maschine; nur ein Arbeitsplatz kennt ihn, auf dem Server legt ihn der Host an. */
   runFolder?: (runId: string) => string;
+  /** Die Beiträge der Plugins, gebaut für diese Maschine; Server und Arbeitsplatz bekommen dieselben. */
+  contributions: readonly WorkspaceExecutorParts[];
 }
 
-/** Die Module jedes Executors, im Server wie auf dem Arbeitsplatz dieselben. */
-export const workspaceExecutorModules = (options: WorkspaceExecutorModuleOptions = {}): readonly WorkspaceModuleFactory[] => [
+/** Die Module eines Executors: die eigenen und was die Beiträge der Plugins hinzufügen. */
+export const workspaceExecutorModules = (options: WorkspaceExecutorModuleOptions): readonly WorkspaceModuleFactory[] => [
   sandboxToolsModule,
-  languageServerModule(workspaceLanguageServers),
+  languageServerModule(options.contributions.flatMap((parts) => parts.languageServers ?? [])),
   fileModule,
   processModule(),
   commandModule(),
-  browserModule(),
+  ...options.contributions.flatMap((parts) => parts.modules ?? []),
   runFolderModule(options.runFolder),
 ];

package/packages/workspace-executor/src/sandbox-tools.ts

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import {
@@ -12,7 +12,7 @@ import {
 import { bashLaunch } from "./bash-launch.js";
 import type { WorkspaceProcessContext } from "./context.js";
 import { WorkspaceOperationError } from "./errors.js";
-import { processGroupExists, stopProcessTree } from "./managed-process.js";
+import { MSYS_CALL_ENV, processGroupExists, stopMsysCall, stopProcessTree } from "./managed-process.js";
 import type { WorkspaceModuleFactory, WorkspaceOperation } from "./module.js";
 import { sandboxedLaunch } from "./process-sandbox.js";
 import { stopUidProcesses } from "./session-ident.js";
@@ -40,11 +40,6 @@ export interface SandboxTools {
   shutdown: () => Promise<void>;
 }
 
-export const DEFAULT_BASH_TIMEOUT_SECONDS = (() => {
-  const value = Number(process.env.RAGENTS_BASH_TIMEOUT_SECONDS);
-  return Number.isFinite(value) && value > 0 ? value : 600;
-})();
-
 type ToolResult = { content?: Array<{ type: string; text?: string }>; details?: unknown };
 
 /** Der Stand einer Datei, den das Modell zuletzt gesehen hat; der Host führt ihn je Actor und gibt ihn mit, das Modell nennt ihn nie. */
@@ -130,10 +125,14 @@ export const createSandboxTools = async (
   let toolOperation: Promise<void> = Promise.resolve();
   let shuttingDown = false;
   const processGroups = new Set<number>();
+  const msysCalls = new Map<number, { readonly bash: string; readonly env: NodeJS.ProcessEnv; readonly marker: string }>();
 
   const killProcessGroup = async (pid: number): Promise<void> => {
     if (onWindows) {
       stopProcessTree(pid);
+      const call = msysCalls.get(pid);
+      msysCalls.delete(pid);
+      if (call) await stopMsysCall(call.bash, call.env, call.marker);
       processGroups.delete(pid);
       return;
     }
@@ -269,21 +268,23 @@ export const createSandboxTools = async (
       const context = await contextFor();
       if (shuttingDown) throw new Error("Die Werkzeuge werden killed");
       options.signal?.throwIfAborted();
-      const bash = bashLaunch(context.bash, command, context.env);
+      const bash = bashLaunch({ bash: context.bash, rg: context.rg }, command, context.env);
       const launch = await sandboxedLaunch(context, bash);
       if (shuttingDown) throw new Error("Die Werkzeuge werden killed");
       options.signal?.throwIfAborted();
+      const marker = onWindows ? randomUUID() : undefined;
       return new Promise((resolve, reject) => {
         const child = spawn(launch.command, [...launch.args], {
           cwd: commandCwd,
           detached: !onWindows,
           stdio: ["ignore", "pipe", "pipe"],
-          env: bash.env,
+          env: marker === undefined ? bash.env : { ...bash.env, [MSYS_CALL_ENV]: marker },
           uid: context.uid,
           gid: context.gid,
           windowsHide: true,
         });
         if (child.pid) processGroups.add(child.pid);
+        if (child.pid && marker !== undefined && context.bash !== undefined) msysCalls.set(child.pid, { bash: context.bash, env: context.env, marker });
         child.stdout?.on("data", options.onData);
         child.stderr?.on("data", options.onData);
         let killed = false;
@@ -303,11 +304,10 @@ export const createSandboxTools = async (
             }
           });
         };
-        const timeoutSeconds = options.timeout ?? DEFAULT_BASH_TIMEOUT_SECONDS;
         const timer = setTimeout(() => {
           timedOut = true;
           kill();
-        }, timeoutSeconds * 1000);
+        }, options.timeout * 1000);
         options.signal?.addEventListener("abort", kill);
         const cleanup = () => {
           if (timer) clearTimeout(timer);
@@ -322,7 +322,7 @@ export const createSandboxTools = async (
           const finish = () => processError
             ? reject(processError)
             : timedOut
-              ? reject(new Error(`timeout:${timeoutSeconds}`))
+              ? reject(new Error(`timeout:${options.timeout}`))
               : resolve({ exitCode: killed ? null : code });
           if (!child.pid) {
             finish();

package/packages/workspace-executor/src/shell-platform.ts

@@ -1,11 +1,22 @@
 const platformTexts: Partial<Record<NodeJS.Platform, string>> = {
-  darwin: "`bash` runs on macOS with the BSD userland: `grep` has no `-P` (use `grep -E` or `rg`), in-place `sed` needs an explicit backup suffix (`sed -i '' ...`), `date` uses `-v` instead of `-d`, `xargs` uses `-I{}` instead of `-i`, and other GNU-only flags are unavailable. `/bin/bash` is version 3.2: no associative arrays (`declare -A`), no `mapfile`/`readarray`, no `${var,,}` case conversion.",
+  darwin: "`bash` runs on macOS with the BSD userland: `grep` has no `-P` (use `grep -E`), in-place `sed` needs an explicit backup suffix (`sed -i '' ...`), `date` uses `-v` instead of `-d`, `xargs` uses `-I{}` instead of `-i`, and other GNU-only flags are unavailable. `/bin/bash` is version 3.2: no associative arrays (`declare -A`), no `mapfile`/`readarray`, no `${var,,}` case conversion.",
   linux: "`bash` runs on Linux with the GNU userland: `grep -P`, `sed -i` without suffix and the usual GNU flags work.",
   win32: "`bash` runs on Windows with the bash RAgents brings along, an MSYS userland with the GNU tools (coreutils, `grep`, `sed`, `awk`, `find`, `xargs`, `diff`, `patch`, `tar`, `gzip`, `unzip`, `file`, `cygpath`, `dos2unix`): `grep -P`, `sed -i` without suffix and the usual GNU flags work. `git`, `dotnet` and `node` are the Windows programs of this machine on the `PATH`, with the user's own configuration and login; they take Windows paths, not `/c/...` (`cygpath -w` converts). The file system is the Windows one: absolute paths are `C:/project/...` or `/c/project/...`, both spellings reach the same file, and a path from another tool may use backslashes. Files often carry CRLF line endings, so anchor patterns with `\\r\\?$` and keep the line ending a file already has.",
 };
 
-export const shellPlatformText = (platform: NodeJS.Platform = process.platform): string => {
+const searchTexts = {
+  ripgrep: "Search code with `rg` (ripgrep) and list files with `rg --files`: it skips hidden files and everything `.gitignore` excludes, such as `node_modules`, `bin` and `obj`, and is far faster than `grep -r` (`rg -uu` searches those too). Use `grep` only on single files or in pipes.",
+  grep: "`rg` (ripgrep) is not available here. `grep -r` also walks dependency and build folders, so exclude them: `grep -r --exclude-dir=node_modules --exclude-dir=.git --exclude-dir=bin --exclude-dir=obj ...`.",
+};
+
+/** Was der Executor dem Werkzeug bash über die Plattform hinaus bietet. */
+export interface ShellTools {
+  readonly ripgrep: boolean;
+}
+
+export const shellPlatformText = (platform: NodeJS.Platform, tools: ShellTools): string => {
   const text = platformTexts[platform];
   if (!text) throw new Error(`Für die Plattform ${platform} gibt es keine Shell-Beschreibung.`);
-  return `${text} A nonzero exit code, for example \`grep\` without a match, comes back as an ordinary result with the code at the end, not as a tool error; only start, timeout and abort problems are tool errors.`;
+  const search = tools.ripgrep ? searchTexts.ripgrep : searchTexts.grep;
+  return `${text} ${search} A nonzero exit code, for example \`grep\` without a match, comes back as an ordinary result with the code at the end, not as a tool error; only start, timeout and abort problems are tool errors.`;
 };

package/packages/workspace-executor/src/tools.ts

@@ -23,6 +23,3 @@ export const workspaceDataDirectory = (home = homedir()): string => path.join(ra
 /** Der Datenordner dieses Prozesses: DATA_DIR wie beim Server, sonst der des Arbeitsplatzes ohne Profil. */
 export const hostDataDirectory = (environment: NodeJS.ProcessEnv = process.env): string =>
   path.resolve(environment.DATA_DIR ?? workspaceDataDirectory());
-
-export const hostToolFile = (pluginId: string, relative: string): string =>
-  path.join(pluginToolsDirectory(hostDataDirectory(), pluginId), ...relative.split("/"));

package/plugins/ragents.actor-programs/server/access-projections.ts

@@ -0,0 +1,31 @@
+import type { AccessProjectionContribution, JsonValue } from "@ragents/engine";
+import { ACTOR_INVOCATIONS_STATE_ID, ACTOR_PROGRAMS_STATE_ID } from "@ragents/host/plugin-support/actor-programs/contract.js";
+
+const record = (value: JsonValue | undefined): Record<string, JsonValue | undefined> | undefined =>
+  value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+
+/** Ohne runs.inspect bleiben von einem Programm Name, Actor und Ansichten; Quellen, Funktionen und Verzeichnisse fehlen. */
+const visibleProgram = (state: JsonValue): JsonValue => {
+  const program = record(record(state)?.program);
+  if (!program) return state;
+  const views = Array.isArray(program.views) ? program.views.map((value) => {
+    const view = record(value);
+    return view ? { id: view.id, key: view.key, title: view.title, visible: view.visible, placements: view.placements } : value;
+  }) : [];
+  return {
+    version: 1,
+    program: {
+      name: program.name,
+      title: program.title,
+      actorId: program.actorId,
+      actorHandle: program.actorHandle,
+      revision: program.revision,
+      views,
+    },
+  };
+};
+
+export const actorProgramAccessProjections: readonly AccessProjectionContribution[] = [
+  { id: ACTOR_PROGRAMS_STATE_ID, state: (entry) => visibleProgram(entry.state), chatEvent: () => undefined },
+  { id: ACTOR_INVOCATIONS_STATE_ID, state: (entry) => ({ version: 1, revision: entry.updatedAt }), chatEvent: () => undefined },
+];

package/plugins/ragents.actor-programs/server/index.ts

@@ -13,6 +13,7 @@ import { actorProgramSummary } from "./prompts.js";
 import { sandboxServicesToken } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
 import { actorProgramsToken } from "@ragents/host/plugin-support/actor-programs/service.js";
 import { createProjectDiagnostics } from "./project-diagnostics.js";
+import { actorProgramAccessProjections } from "./access-projections.js";
 const actorProgramsPlugin = (pluginHost: PluginHost): RAgentsPlugin => ({
     manifest: { id: "ragents.actor-programs" },
     register: (host) => {
@@ -45,6 +46,7 @@ const actorProgramsPlugin = (pluginHost: PluginHost): RAgentsPlugin => ({
             deleteSession: async ({ runId }) => { diagnostics.forget(runId); await runtime.deleteSession(runId); }, shutdown: () => runtime.shutdown(),
         });
         host.prompts(actorProgramSummary);
+        host.accessProjections(...actorProgramAccessProjections);
         host.functions(createControlsToolContributor(), ...createActorProgramToolContributors(runtime, diagnostics));
     },
 });

package/plugins/ragents.ask/ask-payload.ts

@@ -1,5 +1,8 @@
 export const ASK_PLUGIN_ID = "ragents.ask";
 
+/** What the asking tool call gets when a person's message to the asker closes its question. */
+export const SUPERSEDED_ANSWER = "Not answered: the user sent a new message instead.";
+
 export interface AskPayload {
   question: string;
   options: string[];
@@ -23,3 +26,9 @@ export const askPayloadOf = (payload: unknown): AskPayload | undefined => {
     ...(typeof candidate.recipient === "string" ? { recipient: candidate.recipient } : {}),
   };
 };
+
+export const supersedingInputOf = (result: unknown): string | undefined => {
+  if (typeof result !== "object" || result === null) return undefined;
+  const { supersededBy } = result as { supersededBy?: unknown };
+  return typeof supersededBy === "string" ? supersededBy : undefined;
+};