@makerbi/remodex 3.1.0 → 3.3.0

package/src/thread-activity-store.js

@@ -0,0 +1,325 @@
+// FILE: thread-activity-store.js
+// Purpose: Owns Activity snapshots, revisions, opt-in delivery, and bounded retention.
+// Layer: CLI helper
+// Exports: createThreadActivityStore
+// Depends on: crypto
+
+const { randomUUID } = require("crypto");
+
+const ACTIVITY_SCHEMA_VERSION = 1;
+const ACTIVITY_SUBSCRIBE_METHOD = "remodex/activity/subscribe";
+const ACTIVITY_UNSUBSCRIBE_METHOD = "remodex/activity/unsubscribe";
+const ACTIVITY_UPDATED_METHOD = "remodex/activity/updated";
+const DEFAULT_MAX_INACTIVE_ENTRIES = 200;
+const DEFAULT_COALESCE_MS = 225;
+
+function createThreadActivityStore({
+  sendApplicationResponse,
+  createEpoch = randomUUID,
+  maxInactiveEntries = DEFAULT_MAX_INACTIVE_ENTRIES,
+  coalesceMs = DEFAULT_COALESCE_MS,
+  setTimeoutFn = setTimeout,
+  clearTimeoutFn = clearTimeout,
+  onEvict = () => {},
+} = {}) {
+  const epoch = createEpoch();
+  const entriesByThreadId = new Map();
+  const serializedEntriesByThreadId = new Map();
+  const pendingUpsertsByThreadId = new Map();
+  const pendingRemovedThreadIds = new Set();
+  let revision = 0;
+  let deliveredRevision = 0;
+  let subscribed = false;
+  let flushTimer = null;
+  let disposed = false;
+
+  function handleRequest(message) {
+    if (disposed) {
+      return false;
+    }
+    if (message?.method === ACTIVITY_SUBSCRIBE_METHOD) {
+      handleSubscribe(message);
+      return true;
+    }
+    if (message?.method === ACTIVITY_UNSUBSCRIBE_METHOD) {
+      handleUnsubscribe(message);
+      return true;
+    }
+    return false;
+  }
+
+  function handleSubscribe(message) {
+    if (!validRequest(message)) {
+      sendInvalidParams(message?.id);
+      return;
+    }
+    clearPendingDelivery();
+    sendResponse(message.id, snapshot());
+    deliveredRevision = revision;
+    subscribed = true;
+  }
+
+  function handleUnsubscribe(message) {
+    if (!validRequest(message)) {
+      sendInvalidParams(message?.id);
+      return;
+    }
+    resetSubscriber();
+    sendResponse(message.id, { schemaVersion: ACTIVITY_SCHEMA_VERSION });
+  }
+
+  function upsert(entry) {
+    if (disposed || !validEntry(entry)) {
+      return false;
+    }
+    const previous = entriesByThreadId.get(entry.threadId) || null;
+    const serialized = JSON.stringify(entry);
+    if (serializedEntriesByThreadId.get(entry.threadId) === serialized) {
+      return false;
+    }
+
+    entriesByThreadId.delete(entry.threadId);
+    entriesByThreadId.set(entry.threadId, entry);
+    serializedEntriesByThreadId.set(entry.threadId, serialized);
+    const removedThreadIds = evictInactiveEntries();
+    commitChanges({
+      upserts: [entry],
+      removedThreadIds,
+      urgent: isUrgentChange(previous, entry) || removedThreadIds.length > 0,
+    });
+    return true;
+  }
+
+  function remove(threadId, { source = "" } = {}) {
+    const entry = entriesByThreadId.get(threadId);
+    if (!entry || (source && entry.source !== source)) {
+      return false;
+    }
+    entriesByThreadId.delete(threadId);
+    serializedEntriesByThreadId.delete(threadId);
+    commitChanges({ removedThreadIds: [threadId], urgent: true });
+    return true;
+  }
+
+  function markSourceStale(source, sourceGeneration = null) {
+    const staleEntries = [];
+    for (const entry of entriesByThreadId.values()) {
+      if (entry.source !== source
+          || (sourceGeneration != null && entry.sourceGeneration !== sourceGeneration)
+          || entry.freshness === "stale") {
+        continue;
+      }
+      staleEntries.push({ ...entry, freshness: "stale" });
+    }
+    if (staleEntries.length === 0) {
+      return false;
+    }
+    for (const entry of staleEntries) {
+      entriesByThreadId.set(entry.threadId, entry);
+      serializedEntriesByThreadId.set(entry.threadId, JSON.stringify(entry));
+    }
+    commitChanges({ upserts: staleEntries, urgent: true });
+    return true;
+  }
+
+  function resetSubscriber() {
+    subscribed = false;
+    clearPendingDelivery();
+    deliveredRevision = revision;
+  }
+
+  function dispose() {
+    disposed = true;
+    resetSubscriber();
+    entriesByThreadId.clear();
+    serializedEntriesByThreadId.clear();
+  }
+
+  function snapshot() {
+    return {
+      schemaVersion: ACTIVITY_SCHEMA_VERSION,
+      epoch,
+      revision,
+      coverage: "observedThreads",
+      entries: [...entriesByThreadId.values()]
+        .slice()
+        .sort((left, right) => left.threadId.localeCompare(right.threadId)),
+    };
+  }
+
+  function evictInactiveEntries() {
+    let inactiveCount = [...entriesByThreadId.values()].filter(isInactiveEntry).length;
+    const removedThreadIds = [];
+    if (inactiveCount <= maxInactiveEntries) {
+      return removedThreadIds;
+    }
+    for (const [threadId, entry] of entriesByThreadId) {
+      if (!isInactiveEntry(entry)) {
+        continue;
+      }
+      entriesByThreadId.delete(threadId);
+      serializedEntriesByThreadId.delete(threadId);
+      removedThreadIds.push(threadId);
+      onEvict(threadId, entry.source);
+      inactiveCount -= 1;
+      if (inactiveCount <= maxInactiveEntries) {
+        break;
+      }
+    }
+    return removedThreadIds;
+  }
+
+  function commitChanges({ upserts = [], removedThreadIds = [], urgent = false }) {
+    revision += 1;
+    if (!subscribed) {
+      return;
+    }
+    for (const entry of upserts) {
+      pendingRemovedThreadIds.delete(entry.threadId);
+      pendingUpsertsByThreadId.set(entry.threadId, entry);
+    }
+    for (const threadId of removedThreadIds) {
+      pendingUpsertsByThreadId.delete(threadId);
+      pendingRemovedThreadIds.add(threadId);
+    }
+    if (urgent) {
+      flushPendingDelivery();
+    } else {
+      scheduleFlush();
+    }
+  }
+
+  function scheduleFlush() {
+    if (flushTimer) {
+      return;
+    }
+    flushTimer = setTimeoutFn(flushPendingDelivery, coalesceMs);
+    flushTimer?.unref?.();
+  }
+
+  function flushPendingDelivery() {
+    clearFlushTimer();
+    if (!subscribed || !hasPendingDelivery()) {
+      return;
+    }
+    const notification = {
+      method: ACTIVITY_UPDATED_METHOD,
+      params: {
+        schemaVersion: ACTIVITY_SCHEMA_VERSION,
+        epoch,
+        baseRevision: deliveredRevision,
+        revision,
+        upserts: [...pendingUpsertsByThreadId.values()]
+          .sort((left, right) => left.threadId.localeCompare(right.threadId)),
+        removedThreadIds: [...pendingRemovedThreadIds].sort(),
+      },
+    };
+    clearPendingCollections();
+    deliveredRevision = revision;
+    sendApplicationResponse(JSON.stringify(notification));
+  }
+
+  function clearPendingDelivery() {
+    clearFlushTimer();
+    clearPendingCollections();
+  }
+
+  function clearPendingCollections() {
+    pendingUpsertsByThreadId.clear();
+    pendingRemovedThreadIds.clear();
+  }
+
+  function clearFlushTimer() {
+    if (!flushTimer) {
+      return;
+    }
+    clearTimeoutFn(flushTimer);
+    flushTimer = null;
+  }
+
+  function hasPendingDelivery() {
+    return pendingUpsertsByThreadId.size > 0 || pendingRemovedThreadIds.size > 0;
+  }
+
+  function sendResponse(id, result) {
+    if (id == null) {
+      return;
+    }
+    sendApplicationResponse(JSON.stringify({ id, result }));
+  }
+
+  function sendInvalidParams(id) {
+    if (id == null) {
+      return;
+    }
+    sendApplicationResponse(JSON.stringify({
+      id,
+      error: {
+        code: -32602,
+        message: "Activity requests support schemaVersion 1.",
+      },
+    }));
+  }
+
+  return {
+    get(threadId) { return entriesByThreadId.get(threadId) || null; },
+    dispose,
+    flush: flushPendingDelivery,
+    handleRequest,
+    markSourceStale,
+    remove,
+    resetSubscriber,
+    snapshot,
+    upsert,
+  };
+}
+
+function validRequest(message) {
+  if (message?.id == null) {
+    return false;
+  }
+  const params = message.params;
+  if (params == null) {
+    return true;
+  }
+  return typeof params === "object"
+    && !Array.isArray(params)
+    && (params.schemaVersion == null || params.schemaVersion === ACTIVITY_SCHEMA_VERSION);
+}
+
+function validEntry(entry) {
+  return entry
+    && typeof entry === "object"
+    && typeof entry.threadId === "string"
+    && entry.threadId.length > 0;
+}
+
+function isInactiveEntry(entry) {
+  return entry.runtime !== "active"
+    && entry.runningWithoutTurnId !== true
+    && entry.approvalRequired !== true
+    && entry.userInputRequired !== true;
+}
+
+function isUrgentChange(previous, next) {
+  if (!previous || previous.source !== next.source) {
+    return true;
+  }
+  return previous.runtime !== next.runtime
+    || previous.runningWithoutTurnId !== next.runningWithoutTurnId
+    || previous.approvalRequestCount !== next.approvalRequestCount
+    || previous.approvalRequired !== next.approvalRequired
+    || previous.userInputRequestCount !== next.userInputRequestCount
+    || previous.userInputRequired !== next.userInputRequired
+    || previous.freshness !== next.freshness
+    || JSON.stringify(previous.activeTurnIds) !== JSON.stringify(next.activeTurnIds)
+    || JSON.stringify(previous.lastOutcome) !== JSON.stringify(next.lastOutcome);
+}
+
+module.exports = {
+  ACTIVITY_SCHEMA_VERSION,
+  ACTIVITY_SUBSCRIBE_METHOD,
+  ACTIVITY_UNSUBSCRIBE_METHOD,
+  ACTIVITY_UPDATED_METHOD,
+  createThreadActivityStore,
+};

