remote-codex 0.11.41 → 0.11.43

package/apps/relay-server/dist/index.js

@@ -675,6 +675,20 @@ var RelayStore = class _RelayStore {
     ).get(deviceId, userId);
     return row ? { sandboxId: row.id, enabled: Boolean(row.workspace_isolation_enabled) } : null;
   }
+  hostedWorkspaceBootstrapContext(deviceId) {
+    const sandbox = this.hostedWorkspaceIsolation(deviceId);
+    if (!sandbox?.enabled) {
+      return null;
+    }
+    const users = this.sqlite.prepare(
+      `SELECT u.*
+           FROM relay_hosted_sandbox_members m
+           JOIN relay_users u ON u.id = m.user_id
+           WHERE m.sandbox_id = ? AND u.enabled = 1
+           ORDER BY m.position ASC, m.created_at ASC`
+    ).all(sandbox.sandboxId).map((row) => this.rowToUser(row)).filter((user) => Boolean(user)).map((user) => this.publicUser(user));
+    return { sandboxId: sandbox.sandboxId, users };
+  }
   hostedUserWorkspaceIds(sandboxId, userId) {
     return this.sqlite.prepare(
       `SELECT workspace_id FROM relay_hosted_user_workspaces
@@ -683,11 +697,24 @@ var RelayStore = class _RelayStore {
   }
   recordHostedUserWorkspace(sandboxId, userId, workspaceId, initial = false) {
     this.sqlite.prepare(
-      `INSERT OR IGNORE INTO relay_hosted_user_workspaces
+      `INSERT INTO relay_hosted_user_workspaces
           (sandbox_id, user_id, workspace_id, initial_workspace, created_at)
-         VALUES (?, ?, ?, ?, ?)`
+         VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT(sandbox_id, workspace_id) DO UPDATE SET
+           initial_workspace = MAX(
+             relay_hosted_user_workspaces.initial_workspace,
+             excluded.initial_workspace
+           )`
     ).run(sandboxId, userId, workspaceId, initial ? 1 : 0, (/* @__PURE__ */ new Date()).toISOString());
   }
+  hostedInitialWorkspaceId(sandboxId, userId) {
+    const row = this.sqlite.prepare(
+      `SELECT workspace_id FROM relay_hosted_user_workspaces
+         WHERE sandbox_id = ? AND user_id = ? AND initial_workspace = 1
+         ORDER BY created_at ASC LIMIT 1`
+    ).get(sandboxId, userId);
+    return row?.workspace_id ?? null;
+  }
   ownsHostedWorkspace(sandboxId, userId, workspaceId) {
     return Boolean(
       this.sqlite.prepare(
@@ -711,6 +738,15 @@ var RelayStore = class _RelayStore {
       ).get(sandboxId, userId, threadId)
     );
   }
+  hasHostedUserThreadInWorkspace(sandboxId, userId, workspaceId) {
+    return Boolean(
+      this.sqlite.prepare(
+        `SELECT 1 FROM relay_hosted_user_threads
+           WHERE sandbox_id = ? AND user_id = ? AND workspace_id = ?
+           LIMIT 1`
+      ).get(sandboxId, userId, workspaceId)
+    );
+  }
   listHostedProviderRecords() {
     return this.sqlite.prepare(
       "SELECT id, credential_ref FROM relay_hosted_sandboxes ORDER BY id"
@@ -3951,6 +3987,37 @@ function buildRelayServer(config2, options = {}) {
     hostedSandboxProvider,
     config2.hostedSandbox
   );
+  const scheduleHostedUserBootstraps = (deviceId) => {
+    const context = store.hostedWorkspaceBootstrapContext(deviceId);
+    const supervisor = state.supervisors.get(deviceId);
+    if (!context || !supervisor || supervisor.socket.readyState !== WEBSOCKET_OPEN) {
+      return;
+    }
+    void Promise.allSettled(
+      context.users.map(
+        (bootstrapUser) => ensureHostedUserBootstrap({
+          store,
+          supervisor,
+          deviceId,
+          sandboxId: context.sandboxId,
+          user: bootstrapUser
+        })
+      )
+    ).then((results) => {
+      results.forEach((result, index) => {
+        if (result.status === "rejected") {
+          app2.log.warn(
+            {
+              err: result.reason,
+              deviceId,
+              userId: context.users[index]?.id
+            },
+            "Hosted VM user bootstrap failed."
+          );
+        }
+      });
+    });
+  };
   const allowedWebViewCorsOrigins = webViewCorsOrigins(
     options.env ?? process.env
   );
@@ -4303,10 +4370,12 @@ function buildRelayServer(config2, options = {}) {
       }
       const { sandboxId } = z.object({ sandboxId: z.string().uuid() }).parse(request.params);
       const body = updateHostedSandboxMembersSchema.parse(request.body ?? {});
-      return hostedSandboxService.updateMembers(
+      const sandbox = hostedSandboxService.updateMembers(
         sandboxId,
         body.assignedUserIds
       );
+      scheduleHostedUserBootstraps(sandbox.deviceId);
+      return sandbox;
     }
   );
   app2.patch(
@@ -4316,10 +4385,14 @@ function buildRelayServer(config2, options = {}) {
       if (!user) return;
       const { sandboxId } = z.object({ sandboxId: z.string().uuid() }).parse(request.params);
       const body = updateHostedSandboxSettingsSchema.parse(request.body ?? {});
-      return store.setHostedWorkspaceIsolation(
+      const sandbox = store.setHostedWorkspaceIsolation(
         sandboxId,
         body.workspaceIsolationEnabled
       );
+      if (sandbox.workspaceIsolationEnabled) {
+        scheduleHostedUserBootstraps(sandbox.deviceId);
+      }
+      return sandbox;
     }
   );
   app2.post(
@@ -4629,6 +4702,10 @@ function buildRelayServer(config2, options = {}) {
               parsed.clientId
             );
             const eventThreadId = threadIdFromSocketPayload(parsed.payload);
+            const shellEventForClient = clientConnection ? isShellEventForClient(
+              parsed.payload,
+              clientConnection.attachedShellId
+            ) : false;
             if (clientConnection) {
               const freshAccess = store.effectiveAccess(
                 clientConnection.user.id,
@@ -4651,7 +4728,7 @@ function buildRelayServer(config2, options = {}) {
                 clientConnection.user.id
               );
               const connectionControlEvent = parsed.payload.type === "supervisor.connected" || parsed.payload.type === "supervisor.pong";
-              if (isolation?.enabled && !connectionControlEvent && (!eventThreadId || !store.ownsHostedThread(
+              if (isolation?.enabled && !connectionControlEvent && !shellEventForClient && (!eventThreadId || !store.ownsHostedThread(
                 isolation.sandboxId,
                 clientConnection.user.id,
                 eventThreadId
@@ -4661,7 +4738,8 @@ function buildRelayServer(config2, options = {}) {
             }
             if (clientConnection && clientConnection.socket.readyState === WEBSOCKET_OPEN && shouldForwardSocketEvent(
               parsed.payload,
-              clientConnection.threadId
+              clientConnection.threadId,
+              clientConnection.attachedShellId
             )) {
               clientConnection.socket.send(JSON.stringify(parsed.payload));
             }
@@ -4681,6 +4759,7 @@ function buildRelayServer(config2, options = {}) {
             clientConnection.socket.close();
           }
         });
+        scheduleHostedUserBootstraps(deviceId);
       }
     });
     realtimeApp.route({
@@ -5073,9 +5152,6 @@ async function forwardSharedThreadList(input) {
   );
 }
 async function ensureHostedUserBootstrap(input) {
-  if (input.store.hostedUserWorkspaceIds(input.sandboxId, input.user.id).length) {
-    return;
-  }
   const key = `${input.sandboxId}:${input.user.id}`;
   const existing = hostedBootstrapPromises.get(key);
   if (existing) return existing;
@@ -5084,55 +5160,69 @@ async function ensureHostedUserBootstrap(input) {
     const directory = `${slug}-${input.user.id.slice(0, 8)}`;
     const absoluteDirectory = `/home/remote-codex/workspaces/${directory}`;
     const label = `${input.user.username}'s workspace`;
-    const current = await forwardSupervisorCommandJson(
-      input.supervisor,
-      input.deviceId,
-      "GET",
-      "/api/workspaces"
-    );
-    const currentWorkspaces = Array.isArray(current) ? current : [];
-    let workspace = currentWorkspaces.find(
-      (candidate) => isObject(candidate) && typeof candidate.absPath === "string" && candidate.absPath === absoluteDirectory
+    let workspaceId = input.store.hostedInitialWorkspaceId(
+      input.sandboxId,
+      input.user.id
     );
-    if (!workspace) {
-      workspace = await forwardSupervisorCommandJson(
+    if (!workspaceId) {
+      const current = await forwardSupervisorCommandJson(
         input.supervisor,
         input.deviceId,
-        "POST",
-        "/api/workspaces",
-        { absPath: absoluteDirectory, label }
+        "GET",
+        "/api/workspaces"
       );
-    }
-    const workspaceId = stringField(workspace, "id");
-    if (!workspaceId) throw new Error("Initial workspace creation returned no id.");
-    const thread = await forwardSupervisorCommandJson(
-      input.supervisor,
-      input.deviceId,
-      "POST",
-      "/api/threads/start",
-      {
-        workspaceId,
-        title: "Getting started",
-        provider: "codex",
-        model: "gpt-5.6-sol",
-        reasoningEffort: "low",
-        approvalMode: "yolo"
+      const currentWorkspaces = Array.isArray(current) ? current : [];
+      let workspace = currentWorkspaces.find(
+        (candidate) => isObject(candidate) && typeof candidate.absPath === "string" && candidate.absPath === absoluteDirectory
+      );
+      if (!workspace) {
+        workspace = await forwardSupervisorCommandJson(
+          input.supervisor,
+          input.deviceId,
+          "POST",
+          "/api/workspaces",
+          { absPath: absoluteDirectory, label }
+        );
       }
-    );
-    const threadId = stringField(thread, "id");
-    if (!threadId) throw new Error("Initial thread creation returned no id.");
-    input.store.recordHostedUserWorkspace(
-      input.sandboxId,
-      input.user.id,
-      workspaceId,
-      true
-    );
-    input.store.recordHostedUserThread(
+      workspaceId = stringField(workspace, "id");
+      if (!workspaceId) {
+        throw new Error("Initial workspace creation returned no id.");
+      }
+      input.store.recordHostedUserWorkspace(
+        input.sandboxId,
+        input.user.id,
+        workspaceId,
+        true
+      );
+    }
+    if (!input.store.hasHostedUserThreadInWorkspace(
       input.sandboxId,
       input.user.id,
-      threadId,
       workspaceId
-    );
+    )) {
+      const thread = await forwardSupervisorCommandJson(
+        input.supervisor,
+        input.deviceId,
+        "POST",
+        "/api/threads/start",
+        {
+          workspaceId,
+          title: "Getting started",
+          provider: "codex",
+          model: "gpt-5.6-sol",
+          reasoningEffort: "low",
+          approvalMode: "yolo"
+        }
+      );
+      const threadId = stringField(thread, "id");
+      if (!threadId) throw new Error("Initial thread creation returned no id.");
+      input.store.recordHostedUserThread(
+        input.sandboxId,
+        input.user.id,
+        threadId,
+        workspaceId
+      );
+    }
   })().finally(() => hostedBootstrapPromises.delete(key));
   hostedBootstrapPromises.set(key, pending);
   return pending;
@@ -5234,6 +5324,7 @@ function connectRelayWebsocket(supervisor, socket, store, user, deviceId, thread
   supervisor.clientSockets.set(clientId, {
     socket,
     threadId,
+    attachedShellId: null,
     deviceId,
     user,
     access
@@ -5266,6 +5357,10 @@ function connectRelayWebsocket(supervisor, socket, store, user, deviceId, thread
       socket.close(1008, "Shared read-only session cannot control supervisor.");
       return;
     }
+    const attachedShellId = shellAttachIdFromSocketPayload(payload);
+    if (clientConnection && attachedShellId) {
+      clientConnection.attachedShellId = attachedShellId;
+    }
     sendToSupervisor(supervisor, {
       type: "relay.client.message",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -5763,7 +5858,9 @@ function isAllowedSharedRuntimeMetadataRequest(method, pathname) {
 function threadIdFromPath(pathValue) {
   const pathname = new URL(pathValue, "http://relay.local").pathname;
   const match = /^\/api\/threads\/([^/?#]+)/.exec(pathname);
-  return match ? decodeURIComponent(match[1]) : null;
+  if (!match) return null;
+  const threadId = decodeURIComponent(match[1]);
+  return threadId === "start" || threadId === "import" ? null : threadId;
 }
 function workspaceIdFromPath(pathValue) {
   const pathname = new URL(pathValue, "http://relay.local").pathname;
@@ -5960,14 +6057,25 @@ function isAllowedSharedWorkspacePath(access, methodName, pathname, workspaceId)
   ];
   return ["POST", "PUT", "PATCH", "DELETE"].includes(methodName) && writePatterns.some((pattern) => pattern.test(pathname));
 }
-function shouldForwardSocketEvent(event, threadId) {
+function shouldForwardSocketEvent(event, threadId, attachedShellId) {
   if (!threadId) {
     return true;
   }
   if (event.type === "supervisor.connected" || event.type === "supervisor.pong") {
     return true;
   }
-  return "threadId" in event && event.threadId === threadId;
+  if ("threadId" in event && event.threadId === threadId) {
+    return true;
+  }
+  return isShellEventForClient(event, attachedShellId);
+}
+function shellAttachIdFromSocketPayload(payload) {
+  return isObject(payload) && payload.type === "shell.attach" && typeof payload.shellId === "string" ? payload.shellId : null;
+}
+function isShellEventForClient(event, attachedShellId) {
+  return Boolean(
+    attachedShellId && event.type.startsWith("shell.") && "shellId" in event && event.shellId === attachedShellId
+  );
 }
 function relayRequestBody(body) {
   if (body === void 0 || body === null) {

package/apps/supervisor-api/dist/index.js

@@ -12089,7 +12089,7 @@ function mapModelInfo(model, index) {
   return {
     id: model.value,
     model: model.value,
-    displayName: model.displayName,
+    displayName: versionedClaudeModelDisplayName(model),
     description: model.description,
     isDefault: index === 0,
     hidden: false,
@@ -12100,11 +12100,44 @@ function mapModelInfo(model, index) {
     defaultReasoningEffort: model.supportsEffort ? "medium" : null
   };
 }
+function versionedClaudeModelDisplayName(model) {
+  const resolved = model.resolvedModel?.match(
+    /^claude-(sonnet|opus|haiku|fable)-(\d+)(?:-(\d+))?(?:-|\[|$)/i
+  );
+  if (!resolved) {
+    return model.displayName;
+  }
+  const family = `${resolved[1][0].toUpperCase()}${resolved[1].slice(1).toLowerCase()}`;
+  const version2 = resolved[3] ? `${resolved[2]}.${resolved[3]}` : resolved[2];
+  if (model.value === "default") {
+    return `Default \xB7 ${family} ${version2}`;
+  }
+  const qualifier = model.displayName.match(/\s*(\([^)]+\))\s*$/)?.[1];
+  return `${family} \xB7 ${version2}${qualifier ? ` ${qualifier}` : ""}`;
+}
+function versionedAlias(alias, discovered, qualifier) {
+  if (!discovered) {
+    return alias;
+  }
+  return {
+    ...alias,
+    displayName: `${discovered.displayName.replace(/\s+\([^)]+\)\s*$/, "")}${qualifier ?? ""}`,
+    description: discovered.description,
+    supportedReasoningEfforts: discovered.supportedReasoningEfforts,
+    defaultReasoningEffort: discovered.defaultReasoningEffort
+  };
+}
 function withClaudeCodeModelAliases(models) {
   const output = [...models];
-  const defaultSonnet = DEFAULT_CLAUDE_MODELS[0];
-  const oneMillionSonnet = DEFAULT_CLAUDE_MODELS[1];
-  const fable = DEFAULT_CLAUDE_MODELS[2];
+  const discoveredSonnet = output.find((model) => /^Sonnet · /.test(model.displayName));
+  const discoveredFable = output.find((model) => /^Fable · /.test(model.displayName));
+  const defaultSonnet = versionedAlias(DEFAULT_CLAUDE_MODELS[0], discoveredSonnet);
+  const oneMillionSonnet = versionedAlias(
+    DEFAULT_CLAUDE_MODELS[1],
+    discoveredSonnet,
+    " (1M context)"
+  );
+  const fable = versionedAlias(DEFAULT_CLAUDE_MODELS[2], discoveredFable);
   const hasSonnetAlias = output.some((model) => model.model === "sonnet");
   if (!hasSonnetAlias) {
     output.unshift(defaultSonnet);
@@ -12613,6 +12646,7 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
   subscriptionUsageWindows = /* @__PURE__ */ new Map();
   subscriptionAuthKind = "unknown";
   subscriptionUsageObservedAt = null;
+  modelOptionsCache = null;
   historicalTurnIdAliases = /* @__PURE__ */ new Map();
   clientApp;
   sdkLoadError = null;
@@ -12733,14 +12767,33 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
   }
   async listModels() {
     const active = [...this.activeTurns.values()][0];
-    if (!active) {
-      return DEFAULT_CLAUDE_MODELS;
+    if (!active && this.modelOptionsCache) {
+      return this.modelOptionsCache;
     }
+    let query = active?.query ?? null;
     try {
-      const models = await active.query.supportedModels();
-      return withClaudeCodeModelAliases(models.map(mapModelInfo));
+      query ??= this.queryFactory({
+        prompt: "",
+        options: queryOptionsForRuntime({
+          home: this.options.home,
+          command: this.options.command,
+          clientApp: this.clientApp,
+          approvalMode: "guarded",
+          includePartialMessages: false,
+          tools: [],
+          maxTurns: 1
+        })
+      });
+      const models = await query.supportedModels();
+      const mapped = withClaudeCodeModelAliases(models.map(mapModelInfo));
+      this.modelOptionsCache = mapped;
+      return mapped;
     } catch {
-      return DEFAULT_CLAUDE_MODELS;
+      return this.modelOptionsCache ?? DEFAULT_CLAUDE_MODELS;
+    } finally {
+      if (!active && query) {
+        query.close();
+      }
     }
   }
   async listSessions() {
@@ -16459,7 +16512,7 @@ var ThreadAuxiliaryStateStore = class {
       );
       return {
         id: record.id,
-        kind: "fastMode",
+        kind: record.kind === "goal" ? "goal" : "fastMode",
         text: record.text,
         createdAt: record.createdAt,
         anchorTurnId: record.anchorTurnId ?? fallbackAnchor?.id ?? null
@@ -16673,13 +16726,10 @@ var ThreadGoalCoordinator = class {
     }
     try {
       await this.ensureGoalsFeatureEnabled(record.provider);
-      const activeGoal = this.listThreadGoalHistory(record.id).find(
+      const goalHistoryBeforeUpdate = this.listThreadGoalHistory(record.id);
+      const activeGoal = goalHistoryBeforeUpdate.find(
         (goal2) => ["active", "paused", "budgetLimited"].includes(goal2.status)
       ) ?? null;
-      const creatingNewGoal = goalObjectiveChanged(activeGoal, input.objective);
-      if (creatingNewGoal) {
-        markActiveThreadGoalRecordTerminated(this.db, record.id);
-      }
       if (input.status === "terminated") {
         const terminatedGoal = markActiveThreadGoalRecordTerminated(this.db, record.id);
         const goalHistory = this.listThreadGoalHistory(record.id);
@@ -16690,6 +16740,23 @@ var ThreadGoalCoordinator = class {
         });
         return goal2;
       }
+      const startingNewGoal = shouldStartNewGoal(activeGoal, input.objective);
+      if (startingNewGoal && (record.providerTurnId || record.status === "running")) {
+        throw new HttpError(409, {
+          code: "conflict",
+          message: "Interrupt the running turn before replacing this goal."
+        });
+      }
+      if (startingNewGoal && goalHistoryBeforeUpdate.length > 0) {
+        if (!runtime.clearGoal) {
+          throw new HttpError(409, {
+            code: "conflict",
+            message: "This backend cannot safely replace an existing goal."
+          });
+        }
+        await runtime.clearGoal(providerSessionId);
+        markActiveThreadGoalRecordTerminated(this.db, record.id);
+      }
       const upstreamStatus = input.status;
       const goal = await runtime.setGoal({
         providerSessionId,
@@ -16701,10 +16768,15 @@ var ThreadGoalCoordinator = class {
         toThreadGoalDtoFromAgentGoal(goal),
         record
       );
-      const dto = creatingNewGoal ? resetGoalProgress(upstreamDto) : upstreamDto;
+      const dto = startingNewGoal ? startFreshGoalLifecycle(upstreamDto) : upstreamDto;
       const persistedGoal = toThreadGoalDtoFromRecord(
-        this.persistThreadGoalSnapshot(record.id, dto)
+        this.persistThreadGoalSnapshot(record.id, dto, {
+          createNew: startingNewGoal
+        })
       );
+      if (startingNewGoal) {
+        this.callbacks.appendGoalActivityNote(record.id, persistedGoal.objective);
+      }
       this.callbacks.emitThreadEvent("thread.goal.updated", record.id, {
         goal: persistedGoal,
         goalHistory: this.listThreadGoalHistory(record.id)
@@ -16772,12 +16844,13 @@ var ThreadGoalCoordinator = class {
       throw error;
     }
   }
-  persistThreadGoalSnapshot(localThreadId, goal) {
+  persistThreadGoalSnapshot(localThreadId, goal, options = {}) {
     const dto = "createdAt" in goal && typeof goal.createdAt === "string" ? goal : toThreadGoalDto(goal);
     return upsertThreadGoalRecord(this.db, {
       threadId: localThreadId,
       providerSessionId: dto.threadId,
       localGoalId: dto.localGoalId ?? null,
+      createNew: options.createNew ?? false,
       objective: dto.objective,
       status: dto.status,
       tokenBudget: dto.tokenBudget,
@@ -16900,15 +16973,19 @@ function mergeGoalHistoryEntry(existing, incoming) {
 function goalHistoryStatusRank(status) {
   return ["active", "paused", "budgetLimited"].includes(status) ? 0 : 1;
 }
-function resetGoalProgress(goal) {
+function startFreshGoalLifecycle(goal) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
   return {
     ...goal,
     tokensUsed: 0,
-    timeUsedSeconds: 0
+    timeUsedSeconds: 0,
+    createdAt: now,
+    updatedAt: now,
+    completedAt: null
   };
 }
-function goalObjectiveChanged(existing, nextObjective) {
-  return existing !== null && typeof nextObjective === "string" && nextObjective.trim().length > 0 && nextObjective !== existing.objective;
+function shouldStartNewGoal(existing, nextObjective) {
+  return typeof nextObjective === "string" && nextObjective.trim().length > 0 && (existing === null || nextObjective !== existing.objective);
 }
 function isLocalGoalStatus(status) {
   return ["active", "paused", "budgetLimited"].includes(status);
@@ -18109,6 +18186,14 @@ var ThreadRuntimeEventProjector = class {
         if (!record) {
           return;
         }
+        const currentGoal = await callbacks.getThreadGoalAfterRuntimeClear(record);
+        if (currentGoal) {
+          callbacks.emitThreadEvent("thread.goal.updated", record.id, {
+            goal: currentGoal,
+            goalHistory: callbacks.listThreadGoalHistory(record.id)
+          });
+          return;
+        }
         markActiveThreadGoalRecordTerminated(db, record.id);
         callbacks.emitThreadEvent("thread.goal.cleared", record.id, {
           goalHistory: callbacks.listThreadGoalHistory(record.id)
@@ -22423,7 +22508,11 @@ var ThreadService = class {
     this.goalCoordinator = new ThreadGoalCoordinator(db, providerFeatures, {
       emitThreadEvent: (type, threadId, payload) => this.emitThreadEvent(type, threadId, payload),
       requireProviderSessionId: (record) => this.requireProviderSessionId(record),
-      runtimeForProvider: (provider2) => this.runtimeForProvider(provider2)
+      runtimeForProvider: (provider2) => this.runtimeForProvider(provider2),
+      appendGoalActivityNote: (threadId, objective) => this.auxiliaryState.appendActivityNote(threadId, {
+        kind: "goal",
+        text: objective
+      })
     });
     this.auxiliaryState = new ThreadAuxiliaryStateStore(db, {
       cachedTurns: (localThreadId) => this.detailAssembler.cachedTurns(localThreadId),
@@ -22521,6 +22610,7 @@ var ThreadService = class {
         resetThreadContextUsage: (localThreadId, emitEvent) => this.resetThreadContextUsage(localThreadId, emitEvent),
         setThreadContextUsage: (localThreadId, usage, emitEvent) => this.setThreadContextUsage(localThreadId, usage, emitEvent),
         getThreadContextUsage: (localThreadId) => this.getThreadContextUsage(localThreadId),
+        getThreadGoalAfterRuntimeClear: (record) => this.goalCoordinator.getThreadGoalForRecord(record),
         toThreadGoalDtoFromAgentGoal: (goal) => this.goalCoordinator.toThreadGoalDtoFromAgentGoal(goal),
         toThreadGoalDtoFromRecord: (record) => this.goalCoordinator.toThreadGoalDtoFromRecord(record)
       }