@schlenkr/ragents 0.1.6 → 0.1.8

package/apps/server/src/chat-handler.ts

@@ -8,6 +8,8 @@ export interface SessionInfo {
   createdAt?: number;
   updatedAt: number;
   revision?: number;
+  /** Warum der Run gesperrt ist; er bleibt sichtbar und löschbar, alles andere meldet journal-unavailable. */
+  locked?: string;
 }
 
 export interface ChatUser {

package/apps/server/src/config.ts

@@ -11,6 +11,8 @@ export const hostConfigDescriptors = [
   { key: "PORT", source: "environment" },
   { key: "DATA_DIR", source: "environment" },
   { key: "AGENT_THINKING", source: "environment" },
+  { key: "AGENT_COMPACTION_RESERVE_TOKENS", source: "environment" },
+  { key: "AGENT_COMPACTION_KEEP_RECENT_TOKENS", source: "environment" },
   { key: "COMPACTION_PROVIDER", source: "environment" },
   { key: "COMPACTION_MODEL", source: "environment" },
   ...modelAliasEnvDescriptors,
@@ -35,6 +37,10 @@ export const config = Object.freeze({
   dataDir: path.resolve(env.value("DATA_DIR", defaultDataDirectory(env.required("PRODUCT_PROFILE")))),
   webDistDir: hostWebDirectory(rootDir),
   agentThinking: env.value("AGENT_THINKING", "high"),
+  agentCompaction: {
+    ...(env.optional("AGENT_COMPACTION_RESERVE_TOKENS") ? { reserveTokens: env.positiveNumber("AGENT_COMPACTION_RESERVE_TOKENS", "") } : {}),
+    ...(env.optional("AGENT_COMPACTION_KEEP_RECENT_TOKENS") ? { keepRecentTokens: env.positiveNumber("AGENT_COMPACTION_KEEP_RECENT_TOKENS", "") } : {}),
+  },
   compactionProvider: env.value("COMPACTION_PROVIDER", "openrouter"),
   compactionModel: env.value("COMPACTION_MODEL", ""),
   productProfile: env.required("PRODUCT_PROFILE"),

package/apps/server/src/host-api.json

@@ -899,6 +899,7 @@
       "timestampLabel",
       "useChatAction",
       "useQuasselComponents",
+      "useQuasselPortalContainer",
       "validateAttachmentSelection"
     ],
     "react": [

package/apps/server/src/layout.ts

@@ -1,13 +1,6 @@
 import path from "node:path";
-import { isPortableId } from "@ragents/engine";
 import { config } from "./config.js";
 
-const portableId = (value: string, name: string) => {
-  if (!isPortableId(value)) throw new Error(`${name} must be a lowercase portable ID.`);
-
-  return value;
-};
-
 export const layout = {
   runsDir: path.join(config.dataDir, "runs"),
   artifactsDir: path.join(config.dataDir, "artifacts"),
@@ -18,14 +11,6 @@ export const layout = {
   serverLog: path.join(config.dataDir, "logs/server.log"),
 
   sessionDir: (id: string) => path.join(config.dataDir, "sessions", id),
-  chatDir: (id: string) => path.join(config.dataDir, "sessions", id, "chat"),
-  agentChatDir: (id: string, agentId: string) => path.join(
-    config.dataDir,
-    "sessions",
-    portableId(id, "Run ID"),
-    "chat",
-    portableId(agentId, "Actor ID"),
-  ),
   deleteIntentFile: (id: string) => path.join(config.dataDir, "delete-intents", `${id}.json`),
   archiveSessionDir: (id: string) => path.join(config.dataDir, "archive", id),
   recoverySessionDir: (id: string) => path.join(config.dataDir, "recovery", id),

package/apps/server/src/plugin-support/agent-tool.ts

@@ -9,7 +9,7 @@ import {
   type ToolExecutionMode,
 } from "@ragents/engine";
 
-export type AgentToolDefinition = ToolDefinition<any, any, any> & { longDescription?: string; nativeTool?: boolean };
+export type AgentToolDefinition = ToolDefinition<any, any> & { longDescription?: string; nativeTool?: boolean };
 
 export interface AgentToolMetadata {
   readonly name: string;
@@ -24,7 +24,6 @@ type BoundExecute = (
   params: unknown,
   signal: AbortSignal | undefined,
   onUpdate: unknown,
-  ctx: unknown,
 ) => Promise<ToolOutput>;
 
 export const textOf = (result: ToolOutput): string =>
@@ -49,7 +48,7 @@ export const agentToolFrom = (
     available,
     ...(executionMode ? { executionMode } : {}),
     run: async (scope, toolCallId, input) =>
-      textOf(await (definition.execute as BoundExecute)(toolCallId, input, scope.signal, undefined, undefined)),
+      textOf(await (definition.execute as BoundExecute)(toolCallId, input, scope.signal, undefined)),
   });
 
 export const toolDescriptorFrom = (

package/apps/server/src/plugin-support/plugin-folder.ts

@@ -74,8 +74,9 @@ export const withFolderAssets = (plugin: RAgentsPlugin): RAgentsPlugin => ({
     if (skillPaths.length === 0) return;
     host.skills({
       id: `${plugin.manifest.id}.folder-skills`,
+      // Ein ausdrücklich angemeldeter Pfad gehört in jedem Run dem ausdrücklichen Beitrag, auch wo der ihn für diesen Run weglässt.
       paths: async (context) => {
-        const explicit = await Promise.all(explicitSkills.map((skill) => skill.paths(context)));
+        const explicit = await Promise.all(explicitSkills.flatMap((skill) => [skill.paths(undefined), skill.paths(context)]));
         const taken = new Set(explicit.flat());
         return skillPaths.filter((skillPath) => !taken.has(skillPath));
       },

package/apps/server/src/provider.ts

@@ -1,10 +1,10 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { randomUUID } from "node:crypto";
-import { existsSync } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import { chmod, mkdir, open, readFile, readdir, realpath, rename, rm } from "node:fs/promises";
 import path from "node:path";
 import type { ChatSessionLike, ChatSessionProvider, RunListScope, SessionInfo } from "./chat-handler.js";
-import { DomainError, isRunId, unrestrictedAccess, type AccessContext, type HttpRouteContribution, type MethodContribution, type PluginHost, type ServiceToken, type SessionStartedContext } from "@ragents/engine";
+import { DomainError, isRunId, unrestrictedAccess, type AccessContext, type HttpRouteContribution, type Journal, type JournalLoadFailure, type MethodContribution, type PluginHost, type ServiceToken, type SessionStartedContext } from "@ragents/engine";
 import { WORKSPACE_EXECUTOR_VERSION } from "@ragents/workspace-executor";
 import { assertRunRights, assertRunWorkspaceAccess, runIdInPath, runListScope, runReachable, type GlobalRunPolicy, type RunAccessPolicy } from "./api/rights.js";
 import { configuredAnonymousUser, configuredUsers } from "./config-file.js";
@@ -17,6 +17,8 @@ import {
   assertRunIdFree,
   assertRunStopped,
   assertWorkspaceReplacement,
+  contentHashesOf,
+  installContents,
   installSessionDirectory,
   packRunArchive,
   runTransferStagingDirectory,
@@ -314,7 +316,10 @@ export class RunSessionProvider implements ChatSessionProvider {
         ...(Object.keys(metadata.unavailable).length > 0 ? { metadataUnavailable: metadata.unavailable } : {}),
       };
     }));
-    const infos = described.filter((info): info is ListedSession => info !== undefined);
+    const locked = engine.journal.unavailableRuns()
+      .filter(({ runId }) => !isCoordinator(runId) && !this.deleteRequested.has(runId) && !this.deleted.has(runId) && visible(runId))
+      .map((failure) => lockedSession(failure, engine.journal));
+    const infos = [...described.filter((info): info is ListedSession => info !== undefined), ...locked];
     for (const [id, session] of this.sessions) {
       if (isCoordinator(id) || !visible(id)) continue;
       if (this.deleteRequested.has(id) || this.deleted.has(id)) continue;
@@ -466,10 +471,6 @@ export class RunSessionProvider implements ChatSessionProvider {
     this.ensureUsable(id);
     if (!this.plugins.optionalService(globalChatToken)?.isCoordinator(id)) await this.plugins.lifecycle.prepareSession(id);
     this.ensureUsable(id);
-    await mkdir(layout.chatDir(id), { recursive: true, mode: ROOT_ONLY_MODE });
-    this.ensureUsable(id);
-    await chmod(layout.chatDir(id), ROOT_ONLY_MODE);
-    this.ensureUsable(id);
   }
 
   private async startedRun(id: string, startEntry: SessionStartedContext["startEntry"]): Promise<void> {
@@ -496,7 +497,7 @@ export class RunSessionProvider implements ChatSessionProvider {
     return this.deleting.get(id)?.done;
   }
 
-  /** Ein gestoppter Run als Archiv: Journal, Payloads, Modellkontexte und seine Plugin-Ablagen. */
+  /** Ein gestoppter Run als Archiv: Journal, Payloads, die Inhalte, auf die er verweist, und seine Plugin-Ablagen. */
   exportRun(id: string): Promise<RunTransferExport> {
     this.ensureUsable(id);
     if (this.plugins.optionalService(globalChatToken)?.isCoordinator(id)) {
@@ -524,7 +525,12 @@ export class RunSessionProvider implements ChatSessionProvider {
         boundDirectory: this.workspaceTransfer().boundDirectory(id),
         exportedAt: new Date().toISOString(),
       };
-      const archive = await packRunArchive({ places: this.transferPlaces(), runId: id, manifest });
+      const archive = await packRunArchive({
+        places: this.transferPlaces(),
+        runId: id,
+        manifest,
+        contentHashes: contentHashesOf(engine.journal.load(id)),
+      });
       return { manifest, archive: archive.toString("base64") };
     });
   }
@@ -543,6 +549,7 @@ export class RunSessionProvider implements ChatSessionProvider {
         assertWorkspaceReplacement(manifest, workspacePath);
         if (workspacePath !== undefined) transfer.assertDirectory(workspacePath);
         const sessionDirectory = await installSessionDirectory({ places, runId: manifest.runId, staging, mode: SESSION_MODE });
+        await installContents({ places, staging });
         const engine = this.requireEngine();
         try {
           engine.journal.adopt(unpacked.records);
@@ -639,7 +646,7 @@ export class RunSessionProvider implements ChatSessionProvider {
       await settled;
       await this.plugins.optionalService(sandboxServicesToken)?.shutdown(id);
       await this.removeGlobalConversation(id, policy);
-      engine.journal.forget(id);
+      engine.runtime.forgetRun(id);
       this.sessionWorkspaces.delete(id);
       this.workspaces.forget(id);
     });
@@ -756,7 +763,7 @@ export class RunSessionProvider implements ChatSessionProvider {
     if (failures.length > 0) throw new AggregateError(failures, `Run ${id} konnte nicht gestoppt werden`);
     await this.plugins.lifecycle.deleteSession(id);
     await this.archiveSession(id);
-    this.engine?.journal.forget(id);
+    this.engine?.runtime.forgetRun(id);
     this.sessions.delete(id);
     this.sessionWorkspaces.delete(id);
     this.workspaces.forget(id);
@@ -870,6 +877,7 @@ export class RunSessionProvider implements ChatSessionProvider {
   private async archiveSession(id: string): Promise<void> {
     const target = layout.archiveSessionDir(id);
     await mkdir(target, { recursive: true, mode: ROOT_ONLY_MODE });
+    // Journale vor Format 7 hielten den Modellkontext unter sessions/<id>/chat; er bleibt im Archiv erhalten.
     const moves = [
       [path.join(layout.sessionDir(id), "chat"), "chat"],
       [path.join(layout.runsDir, id), "run"],
@@ -893,6 +901,21 @@ export class RunSessionProvider implements ChatSessionProvider {
   }
 }
 
+/** Ein gesperrter Run ohne Plugin-Metadaten und Arbeitsbereich; ohne geladenen Zustand zählt die Journaldatei. */
+const lockedSession = (failure: JournalLoadFailure, journal: Journal): ListedSession => {
+  const state = journal.stateOf(failure.runId);
+  const updatedAt = state ? Date.parse(journal.updatedAt(failure.runId) ?? state.createdAt) : statSync(failure.path, { throwIfNoEntry: false })?.mtimeMs ?? 0;
+  return {
+    id: failure.runId,
+    title: state?.title ?? failure.runId,
+    ...(state ? { createdAt: Date.parse(state.createdAt), revision: state.revision } : {}),
+    updatedAt,
+    running: false,
+    workspaceAccessible: false,
+    locked: failure.message,
+  };
+};
+
 const sessionTitle = (text: string | undefined): string | undefined => {
   const lines = text?.split(/\r?\n/).map((line) => line.trim()).filter(Boolean) ?? [];
   if (lines.length === 0) return undefined;

package/apps/server/src/ragents/actor-chat-history.ts

@@ -81,6 +81,7 @@ export function actorChatHistoryOf(view: RunView, events: readonly JournalEvent[
       case "tool.call.completed":
       case "tool.call.failed":
       case "runtime.output.recorded":
+      case "context.compacted":
       case "turn.finished":
       case "turn.interrupted": {
         const actorId = turnActorOf(event.payload.turnId);

package/apps/server/src/ragents/engine.ts

@@ -7,7 +7,7 @@ import {
   Journal,
   LiveBus,
   Orchestration,
-  AgentSessionDriver,
+  AgentLoopDriver,
   attachmentInputKind,
   RunStopper,
   type PluginHost,
@@ -39,7 +39,7 @@ import { config } from "../config.js";
 import { accessibleRunView } from "../access-projection.js";
 import { assertRunRights } from "../api/rights.js";
 import { runOwnerOf, runOwnerOnly } from "./run-owner.js";
-import { layout, ROOT_ONLY_MODE } from "../layout.js";
+import { layout } from "../layout.js";
 import { renderSystemPromptOption, systemPromptSelectionPromptIds } from "../plugin-support/prompt.js";
 import { actorProgramsToken } from "../plugin-support/actor-programs/service.js";
 import { checkedThinkingLevel } from "../plugin-support/thinking-level.js";
@@ -88,11 +88,6 @@ export class SessionWorkspaces implements Workspaces {
     return this.#roots.get(runId)?.description;
   }
 
-  /** Der Ordner auf diesem Server für Arbeit des Runs, die hier läuft; bei einem Arbeitsplatz nie dessen Pfad. */
-  async runtimeDirectory(runId: string): Promise<string> {
-    return (await this.#sandbox().serverProcessContextFor(runId)).cwd;
-  }
-
   async storeAttachment(runId: string, name: string, content: Uint8Array): Promise<string> {
     const stored = await this.#sandbox().execute(runId, FILE_OPERATIONS.attach, { name, content: Buffer.from(content).toString("base64") });
     const storedName = (stored as { name?: unknown } | null)?.name;
@@ -206,15 +201,12 @@ export const createEngine = async (options: EngineOptions): Promise<Engine> => {
     workspace: context.workspace,
     audience: isRunCoordinator(runtime, context.runId, context.agentId) ? "coordinator" : "agent",
   });
-  const agentRuntime = new AgentSessionDriver({
+  const agentRuntime = new AgentLoopDriver({
     modelRuntime: options.modelRuntime,
     resolveSkills: async (context) => globalChat?.isCoordinator(context.runId) ? []
       : (await options.plugins.skills.resolve(contributionContextFor(context))).map(skillOfDirectory),
-    resolveExtensionFactories: (context) => globalChat?.isCoordinator(context.runId) ? [] : options.plugins.agentRuntime.resolve(contributionContextFor(context)),
-    sessions: {
-      directory: (runId, agentId) => layout.agentChatDir(runId, agentId),
-      directoryMode: ROOT_ONLY_MODE,
-    },
+    resolveHooks: (context) => globalChat?.isCoordinator(context.runId) ? [] : options.plugins.agentRuntime.resolve(contributionContextFor(context)),
+    settings: { compaction: config.agentCompaction },
   });
   const configuredModels = await Promise.all(options.plugins.profiles.models().map(async (model) => {
     if (model.driver !== "agent") return model;
@@ -279,32 +271,39 @@ export const createEngine = async (options: EngineOptions): Promise<Engine> => {
     });
   const boundToTools = (entry: PublicPromptContribution, toolNames: readonly string[]): boolean =>
     entry.requiresTools.some((name) => toolNames.includes(name));
-  /** Ein Beitrag darf je Run anders lauten, etwa die Shell-Plattform des Executors, der den Run ausführt. */
-  const contentFor = (runId: string | null): ((entry: PublicPromptContribution) => string) => {
+  /** Ein Beitrag darf je Run anders lauten oder fehlen, etwa die Shell-Plattform des Executors oder ein Plugin, dessen Laufbedingung nicht zutrifft; das gilt auch für die gewählten Systemprompts. */
+  const contentFor = (runId: string | null, texts: () => readonly string[]): ((entry: PublicPromptContribution) => string) => {
     const overrides = runId === null ? undefined : options.plugins.prompts.runOverrides(runId);
-    return (entry) => overrides?.get(entry.id) ?? entry.content;
+    return (entry) => overrides?.get(entry.id)
+      ?? (systemPromptSelectionPromptIds.has(entry.id) ? texts().join("\n\n") : entry.content);
   };
   const composeWith = (runId: string | null, texts: readonly string[], toolNames: readonly string[] | null): string => {
-    const content = contentFor(runId);
+    const content = contentFor(runId, () => texts);
     return baseSnapshot
       .contributions
       .filter((entry) => entry.delivery === "initial")
       .filter((entry) => toolNames === null || entry.requiresTools.length === 0 || boundToTools(entry, toolNames))
-      .map((entry) => systemPromptSelectionPromptIds.has(entry.id) ? texts.join("\n\n") : content(entry))
+      .map(content)
       .filter(Boolean)
       .join("\n\n");
   };
-  const chaptersFor = async (toolNames: readonly string[]): Promise<string> => {
+  const chaptersFor = async (runId: string, toolNames: readonly string[]): Promise<string> => {
     const chapters = await options.plugins.prompts.describe({
     }, { delivery: "on-demand", toolNames });
-    return chapters.map((entry) => entry.content).filter(Boolean).join("\n\n");
+    const content = contentFor(runId, () => []);
+    return chapters.map(content).filter(Boolean).join("\n\n");
   };
   const systemPromptFor = (runId: string): string => globalChat?.isCoordinator(runId)
     ? globalChat.prompt : composeWith(runId, textsFor(runId), null);
   const coordinatorPromptFor = (runId: string, toolNames: readonly string[]): string =>
     composeWith(runId, textsFor(runId), toolNames);
-  const agentPromptFor = (runId: string): string =>
-    storedSystemPrompt(journal.stateOf(runId)).shareWithAgents ? textsFor(runId).join("\n\n") : "";
+  const selectionPrompts = baseSnapshot.contributions.filter((entry) => systemPromptSelectionPromptIds.has(entry.id));
+  const agentPromptFor = (runId: string): string => {
+    if (!storedSystemPrompt(journal.stateOf(runId)).shareWithAgents) return "";
+    if (selectionPrompts.length === 0) return textsFor(runId).join("\n\n");
+    const content = contentFor(runId, () => textsFor(runId));
+    return selectionPrompts.map(content).filter(Boolean).join("\n\n");
+  };
   const systemPrompt = composeWith(
     null,
     selectedSystemPrompts(promptCatalog, promptCatalog.defaultIds).map((option) => optionTexts.get(option.id) ?? ""),
@@ -317,7 +316,7 @@ export const createEngine = async (options: EngineOptions): Promise<Engine> => {
       : [agentPromptFor(runId), actor.kind === "agent" ? actor.prompt : "",
           ...baseSnapshot.contributions
             .filter((entry) => entry.delivery === "initial" && boundToTools(entry, toolNames))
-            .map(contentFor(runId)),
+            .map(contentFor(runId, () => textsFor(runId))),
         ].filter(Boolean).join("\n\n");
     return [prompt, productRuntime.contract(role), outputContractFor(role)]
       .filter(Boolean)
@@ -339,7 +338,7 @@ export const createEngine = async (options: EngineOptions): Promise<Engine> => {
     ...(workspaceToolNaming ? { workspaceToolNaming } : {}),
     basePrompt: basePromptFor,
     contract: (actor) => coreContractFor(actor),
-    toolChapters: (_runId, _actor, toolNames) => chaptersFor(toolNames),
+    toolChapters: (runId, _actor, toolNames) => chaptersFor(runId, toolNames),
     onError: (error) => console.error(`Turn fehlgeschlagen: ${error instanceof Error ? error.stack ?? error.message : String(error)}`),
   });
   const stopExternal: RunStopBoundary = (runId, stopJournal) => scheduler.haltRun(runId, async (

package/apps/server/src/ragents/journal-chat-events.ts

@@ -62,6 +62,8 @@ export const journalChatEventsOf = (
       ];
     case "actor.stopped":
       return [{ kind: "system", text: event.payload.reason, at }];
+    case "context.compacted":
+      return [{ kind: "system", text: `Model context compacted: the model now sees the history before this point (about ${event.payload.tokensBefore} tokens) only as a summary.`, at }];
     default:
       return [];
   }

package/apps/server/src/ragents/run-owner.ts

@@ -1,10 +1,11 @@
 import type { Journal, StartOptionContributionRegistry } from "@ragents/engine";
 import { storedStartOption } from "./start-option-state.js";
 
-/** Der Benutzer eines Runs aus seinem Journal: null ohne Eigentümer, undefined für eine Kennung ohne Run. */
+/** Der Benutzer eines Runs aus seinem Journal: null ohne Eigentümer und für ein gesperrtes Journal ohne Zustand, undefined für eine Kennung ohne Run. */
 export const runOwnerOf = (journal: Journal, runId: string): string | null | undefined => {
   const state = journal.stateOf(runId);
-  return state ? state.ownerUserId : undefined;
+  if (state) return state.ownerUserId;
+  return journal.failureOf(runId) ? null : undefined;
 };
 
 /** Nur der Eigentümer bedient einen Run, dessen gespeicherte Startoption das für ihren Wert erklärt. */

package/apps/server/src/ragents/session.ts

@@ -856,9 +856,9 @@ export class RunChatSession implements ChatSessionLike {
         const cursor = this.#textPositions.observe(event);
         const primaryActorId = this.#primaryActorId;
         if (!primaryActorId) continue;
-        if (event.actorId === primaryActorId
-          && (event.type === "turn.finished" || event.type === "turn.interrupted")
-          && this.#liveTurns.has(event.payload.turnId)) this.#journalFinishedTurns.add(event.payload.turnId);
+        if ((event.type === "turn.finished" || event.type === "turn.interrupted")
+          && this.#liveTurns.has(event.payload.turnId)
+          && this.#engine.runtime.state(this.id).turns.get(event.payload.turnId)?.actorId === primaryActorId) this.#journalFinishedTurns.add(event.payload.turnId);
         if (live) continue;
         for (const chatEvent of chatEventsOf(event, this.#scope(primaryActorId), cursor, this.#pluginStates)) this.#emit(chatEvent);
       }

package/apps/server/src/run-preparation.ts

@@ -1,6 +1,6 @@
-import { createAgentSession, DefaultResourceLoader, defineTool, SessionManager, type ModelRuntime } from "@ragents/agent";
+import { Agent, convertToLlm, type AgentTool, type ModelRuntime } from "@ragents/agent";
 import { Type } from "typebox";
-import type { Message } from "@ragents/ai";
+import { clampThinkingLevel, type Message } from "@ragents/ai";
 import { DomainError, type ModelSelection } from "@ragents/engine";
 import { prepareInputAttachments } from "../../../packages/ragents/src/drivers/attachments.ts";
 import { MAX_CHAT_REQUEST_BYTES, parseChatAttachments } from "quassel/events";
@@ -86,13 +86,8 @@ export const prepareRunMessage = async (options: {
     }
     signal.throwIfAborted();
     const systemPrompt = [options.prompt, options.request.skillName ? `Ausgewählter Skill: ${options.request.skillName}` : ""].filter(Boolean).join("\n\n");
-    const resourceLoader = new DefaultResourceLoader({ systemPrompt });
-    await resourceLoader.reload({ signal });
-    signal.throwIfAborted();
-    const sessionManager = SessionManager.inMemory();
-    for (const message of messages.slice(0, -1)) sessionManager.appendMessage(message);
     let startRequested = false;
-    const startRun = defineTool({
+    const startRun: AgentTool = {
       name: "start_run", label: "Run starten",
       description: "Den besprochenen Run starten, ausschließlich nach dem ausdrücklichen sinngemäßen Go des Benutzers zur Ausführung. Keine feste Formulierung nötig. Eine Detailbestätigung, ein Zitat oder eine Fähigkeitsfrage genügt nicht. Der Host übernimmt Auftrag, Skill und Anhänge aus dem Gespräch sowie die Startoptionen.",
       parameters: Type.Object({}),
@@ -101,23 +96,25 @@ export const prepareRunMessage = async (options: {
         startRequested = true;
         return { content: [{ type: "text", text: "Start zur Übergabe vorgemerkt. Nach Abschluss dieser Antwort übernimmt die Oberfläche den Auftrag." }], details: {} };
       },
+    };
+    if (!(await runtime.checkAuth(model.provider))) throw new Error(`No key is configured for the provider ${model.provider}.`);
+    const agent = new Agent({
+      initialState: { systemPrompt, model, thinkingLevel: clampThinkingLevel(model, selection.thinking ?? "off"), tools: [startRun], messages: messages.slice(0, -1) },
+      convertToLlm,
+      streamFn: (streamModel, context, streamOptions) => runtime.streamSimple(streamModel, context, { ...streamOptions, maxRetries: 0, timeoutMs: PREPARATION_TIMEOUT_MS }),
     });
-    const { session } = await createAgentSession({ modelRuntime: runtime,
-      model, thinkingLevel: selection.thinking ?? "off", resourceLoader, sessionManager,
-      settings: { compaction: { enabled: false }, retry: { enabled: false }, providerRequest: { maxRetries: 0, timeoutMs: PREPARATION_TIMEOUT_MS } },
-      tools: [startRun.name], customTools: [startRun],
-    });
-    const abort = () => { void session.abort(); };
+    const abort = () => { agent.abort(); };
     signal.addEventListener("abort", abort, { once: true });
     try {
       signal.throwIfAborted();
       const latest = messages.at(-1)!;
       if (latest.role !== "user") throw new Error("Die letzte Nachricht muss vom Benutzer kommen.");
       const content = latest.content;
-      await session.prompt(typeof content === "string" ? content : content.filter((part) => part.type === "text").map((part) => part.text).join("\n"),
-        typeof content === "string" ? {} : { attachments: content.filter((part) => part.type !== "text") });
+      await agent.prompt({ role: "user", timestamp: Date.now(), content: typeof content === "string"
+        ? [{ type: "text", text: content }]
+        : [{ type: "text", text: content.filter((part) => part.type === "text").map((part) => part.text).join("\n") }, ...content.filter((part) => part.type !== "text")] });
       signal.throwIfAborted();
-      const completed = session.messages.at(-1);
+      const completed = agent.state.messages.at(-1);
       if (!completed || completed.role !== "assistant" || completed.stopReason !== "stop") {
         throw new DomainError("preparation-model-failed", completed?.role === "assistant"
           ? completed.errorMessage ?? `Die Vorbereitung wurde nicht vollständig beantwortet (${completed.stopReason}).`
@@ -129,7 +126,6 @@ export const prepareRunMessage = async (options: {
       return { kind: "reply", text };
     } finally {
       signal.removeEventListener("abort", abort);
-      session.dispose();
     }
   } catch (error) {
     if (options.signal.aborted) throw new DomainError("preparation-aborted", "Die Vorbereitung wurde abgebrochen.", 499);

package/apps/server/src/run-transfer.ts

@@ -1,8 +1,9 @@
-import { existsSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { existsSync, readlinkSync, Stats } from "node:fs";
 import { chmod, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { create as createTar, extract as extractTar } from "tar";
-import { DomainError, isPendingActorInput, isRunId, type CommandRecord, type RunState } from "@ragents/engine";
+import { create as createTar, extract as extractTar, type ReadEntry } from "tar";
+import { DomainError, isPendingActorInput, isRunId, type CommandRecord, type JournalEvent, type RunState } from "@ragents/engine";
 import { parseJournalRecord } from "@ragents/engine/src/runtime/journal-storage";
 
 export const RUN_TRANSFER_FORMAT_VERSION = 1;
@@ -100,16 +101,36 @@ export const assertRunIdFree = (options: { runId: string; known: boolean; direct
   }
 };
 
+/** Die Inhalte unter artifacts/, auf die der Run verweist: veröffentlichte Artefakte und Medien seiner Modellkontexte. */
+export const contentHashesOf = (events: readonly JournalEvent[]): string[] => [...new Set(events.flatMap((event) => {
+  if (event.type === "artifact.published") return [event.payload.artifact.hash];
+  const content = event.type === "model.input.presented" || event.type === "model.tool-result.presented" ? event.payload.content : undefined;
+  return Array.isArray(content) ? content.flatMap((part) => "hash" in part ? [part.hash] : []) : [];
+}))].sort();
+
+const sha256 = /^[0-9a-f]{64}$/;
+
 // Halbfertige Journal- und Payload-Schreibvorgänge gehören nie ins Archiv.
 const temporary = (entry: string): boolean => {
   const name = path.basename(entry);
   return name.startsWith(".journal.") || name.startsWith(".payload.");
 };
 
+/** A link travels only inside the run's tree; one out of it below node_modules is left for the next install, elsewhere refused. */
+const linkDecision = (dataDirectory: string, entry: string): "keep" | "skip" | "refuse" => {
+  const file = path.join(dataDirectory, entry);
+  const target = readlinkSync(file);
+  const root = path.join(dataDirectory, ...entry.split("/").slice(0, 2));
+  const resolved = path.resolve(path.dirname(file), target);
+  if (!path.isAbsolute(target) && (resolved === root || resolved.startsWith(`${root}${path.sep}`))) return "keep";
+  return entry.split("/").includes("node_modules") ? "skip" : "refuse";
+};
+
 export const packRunArchive = async (options: {
   places: RunTransferPlaces;
   runId: string;
   manifest: RunTransferManifest;
+  contentHashes: readonly string[];
 }): Promise<Buffer> => {
   const runId = assertRunId(options.runId);
   const { dataDirectory } = options.places;
@@ -123,15 +144,36 @@ export const packRunArchive = async (options: {
     RUN_TRANSFER_MANIFEST_ENTRY,
     `runs/${runId}`,
     ...(existsSync(runTransferSessionDirectory(dataDirectory, runId)) ? [`sessions/${runId}`] : []),
+    ...options.contentHashes.map((hash) => {
+      if (!sha256.test(hash) || !existsSync(path.join(dataDirectory, "artifacts", hash))) {
+        throw new DomainError("run-transfer-missing", `The content ${hash} of run ${runId} is missing under artifacts`, 404);
+      }
+      return `artifacts/${hash}`;
+    }),
   ];
   const chunks: Buffer[] = [];
+  const refused: string[] = [];
+  const portable = (entry: string, stat: Stats | ReadEntry): boolean => {
+    if (temporary(entry)) return false;
+    if (!(stat instanceof Stats) || !stat.isSymbolicLink()) return true;
+    const decision = linkDecision(dataDirectory, entry);
+    if (decision === "refuse") refused.push(entry);
+    return decision === "keep";
+  };
   try {
-    for await (const chunk of createTar({ gzip: true, cwd: dataDirectory, portable: true, filter: (entry) => !temporary(entry) }, entries)) {
+    for await (const chunk of createTar({ gzip: true, cwd: dataDirectory, portable: true, filter: portable }, entries)) {
       chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
     }
   } finally {
     await rm(manifestFile, { force: true });
   }
+  if (refused.length > 0) {
+    throw new DomainError(
+      "run-transfer-link",
+      `Run ${runId} contains links that would point nowhere on the target: ${refused.join(", ")}. Replace them with files or relative links inside the run.`,
+      409,
+    );
+  }
   const archive = Buffer.concat(chunks);
   if (archive.byteLength > RUN_TRANSFER_MAX_ARCHIVE_BYTES) {
     throw new DomainError(
@@ -234,6 +276,14 @@ export const unpackRunArchive = async (options: {
   if (existsSync(path.join(staging, "sessions"))) {
     await onlyEntry(path.join(staging, "sessions"), manifest.runId, "Der Ordner sessions des Archivs");
   }
+  if (existsSync(path.join(staging, "artifacts"))) {
+    for (const name of await readdir(path.join(staging, "artifacts"))) {
+      const content = sha256.test(name) ? await readFile(path.join(staging, "artifacts", name)) : undefined;
+      if (!content || createHash("sha256").update(content).digest("hex") !== name) {
+        throw new DomainError("run-transfer-invalid", `The archive content artifacts/${name} does not match its name`, 400);
+      }
+    }
+  }
   const lines = (await readFile(journalFile, "utf8")).split("\n").filter((line) => line.trim().length > 0);
   const records = lines.map((line, index) => parseJournalRecord(line, runDirectory, `${journalFile}:${index + 1}`));
   if (records.length === 0) throw new DomainError("run-transfer-invalid", `Das Journal des Runs ${manifest.runId} im Archiv ist leer`, 400);
@@ -246,6 +296,17 @@ export const unpackRunArchive = async (options: {
   return { manifest, staging, records };
 };
 
+/** Legt die Inhalte des Archivs unter artifacts/ des Ziels ab; vorhandene sind wegen ihres Hash-Namens dieselben. */
+export const installContents = async (options: { places: RunTransferPlaces; staging: string }): Promise<void> => {
+  const source = path.join(options.staging, "artifacts");
+  if (!existsSync(source)) return;
+  const target = path.join(options.places.dataDirectory, "artifacts");
+  await mkdir(target, { recursive: true });
+  for (const name of await readdir(source)) {
+    if (!existsSync(path.join(target, name))) await rename(path.join(source, name), path.join(target, name));
+  }
+};
+
 /** Legt die Session-Ablage des Archivs an ihrem Platz im Ziel ab; das Journal übernimmt danach die Records. */
 export const installSessionDirectory = async (options: {
   places: RunTransferPlaces;

package/apps/server/src/settings.ts

@@ -3,8 +3,7 @@ import { readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import {
   modelToolDescriptors,
-  skillPreloadExtensionName,
-  turnDispatcherExtensionName,
+  skillPreloadHookName,
   runtimeOwner,
   type AgentProfile,
   type CatalogModel,
@@ -104,8 +103,7 @@ const runtimeSettings = (plugins: PluginHost): SettingsRuntime => {
 };
 
 const internalAgentHooks: readonly InternalAgentHookContribution[] = [
-  turnDispatcherExtensionName,
-  skillPreloadExtensionName,
+  skillPreloadHookName,
 ].map((name): InternalAgentHookContribution => ({
   id: name,
   owner: runtimeOwner,

package/apps/web/dist/assets/{highlighted-body-KPVGNVTW-B9qYBARS.js → highlighted-body-KPVGNVTW-xXXhTDbh.js}

@@ -1 +1 @@
-import{r,S as d,E as p,j as E,c as f}from"./mermaid-HWGCJPDP-CvYYFK_n.js";var j=({code:i,language:e,maxHeight:o,raw:a,className:u,startLine:m,lineNumbers:n,...h})=>{let{shikiTheme:l}=r.useContext(d),t=p(),[c,s]=r.useState(a);return r.useEffect(()=>{if(!t){s(a);return}let g=t.highlight({code:i,language:e,themes:l},x=>{s(x)});g&&s(g)},[i,e,l,t,a]),E.jsx(f,{className:u,language:e,lineNumbers:n,maxHeight:o,result:c,startLine:m,...h})};export{j as HighlightedCodeBlockBody};
+import{r,S as d,E as p,j as E,c as f}from"./mermaid-HWGCJPDP-DfsU5ofC.js";var j=({code:i,language:e,maxHeight:o,raw:a,className:u,startLine:m,lineNumbers:n,...h})=>{let{shikiTheme:l}=r.useContext(d),t=p(),[c,s]=r.useState(a);return r.useEffect(()=>{if(!t){s(a);return}let g=t.highlight({code:i,language:e,themes:l},x=>{s(x)});g&&s(g)},[i,e,l,t,a]),E.jsx(f,{className:u,language:e,lineNumbers:n,maxHeight:o,result:c,startLine:m,...h})};export{j as HighlightedCodeBlockBody};

package/apps/web/dist/assets/{main-BCjvD2Hh.js → main-C7JeZFjs.js}

@@ -1,4 +1,4 @@
-import{a as De,r as t,j as e,D as oe,b as ce,d as G,B as b,X as Le,M as Pe,C as de,e as Me,f as Oe,g as He,h as Ie,u as Be,i as _e,k as Fe,l as Ue,m as Ke,A as Te,n as qe,o as We,p as $e,U as Qe,P as Ve,W as Ge,R as Xe,q as ae,s as V,t as Je,v as Ye,w as Ze,x as et,y as tt,z as st,F as nt,Q as rt,G as at,H as it}from"./mermaid-HWGCJPDP-CvYYFK_n.js";/**
+import{a as De,r as t,j as e,D as oe,b as ce,d as G,B as b,X as Le,M as Pe,C as de,e as Me,f as Oe,g as He,h as Ie,u as Be,i as _e,k as Fe,l as Ue,m as Ke,A as Te,n as qe,o as We,p as $e,U as Qe,P as Ve,W as Ge,R as Xe,q as ae,s as V,t as Je,v as Ye,w as Ze,x as et,y as tt,z as st,F as nt,Q as rt,G as at,H as it}from"./mermaid-HWGCJPDP-DfsU5ofC.js";/**
  * @license lucide-react v1.46.0 - ISC
  *
  * This source code is licensed under the ISC license.