package/src/thread-runtime-settings-store.js

@@ -9,7 +9,10 @@ const os = require("os");
 const path = require("path");
 const { forEachThreadRowInResponse } = require("./thread-row-enrichment");
 
-const STORE_VERSION = 1;
+const { randomUUID } = require("crypto");
+const { runtimeSettingsPatch, runtimeSettingsFromConversation } = require("./codex-runtime-settings");
+
+const STORE_VERSION = 2;
 const DEFAULT_MAX_THREADS = 500;
 const DEFAULT_MAX_AGE_MS = 180 * 24 * 60 * 60 * 1_000;
 const DEFAULT_STORE_DIR = path.join(os.homedir(), ".remodex");
@@ -21,6 +24,8 @@ function createThreadRuntimeSettingsStore({
   now = () => Date.now(),
   maxThreads = DEFAULT_MAX_THREADS,
   maxAgeMs = DEFAULT_MAX_AGE_MS,
+  onChange = () => {},
+  onError = (error) => console.warn(`[remodex] runtime settings persistence failed: ${error.message}`),
 } = {}) {
   let state = readState({ storeFile, fsImpl });
 
@@ -29,26 +34,24 @@ function createThreadRuntimeSettingsStore({
     if (!normalizedThreadId) {
       return null;
     }
-    return cloneSettings(state.threads[normalizedThreadId]);
+    const settings = state.threads[normalizedThreadId];
+    return settings?.confirmed ? cloneSettings(settings) : null;
   }
 
   function commit(threadId, turnParams, { source = "unknown", turnId = "" } = {}) {
     const normalizedThreadId = normalizeString(threadId);
     const nextSource = normalizeString(source) || "unknown";
-    // Runtime choices are intentionally one-way: the phone may configure the
-    // runtime that executes its turn, while Desktop choices stay local.
-    if (!normalizedThreadId || nextSource !== "phone") {
+    if (!normalizedThreadId || !["phone", "desktop", "runtime"].includes(nextSource)) {
       return null;
     }
-    const previous = state.threads[normalizedThreadId] || null;
-    const nextValues = runtimeSettingsFromTurnParams(turnParams, previous);
-    if (!nextValues.model && !nextValues.reasoningEffort && !previous) {
+    const previous = get(normalizedThreadId);
+    const nextValues = runtimeSettingsFromTurnParams(turnParams, previous, { authoritative: source === "runtime" });
+    if (Object.keys(nextValues).length === 0) {
       return null;
     }
 
     const normalizedTurnId = normalizeString(turnId);
     if (previous
-      && previous.turnId === normalizedTurnId
       && previous.model === nextValues.model
       && previous.reasoningEffort === nextValues.reasoningEffort
       && previous.serviceTier === nextValues.serviceTier) {
@@ -56,20 +59,33 @@ function createThreadRuntimeSettingsStore({
     }
 
     const next = {
-      model: nextValues.model || null,
-      reasoningEffort: nextValues.reasoningEffort || null,
-      serviceTier: nextValues.serviceTier,
+      ...nextValues,
       revision: Math.max(0, Number(previous?.revision) || 0) + 1,
-      updatedAt: now(),
+      updatedAt: Math.max(now(), (previous?.updatedAt || 0) + 1),
+      epoch: previous?.epoch || randomUUID(),
+      confirmed: true,
       source: nextSource,
       turnId: normalizedTurnId || null,
     };
-    state.threads[normalizedThreadId] = next;
-    pruneState(state, { now: now(), maxThreads, maxAgeMs });
-    writeState(state, { storeFile, fsImpl });
+    const nextState = { ...state, threads: { ...state.threads, [normalizedThreadId]: next } };
+    pruneState(nextState, { now: now(), maxThreads, maxAgeMs });
+    writeState(nextState, { storeFile, fsImpl });
+    state = nextState;
+    onChange(normalizedThreadId, cloneSettings(next));
     return cloneSettings(next);
   }
 
+  // Unsolicited owner notifications must not interrupt the live event stream
+  // when the local settings cache cannot be written. A later snapshot retries.
+  function observe(threadId, settings, source = "runtime") {
+    try {
+      return commit(threadId, settings, { source });
+    } catch (error) {
+      onError(error);
+      return get(threadId);
+    }
+  }
+
   function attachToConversation(threadId, conversation) {
     if (!conversation || typeof conversation !== "object") {
       return conversation;
@@ -79,34 +95,6 @@ function createThreadRuntimeSettingsStore({
       return conversation;
     }
     conversation.remodexRuntimeSettings = settings;
-    if (settings.model) {
-      conversation.latestModel = settings.model;
-    }
-    if (settings.reasoningEffort) {
-      conversation.latestReasoningEffort = settings.reasoningEffort;
-    }
-    conversation.latestServiceTier = settings.serviceTier;
-    conversation.latestThreadSettings = {
-      ...(conversation.latestThreadSettings && typeof conversation.latestThreadSettings === "object"
-        ? conversation.latestThreadSettings
-        : {}),
-      model: settings.model,
-      effort: settings.reasoningEffort,
-      serviceTier: settings.serviceTier,
-    };
-    const collaborationSettings = conversation.latestCollaborationMode?.settings;
-    conversation.latestCollaborationMode = {
-      mode: conversation.latestCollaborationMode?.mode || "default",
-      settings: {
-        ...(collaborationSettings && typeof collaborationSettings === "object"
-          ? collaborationSettings
-          : { developer_instructions: null }),
-        model: settings.model || collaborationSettings?.model || "",
-        reasoning_effort: settings.reasoningEffort
-          || collaborationSettings?.reasoning_effort
-          || null,
-      },
-    };
     return conversation;
   }
 
@@ -120,9 +108,12 @@ function createThreadRuntimeSettingsStore({
     if (!settings || !thread || typeof thread !== "object") {
       return thread;
     }
-    thread.model = settings.model || thread.model || null;
-    thread.reasoningEffort = settings.reasoningEffort;
-    thread.serviceTier = settings.serviceTier;
+    thread.runtimeSettings = settings;
+    // Legacy phone fields remain readable, while the v2 object explicitly
+    // represents next-turn choices rather than an executing turn's metadata.
+    thread.model ||= settings.model;
+    if (Object.hasOwn(settings, "reasoningEffort")) thread.reasoningEffort = settings.reasoningEffort;
+    if (Object.hasOwn(settings, "serviceTier")) thread.serviceTier = settings.serviceTier === "priority" ? "fast" : settings.serviceTier;
     thread.runtimeSettingsRevision = settings.revision;
     thread.runtimeSettingsUpdatedAt = settings.updatedAt;
     thread.runtimeSettingsSource = settings.source;
@@ -132,31 +123,25 @@ function createThreadRuntimeSettingsStore({
   return {
     get,
     commit,
+    observe,
     attachToConversation,
     attachToThread,
     enrichResponse,
+    observeConversation(threadId, conversation) {
+      const patch = runtimeSettingsFromConversation(conversation);
+      if (!patch.model) return get(threadId);
+      const settings = observe(threadId, patch, "desktop");
+      attachToConversation(threadId, conversation);
+      return settings;
+    },
   };
 }
 
-function runtimeSettingsFromTurnParams(turnParams, previous = null) {
-  const params = turnParams && typeof turnParams === "object" ? turnParams : {};
-  const collaborationSettings = params.collaborationMode?.settings
-    || params.collaboration_mode?.settings
-    || {};
-  const model = normalizeString(params.model)
-    || normalizeString(collaborationSettings.model)
-    || normalizeString(previous?.model)
-    || null;
-  const reasoningEffort = normalizeString(params.effort)
-    || normalizeString(params.reasoningEffort)
-    || normalizeString(collaborationSettings.reasoning_effort)
-    || normalizeString(collaborationSettings.reasoningEffort)
-    || normalizeString(previous?.reasoningEffort)
-    || null;
-  const serviceTier = normalizeString(params.serviceTier)
-    || normalizeString(params.service_tier)
-    || null;
-  return { model, reasoningEffort, serviceTier };
+function runtimeSettingsFromTurnParams(turnParams, previous = null, options = {}) {
+  return {
+    ...runtimeSettingsPatch(previous || {}),
+    ...runtimeSettingsPatch(turnParams, options),
+  };
 }
 
 function readState({ storeFile, fsImpl }) {
@@ -164,7 +149,7 @@ function readState({ storeFile, fsImpl }) {
     const parsed = JSON.parse(fsImpl.readFileSync(storeFile, "utf8"));
     return normalizeState(parsed);
   } catch {
-    return { version: STORE_VERSION, threads: {} };
+    return { version: STORE_VERSION, epoch: randomUUID(), threads: {} };
   }
 }
 
@@ -173,25 +158,26 @@ function normalizeState(rawState) {
     ? rawState.threads
     : {};
   const threads = {};
+  const epoch = normalizeString(rawState?.epoch) || randomUUID();
   for (const [threadId, rawSettings] of Object.entries(rawThreads)) {
     const normalizedThreadId = normalizeString(threadId);
     const source = normalizeString(rawSettings?.source) || "unknown";
-    // Drop records written by older bidirectional builds so a Desktop choice
-    // cannot be replayed to the phone after upgrading.
-    if (!normalizedThreadId || !rawSettings || typeof rawSettings !== "object" || source !== "phone") {
+    if (!normalizedThreadId || !rawSettings || typeof rawSettings !== "object") {
       continue;
     }
     threads[normalizedThreadId] = {
-      model: normalizeString(rawSettings.model) || null,
-      reasoningEffort: normalizeString(rawSettings.reasoningEffort) || null,
-      serviceTier: normalizeString(rawSettings.serviceTier) || null,
+      ...runtimeSettingsFromTurnParams(rawSettings),
+      epoch: normalizeString(rawSettings.epoch) || epoch,
+      // Preserve old preferences on disk, but require fresh owner evidence
+      // before exposing them as confirmed runtime state.
+      confirmed: rawState.version === STORE_VERSION && rawSettings.confirmed === true,
       revision: Math.max(0, Number(rawSettings.revision) || 0),
       updatedAt: Math.max(0, Number(rawSettings.updatedAt) || 0),
       source,
       turnId: normalizeString(rawSettings.turnId) || null,
     };
   }
-  return { version: STORE_VERSION, threads };
+  return { version: STORE_VERSION, epoch, threads };
 }
 
 function pruneState(storeState, { now, maxThreads, maxAgeMs }) {