@retaw106/mmc-oc 0.0.0-stage → 1.2.1

package/dist/index-53g38ggt.js

@@ -0,0 +1,40 @@
+import {
+  log
+} from "./index-qbkzdkk0.js";
+
+// src/shared/safe-notification-target.ts
+var DEFAULT_TITLE_RE = /^(New session - |Child session - )\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+function isDefaultSessionTitle2(title) {
+  return DEFAULT_TITLE_RE.test(title);
+}
+async function readSessionTitle(client, sessionId) {
+  try {
+    const c = client;
+    if (typeof c.session?.get !== "function")
+      return null;
+    const raw = await Promise.resolve(c.session.get({ path: { id: sessionId } }));
+    const obj = raw;
+    const title = obj && typeof obj === "object" ? obj.data?.title ?? obj.title : undefined;
+    return typeof title === "string" ? title : null;
+  } catch {
+    return null;
+  }
+}
+async function waitForSafeNotificationTarget2(client, sessionId, options) {
+  const attempts = Math.max(1, options?.attempts ?? 4);
+  const delayMs = options?.delayMs ?? 15000;
+  for (let attempt = 0;attempt < attempts; attempt += 1) {
+    const title = await readSessionTitle(client, sessionId);
+    if (title === null)
+      return "safe";
+    if (!isDefaultSessionTitle2(title))
+      return "safe";
+    if (attempt < attempts - 1) {
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  log(`[magic-context] notification skipped: session ${sessionId} still has its default title (would suppress title generation); will retry on a later startup`);
+  return "skip";
+}
+
+export { isDefaultSessionTitle2, waitForSafeNotificationTarget2 };

package/dist/index-5pg0acf7.js

@@ -0,0 +1,410 @@
+import {
+  sessionLog
+} from "./index-qbkzdkk0.js";
+import {
+  shouldHoldIgnoredNotification
+} from "./index-977gxfz0.js";
+
+// src/shared/error-message.ts
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function readString(value) {
+  if (typeof value === "string" && value.length > 0)
+    return value;
+  if (typeof value === "number")
+    return String(value);
+  return;
+}
+function clip(value, max) {
+  if (value.length <= max)
+    return value;
+  return `${value.slice(0, max)}…`;
+}
+function describeError(error) {
+  const stringForm = clip(safeString(error), 400);
+  if (!(error instanceof Error) && !(error && typeof error === "object")) {
+    return {
+      name: typeof error,
+      message: "",
+      stringForm,
+      brief: stringForm || "<empty>"
+    };
+  }
+  const obj = error;
+  const nameFromField = readString(obj.name);
+  const nameFromCtor = error?.constructor?.name;
+  const name = nameFromField ?? nameFromCtor ?? "Error";
+  const message = readString(obj.message) ?? "";
+  const status = readString(obj.status) ?? readString(obj.statusCode);
+  const code = readString(obj.code);
+  let causeName;
+  const cause = obj.cause;
+  if (cause && typeof cause === "object") {
+    const causeRecord = cause;
+    causeName = readString(causeRecord.name) ?? cause.constructor?.name;
+  }
+  const stack = readString(obj.stack);
+  const stackHead = stack ? stack.split(`
+`).slice(0, 4).map((l) => l.trim()).filter((l) => l.length > 0).join(" | ") : undefined;
+  const briefParts = [];
+  if (name)
+    briefParts.push(name);
+  if (message)
+    briefParts.push(`message="${clip(message, 200)}"`);
+  if (status)
+    briefParts.push(`status=${status}`);
+  if (code)
+    briefParts.push(`code=${code}`);
+  if (causeName)
+    briefParts.push(`cause=${causeName}`);
+  if (!message && stringForm && stringForm !== name) {
+    briefParts.push(`str="${clip(stringForm, 200)}"`);
+  }
+  const brief = briefParts.join(" ") || stringForm || name;
+  return {
+    name,
+    message,
+    ...status ? { status } : {},
+    ...code ? { code } : {},
+    ...causeName ? { causeName } : {},
+    ...stackHead ? { stackHead } : {},
+    stringForm,
+    brief
+  };
+}
+function safeString(value) {
+  try {
+    return String(value);
+  } catch {
+    return "<unstringifiable>";
+  }
+}
+
+// src/hooks/magic-context/send-session-notification.ts
+var MAX_QUEUED_IGNORED_NOTIFICATIONS = 16;
+var queuedIgnoredNotifications = new Map;
+var flushingIgnoredNotifications = new Set;
+var idleSessions = new Set;
+var lastDeliveredText = new Map;
+var activityEpoch = new Map;
+var defaultHoldDetector = (sessionId) => !idleSessions.has(sessionId) || shouldHoldIgnoredNotification(sessionId);
+var holdDetector = defaultHoldDetector;
+var notificationServerUrl;
+var noticeDeleter;
+var notificationDiagnosticObserverForTests;
+function notificationDiagnostic(sessionId, message) {
+  notificationDiagnosticObserverForTests?.(message);
+  sessionLog(sessionId, message);
+}
+function queueIgnoredNotification(notification) {
+  const queued = queuedIgnoredNotifications.get(notification.sessionId) ?? [];
+  if (queued.at(-1)?.text === notification.text)
+    return;
+  queued.push(notification);
+  if (queued.length > MAX_QUEUED_IGNORED_NOTIFICATIONS) {
+    queued.splice(0, queued.length - MAX_QUEUED_IGNORED_NOTIFICATIONS);
+    sessionLog(notification.sessionId, `ignored notification queue full; dropped oldest entries (kept newest ${MAX_QUEUED_IGNORED_NOTIFICATIONS})`);
+  }
+  queuedIgnoredNotifications.set(notification.sessionId, queued);
+}
+function holdIgnoredNotification(notification, checkpoint) {
+  queueIgnoredNotification(notification);
+  notificationDiagnostic(notification.sessionId, `ignored notification held ${checkpoint} (session active); queued`);
+}
+async function trySendTuiToast(sessionId, text, params, forcePersist) {
+  if (forcePersist)
+    return false;
+  const title = extractToastTitle(text);
+  const message = text.length > 200 ? `${text.slice(0, 200)}…` : text;
+  const toastVariant = inferToastVariant(text);
+  const duration = params.toastDurationMs ?? 5000;
+  const { isTuiConnected: checkTui } = await import("./rpc-notifications-4amf6mf4.js");
+  if (!checkTui(sessionId))
+    return false;
+  try {
+    const { pushNotification } = await import("./rpc-notifications-4amf6mf4.js");
+    pushNotification("toast", {
+      title,
+      message,
+      variant: toastVariant,
+      duration
+    }, sessionId);
+    return true;
+  } catch {
+    sessionLog(sessionId, "TUI RPC toast enqueue failed, falling back to ignored message");
+    return false;
+  }
+}
+function notifyDelivered(sessionId, params) {
+  try {
+    params.onDelivered?.();
+  } catch (error) {
+    sessionLog(sessionId, "notification delivery callback failed:", getErrorMessage(error));
+  }
+}
+function hasNotificationSessionClient(client) {
+  if (client === null || typeof client !== "object")
+    return false;
+  const candidate = client;
+  if (candidate.session === undefined)
+    return true;
+  if (candidate.session === null || typeof candidate.session !== "object")
+    return false;
+  const session = candidate.session;
+  return (session.prompt === undefined || typeof session.prompt === "function") && (session.promptAsync === undefined || typeof session.promptAsync === "function");
+}
+function inferToastVariant(text) {
+  const lower = text.toLowerCase();
+  if (lower.includes("error") || lower.includes("failed") || lower.includes("alert"))
+    return "error";
+  if (lower.includes("warning") || lower.includes("⚠"))
+    return "warning";
+  if (lower.includes("complete") || lower.includes("success") || lower.includes("✓") || lower.includes("finished"))
+    return "success";
+  return "info";
+}
+function extractToastTitle(text) {
+  const headingMatch = text.match(/^#+\s+(.+)/m);
+  if (headingMatch)
+    return headingMatch[1].trim();
+  const firstLine = text.split(`
+`)[0].trim();
+  if (firstLine.length <= 80)
+    return firstLine;
+  return "Magic Context";
+}
+async function sendIgnoredMessageNow(client, sessionId, text, params, forcePersist) {
+  const epoch = activityEpoch.get(sessionId) ?? 0;
+  if (holdDetector(sessionId)) {
+    holdIgnoredNotification({ client, sessionId, text, params, forcePersist }, "during target checks");
+    return "queued";
+  }
+  const { waitForSafeNotificationTarget } = await import("./safe-notification-target-ph3xd1ve.js");
+  if (await waitForSafeNotificationTarget(client, sessionId) === "skip") {
+    sessionLog(sessionId, "notification skipped (session not titled yet)");
+    return "skipped";
+  }
+  if ((activityEpoch.get(sessionId) ?? 0) !== epoch)
+    return "skipped";
+  if (holdDetector(sessionId)) {
+    holdIgnoredNotification({ client, sessionId, text, params, forcePersist }, "during target checks");
+    return "queued";
+  }
+  if (!hasNotificationSessionClient(client)) {
+    sessionLog(sessionId, "session prompt API unavailable for notification");
+    return "failed";
+  }
+  const c = client;
+  let agent = params.agent || undefined;
+  let variant = params.variant || undefined;
+  let model = params.providerId && params.modelId ? { providerID: params.providerId, modelID: params.modelId } : undefined;
+  if (!agent || !model || !variant) {
+    try {
+      const { resolvePromptContext } = await import("./prompt-context-ffa5xcfx.js");
+      const resolved = await resolvePromptContext(client, sessionId);
+      if (resolved) {
+        agent = agent ?? resolved.agent;
+        model = model ?? resolved.model;
+        variant = variant ?? resolved.variant;
+      }
+    } catch {}
+  }
+  if ((activityEpoch.get(sessionId) ?? 0) !== epoch)
+    return "skipped";
+  if (holdDetector(sessionId)) {
+    holdIgnoredNotification({ client, sessionId, text, params, forcePersist }, "before append");
+    return "queued";
+  }
+  const input = {
+    path: { id: sessionId },
+    body: {
+      noReply: true,
+      agent,
+      model,
+      variant,
+      parts: [
+        {
+          type: "text",
+          text,
+          ignored: true
+        }
+      ]
+    }
+  };
+  try {
+    let result;
+    if (typeof c.session?.prompt === "function") {
+      result = await Promise.resolve(c.session.prompt(input));
+    } else if (typeof c.session?.promptAsync === "function") {
+      result = await c.session.promptAsync(input);
+    } else {
+      sessionLog(sessionId, "session prompt API unavailable for notification");
+      return "failed";
+    }
+    const messageId = extractPromptedMessageId(result);
+    if (await revertNoticeIfUnsafe({
+      client,
+      sessionId,
+      text,
+      params,
+      forcePersist,
+      messageId,
+      epoch
+    })) {
+      return "skipped";
+    }
+    lastDeliveredText.set(sessionId, text);
+    notifyDelivered(sessionId, params);
+    return "sent";
+  } catch (error) {
+    const msg = getErrorMessage(error);
+    sessionLog(sessionId, "failed to send notification:", msg);
+    return "failed";
+  }
+}
+function extractPromptedMessageId(result) {
+  if (result === null || typeof result !== "object")
+    return;
+  const root = result;
+  const data = root.data !== null && typeof root.data === "object" ? root.data : root;
+  const info = data.info !== null && typeof data.info === "object" ? data.info : data;
+  return typeof info.id === "string" && info.id.length > 0 ? info.id : undefined;
+}
+function getServerAuth() {
+  const password = process.env.OPENCODE_SERVER_PASSWORD;
+  if (!password)
+    return;
+  const username = process.env.OPENCODE_SERVER_USERNAME ?? "opencode";
+  return `Basic ${Buffer.from(`${username}:${password}`, "utf8").toString("base64")}`;
+}
+async function deleteNoticeMessage(sessionId, messageId) {
+  if (noticeDeleter)
+    return noticeDeleter(sessionId, messageId);
+  if (!notificationServerUrl) {
+    sessionLog(sessionId, "cannot roll back notice: no server URL for session.message.delete");
+    return false;
+  }
+  const url = `${notificationServerUrl}/session/${encodeURIComponent(sessionId)}/message/${encodeURIComponent(messageId)}`;
+  try {
+    const auth = getServerAuth();
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: auth ? { Authorization: auth } : {},
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      sessionLog(sessionId, `notice rollback DELETE failed status=${response.status} url=${url}`);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    sessionLog(sessionId, "notice rollback DELETE error:", getErrorMessage(error));
+    return false;
+  }
+}
+async function revertNoticeIfUnsafe(notification) {
+  const superseded = (activityEpoch.get(notification.sessionId) ?? 0) !== notification.epoch;
+  if (!superseded && !holdDetector(notification.sessionId))
+    return false;
+  if (notification.messageId) {
+    const deleted = await deleteNoticeMessage(notification.sessionId, notification.messageId);
+    if (deleted) {
+      notificationDiagnostic(notification.sessionId, `notice rolled back (deleted row ${notification.messageId}); consumed after append`);
+    } else {
+      sessionLog(notification.sessionId, "failed to roll back a notice that landed while a run was active");
+    }
+  } else {
+    sessionLog(notification.sessionId, "notice landed while a run was active but the new row id was not returned");
+  }
+  lastDeliveredText.set(notification.sessionId, notification.text);
+  return true;
+}
+async function sendIgnoredMessage2(client, sessionId, text, params, forcePersist = false) {
+  if (await trySendTuiToast(sessionId, text, params, forcePersist)) {
+    notifyDelivered(sessionId, params);
+    return "sent";
+  }
+  if (holdDetector(sessionId)) {
+    holdIgnoredNotification({ client, sessionId, text, params, forcePersist }, "before target checks");
+    return "queued";
+  }
+  if (lastDeliveredText.get(sessionId) === text)
+    return "sent";
+  return sendIgnoredMessageNow(client, sessionId, text, params, forcePersist);
+}
+async function flushIgnoredMessages2(sessionId) {
+  if (flushingIgnoredNotifications.has(sessionId))
+    return;
+  const queued = queuedIgnoredNotifications.get(sessionId);
+  if (!queued || queued.length === 0)
+    return;
+  if (holdDetector(sessionId))
+    return;
+  const epoch = activityEpoch.get(sessionId) ?? 0;
+  queuedIgnoredNotifications.delete(sessionId);
+  flushingIgnoredNotifications.add(sessionId);
+  try {
+    for (const notification of queued) {
+      if ((activityEpoch.get(sessionId) ?? 0) !== epoch)
+        break;
+      const disposition = await sendIgnoredMessage2(notification.client, notification.sessionId, notification.text, notification.params, notification.forcePersist);
+      if (disposition === "queued") {
+        for (const remaining of queued.slice(queued.indexOf(notification) + 1)) {
+          queueIgnoredNotification(remaining);
+        }
+        break;
+      }
+    }
+  } finally {
+    flushingIgnoredNotifications.delete(sessionId);
+  }
+}
+function clearIgnoredMessages2(sessionId) {
+  queuedIgnoredNotifications.delete(sessionId);
+  flushingIgnoredNotifications.delete(sessionId);
+  idleSessions.delete(sessionId);
+  lastDeliveredText.delete(sessionId);
+  activityEpoch.delete(sessionId);
+}
+function observeIgnoredNotificationEvent2(event) {
+  const record = (value) => value !== null && typeof value === "object" ? value : undefined;
+  const props = record(event.properties);
+  const info = record(props?.info);
+  const part = record(props?.part);
+  const sessionId = props?.sessionID ?? info?.sessionID ?? part?.sessionID;
+  if (typeof sessionId !== "string")
+    return;
+  if (event.type === "session.idle") {
+    idleSessions.add(sessionId);
+    return;
+  }
+  if (event.type === "session.deleted") {
+    clearIgnoredMessages2(sessionId);
+    return;
+  }
+  const active = event.type === "session.status" && record(props?.status)?.type !== "idle" || event.type === "message.updated" && info?.role === "assistant" || event.type === "message.part.updated" && part?.ignored !== true && part?.type !== "compaction";
+  if (!active)
+    return;
+  idleSessions.delete(sessionId);
+  activityEpoch.set(sessionId, (activityEpoch.get(sessionId) ?? 0) + 1);
+  queuedIgnoredNotifications.delete(sessionId);
+}
+async function sendStatusNotification2(_client, sessionId, text, params) {
+  try {
+    const { pushNotification } = await import("./rpc-notifications-4amf6mf4.js");
+    pushNotification("toast", {
+      title: extractToastTitle(text),
+      message: text,
+      variant: inferToastVariant(text),
+      duration: params.toastDurationMs ?? 5000
+    }, sessionId);
+    notifyDelivered(sessionId, params);
+    return "sent";
+  } catch (error) {
+    sessionLog(sessionId, "status RPC enqueue failed:", getErrorMessage(error));
+    return "failed";
+  }
+}
+
+export { getErrorMessage, describeError, sendIgnoredMessage2, flushIgnoredMessages2, clearIgnoredMessages2, observeIgnoredNotificationEvent2, sendStatusNotification2 };

package/dist/index-5s9w99sf.js

@@ -0,0 +1,126 @@
+import {
+  clearEmergencyRecovery,
+  dropSlot,
+  renderUserFacingFailure,
+  userFacingFailureCode,
+  executeContextRecomp
+} from "./index-xyjcjq10.js";
+import {
+  sessionLog
+} from "./index-qbkzdkk0.js";
+
+// src/hooks/magic-context/recomp-orchestrator.ts
+function resolveLiveModelKey(liveSessionState, sessionId) {
+  const model = liveSessionState.liveModelBySession.get(sessionId);
+  return model ? `${model.providerID}/${model.modelID}` : undefined;
+}
+function isRecompFailure(message) {
+  return /—\s*(Failed|Skipped)/.test(message);
+}
+function isRecompSkip(message) {
+  return /—\s*Skipped|already mutating compartment state|already running/i.test(message);
+}
+function extractRecompReason(raw) {
+  const meaningful = raw.split(`
+`).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#"));
+  return meaningful.join(" ").trim() || "Recomp finished";
+}
+var RECOMP_DONE_GRACE_MS = 30000;
+function setRecompStarting2(liveSessionState, sessionId, note, kind = "recomp") {
+  dropSlot(sessionId, "recomp-start");
+  liveSessionState.recompProgressBySession.set(sessionId, {
+    sessionId,
+    kind,
+    phase: "recomp",
+    processedMessages: 0,
+    totalMessages: 0,
+    passCount: 0,
+    compartmentsCreated: 0,
+    startedAt: Date.now(),
+    updatedAt: Date.now(),
+    note
+  });
+}
+function setRecompTerminal2(liveSessionState, sessionId, phase, message) {
+  const existing = liveSessionState.recompProgressBySession.get(sessionId);
+  liveSessionState.recompProgressBySession.set(sessionId, {
+    sessionId,
+    kind: existing?.kind ?? "recomp",
+    phase,
+    processedMessages: existing?.processedMessages ?? 0,
+    totalMessages: existing?.totalMessages ?? 0,
+    passCount: existing?.passCount ?? 0,
+    compartmentsCreated: existing?.compartmentsCreated ?? 0,
+    startedAt: existing?.startedAt ?? Date.now(),
+    updatedAt: Date.now(),
+    message
+  });
+  if (phase === "done" || phase === "skipped") {
+    const t = setTimeout(() => {
+      const cur = liveSessionState.recompProgressBySession.get(sessionId);
+      if (cur?.phase === phase)
+        liveSessionState.recompProgressBySession.delete(sessionId);
+    }, RECOMP_DONE_GRACE_MS);
+    t.unref?.();
+  }
+}
+function buildRecompDeps(ctx, sessionId) {
+  return {
+    client: ctx.client,
+    hiddenCompletionExecutor: ctx.hiddenCompletionExecutor,
+    db: ctx.db,
+    sessionId,
+    historianChunkTokens: ctx.historianChunkTokens,
+    historianTimeoutMs: ctx.historianTimeoutMs,
+    directory: ctx.directory,
+    memoryEnabled: ctx.memoryEnabled,
+    autoPromote: ctx.autoPromote,
+    model: ctx.historianModel,
+    historianContextLimit: ctx.historianContextLimit,
+    historianMaxOutputTokens: ctx.historianMaxOutputTokens,
+    fallbackModels: ctx.fallbackModels,
+    language: ctx.language,
+    fallbackModelId: ctx.fallbackModelId ?? resolveLiveModelKey(ctx.liveSessionState, sessionId),
+    historianTwoPass: ctx.historianTwoPass,
+    historianExpandTools: ctx.historianExpandTools,
+    ensureProjectRegistered: ctx.ensureProjectRegistered,
+    getNotificationParams: () => ctx.getNotificationParams(sessionId),
+    onCompartmentStatePublished: (sid) => {
+      ctx.liveSessionState.historyRefreshSessions.add(sid);
+      ctx.liveSessionState.pendingMaterializationSessions.add(sid);
+    },
+    onDeferredMarkerPending: (sid) => {
+      ctx.liveSessionState.deferredHistoryRefreshSessions.add(sid);
+    },
+    onRecompProgress: (p) => {
+      const prevKind = ctx.liveSessionState.recompProgressBySession.get(sessionId)?.kind ?? "recomp";
+      ctx.liveSessionState.recompProgressBySession.set(sessionId, {
+        ...p,
+        kind: p.kind ?? prevKind
+      });
+    }
+  };
+}
+async function runManagedRecomp2(ctx, sessionId, options) {
+  setRecompStarting2(ctx.liveSessionState, sessionId, "Starting recomp…", "recomp");
+  try {
+    const message = await executeContextRecomp(buildRecompDeps(ctx, sessionId), options);
+    const terminalPhase = isRecompSkip(message) ? "skipped" : isRecompFailure(message) ? "failed" : "done";
+    if (terminalPhase === "done") {
+      try {
+        clearEmergencyRecovery(ctx.db, sessionId);
+      } catch {}
+    }
+    setRecompTerminal2(ctx.liveSessionState, sessionId, terminalPhase, extractRecompReason(message));
+    return message;
+  } catch (error) {
+    const failure = renderUserFacingFailure("recomp_unavailable");
+    sessionLog(sessionId, `recomp failed code=${userFacingFailureCode("recomp_unavailable")}`, error);
+    setRecompTerminal2(ctx.liveSessionState, sessionId, "failed", failure);
+    return `## Magic Recomp — Failed
+
+${failure}`;
+  }
+}
+
+export { setRecompStarting2, setRecompTerminal2, runManagedRecomp2 };

package/dist/index-7dgv6pzg.js

@@ -0,0 +1,126 @@
+import {
+  clearEmergencyRecovery,
+  dropSlot,
+  renderUserFacingFailure,
+  userFacingFailureCode,
+  executeContextRecomp
+} from "./index-46j0tj1s.js";
+import {
+  sessionLog
+} from "./index-qbkzdkk0.js";
+
+// src/hooks/magic-context/recomp-orchestrator.ts
+function resolveLiveModelKey(liveSessionState, sessionId) {
+  const model = liveSessionState.liveModelBySession.get(sessionId);
+  return model ? `${model.providerID}/${model.modelID}` : undefined;
+}
+function isRecompFailure(message) {
+  return /—\s*(Failed|Skipped)/.test(message);
+}
+function isRecompSkip(message) {
+  return /—\s*Skipped|already mutating compartment state|already running/i.test(message);
+}
+function extractRecompReason(raw) {
+  const meaningful = raw.split(`
+`).map((l) => l.trim()).filter((l) => l.length > 0 && !l.startsWith("#"));
+  return meaningful.join(" ").trim() || "Recomp finished";
+}
+var RECOMP_DONE_GRACE_MS = 30000;
+function setRecompStarting2(liveSessionState, sessionId, note, kind = "recomp") {
+  dropSlot(sessionId, "recomp-start");
+  liveSessionState.recompProgressBySession.set(sessionId, {
+    sessionId,
+    kind,
+    phase: "recomp",
+    processedMessages: 0,
+    totalMessages: 0,
+    passCount: 0,
+    compartmentsCreated: 0,
+    startedAt: Date.now(),
+    updatedAt: Date.now(),
+    note
+  });
+}
+function setRecompTerminal2(liveSessionState, sessionId, phase, message) {
+  const existing = liveSessionState.recompProgressBySession.get(sessionId);
+  liveSessionState.recompProgressBySession.set(sessionId, {
+    sessionId,
+    kind: existing?.kind ?? "recomp",
+    phase,
+    processedMessages: existing?.processedMessages ?? 0,
+    totalMessages: existing?.totalMessages ?? 0,
+    passCount: existing?.passCount ?? 0,
+    compartmentsCreated: existing?.compartmentsCreated ?? 0,
+    startedAt: existing?.startedAt ?? Date.now(),
+    updatedAt: Date.now(),
+    message
+  });
+  if (phase === "done" || phase === "skipped") {
+    const t = setTimeout(() => {
+      const cur = liveSessionState.recompProgressBySession.get(sessionId);
+      if (cur?.phase === phase)
+        liveSessionState.recompProgressBySession.delete(sessionId);
+    }, RECOMP_DONE_GRACE_MS);
+    t.unref?.();
+  }
+}
+function buildRecompDeps(ctx, sessionId) {
+  return {
+    client: ctx.client,
+    hiddenCompletionExecutor: ctx.hiddenCompletionExecutor,
+    db: ctx.db,
+    sessionId,
+    historianChunkTokens: ctx.historianChunkTokens,
+    historianTimeoutMs: ctx.historianTimeoutMs,
+    directory: ctx.directory,
+    memoryEnabled: ctx.memoryEnabled,
+    autoPromote: ctx.autoPromote,
+    model: ctx.historianModel,
+    historianContextLimit: ctx.historianContextLimit,
+    historianMaxOutputTokens: ctx.historianMaxOutputTokens,
+    fallbackModels: ctx.fallbackModels,
+    language: ctx.language,
+    fallbackModelId: ctx.fallbackModelId ?? resolveLiveModelKey(ctx.liveSessionState, sessionId),
+    historianTwoPass: ctx.historianTwoPass,
+    historianExpandTools: ctx.historianExpandTools,
+    ensureProjectRegistered: ctx.ensureProjectRegistered,
+    getNotificationParams: () => ctx.getNotificationParams(sessionId),
+    onCompartmentStatePublished: (sid) => {
+      ctx.liveSessionState.historyRefreshSessions.add(sid);
+      ctx.liveSessionState.pendingMaterializationSessions.add(sid);
+    },
+    onDeferredMarkerPending: (sid) => {
+      ctx.liveSessionState.deferredHistoryRefreshSessions.add(sid);
+    },
+    onRecompProgress: (p) => {
+      const prevKind = ctx.liveSessionState.recompProgressBySession.get(sessionId)?.kind ?? "recomp";
+      ctx.liveSessionState.recompProgressBySession.set(sessionId, {
+        ...p,
+        kind: p.kind ?? prevKind
+      });
+    }
+  };
+}
+async function runManagedRecomp2(ctx, sessionId, options) {
+  setRecompStarting2(ctx.liveSessionState, sessionId, "Starting recomp…", "recomp");
+  try {
+    const message = await executeContextRecomp(buildRecompDeps(ctx, sessionId), options);
+    const terminalPhase = isRecompSkip(message) ? "skipped" : isRecompFailure(message) ? "failed" : "done";
+    if (terminalPhase === "done") {
+      try {
+        clearEmergencyRecovery(ctx.db, sessionId);
+      } catch {}
+    }
+    setRecompTerminal2(ctx.liveSessionState, sessionId, terminalPhase, extractRecompReason(message));
+    return message;
+  } catch (error) {
+    const failure = renderUserFacingFailure("recomp_unavailable");
+    sessionLog(sessionId, `recomp failed code=${userFacingFailureCode("recomp_unavailable")}`, error);
+    setRecompTerminal2(ctx.liveSessionState, sessionId, "failed", failure);
+    return `## Magic Recomp — Failed
+
+${failure}`;
+  }
+}
+
+export { setRecompStarting2, setRecompTerminal2, runManagedRecomp2 };