remote-codex 0.11.40 → 0.11.42

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(
@@ -4681,6 +4754,7 @@ function buildRelayServer(config2, options = {}) {
             clientConnection.socket.close();
           }
         });
+        scheduleHostedUserBootstraps(deviceId);
       }
     });
     realtimeApp.route({
@@ -5073,9 +5147,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 +5155,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;
@@ -5763,7 +5848,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;

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

@@ -11717,7 +11717,40 @@ import { pathToFileURL } from "url";
 import { promisify } from "util";
 var execFileAsync = promisify(execFile);
 var promptPhotoTokenPattern2 = /\[PHOTO\s+([^\]]+)\]/g;
+var claudeCompactSummaryPrefix = "This session is being continued from a previous conversation that ran out of context.";
 var activeTranscriptMatchWindowMs = 12e4;
+function isClaudeCompactBoundaryMessage(message) {
+  if (message.type !== "system") {
+    return false;
+  }
+  if (message.subtype === "compact_boundary" || message.compact_metadata) {
+    return true;
+  }
+  return isRecord8(message.message) && (message.message.subtype === "compact_boundary" || isRecord8(message.message.compact_metadata));
+}
+function isClaudeCompactSummaryMessage(message) {
+  if (message.type !== "user" || message.parent_tool_use_id) {
+    return false;
+  }
+  const payload = isRecord8(message.message) ? message.message : null;
+  if (message.isCompactSummary || message.is_compact_summary || payload?.isCompactSummary === true || payload?.is_compact_summary === true) {
+    return true;
+  }
+  return messageContentText(message.message).trim().startsWith(claudeCompactSummaryPrefix);
+}
+function claudeContextCompactionItem(id, status, error = null) {
+  const completed = status === "completed";
+  const failed = status === "failed";
+  const text2 = failed ? "Context compaction failed" : completed ? "Context compacted" : "Compacting context";
+  return {
+    id,
+    kind: "contextCompaction",
+    text: text2,
+    previewText: text2,
+    detailText: failed ? error : null,
+    status
+  };
+}
 function normalizePromptForTurnReconciliation(value) {
   return value.replace(/\[PHOTO\s+[^\]]+\]/g, " ").replace(/\s+/g, " ").trim();
 }
@@ -12923,7 +12956,8 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
       suppressedToolUseIds: /* @__PURE__ */ new Set(),
       assistantUsage: null,
       resultUsage: null,
-      modelContextWindow: null
+      modelContextWindow: null,
+      currentCompactionItemId: null
     };
     this.knownSessionIds.add(input.providerSessionId);
     let sessionPrompts = this.liveUserPrompts.get(input.providerSessionId);
@@ -13147,6 +13181,53 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
       }
       return;
     }
