@makerbi/remodex 2.3.1 → 2.4.0

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

@@ -220,6 +220,34 @@ function applyAppServerMessageToConversationState({
       conversation.updatedAt = now();
       return { threadId, changed: true };
     }
+    case "thread/goal/updated": {
+      const threadId = readThreadIdFromParams(message.params);
+      const goal = normalizeThreadGoal(message.params?.goal, threadId);
+      if (!threadId || !shouldOwnThread(threadId) || !goal) {
+        return null;
+      }
+      const conversation = ensureConversationInMap(conversations, threadId, { hostId, now });
+      if (goal.status === "complete") {
+        conversation.threadGoal = null;
+        conversation.completedThreadGoal = goal;
+      } else {
+        conversation.threadGoal = goal;
+        conversation.completedThreadGoal = null;
+      }
+      conversation.updatedAt = now();
+      return { threadId, changed: true };
+    }
+    case "thread/goal/cleared": {
+      const threadId = readThreadIdFromParams(message.params);
+      if (!threadId || !shouldOwnThread(threadId)) {
+        return null;
+      }
+      const conversation = ensureConversationInMap(conversations, threadId, { hostId, now });
+      conversation.threadGoal = null;
+      conversation.completedThreadGoal = null;
+      conversation.updatedAt = now();
+      return { threadId, changed: true };
+    }
     case "turn/started":
     case "turn/completed": {
       const threadId = readThreadIdFromParams(message.params);
@@ -322,6 +350,30 @@ function applyAppServerMessageToConversationState({
       conversation.updatedAt = now();
       return { threadId, changed: true };
     }
+    case "item/autoApprovalReview/started":
+    case "item/autoApprovalReview/completed": {
+      const threadId = readThreadIdFromParams(message.params);
+      if (!threadId || !shouldOwnThread(threadId)) {
+        return null;
+      }
+      const item = automaticApprovalReviewItemFromParams(message.params);
+      if (!item) {
+        return { threadId, changed: false };
+      }
+      const conversation = ensureConversationInMap(conversations, threadId, { hostId, now });
+      const turn = ensureTurn(conversation, resolveTurnIdForParams({
+        conversation,
+        params: message.params,
+        fallbackTurnIdsByThreadId,
+        now,
+      }), { now });
+      if (turn) {
+        upsertItem(turn, item);
+        turn.firstTurnWorkItemStartedAtMs = turn.firstTurnWorkItemStartedAtMs || now();
+      }
+      conversation.updatedAt = now();
+      return { threadId, changed: true };
+    }
     case "item/agentMessage/delta":
     case "item/plan/delta":
     case "item/reasoning/summaryTextDelta":
@@ -582,6 +634,7 @@ function buildConversationTurn(turn, {
   // Drop it here, position-independently, so no Desktop snapshot path leaks it
   // as a user bubble regardless of where the app-server placed it in the turn.
   builtTurn.items = builtTurn.items
+    .map(normalizeDesktopItemCompatibility)
     .map(sanitizeUserMessageItem)
     .filter(Boolean);
   // Hydrated turns from thread/read carry the prompt as an item with empty
@@ -731,6 +784,34 @@ 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.
+function normalizeDesktopItemCompatibility(item) {
+  if (!item || typeof item !== "object" || normalizeToken(item.type) !== "collabagenttoolcall") {
+    return item;
+  }
+
+  const receiverThreads = Array.isArray(item.receiverThreads)
+    ? item.receiverThreads
+    : [];
+  const receiverThreadIds = Array.isArray(item.receiverThreadIds)
+    ? item.receiverThreadIds.map(readString).filter(Boolean)
+    : receiverThreads.map((entry) => readString(entry?.threadId)).filter(Boolean);
+  if (Array.isArray(item.receiverThreads) && Array.isArray(item.receiverThreadIds)) {
+    return item;
+  }
+
+  return {
+    ...item,
+    receiverThreadIds,
+    receiverThreads: Array.isArray(item.receiverThreads)
+      ? receiverThreads
+      : receiverThreadIds.map((threadId) => ({ threadId })),
+  };
+}
+
 function isInitialPromptUserMessageItem(turn, item) {
   if (!isUserMessageItem(item)) {
     return false;
@@ -908,8 +989,10 @@ function upsertItem(turn, item) {
   // user items too; no Codex UI renders it, so it must not reach the stream.
   // Also evict any copy that slipped into the state before this filter existed.
   const index = turn.items.findIndex((candidate) => readString(candidate?.id) === itemId);
-  const sanitizedItem = sanitizeUserMessageItem(item);
-  const existingItem = index >= 0 ? sanitizeUserMessageItem(turn.items[index]) : null;
+  const sanitizedItem = sanitizeUserMessageItem(normalizeDesktopItemCompatibility(item));
+  const existingItem = index >= 0
+    ? sanitizeUserMessageItem(normalizeDesktopItemCompatibility(turn.items[index]))
+    : null;
   if (!sanitizedItem) {
     if (index >= 0) {
       turn.items.splice(index, 1);
@@ -1099,10 +1182,62 @@ function readTurnIdFromTurn(turn) {
     || readString(turn?.turn_id);
 }
 
+function automaticApprovalReviewItemFromParams(params) {
+  const reviewId = readString(params?.reviewId);
+  const review = params?.review && typeof params.review === "object" ? params.review : null;
+  const status = readString(review?.status);
+  if (!reviewId || !status || !params?.action) {
+    return null;
+  }
+  return {
+    id: `automatic-approval-review:${reviewId}`,
+    type: "automaticApprovalReview",
+    reviewId,
+    targetItemId: readString(params?.targetItemId) || null,
+    status,
+    startedAtMs: params?.startedAtMs ?? null,
+    completedAtMs: params?.completedAtMs ?? null,
+    decisionSource: readString(params?.decisionSource) || null,
+    review: cloneJSON(review),
+    action: cloneJSON(params.action),
+    remodexGuardianRetrySupported: false,
+  };
+}
+
 function timestampSecondsToMs(value) {
   return Number.isFinite(value) && value > 0 ? Math.round(value * 1000) : 0;
 }
 
+function normalizeThreadGoal(value, fallbackThreadId = "") {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const threadId = readString(value.threadId) || readString(value.thread_id) || readString(fallbackThreadId);
+  const objective = readString(value.objective);
+  const statusByToken = {
+    active: "active",
+    paused: "paused",
+    blocked: "blocked",
+    usagelimited: "usageLimited",
+    budgetlimited: "budgetLimited",
+    complete: "complete",
+  };
+  const status = statusByToken[normalizeToken(value.status)] || "";
+  if (!threadId || !objective || !status) {
+    return null;
+  }
+  return {
+    threadId,
+    objective,
+    status,
+    tokenBudget: value.tokenBudget ?? value.token_budget ?? null,
+    tokensUsed: Number(value.tokensUsed ?? value.tokens_used) || 0,
+    timeUsedSeconds: Number(value.timeUsedSeconds ?? value.time_used_seconds) || 0,
+    createdAt: Number(value.createdAt ?? value.created_at) || 0,
+    updatedAt: Number(value.updatedAt ?? value.updated_at) || 0,
+  };
+}
+
 const REQUEST_METHODS_WITH_THREAD = new Set([
   "item/commandExecution/requestApproval",
   "item/fileChange/requestApproval",
@@ -1123,6 +1258,7 @@ module.exports = {
   createEmptyConversationState,
   ensureConversationInMap,
   mergeConversationTurnsFromThread,
+  normalizeThreadGoal,
   readThreadIdFromParams,
   readTurnIdFromParams,
   readTurnIdFromTurn,

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

@@ -172,6 +172,10 @@ function projectDesktopConversationStateToThread(threadId, rawState, { now = ()
   return projectConversationState(threadId, rawState, { now }).thread;
 }
 
+function projectDesktopConversationStateToGoal(threadId, rawState) {
+  return latestThreadGoal(rawState, threadId);
+}
+
 function projectConversationState(threadId, rawState, {
   now = () => Date.now(),
   turnCache = null,
@@ -215,9 +219,12 @@ function projectConversationState(threadId, rawState, {
     turns,
   };
 
+  const goal = latestThreadGoal(rawState, threadId);
+
   return {
     thread,
     turns,
+    goal,
     activeTurnId,
     status: thread.status,
   };
@@ -332,6 +339,9 @@ function bootstrapNotifications(
   const notifications = includeThreadStarted && shouldEmitThreadStarted(projection.thread)
     ? [threadStartedNotification(projection.thread)]
     : [];
+  if (projection.goal) {
+    notifications.push(threadGoalUpdatedNotification(threadId, projection.goal));
+  }
   const activeTurns = includeAllActiveTurns
     ? projection.turns.filter((turn) => isActiveTurnStatus(turn.status))
     : [projection.activeTurnId
@@ -367,12 +377,26 @@ function diffProjections(threadId, previousProjection, nextProjection) {
   const notifications = [];
 
   notifications.push(...diffThreadMetadata(previousProjection.thread, nextProjection.thread));
+  notifications.push(...diffThreadGoal(threadId, previousProjection.goal, nextProjection.goal));
   notifications.push(...diffTurnLifecycle(threadId, previousProjection, nextProjection));
   notifications.push(...diffTurnItems(threadId, previousProjection, nextProjection));
 
   return notifications;
 }
 
+function diffThreadGoal(threadId, previousGoal, nextGoal) {
+  if (JSON.stringify(previousGoal || null) === JSON.stringify(nextGoal || null)) {
+    return [];
+  }
+  if (nextGoal) {
+    return [threadGoalUpdatedNotification(threadId, nextGoal)];
+  }
+  return [tagNotification({
+    method: "thread/goal/cleared",
+    params: { threadId },
+  })];
+}
+
 function diffThreadMetadata(previousThread, nextThread) {
   const notifications = [];
   const previousRuntimeRevision = Number(previousThread.runtimeSettingsRevision) || 0;
@@ -486,7 +510,11 @@ function diffTurnItems(threadId, previousProjection, nextProjection) {
         continue;
       }
       if (!isActiveTurn) {
-        notifications.push(itemCompletedNotification(threadId, nextTurn.id, nextItem));
+        if (isAutoApprovalReviewItem(nextItem) && !isTerminalItemState(nextItem)) {
+          notifications.push(itemStartedNotification(threadId, nextTurn.id, nextItem));
+        } else {
+          notifications.push(itemCompletedNotification(threadId, nextTurn.id, nextItem));
+        }
         continue;
       }
       notifications.push(...diffItem(threadId, nextTurn.id, previousItem, nextItem));
@@ -502,6 +530,11 @@ function diffItem(threadId, turnId, previousItem, nextItem) {
   // Previous text lengths come straight from the previous projection, which is
   // exactly what the per-thread snapshot map used to store.
   const snapshot = snapshotItem(previousItem);
+  if (isAutoApprovalReviewItem(nextItem)) {
+    return [isTerminalItemState(nextItem)
+      ? itemCompletedNotification(threadId, turnId, nextItem)
+      : itemStartedNotification(threadId, turnId, nextItem)];
+  }
   if (isAssistantMessageItem(nextItem)) {
     const previousText = assistantMessageText(previousItem);
     const nextText = assistantMessageText(nextItem);
@@ -644,6 +677,17 @@ function turnStartedNotification(threadId, turn) {
   });
 }
 
+function threadGoalUpdatedNotification(threadId, goal) {
+  return tagNotification({
+    method: "thread/goal/updated",
+    params: {
+      threadId,
+      turnId: null,
+      goal: cloneJSON(goal),
+    },
+  });
+}
+
 function turnCompletedNotification(threadId, turn) {
   return tagNotification({
     method: "turn/completed",
@@ -658,6 +702,9 @@ function turnCompletedNotification(threadId, turn) {
 }
 
 function itemStartedNotification(threadId, turnId, item) {
+  if (isAutoApprovalReviewItem(item)) {
+    return autoApprovalReviewNotification("item/autoApprovalReview/started", threadId, turnId, item);
+  }
   return tagNotification({
     method: "item/started",
     params: {
@@ -670,6 +717,9 @@ function itemStartedNotification(threadId, turnId, item) {
 }
 
 function itemCompletedNotification(threadId, turnId, item) {
+  if (isAutoApprovalReviewItem(item)) {
+    return autoApprovalReviewNotification("item/autoApprovalReview/completed", threadId, turnId, item);
+  }
   return tagNotification({
     method: "item/completed",
     params: {
@@ -681,6 +731,21 @@ function itemCompletedNotification(threadId, turnId, item) {
   });
 }
 
+// Guardian reviews have no ThreadItem variant in the app-server protocol; the
+// live wire shape is the dedicated `item/autoApprovalReview/*` notification.
+// Re-emit that shape so mobile reuses one decoder for owned and mirrored threads.
+function autoApprovalReviewNotification(method, threadId, turnId, item) {
+  const { type, id, status, ...payload } = item;
+  return tagNotification({
+    method,
+    params: {
+      threadId,
+      turnId,
+      ...cloneJSON(payload),
+    },
+  });
+}
+
 function deltaNotification(method, threadId, turnId, itemId, delta, extraParams = {}) {
   return tagNotification({
     method,
@@ -994,6 +1059,9 @@ function sanitizeUserInputEntries(entries) {
 // Keep the original type as metadata, but emit the generic shape iOS already decodes.
 // Returns null when the item has nothing user-visible left after sanitizing.
 function projectItemForMobile(item, itemType = normalizeToken(item?.type)) {
+  if (itemType === "automaticapprovalreview") {
+    return projectAutoApprovalReviewItem(item);
+  }
   if (itemType === "usermessage") {
     const visibleContent = sanitizeUserInputEntries(
       Array.isArray(item?.content) ? item.content : []
@@ -1024,8 +1092,53 @@ function projectItemForMobile(item, itemType = normalizeToken(item?.type)) {
   return projected;
 }
 
+const AUTO_APPROVAL_REVIEW_ITEM_ID_PREFIX = "automatic-approval-review:";
+
+function isAutoApprovalReviewItem(item) {
+  return normalizeToken(item?.type) === "automaticapprovalreview";
+}
+
+// Desktop flattens `item/autoApprovalReview/*` notifications into synthetic
+// `automaticApprovalReview` turn items. Normalize back to the app-server
+// notification shape; keep top-level `status` for lifecycle checks.
+function projectAutoApprovalReviewItem(item) {
+  const rawId = itemIdOf(item);
+  if (!rawId) {
+    return null;
+  }
+  const review = item?.review && typeof item.review === "object" ? item.review : item;
+  const status = readString(review.status);
+  if (!status) {
+    return null;
+  }
+  return {
+    type: "automaticApprovalReview",
+    id: rawId,
+    reviewId: readString(item.reviewId)
+      || (rawId.startsWith(AUTO_APPROVAL_REVIEW_ITEM_ID_PREFIX)
+        ? rawId.slice(AUTO_APPROVAL_REVIEW_ITEM_ID_PREFIX.length)
+        : rawId),
+    targetItemId: readString(item.targetItemId) || null,
+    status,
+    startedAtMs: item.startedAtMs ?? null,
+    completedAtMs: item.completedAtMs ?? null,
+    decisionSource: readString(item.decisionSource)
+      || readString(item?.event?.decision_source)
+      || null,
+    review: {
+      status,
+      riskLevel: readString(review.riskLevel) || null,
+      userAuthorization: readString(review.userAuthorization) || null,
+      rationale: readString(review.rationale) || null,
+    },
+    action: cloneJSON(item.action ?? null),
+    ...MIRROR_TAG,
+  };
+}
+
 function isSupportedItemType(type) {
   return type === "usermessage"
+    || type === "automaticapprovalreview"
     || type === "hookprompt"
     || type === "agentmessage"
     || type === "assistantmessage"
@@ -1161,9 +1274,42 @@ function normalizeTimestamp(value) {
   return Number.isFinite(numeric) && numeric > 0 ? numeric : 0;
 }
 
+function latestThreadGoal(rawState, threadId) {
+  const candidates = [rawState?.threadGoal, rawState?.completedThreadGoal]
+    .map((goal) => normalizeProjectedThreadGoal(goal, threadId))
+    .filter(Boolean);
+  return candidates.sort((left, right) => right.updatedAt - left.updatedAt)[0] || null;
+}
+
+function normalizeProjectedThreadGoal(value, fallbackThreadId) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const statusByToken = {
+    active: "active",
+    paused: "paused",
+    blocked: "blocked",
+    usagelimited: "usageLimited",
+    budgetlimited: "budgetLimited",
+    complete: "complete",
+  };
+  const goal = {
+    threadId: readString(value.threadId) || readString(value.thread_id) || fallbackThreadId,
+    objective: readString(value.objective),
+    status: statusByToken[normalizeToken(value.status)] || "",
+    tokenBudget: value.tokenBudget ?? value.token_budget ?? null,
+    tokensUsed: Number(value.tokensUsed ?? value.tokens_used) || 0,
+    timeUsedSeconds: Number(value.timeUsedSeconds ?? value.time_used_seconds) || 0,
+    createdAt: Number(value.createdAt ?? value.created_at) || 0,
+    updatedAt: Number(value.updatedAt ?? value.updated_at) || 0,
+  };
+  return goal.threadId && goal.objective && goal.status ? goal : null;
+}
+
 module.exports = {
   createDesktopConversationProjector,
   desktopTurnsShareLogicalIdentity,
   matchDesktopTurnIdentityContinuities,
+  projectDesktopConversationStateToGoal,
   projectDesktopConversationStateToThread,
 };

package/src/desktop-ipc-shared.js

@@ -63,8 +63,10 @@ const LEGACY_CONTEXT_WARNING_PREFIXES = [
 const LEGACY_APPLY_PATCH_WARNING_PREFIX = "Warning: apply_patch was requested via ";
 const LEGACY_APPLY_PATCH_WARNING_SUFFIX = "Use the apply_patch tool instead of exec_command.";
 const AGENTS_INSTRUCTIONS_PREFIX = "# AGENTS.md instructions";
-const INTERNAL_CONTEXT_PATTERN = /^<codex_internal_context\s+source=(?:"[a-z][a-z0-9_]*"|'[a-z][a-z0-9_]*')>[\s\S]*<\/codex_internal_context>$/;
-const EXTERNAL_CONTEXT_PATTERN = /^<external_([a-z0-9_-]+)>[\s\S]*<\/external_\1>$/;
+const AGENTS_INSTRUCTIONS_BEGIN = "<instructions>";
+const AGENTS_INSTRUCTIONS_END = "</instructions>";
+const INTERNAL_CONTEXT_PREFIX_PATTERN = /^<codex_internal_context\s+source=(?:"[a-z][a-z0-9_]*"|'[a-z][a-z0-9_]*')>[\s\S]*?<\/codex_internal_context>/;
+const EXTERNAL_CONTEXT_PREFIX_PATTERN = /^<external_([a-z0-9_-]+)>[\s\S]*?<\/external_\1>/;
 const PROMPT_REQUEST_BEGIN = "## My request for Codex:";
 const REVIEW_PROMPT_PREFIX = "## Code review guidelines:";
 
@@ -91,38 +93,116 @@ function stripImagePlaceholders(text) {
   return IMAGE_PLACEHOLDER_TOKEN.test(withoutPairs.trim()) ? "" : withoutPairs;
 }
 
-function isContextualUserText(text) {
-  const raw = typeof text === "string" ? text : "";
-  const trimmed = stripImagePlaceholders(raw).trim();
-  if (!trimmed) {
-    return false;
+// Review envelopes contain a real request after the delimiter and are never
+// wholly contextual, even when that request itself contains reserved markup.
+function isReviewEnvelopeText(trimmed) {
+  return trimmed.startsWith(REVIEW_PROMPT_PREFIX) && trimmed.includes(PROMPT_REQUEST_BEGIN);
+}
+
+// Consumes one runtime-owned fragment anchored at the start of `text` and
+// returns what follows it, or null when the text does not open with one.
+// Codex packs several fragments into a single user item, so the opening and
+// closing markers routinely belong to different fragments (a desktop opener
+// reads "<recommended_plugins>...</recommended_plugins>" + AGENTS.md
+// instructions + "<environment_context>...</environment_context>"). Matching
+// the blob as a whole classifies that item as visible and turns the entire
+// injected preamble into the thread's first user bubble.
+function consumeLeadingContextFragment(text) {
+  const lower = text.toLowerCase();
+
+  for (const [start, end] of CONTEXT_MARKER_PAIRS) {
+    if (!lower.startsWith(start)) {
+      continue;
+    }
+    const closeIndex = lower.indexOf(end, start.length);
+    // An unterminated marker is not a fragment we can bound. Leave it visible
+    // rather than swallow a message that merely opens with reserved markup.
+    return closeIndex === -1 ? null : text.slice(closeIndex + end.length);
   }
-  // Review envelopes contain a real request after the delimiter and are never
-  // wholly contextual, even when that request itself contains reserved markup.
-  if (trimmed.startsWith(REVIEW_PROMPT_PREFIX) && trimmed.includes(PROMPT_REQUEST_BEGIN)) {
-    return false;
+
+  const internal = INTERNAL_CONTEXT_PREFIX_PATTERN.exec(text);
+  if (internal) {
+    return text.slice(internal[0].length);
   }
-  const normalized = trimmed.toLowerCase();
-  if (normalized.startsWith(AGENTS_INSTRUCTIONS_PREFIX.toLowerCase())) {
-    // Runtime context can concatenate AGENTS.md with any registered hidden
-    // fragment. Only classify the whole item as hidden when its final fragment
-    // is also runtime-owned; a following real user request must stay visible.
-    return normalized.endsWith("</instructions>")
-      || CONTEXT_MARKER_PAIRS.some(([, end]) => normalized.endsWith(end));
-  }
-  if (CONTEXT_MARKER_PAIRS.some(([start, end]) => (
-    normalized.startsWith(start) && normalized.endsWith(end)
-  ))) {
-    return true;
+  const external = EXTERNAL_CONTEXT_PREFIX_PATTERN.exec(text);
+  if (external) {
+    return text.slice(external[0].length);
   }
-  if (INTERNAL_CONTEXT_PATTERN.test(trimmed) || EXTERNAL_CONTEXT_PATTERN.test(trimmed)) {
-    return true;
+
+  if (lower.startsWith(AGENTS_INSTRUCTIONS_PREFIX.toLowerCase())) {
+    return consumeAgentsInstructionsFragment(text, lower);
   }
-  if (LEGACY_CONTEXT_WARNING_PREFIXES.some((prefix) => trimmed.startsWith(prefix))) {
-    return true;
+
+  // Unlike the marked fragments above, runtime warnings carry no closing marker
+  // and trail free-form runtime lines ("Shell cwd was reset to ..."), so there is
+  // no boundary to peel at. They are emitted as whole items that never contain a
+  // user request, hence consuming the remainder rather than bounding it.
+  if (LEGACY_CONTEXT_WARNING_PREFIXES.some((prefix) => text.startsWith(prefix))) {
+    return "";
+  }
+  return text.startsWith(LEGACY_APPLY_PATCH_WARNING_PREFIX)
+    && text.endsWith(LEGACY_APPLY_PATCH_WARNING_SUFFIX)
+    ? ""
+    : null;
+}
+
+function consumeAgentsInstructionsFragment(text, lower) {
+  const closeIndex = lower.indexOf(AGENTS_INSTRUCTIONS_END);
+  if (closeIndex >= 0) {
+    return consumeChainedInstructionsBlocks(text.slice(closeIndex + AGENTS_INSTRUCTIONS_END.length));
+  }
+  // Older runtimes emit the AGENTS.md body unwrapped and then append another
+  // registered fragment; that next marker is the only reliable boundary.
+  const nextMarkerIndex = CONTEXT_MARKER_PAIRS
+    .map(([start]) => lower.indexOf(start, 1))
+    .filter((index) => index > 0)
+    .sort((left, right) => left - right)[0];
+  return nextMarkerIndex === undefined ? null : text.slice(nextMarkerIndex);
+}
+
+// A single "# AGENTS.md instructions" header can carry one <INSTRUCTIONS> block
+// per nested AGENTS.md file. Stopping at the first close would leave the rest of
+// the preamble in front of the real request, where no registered marker matches
+// and the peeler gives up, turning the leftover into the first user bubble.
+function consumeChainedInstructionsBlocks(text) {
+  let rest = text;
+  for (;;) {
+    const trimmed = rest.trimStart();
+    const lower = trimmed.toLowerCase();
+    if (!lower.startsWith(AGENTS_INSTRUCTIONS_BEGIN)) {
+      return rest;
+    }
+    const closeIndex = lower.indexOf(AGENTS_INSTRUCTIONS_END, AGENTS_INSTRUCTIONS_BEGIN.length);
+    // Unterminated: same rule as everywhere else, leave it visible rather than
+    // guess where the injected block ends.
+    if (closeIndex === -1) {
+      return rest;
+    }
+    rest = trimmed.slice(closeIndex + AGENTS_INSTRUCTIONS_END.length);
+  }
+}
+
+// Peels every injected fragment off the front of an already trimmed message and
+// returns the text the user actually typed (empty when nothing else remains).
+function stripLeadingContextFragments(trimmed) {
+  let rest = trimmed;
+  while (rest) {
+    const remainder = consumeLeadingContextFragment(rest);
+    if (remainder === null) {
+      break;
+    }
+    rest = remainder.trim();
+  }
+  return rest;
+}
+
+function isContextualUserText(text) {
+  const raw = typeof text === "string" ? text : "";
+  const trimmed = stripImagePlaceholders(raw).trim();
+  if (!trimmed || isReviewEnvelopeText(trimmed)) {
+    return false;
   }
-  return trimmed.startsWith(LEGACY_APPLY_PATCH_WARNING_PREFIX)
-    && trimmed.endsWith(LEGACY_APPLY_PATCH_WARNING_SUFFIX);
+  return stripLeadingContextFragments(trimmed) === "";
 }
 
 function decodeXmlText(text) {
@@ -173,14 +253,25 @@ function visibleUserPromptText(text) {
     return "";
   }
   const cleaned = stripImagePlaceholders(text);
-  // Context bodies can contain the request delimiter as ordinary text. Classify
-  // the complete fragment first so the delimiter cannot reveal hidden content.
-  if (isContextualUserText(cleaned)) {
+  const trimmed = cleaned.trim();
+  if (!trimmed) {
     return "";
   }
-  const requestIndex = cleaned.lastIndexOf(PROMPT_REQUEST_BEGIN);
+  // Context bodies can contain the request delimiter as ordinary text. Peel the
+  // injected fragments off first so the delimiter cannot reveal hidden content,
+  // and so a real request that trails them survives instead of the whole blob.
+  const stripped = isReviewEnvelopeText(trimmed)
+    ? trimmed
+    : stripLeadingContextFragments(trimmed);
+  if (!stripped) {
+    return "";
+  }
+  // Untouched prompts keep their original spacing so callers can still detect
+  // "nothing changed" by identity and skip cloning the item.
+  const body = stripped === trimmed ? cleaned : stripped;
+  const requestIndex = body.lastIndexOf(PROMPT_REQUEST_BEGIN);
   if (requestIndex >= 0) {
-    const request = cleaned.slice(requestIndex + PROMPT_REQUEST_BEGIN.length).trim();
+    const request = body.slice(requestIndex + PROMPT_REQUEST_BEGIN.length).trim();
     // A few IDE/review exports end with the delimiter but omit its request
     // suffix. They still contain a real visible prompt before that marker;
     // returning an empty string made live mirroring erase the opener while
@@ -191,14 +282,14 @@ function visibleUserPromptText(text) {
     if (request) {
       return request;
     }
-    const body = cleaned.slice(0, requestIndex).trimEnd();
-    return isContextualUserText(body) ? "" : body;
+    const precedingBody = body.slice(0, requestIndex).trimEnd();
+    return isContextualUserText(precedingBody) ? "" : precedingBody;
   }
-  const envelopeText = extractVisibleRuntimeEnvelope(cleaned);
+  const envelopeText = extractVisibleRuntimeEnvelope(body);
   if (envelopeText != null) {
     return envelopeText;
   }
-  return cleaned;
+  return body;
 }
 
 // Sanitizes text fragments independently so a hidden fragment cannot cause a
@@ -327,6 +418,24 @@ function normalizeToken(value) {
     : "";
 }
 
+// The phone's running-state probe, as opposed to a history page: the explicit
+// marker on current clients, or the probe's unique legacy shape (Remodex iPhone
+// 2.1 predates the marker, and real history pages use limits 1 and 5). Every
+// live source answers this request, so they must all recognize it identically.
+function isThreadTurnStateProbeRequest(message) {
+  const params = message?.params;
+  if (readString(message?.method) !== "thread/turns/list"
+    || readString(params?.cursor)
+    || params?.remodexRequireCanonical === true) {
+    return false;
+  }
+  if (params?.remodexTurnStateOnly === true) {
+    return true;
+  }
+  return Number(params?.limit) === 8
+    && normalizeToken(readString(params?.sortDirection) || "desc") === "desc";
+}
+
 function cloneJSON(value) {
   if (value == null) {
     return value;
@@ -456,6 +565,7 @@ module.exports = {
   hasVisiblePlanUpdate,
   isContextualUserText,
   isPlainJSONObject,
+  isThreadTurnStateProbeRequest,
   isUserRoleItem,
   normalizeToken,
   readString,