@makerbi/remodex 2.3.1 → 2.4.0

package/src/push-notification-tracker.js

@@ -4,14 +4,29 @@
 // Exports: createPushNotificationTracker
 // Depends on: ./push-notification-completion-dedupe
 
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
 const {
   createPushNotificationCompletionDedupe,
 } = require("./push-notification-completion-dedupe");
 
+const DEFAULT_GOAL_PUSH_STATE_PATH = path.join(os.homedir(), ".remodex", "goal-push-state.json");
+
 const DEFAULT_PREVIEW_MAX_CHARS = 160;
 const MAX_THREAD_TITLE_ENTRIES = 200;
 const MAX_TURN_STATE_ENTRIES = 500;
 const MAX_THREAD_ID_BY_TURN_ENTRIES = 500;
+const MAX_GOAL_STATUS_ENTRIES = 500;
+
+// Goal states worth waking the phone for: terminal or needs-user-attention.
+const GOAL_PUSH_BODIES = new Map([
+  ["complete", "Goal complete"],
+  ["blocked", "Goal blocked — Codex needs your input"],
+  ["usageLimited", "Goal stopped — usage limit reached"],
+  ["budgetLimited", "Goal stopped — token budget reached"],
+]);
 
 function createPushNotificationTracker({
   sessionId,
@@ -19,10 +34,14 @@ function createPushNotificationTracker({
   previewMaxChars = DEFAULT_PREVIEW_MAX_CHARS,
   logPrefix = "[remodex]",
   now = () => Date.now(),
+  goalPushStatePath = DEFAULT_GOAL_PUSH_STATE_PATH,
 } = {}) {
   const threadTitleById = new Map();
   const threadIdByTurnId = new Map();
   const turnStateByKey = new Map();
+  // Persisted across bridge restarts so goal transitions that happened while the
+  // bridge was down still notify on the first post-restart snapshot.
+  const goalStatusByThreadId = loadGoalPushState(goalPushStatePath, logPrefix);
   const completionDedupe = createPushNotificationCompletionDedupe({ now });
 
   // ─── ENTRY POINT ─────────────────────────────────────────────
@@ -33,6 +52,18 @@ function createPushNotificationTracker({
       return;
     }
 
+    if (message.method === "thread/goal/updated") {
+      void handleGoalUpdated(message);
+      return;
+    }
+
+    if (message.method === "thread/goal/cleared") {
+      if (message.threadId && goalStatusByThreadId.delete(message.threadId)) {
+        saveGoalPushState(goalPushStatePath, goalStatusByThreadId, logPrefix);
+      }
+      return;
+    }
+
     rememberMessageContext(message);
     clearFallbackSuppressionForNewRun(message);
 
@@ -73,6 +104,59 @@ function createPushNotificationTracker({
     }
   }
 
+  // Pushes goal lifecycle transitions into terminal/attention states so hours-long
+  // background goals still reach the user. Resume snapshots (first observation of a
+  // status) never notify; only live status changes do.
+  async function handleGoalUpdated({ threadId, params }) {
+    const goal = objectValue(params?.goal);
+    const status = readString(goal?.status);
+    const resolvedThreadId = threadId || readString(goal?.threadId);
+    if (!resolvedThreadId || !status) {
+      return;
+    }
+
+    const previousSnapshot = normalizeGoalPushSnapshot(goalStatusByThreadId.get(resolvedThreadId));
+    const nextSnapshot = {
+      status,
+      updatedAt: goal?.updatedAt ?? goal?.updated_at ?? null,
+    };
+    if (!goalStatusByThreadId.has(resolvedThreadId) && goalStatusByThreadId.size >= MAX_GOAL_STATUS_ENTRIES) {
+      const oldest = goalStatusByThreadId.keys().next().value;
+      goalStatusByThreadId.delete(oldest);
+    }
+    const isFirstObservation = previousSnapshot == null;
+    const isDuplicate = previousSnapshot?.status === nextSnapshot.status
+      && previousSnapshot?.updatedAt === nextSnapshot.updatedAt;
+    const body = GOAL_PUSH_BODIES.get(status);
+    if (isFirstObservation || isDuplicate || !body || !pushServiceClient?.hasConfiguredBaseUrl) {
+      if (!isDuplicate) {
+        goalStatusByThreadId.set(resolvedThreadId, nextSnapshot);
+        saveGoalPushState(goalPushStatePath, goalStatusByThreadId, logPrefix);
+      }
+      return;
+    }
+
+    const title = normalizePreviewText(threadTitleById.get(resolvedThreadId)) || "New Thread";
+    // The goal objective intentionally stays out of push payloads and logs.
+    try {
+      await pushServiceClient.notifyCompletion({
+        threadId: resolvedThreadId,
+        turnId: null,
+        result: status === "complete" ? "completed" : "failed",
+        title,
+        body,
+        // updatedAt keeps repeated legitimate transitions (blocked -> active -> blocked) notifiable.
+        dedupeKey: [sessionId || "", resolvedThreadId, "goal", status, goal?.updatedAt ?? ""].join("|"),
+      });
+      // Commit the dedupe cursor only after delivery succeeds so a repeated
+      // app-server snapshot can retry a transient push outage.
+      goalStatusByThreadId.set(resolvedThreadId, nextSnapshot);
+      saveGoalPushState(goalPushStatePath, goalStatusByThreadId, logPrefix);
+    } catch (error) {
+      console.error(`${logPrefix} goal push notify failed: ${error.message}`);
+    }
+  }
+
   // Remembers thread/turn linkage before the terminal event arrives on a different payload shape.
   function rememberMessageContext({ threadId, turnId, params, eventObject }) {
     if (threadId && turnId) {
@@ -273,6 +357,56 @@ function createPushNotificationTracker({
   };
 }
 
+// Best-effort disk persistence for goal statuses; failures must never break the bridge.
+function loadGoalPushState(filePath, logPrefix) {
+  if (!filePath) {
+    return new Map();
+  }
+
+  try {
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return new Map();
+    }
+    const entries = Object.entries(parsed)
+      .map(([threadId, snapshot]) => [threadId, normalizeGoalPushSnapshot(snapshot)])
+      .filter(([threadId, snapshot]) => typeof threadId === "string" && snapshot != null)
+      .slice(-MAX_GOAL_STATUS_ENTRIES);
+    return new Map(entries);
+  } catch (error) {
+    if (error.code !== "ENOENT") {
+      console.error(`${logPrefix} failed to load goal push state: ${error.message}`);
+    }
+    return new Map();
+  }
+}
+
+function normalizeGoalPushSnapshot(value) {
+  if (typeof value === "string") {
+    return { status: value, updatedAt: null };
+  }
+  if (!value || typeof value !== "object" || typeof value.status !== "string") {
+    return null;
+  }
+  return {
+    status: value.status,
+    updatedAt: value.updatedAt ?? null,
+  };
+}
+
+function saveGoalPushState(filePath, goalStatusByThreadId, logPrefix) {
+  if (!filePath) {
+    return;
+  }
+
+  try {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(Object.fromEntries(goalStatusByThreadId)));
+  } catch (error) {
+    console.error(`${logPrefix} failed to save goal push state: ${error.message}`);
+  }
+}
+
 // Normalizes the message envelope once so downstream helpers can share the same parsed view.
 function parseOutboundMessage(rawMessage, parsedMessage = null) {
   const parsed = parsedMessage ?? safeParseJSON(rawMessage);

package/src/rollout-live-mirror.js

@@ -132,9 +132,17 @@ function createRolloutLiveMirrorController({
     mirrorsByThreadId.clear();
   }
 
+  // The real turn id this mirror is actively tailing, or null. Lets the bridge
+  // answer the phone's turn-state probe from mirror truth when the bounded
+  // canonical page reads a busy run as closed.
+  function getActiveTurnId(threadId) {
+    return mirrorsByThreadId.get(threadId)?.getActiveTurnId() || null;
+  }
+
   return {
     observeInbound,
     stopAll,
+    getActiveTurnId,
   };
 }
 
@@ -358,9 +366,30 @@ function createThreadRolloutLiveMirror({
     onStop();
   }
 
+  // Only a healthy, actively-tailed run with a real id counts: synthetic ids
+  // are not actionable app-server turn ids, and suppressed/awaiting states
+  // mean the mirror does not actually know what is running. While another live
+  // source owns the thread the tail keeps parsing with its emissions muted, so
+  // reporting that turn id would resurrect exactly the state the bridge muted.
+  function getActiveTurnId() {
+    if (
+      isStopped
+      || wasSuppressed
+      || state.isDesktopOrigin === false
+      || state.awaitingCoherentBoundary
+      || state.suppressLiveActivityUntilGrowth
+      || state.activeTurnIdIsSynthetic
+      || state.pendingSyntheticTerminalTurnId
+    ) {
+      return null;
+    }
+    return state.activeTurnId || null;
+  }
+
   return {
     bump,
     stop,
+    getActiveTurnId,
   };
 }
 
@@ -401,12 +430,30 @@ function bootstrapFromExistingRollout({
     fsModule,
   });
   if (!bootstrapWindow) {
-    // The active run starts outside the bounded bootstrap window. Do not emit
-    // a plausible-looking tail: canonical history remains the baseline and
-    // this mirror will still consume future growth normally.
     state.awaitingCoherentBoundary = true;
     return;
   }
+  if (!bootstrapWindow.coherent) {
+    // The active run starts outside the bounded bootstrap window. Do not emit
+    // a plausible-looking tail: canonical history remains the baseline. But do
+    // not go dark either — a long busy run would stop mirroring tool activity
+    // until its next turn boundary. Attach to the run in place instead, so
+    // growth from here on keeps streaming live.
+    const attached = attachToActiveRunFromTruncatedTail({
+      contents: bootstrapWindow.alignedContents,
+      boundary: bootstrapWindow.boundary,
+      state,
+      rolloutPath,
+      fsModule,
+      sendApplicationResponse,
+      nowMs,
+      staleActiveRunMaxAgeMs,
+    });
+    if (!attached) {
+      state.awaitingCoherentBoundary = true;
+    }
+    return;
+  }
   const { tailStart, contents: bootstrapContents } = bootstrapWindow;
   let initialContents = bootstrapContents;
   if (!initialContents) {
@@ -532,7 +579,8 @@ function bootstrapFromExistingRollout({
 // Expands backwards only until the newest active task has its opening user
 // message. Every expansion reads just the newly needed prefix, so a 30MB file
 // is read at most once rather than once per retry. The hard cap keeps bootstrap
-// work/memory bounded; no coherent opener means no replay.
+// work/memory bounded; a capped window without a coherent opener comes back
+// with `coherent: false` and must never be replayed as history.
 function readCoherentBootstrapWindow({ rolloutPath, fileSize, fsModule }) {
   const maxBytes = Math.min(fileSize, DEFAULT_BOOTSTRAP_MAX_BYTES);
   let windowBytes = Math.min(fileSize, DEFAULT_BOOTSTRAP_TAIL_BYTES);
@@ -549,10 +597,16 @@ function readCoherentBootstrapWindow({ rolloutPath, fileSize, fsModule }) {
     // some legitimate system/continuation turns have no materialized user row.
     // The opener requirement only protects a truncated tail.
     if (!boundary.hasActiveRun || boundary.hasOpeningUser || tailStart === 0) {
-      return { tailStart, contents };
+      return { tailStart, contents, coherent: true };
     }
     if (windowBytes >= maxBytes || tailStart === 0) {
-      return null;
+      return {
+        tailStart,
+        contents,
+        coherent: false,
+        alignedContents,
+        boundary,
+      };
     }
 
     const nextWindowBytes = Math.min(maxBytes, windowBytes * 2);
@@ -584,12 +638,21 @@ function inspectBootstrapRunBoundary(contents) {
   // closing terminal is evidence of an unknown active boundary, not permission
   // to replay a partial conversation.
   let unboundedActivitySinceTerminal = false;
-
-  for (const rawLine of contents.split("\n")) {
-    const parsed = safeParseJSON(rawLine.trim());
+  // Attach metadata for the incoherent-window case, so the caller never has to
+  // re-parse the (up to 64MB) window a second time.
+  let newestTaskStartedLineIndex = -1;
+  let lastEntryTimestamp = "";
+
+  const lines = contents.split("\n");
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+    const parsed = safeParseJSON(lines[lineIndex].trim());
     if (!parsed) {
       continue;
     }
+    const entryTimestamp = readString(parsed.timestamp);
+    if (entryTimestamp) {
+      lastEntryTimestamp = entryTimestamp;
+    }
     const taskEventType = parsed?.type === "event_msg"
       ? readString(parsed?.payload?.type)
       : "";
@@ -611,6 +674,7 @@ function inspectBootstrapRunBoundary(contents) {
       hasOpeningUser = pendingUserBeforeStart;
       hasTurnOutputSinceStart = false;
       pendingUserBeforeStart = false;
+      newestTaskStartedLineIndex = lineIndex;
       continue;
     }
     if (!activeTurnId) {
@@ -653,6 +717,8 @@ function inspectBootstrapRunBoundary(contents) {
   return {
     hasActiveRun: Boolean(activeTurnId) || unboundedActivitySinceTerminal,
     hasOpeningUser,
+    newestTaskStartedLineIndex,
+    lastEntryTimestamp,
   };
 }
 
@@ -667,6 +733,58 @@ function isBootstrapNeutralRecord(entry, taskEventType = "") {
     || taskEventType === "context_updated";
 }
 
+// Attaches mid-run when the active run's opener is beyond the bounded window:
+// nothing already in the tail is emitted (it stays canonical-history
+// territory), but run state is hydrated so subsequent growth mirrors live.
+// Returns false when the tail proves the visible runs all closed — trailing
+// bytes then belong to an unknown older boundary and stay suppressed.
+function attachToActiveRunFromTruncatedTail({
+  contents,
+  boundary,
+  state,
+  rolloutPath,
+  fsModule,
+  sendApplicationResponse,
+  nowMs,
+  staleActiveRunMaxAgeMs,
+}) {
+  const newestTaskStartedIndex = boundary?.newestTaskStartedLineIndex ?? -1;
+  if (newestTaskStartedIndex >= 0) {
+    // Hydrate through the shared reducer so parallel-turn and terminal
+    // semantics stay authoritative for what is still open at EOF.
+    processRolloutLines(contents.split("\n").slice(newestTaskStartedIndex), state, () => {});
+    if (!state.activeTurnId) {
+      return false;
+    }
+  } else {
+    // Mid-turn tail without its task_started: adopt a synthetic turn. The
+    // first non-terminal event carrying the real id promotes it, and a
+    // mismatched terminal closes it via the synthetic-terminal path.
+    state.activeTurnId = buildSyntheticTurnId(state, { timestamp: boundary?.lastEntryTimestamp || "" });
+    state.activeTurnIdIsSynthetic = true;
+    state.reasoningItemId = buildSyntheticItemId("thinking", state.threadId, state.activeTurnId);
+  }
+
+  if (isRolloutFileStale(rolloutPath, fsModule, nowMs, staleActiveRunMaxAgeMs)) {
+    // Same contract as the stale coherent bootstrap: stay silent until real
+    // growth proves the desktop process is alive again.
+    state.suppressLiveActivityUntilGrowth = true;
+    return true;
+  }
+
+  // A hydrated run that already carries a pending synthetic terminal is
+  // closing, not running: announcing it as live would just be followed by the
+  // tick's synthetic turn/completed one grace period later.
+  if (!state.pendingSyntheticTerminalTurnId) {
+    sendApplicationResponse(JSON.stringify(createNotification("turn/activity", {
+      threadId: state.threadId,
+      turnId: state.activeTurnId,
+      id: state.activeTurnId,
+    })));
+  }
+  return true;
+}
+
 // After a bounded bootstrap cannot reach the old opener, consume only new
 // bytes. A later real user+task_started boundary safely starts a new live run;
 // everything before it remains canonical-history territory.
@@ -799,6 +917,26 @@ function synthesizeNotificationsFromRolloutEntry(entry, state, { nowMs = Date.no
     const payload = entry.payload || {};
     const eventType = readString(payload.type);
 
+    if (eventType === "thread_goal_updated") {
+      const goal = payload.goal && typeof payload.goal === "object" ? payload.goal : null;
+      const threadId = readString(payload.threadId) || readString(goal?.threadId) || state.threadId;
+      if (!goal || !threadId) {
+        return [];
+      }
+      return [createNotification("thread/goal/updated", {
+        threadId,
+        turnId: readString(payload.turnId) || readString(payload.turn_id) || null,
+        goal,
+      })];
+    }
+
+    if (eventType === "thread_goal_cleared") {
+      const threadId = readString(payload.threadId) || readString(payload.thread_id) || state.threadId;
+      return threadId
+        ? [createNotification("thread/goal/cleared", { threadId })]
+        : [];
+    }
+
     if (eventType === "task_started") {
       notifications.push(...finalizePendingSyntheticTerminal(state));
       const explicitTurnId = readString(payload.turn_id) || readString(payload.turnId);
@@ -952,7 +1090,7 @@ function synthesizeNotificationsFromRolloutEntry(entry, state, { nowMs = Date.no
     return notifications;
   }
 
-  if (itemType === "functioncalloutput") {
+  if (itemType === "functioncalloutput" || itemType === "customtoolcalloutput") {
     notifications.push(...toolOutputNotifications(state, payload));
     return notifications;
   }
@@ -1316,6 +1454,16 @@ function customToolStartNotifications(state, payload) {
     return notifications;
   }
 
+  // Custom tool calls settle through custom_tool_call_output. Without tracking
+  // them the activity row never completes, so it lingers between command groups.
+  if (!isCommandToolName(toolName) && !state.applyPatchCalls.has(callId)) {
+    state.commandCalls.set(callId, {
+      toolName,
+      command: toolName,
+      cwd: readString(state.sessionMeta?.cwd) || "",
+    });
+  }
+
   return [
     ...notifications,
     createNotification("codex/event/background_event", {
@@ -1776,8 +1924,19 @@ function genericToolActivityMessage(toolName) {
   }
 }
 
+// Mirrors the wording of genericToolActivityMessage so the completion line
+// supersedes the start line instead of stacking a second row beside it.
 function genericToolCompletionMessage(toolName) {
-  return `Completed ${readString(toolName)}`;
+  switch (readString(toolName).toLowerCase()) {
+  case "apply_patch":
+    return "Applied patch";
+  case "write_stdin":
+    return "Wrote to terminal";
+  case "read_thread_terminal":
+    return "Read terminal output";
+  default:
+    return `Completed ${readString(toolName)}`;
+  }
 }
 
 function createNotification(method, params = {}) {

package/src/session-jsonl-history.js

@@ -10,6 +10,7 @@ const {
   isContextualUserText,
   isUserRoleItem,
   responseItemMessageText: sharedResponseItemMessageText,
+  sanitizeUserRoleItem,
   visibleUserPromptText,
 } = require("./desktop-ipc-shared");
 
@@ -862,7 +863,10 @@ function normalizeResponseItemForHistory(payload, lineNumber, { cwd = "", toolCa
     item.role = "assistant";
   }
 
-  return item;
+  // A single user item can carry injected context next to the real request.
+  // Sanitize here so history readers (including the thread/read JSONL merge,
+  // which runs after the relay sanitizer) never rebuild the hidden fragments.
+  return isUserRoleItem(item) ? sanitizeUserRoleItem(item) : item;
 }
 
 function applyHistoryAssistantSourceAlias(item, turnId, occurrencesByBaseKey = new Map()) {