+    if (message.type === "system" && message.subtype === "status") {
+      if (message.status === "compacting") {
+        const existing = state.currentCompactionItemId ? state.items.get(state.currentCompactionItemId) : null;
+        const itemId = existing?.status === "running" ? existing.id : `claude-compaction-${messageUuid(message, randomUUID2())}`;
+        state.currentCompactionItemId = itemId;
+        const item = withHistoryItemCreatedAt(
+          claudeContextCompactionItem(itemId, "running"),
+          messageCreatedAt
+        );
+        addOrUpdateItem(state, item);
+        this.emitItem(state, item, "item.started", { force: Boolean(existing) });
+        return;
+      }
+      if (message.compact_result) {
+        const itemId = state.currentCompactionItemId ?? `claude-compaction-${messageUuid(message, randomUUID2())}`;
+        const status = message.compact_result === "success" ? "completed" : "failed";
+        const item = withHistoryItemCreatedAt(
+          claudeContextCompactionItem(itemId, status, message.compact_error ?? null),
+          messageCreatedAt
+        );
+        addOrUpdateItem(state, item);
+        this.emitItem(state, item, "item.completed");
+        state.currentCompactionItemId = status === "failed" ? null : itemId;
+        return;
+      }
+      return;
+    }
+    if (isClaudeCompactBoundaryMessage(message)) {
+      const itemId = state.currentCompactionItemId ?? `claude-compaction-${messageUuid(message, randomUUID2())}`;
+      const previous = state.items.get(itemId);
+      const item = withHistoryItemCreatedAt(
+        claudeContextCompactionItem(itemId, "completed"),
+        previous?.createdAt ?? messageCreatedAt
+      );
+      addOrUpdateItem(state, item);
+      if (!previous) {
+        this.emitItem(state, item, "item.started");
+      }
+      if (previous?.status !== "completed") {
+        this.emitItem(state, item, "item.completed");
+      }
+      state.currentCompactionItemId = null;
+      return;
+    }
+    if (isClaudeCompactSummaryMessage(message)) {
+      return;
+    }
     if (message.type === "stream_event") {
       const nextStreamMessageId = streamMessageId(message.event);
       if (nextStreamMessageId) {
@@ -13498,6 +13579,8 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
     const turns = [];
     let current = null;
     let skippingHiddenInit = false;
+    let pendingCompactSummaryItemId = null;
+    let pendingCompactBoundaryItemId = null;
     const suppressedToolUseIds = /* @__PURE__ */ new Set();
     const upsertCurrentItem = (item) => {
       if (!current) {
@@ -13529,6 +13612,18 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
       current.itemsById.set(item.id, item);
     };
     for (const message of messages) {
+      if (isClaudeCompactBoundaryMessage(message)) {
+        const itemId = pendingCompactSummaryItemId ?? `claude-compaction-${messageUuid(message, randomUUID2())}`;
+        pendingCompactSummaryItemId = null;
+        pendingCompactBoundaryItemId = itemId;
+        upsertCurrentItem(
+          withHistoryItemCreatedAt(
+            claudeContextCompactionItem(itemId, "completed"),
+            sessionMessageTimestamp(message) ?? current?.startedAt
+          )
+        );
+        continue;
+      }
       if (message.type === "user") {
         const taskNotification = taskNotificationToolResult(message.message);
         if (taskNotification) {
@@ -13573,6 +13668,20 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
         }
       }
       if (message.type === "user" && !message.parent_tool_use_id) {
+        if (isClaudeCompactSummaryMessage(message)) {
+          const itemId = pendingCompactBoundaryItemId ?? `claude-compaction-${messageUuid(message, randomUUID2())}`;
+          if (!pendingCompactBoundaryItemId) {
+            pendingCompactSummaryItemId = itemId;
+          }
+          pendingCompactBoundaryItemId = null;
+          upsertCurrentItem(
+            withHistoryItemCreatedAt(
+              claudeContextCompactionItem(itemId, "completed"),
+              sessionMessageTimestamp(message) ?? current?.startedAt
+            )
+          );
+          continue;
+        }
         if (isHiddenInitMessage(message.message)) {
           skippingHiddenInit = true;
           current = null;
@@ -13592,19 +13701,19 @@ var ClaudeRuntimeAdapter = class extends EventEmitter5 {
             items: current.items
           }));
         }
-        const messageUuid2 = message.uuid ?? randomUUID2();
-        const userStartedAt = isoFromUuidV7(messageUuid2);
+        const userMessageUuid = message.uuid ?? randomUUID2();
+        const userStartedAt = isoFromUuidV7(userMessageUuid);
         const userItem = await this.userMessageToHistoryItem(
-          messageUuid2,
+          userMessageUuid,
           message.message,
           context
         );
         const stampedUserItem = withHistoryItemCreatedAt(userItem, userStartedAt);
         current = {
-          providerTurnId: `claude-turn-${messageUuid2}`,
+          providerTurnId: `claude-turn-${userMessageUuid}`,
           startedAt: userStartedAt,
           items: [stampedUserItem],
-          itemsById: /* @__PURE__ */ new Map([[messageUuid2, stampedUserItem]])
+          itemsById: /* @__PURE__ */ new Map([[userMessageUuid, stampedUserItem]])
         };
         continue;
       }
@@ -16350,7 +16459,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
@@ -16564,13 +16673,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);
@@ -16581,6 +16687,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,
@@ -16592,10 +16715,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)
@@ -16663,12 +16791,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,
@@ -16791,15 +16920,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);
@@ -18000,6 +18133,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)
@@ -22314,7 +22455,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),
@@ -22412,6 +22557,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)
       }