@makerbi/remodex 3.1.0 → 3.3.0

package/src/desktop-ipc-conversation-adapter.js

@@ -5,6 +5,7 @@
 // Depends on: crypto, ./desktop-ipc-shared
 
 const { randomUUID } = require("crypto");
+const { applyRuntimeSettingsToConversation } = require("./codex-runtime-settings");
 
 const {
   cloneJSON,
@@ -190,11 +191,15 @@ function applyAppServerMessageToConversationState({
         return null;
       }
       const conversation = ensureConversationInMap(conversations, threadId, { hostId, now });
-      conversation.title = readString(message.params?.threadName)
+      const title = readString(message.params?.threadName)
         || readString(message.params?.thread_name)
         || readString(message.params?.name)
         || readString(message.params?.title)
         || conversation.title;
+      if (title === conversation.title) {
+        return { threadId, changed: false };
+      }
+      conversation.title = title;
       conversation.updatedAt = now();
       return { threadId, changed: true };
     }
@@ -446,7 +451,8 @@ function buildConversationStateFromThread(thread, {
   const createdAtMs = timestampSecondsToMs(thread?.createdAt) || previous?.createdAt || now();
   const updatedAtMs = timestampSecondsToMs(thread?.updatedAt) || now();
   const cwd = readString(thread?.cwd) || previous?.cwd || "";
-  const latestModel = readString(thread?.model) || readString(thread?.modelProvider) || previous?.latestModel || "";
+  const latestModel = readString(previous?.latestThreadSettings?.model)
+    || readString(thread?.model) || previous?.latestModel || "";
   const turns = mergeConversationTurnsFromThread(thread?.turns, {
     previousTurns: previous?.turns,
     threadId,
@@ -454,17 +460,28 @@ function buildConversationStateFromThread(thread, {
     now,
   });
 
-  return {
+  const state = {
     id: threadId,
+    forkedFromId: previous?.forkedFromId || null,
     hostId,
     turns,
     requests: cloneJSON(previous?.requests || []),
     createdAt: createdAtMs,
     updatedAt: updatedAtMs,
+    recencyAt: updatedAtMs,
     title: readString(thread?.name) || previous?.title || null,
+    source: readString(thread?.source) || previous?.source || "vscode",
+    agentNickname: previous?.agentNickname || null,
+    threadSource: readString(thread?.threadSource) || previous?.threadSource || "user",
+    historyMode: previous?.historyMode || "legacy",
+    parentThreadId: previous?.parentThreadId || null,
+    mode: previous?.mode || "default",
+    threadStartKind: previous?.threadStartKind || "default",
+    modelProvider: readString(thread?.modelProvider) || previous?.modelProvider || "openai",
     latestModel,
-    latestReasoningEffort: previous?.latestReasoningEffort || null,
-    latestServiceTier: previous?.latestServiceTier || null,
+    latestReasoningEffort: previous?.latestReasoningEffort ?? null,
+    latestServiceTier: previous?.latestServiceTier ?? null,
+    latestThreadSettings: cloneJSON(previous?.latestThreadSettings || null),
     previousTurnModel: previous?.previousTurnModel || null,
     latestCollaborationMode: previous?.latestCollaborationMode || {
       mode: "default",
@@ -488,7 +505,10 @@ function buildConversationStateFromThread(thread, {
     workspaceBrowserRoot: previous?.workspaceBrowserRoot || null,
     projectlessOutputDirectory: previous?.projectlessOutputDirectory || null,
     currentPermissions: cloneJSON(previous?.currentPermissions || null),
+    sessionId: readString(thread?.sessionId) || previous?.sessionId || null,
   };
+  synchronizeDesktopConversationCompatibility(state);
+  return state;
 }
 
 function mergeConversationTurnsFromThread(threadTurns, {
@@ -552,7 +572,7 @@ function createEmptyConversationState(threadId, {
   cwd = "",
 } = {}) {
   const timestamp = now();
-  return {
+  const state = {
     id: threadId,
     hostId,
     turns: [],
@@ -587,6 +607,187 @@ function createEmptyConversationState(threadId, {
     projectlessOutputDirectory: null,
     currentPermissions: null,
   };
+  synchronizeDesktopConversationCompatibility(state);
+  return state;
+}
+
+// Desktop 26.825 moved rendered history to a canonical entity graph. It still
+// accepts legacy turns during normalization, but unified-timeline selectors now
+// assume the graph and several nested collections exist. Keep the bridge's
+// mutable legacy turns for app-server event handling, and mirror them into the
+// current Desktop shape before every stream broadcast.
+function synchronizeDesktopConversationCompatibility(state) {
+  if (!state || typeof state !== "object" || Array.isArray(state)) {
+    return state;
+  }
+
+  const turns = Array.isArray(state.turns) ? state.turns : [];
+  const entries = [];
+  const entitiesByKey = {};
+  for (const turn of turns) {
+    const turnId = readString(turn?.turnId) || readString(turn?.id);
+    if (!turnId) {
+      continue;
+    }
+    turn.params = normalizeTurnParamsCompatibility(turn.params, {
+      cwd: readString(turn.params?.cwd) || readString(state.cwd),
+    });
+    turn.items = Array.isArray(turn.items) ? turn.items.map(normalizeDesktopItemCompatibility) : [];
+    turn.hookRuns = Array.isArray(turn.hookRuns) ? turn.hookRuns : [];
+    const key = `turn:${turnId}`;
+    entries.push({ key, value: key });
+    const { id: _legacyId, ...canonicalTurn } = turn;
+    entitiesByKey[key] = {
+      ...canonicalTurn,
+      turnId,
+    };
+  }
+
+  const islandId = "tail:0";
+  state.turnHistory = {
+    kind: "canonical",
+    history: {
+      entitiesByKey,
+      generation: 0,
+      isComplete: true,
+      islands: [{
+        id: islandId,
+        entries,
+        olderBoundary: {
+          status: "exhausted",
+          boundaryId: `${islandId}:older`,
+        },
+        newerBoundary: {
+          status: "exhausted",
+          boundaryId: `${islandId}:newer`,
+        },
+      }],
+    },
+  };
+  state.turnsPagination = {
+    olderCursor: null,
+    oldestLoadedTurnId: readString(turns[0]?.turnId) || readString(turns[0]?.id) || null,
+    isLoadingOlder: false,
+    hasLoadedOldest: true,
+  };
+
+  const latestParams = [...turns]
+    .reverse()
+    .map((turn) => turn?.params)
+    .find((params) => params && typeof params === "object") || null;
+  const sandboxPolicy = normalizeSandboxPolicyCompatibility(
+    latestParams?.sandboxPolicy || state.currentPermissions?.sandboxPolicy
+  );
+  if (sandboxPolicy) {
+    const runtimeWorkspaceRoots = Array.isArray(latestParams?.runtimeWorkspaceRoots)
+      ? cloneJSON(latestParams.runtimeWorkspaceRoots)
+      : Array.isArray(state.currentPermissions?.runtimeWorkspaceRoots)
+        ? cloneJSON(state.currentPermissions.runtimeWorkspaceRoots)
+        : [];
+    state.currentPermissions = {
+      activePermissionProfile: cloneJSON(
+        latestParams?.activePermissionProfile
+          ?? state.currentPermissions?.activePermissionProfile
+          ?? permissionProfileFromId(latestParams?.permissions)
+      ),
+      approvalPolicy: latestParams?.approvalPolicy
+        ?? state.currentPermissions?.approvalPolicy
+        ?? "on-request",
+      approvalsReviewer: latestParams?.approvalsReviewer
+        ?? state.currentPermissions?.approvalsReviewer
+        ?? "user",
+      runtimeWorkspaceRoots,
+      sandboxPolicy,
+    };
+  }
+
+  state.recencyAt = Number.isFinite(state.recencyAt) ? state.recencyAt : state.updatedAt;
+  state.source ||= "vscode";
+  state.threadSource ||= "user";
+  state.historyMode ||= "legacy";
+  state.mode ||= "default";
+  state.threadStartKind ||= "default";
+  state.modelProvider ||= "openai";
+  state.latestThreadSettings = {
+    cwd: readString(latestParams?.cwd) || readString(state.cwd) || null,
+    approvalPolicy: latestParams?.approvalPolicy ?? state.currentPermissions?.approvalPolicy ?? null,
+    approvalsReviewer: latestParams?.approvalsReviewer
+      ?? state.currentPermissions?.approvalsReviewer
+      ?? null,
+    ...(sandboxPolicy ? { sandboxPolicy } : {}),
+    activePermissionProfile: cloneJSON(state.currentPermissions?.activePermissionProfile ?? null),
+    model: readString(state.latestThreadSettings?.model)
+      || readString(latestParams?.model)
+      || readString(state.latestModel)
+      || null,
+    modelProvider: readString(state.latestThreadSettings?.modelProvider)
+      || readString(state.modelProvider)
+      || "openai",
+    serviceTier: Object.prototype.hasOwnProperty.call(state.latestThreadSettings || {}, "serviceTier")
+      ? state.latestThreadSettings.serviceTier
+      : latestParams?.serviceTier ?? state.latestServiceTier ?? null,
+    effort: Object.prototype.hasOwnProperty.call(state.latestThreadSettings || {}, "effort")
+      ? state.latestThreadSettings.effort
+      : latestParams?.effort ?? state.latestReasoningEffort ?? null,
+    summary: latestParams?.summary ?? state.latestThreadSettings?.summary ?? "none",
+    collaborationMode: cloneJSON(
+      state.latestThreadSettings?.collaborationMode
+        || latestParams?.collaborationMode
+        || state.latestCollaborationMode
+        || null
+    ),
+    multiAgentMode: latestParams?.multiAgentMode
+      ?? state.latestThreadSettings?.multiAgentMode
+      ?? null,
+    personality: latestParams?.personality
+      ?? state.latestThreadSettings?.personality
+      ?? null,
+  };
+  return state;
+}
+
+function normalizeTurnParamsCompatibility(params, { cwd = "" } = {}) {
+  const normalized = params && typeof params === "object" && !Array.isArray(params)
+    ? params
+    : {};
+  normalized.input = normalizeDesktopInputEntries(normalized.input);
+  normalized.attachments = Array.isArray(normalized.attachments) ? normalized.attachments : [];
+  normalized.cwd = readString(normalized.cwd) || readString(cwd) || null;
+  normalized.summary ??= "none";
+  normalized.personality ??= null;
+  normalized.outputSchema ??= null;
+  normalized.collaborationMode ??= null;
+  const sandboxPolicy = normalizeSandboxPolicyCompatibility(normalized.sandboxPolicy);
+  if (sandboxPolicy) {
+    normalized.sandboxPolicy = sandboxPolicy;
+  }
+  return normalized;
+}
+
+function normalizeSandboxPolicyCompatibility(policy) {
+  if (!policy || typeof policy !== "object" || Array.isArray(policy)) {
+    return null;
+  }
+  const normalized = cloneJSON(policy);
+  if (normalizeToken(normalized.type) === "workspacewrite") {
+    normalized.type = "workspaceWrite";
+    normalized.writableRoots = Array.isArray(normalized.writableRoots)
+      ? normalized.writableRoots
+      : [];
+    normalized.excludeSlashTmp = Boolean(normalized.excludeSlashTmp);
+    normalized.excludeTmpdirEnvVar = Boolean(normalized.excludeTmpdirEnvVar);
+    normalized.networkAccess = Boolean(normalized.networkAccess);
+  }
+  if (normalizeToken(normalized.type) === "readonly") {
+    normalized.type = "readOnly";
+    normalized.networkAccess = Boolean(normalized.networkAccess);
+  }
+  return normalized;
+}
+
+function permissionProfileFromId(value) {
+  const id = readString(value);
+  return id ? { id, extends: null } : null;
 }
 
 function buildConversationTurn(turn, {
@@ -596,7 +797,7 @@ function buildConversationTurn(turn, {
   now = () => Date.now(),
 } = {}) {
   const turnId = readString(turn?.id) || readString(turn?.turnId) || readString(turn?.turn_id);
-  const params = cloneJSON(previousTurn?.params || {
+  const params = normalizeTurnParamsCompatibility(cloneJSON(previousTurn?.params || {
     threadId,
     input: [],
     cwd: cwd || null,
@@ -611,7 +812,7 @@ function buildConversationTurn(turn, {
     outputSchema: null,
     collaborationMode: null,
     attachments: [],
-  });
+  }), { cwd });
   const builtTurn = {
     id: turnId,
     turnId,
@@ -678,6 +879,9 @@ function applyPendingTurnStartParams(
     ...turn.params,
     ...cloneJSON(pendingParams),
   };
+  turn.params = normalizeTurnParamsCompatibility(turn.params, {
+    cwd: readString(turn.params?.cwd) || readString(conversation?.cwd),
+  });
   normalizeTurnInitialPrompt(turn);
 }
 
@@ -695,35 +899,8 @@ function applyTurnRuntimeMetadata(conversation, turnParams) {
   if (!conversation || !turnParams) {
     return;
   }
-  const model = readString(turnParams.model);
-  const effort = readString(turnParams.effort);
-  const serviceTier = readString(turnParams.serviceTier) || null;
-  if (model) {
-    conversation.previousTurnModel = conversation.latestModel || null;
-    conversation.latestModel = model;
-  }
-  if (effort) {
-    conversation.latestReasoningEffort = effort;
-  }
-  conversation.latestServiceTier = serviceTier;
-  if (turnParams.collaborationMode && typeof turnParams.collaborationMode === "object") {
-    conversation.latestCollaborationMode = cloneJSON(turnParams.collaborationMode);
-    return;
-  }
-  if (!model && !effort) {
-    return;
-  }
-  const settings = conversation.latestCollaborationMode?.settings;
-  conversation.latestCollaborationMode = {
-    mode: conversation.latestCollaborationMode?.mode || "default",
-    settings: {
-      ...(settings && typeof settings === "object" ? settings : {
-        developer_instructions: null,
-      }),
-      model: model || settings?.model || "",
-      reasoning_effort: effort || settings?.reasoning_effort || null,
-    },
-  };
+  if (readString(turnParams.model)) conversation.previousTurnModel = conversation.latestModel || null;
+  applyRuntimeSettingsToConversation(conversation, turnParams);
 }
 
 function turnHasUserMessageItem(turn) {
@@ -763,7 +940,22 @@ function extractUserText(entries) {
 }
 
 function sanitizeUserInputEntries(entries) {
-  return sanitizeSharedUserInputEntries(entries).map(cloneJSON);
+  return normalizeDesktopInputEntries(sanitizeSharedUserInputEntries(entries)).map(cloneJSON);
+}
+
+// App-server defaults text_elements, but Desktop 26.903 reads its length
+// directly in IPC snapshots. Preserve existing spans and their byte offsets.
+function normalizeDesktopInputEntries(entries) {
+  if (!Array.isArray(entries)) {
+    return [];
+  }
+  return entries.map((entry) => {
+    if (!entry || typeof entry !== "object" || entry.type !== "text"
+      || Array.isArray(entry.text_elements)) {
+      return entry;
+    }
+    return { ...entry, text_elements: [] };
+  });
 }
 
 function sanitizeUserMessageItem(item) {
@@ -784,15 +976,22 @@ function sanitizeUserMessageItem(item) {
   };
 }
 
-// Codex CLI 0.144.1 can omit receiverThreads from persisted collab tool calls,
-// while the matching Desktop renderer reads that collection without a fallback.
-// Keep the richer snapshots unchanged and synthesize lightweight references from
-// receiverThreadIds for older/CLI-owned rollouts so opening them cannot crash.
+// Normalize optional app-server fields required by Desktop's snapshot renderer.
 function normalizeDesktopItemCompatibility(item) {
-  if (!item || typeof item !== "object" || normalizeToken(item.type) !== "collabagenttoolcall") {
+  if (!item || typeof item !== "object") {
+    return item;
+  }
+
+  if (item.type === "userMessage" || item.type === "steeringUserMessage") {
+    const inputKey = item.type === "userMessage" ? "content" : "input";
+    return { ...item, [inputKey]: normalizeDesktopInputEntries(item[inputKey]) };
+  }
+  if (normalizeToken(item.type) !== "collabagenttoolcall") {
     return item;
   }
 
+  // Codex CLI 0.144.1 can omit receiverThreads from persisted collab tool calls.
+  // Keep richer snapshots and synthesize references for older/CLI-owned rollouts.
   const receiverThreads = Array.isArray(item.receiverThreads)
     ? item.receiverThreads
     : [];
@@ -886,14 +1085,19 @@ function normalizeTurnInitialPrompt(turn) {
 function userMessageContentFromTurnInput(entry) {
   if (typeof entry === "string") {
     const text = readString(entry);
-    return text ? { type: "text", text } : null;
+    return text ? { type: "text", text, text_elements: [] } : null;
   }
   if (!entry || typeof entry !== "object") {
     return null;
   }
   const type = normalizeToken(entry.type);
   if (type === "inputtext" || type === "text") {
-    return { type: "text", text: readString(entry.text) };
+    return {
+      ...cloneJSON(entry),
+      type: "text",
+      text: typeof entry.text === "string" ? entry.text : "",
+      text_elements: Array.isArray(entry.text_elements) ? cloneJSON(entry.text_elements) : [],
+    };
   }
   return cloneJSON(entry);
 }
@@ -1262,6 +1466,7 @@ module.exports = {
   readThreadIdFromParams,
   readTurnIdFromParams,
   readTurnIdFromTurn,
+  synchronizeDesktopConversationCompatibility,
   timestampSecondsToMs,
   upsertItem,
   upsertTurn,

package/src/desktop-ipc-conversation-projector.js

@@ -203,6 +203,7 @@ function projectConversationState(threadId, rawState, {
       || readString(rawState?.latest_model)
       || "",
     ...(runtimeSettings ? {
+      runtimeSettings: cloneJSON(runtimeSettings),
       reasoningEffort: readString(runtimeSettings.reasoningEffort) || null,
       serviceTier: readString(runtimeSettings.serviceTier) || null,
       runtimeSettingsRevision: Number(runtimeSettings.revision) || 0,