@cortexkit/opencode-magic-context 0.42.6 → 0.43.0

package/dist/{index-s61hh7gv.js → index-rpz2me0v.js}

@@ -3,7 +3,7 @@ import {
 } from "./index-qp20p2py.js";
 import {
   sendStatusNotification2
-} from "./index-ngjmj6xx.js";
+} from "./index-rvwvdq59.js";
 import {
   readJsoncFile
 } from "./index-sd3egckz.js";
@@ -20,28 +20,25 @@ import { join as join2 } from "node:path";
 // src/shared/opencode-config-dir.ts
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
-function getCliConfigDir() {
-  const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
-  if (envConfigDir) {
-    return resolve(envConfigDir);
-  }
+function resolveHomeDir() {
+  return process.env.HOME?.trim() || homedir();
+}
+function getOpenCodeGlobalConfigDir() {
   if (process.platform === "win32") {
-    return join(homedir(), ".config", "opencode");
+    return join(resolveHomeDir(), ".config", "opencode");
   }
-  return join(process.env.XDG_CONFIG_HOME || join(homedir(), ".config"), "opencode");
+  return join(process.env.XDG_CONFIG_HOME || join(resolveHomeDir(), ".config"), "opencode");
 }
-function getOpenCodeConfigDir(_options) {
-  return getCliConfigDir();
+function getEnvConfigDir() {
+  const envConfigDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+  return envConfigDir ? resolve(envConfigDir) : undefined;
 }
-function getOpenCodeConfigPaths(options) {
-  const configDir = getOpenCodeConfigDir(options);
-  return {
-    configDir,
-    configJson: join(configDir, "opencode.json"),
-    configJsonc: join(configDir, "opencode.jsonc"),
-    packageJson: join(configDir, "package.json"),
-    omoConfig: join(configDir, "magic-context.jsonc")
-  };
+function getOpenCodeConfigDirs() {
+  const dirs = [getOpenCodeGlobalConfigDir(), join(resolveHomeDir(), ".opencode")];
+  const envDir = getEnvConfigDir();
+  if (envDir)
+    dirs.push(envDir);
+  return [...new Set(dirs)];
 }
 
 // src/shared/conflict-detector.ts
@@ -130,11 +127,11 @@ async function resolveCompactionForBoot(client, timeoutMs = 2000, hostGeneration
         ...buffer === undefined ? {} : { buffer }
       };
     }
-    if (typeof compaction?.auto !== "boolean" || typeof compaction?.prune !== "boolean") {
-      log(`[magic-context] conflict-detector: resolved config carried no explicit compaction block (${JSON.stringify(compaction) ?? "absent"}); falling back to file-based detection`);
+    if (typeof compaction?.auto !== "boolean") {
+      log(`[magic-context] conflict-detector: resolved config carried no explicit compaction.auto (${JSON.stringify(compaction) ?? "absent"}); falling back to file-based detection`);
       return null;
     }
-    return { auto: compaction.auto, prune: compaction.prune };
+    return { auto: compaction.auto, prune: compaction.prune === true };
   } catch {
     return null;
   } finally {
@@ -146,47 +143,69 @@ function checkCompaction(directory, hostGeneration) {
   if (process.env.OPENCODE_DISABLE_AUTOCOMPACT) {
     return { auto: false, prune: false };
   }
-  const projectResult = readProjectCompaction(directory, hostGeneration);
-  if (projectResult.resolved)
-    return projectResult;
-  const userResult = readUserCompaction(hostGeneration);
-  if (userResult.resolved)
-    return userResult;
-  return { auto: true, prune: false };
-}
-function readProjectCompaction(directory, hostGeneration) {
-  const dotOcJsonc = join2(directory, ".opencode", "opencode.jsonc");
-  const dotOcJson = join2(directory, ".opencode", "opencode.json");
-  const dotOcConfig = readJsoncFile(dotOcJsonc) ?? readJsoncFile(dotOcJson);
-  if (dotOcConfig?.compaction) {
-    const c = dotOcConfig.compaction;
-    if (c.auto !== undefined || hostGeneration === "v1" && c.prune !== undefined || hostGeneration === "v2" && (c.keep?.tokens !== undefined || c.buffer !== undefined)) {
-      return resolvedCompactionBlock(c, hostGeneration);
-    }
+  const merged = readCompactionFromConfigFiles(directory, hostGeneration);
+  if (isRelevantCompactionBlock(merged, hostGeneration)) {
+    return resolvedCompactionBlock(merged, hostGeneration);
   }
-  const rootJsonc = join2(directory, "opencode.jsonc");
-  const rootJson = join2(directory, "opencode.json");
-  const rootConfig = readJsoncFile(rootJsonc) ?? readJsoncFile(rootJson);
-  if (rootConfig?.compaction) {
-    const c = rootConfig.compaction;
-    if (c.auto !== undefined || hostGeneration === "v1" && c.prune !== undefined || hostGeneration === "v2" && (c.keep?.tokens !== undefined || c.buffer !== undefined)) {
-      return resolvedCompactionBlock(c, hostGeneration);
-    }
-  }
-  return { auto: false, prune: false, resolved: false };
+  log("[magic-context] conflict-detector: no OpenCode config file carried an explicit compaction block; treating native compaction as inconclusive (not disabling the plugin)");
+  return { auto: false, prune: false };
 }
-function readUserCompaction(hostGeneration) {
-  try {
-    const paths = getOpenCodeConfigPaths({ binary: "opencode" });
-    const config = readJsoncFile(paths.configJsonc) ?? readJsoncFile(paths.configJson);
-    if (config?.compaction) {
-      const c = config.compaction;
-      if (c.auto !== undefined || hostGeneration === "v1" && c.prune !== undefined || hostGeneration === "v2" && (c.keep?.tokens !== undefined || c.buffer !== undefined)) {
-        return resolvedCompactionBlock(c, hostGeneration);
-      }
-    }
-  } catch {}
-  return { auto: false, prune: false, resolved: false };
+function openCodeConfigFileChain(directory, hostGeneration) {
+  const globalDir = getOpenCodeGlobalConfigDir();
+  const wellKnown = [
+    join2(globalDir, "config.json"),
+    join2(globalDir, "opencode.json"),
+    join2(globalDir, "opencode.jsonc")
+  ];
+  const globalSupplementary = getOpenCodeConfigDirs().filter((dir) => dir !== globalDir).flatMap((dir) => [join2(dir, "opencode.json"), join2(dir, "opencode.jsonc")]);
+  const explicitConfig = process.env.OPENCODE_CONFIG?.trim();
+  const explicit = explicitConfig ? [explicitConfig] : [];
+  const direct = [join2(directory, "opencode.json"), join2(directory, "opencode.jsonc")];
+  const projectSupplementary = [
+    join2(directory, ".opencode", "opencode.json"),
+    join2(directory, ".opencode", "opencode.jsonc")
+  ];
+  const files = hostGeneration === "v2" ? [
+    ...wellKnown,
+    ...globalSupplementary,
+    ...explicit,
+    ...direct,
+    ...projectSupplementary
+  ] : [
+    ...wellKnown,
+    ...explicit,
+    ...direct,
+    ...projectSupplementary,
+    ...globalSupplementary
+  ];
+  return [...new Set(files)];
+}
+function readCompactionFromConfigFiles(directory, hostGeneration) {
+  const merged = {};
+  for (const filePath of openCodeConfigFileChain(directory, hostGeneration)) {
+    let block;
+    try {
+      block = readJsoncFile(filePath)?.compaction;
+    } catch {}
+    if (!block || typeof block !== "object")
+      continue;
+    if (block.auto !== undefined)
+      merged.auto = block.auto;
+    if (block.prune !== undefined)
+      merged.prune = block.prune;
+    if (block.buffer !== undefined)
+      merged.buffer = block.buffer;
+    if (block.keep !== undefined)
+      merged.keep = { ...merged.keep, ...block.keep };
+  }
+  return merged;
+}
+function isRelevantCompactionBlock(block, hostGeneration) {
+  if (block.auto !== undefined)
+    return true;
+  if (hostGeneration === "v1")
+    return block.prune !== undefined;
+  return block.keep?.tokens !== undefined || block.buffer !== undefined;
 }
 function resolvedCompactionBlock(block, hostGeneration) {
   if (hostGeneration === "v2") {
@@ -241,10 +260,13 @@ function collectPluginEntries(directory) {
     pushFrom(config?.plugin);
   }
   try {
-    const paths = getOpenCodeConfigPaths({ binary: "opencode" });
-    for (const configPath of [paths.configJsonc, paths.configJson]) {
-      const config = readJsoncFile(configPath);
-      pushFrom(config?.plugin);
+    const globalDir = getOpenCodeGlobalConfigDir();
+    for (const dir of getOpenCodeConfigDirs()) {
+      const names = dir === globalDir ? ["config.json", "opencode.json", "opencode.jsonc"] : ["opencode.json", "opencode.jsonc"];
+      for (const name of names) {
+        const config = readJsoncFile(join2(dir, name));
+        pushFrom(config?.plugin);
+      }
     }
   } catch {}
   return plugins;
@@ -275,13 +297,13 @@ function readOmoDisabledHooks(directory) {
     "oh-my-openagent.json"
   ];
   try {
-    const paths = getOpenCodeConfigPaths({ binary: "opencode" });
-    for (const name of configNames) {
-      const configPath = join2(paths.configDir, name);
-      const config = readJsoncFile(configPath);
-      if (config?.disabled_hooks) {
-        for (const hook of config.disabled_hooks) {
-          disabled.add(hook);
+    for (const dir of getOpenCodeConfigDirs()) {
+      for (const name of configNames) {
+        const config = readJsoncFile(join2(dir, name));
+        if (config?.disabled_hooks) {
+          for (const hook of config.disabled_hooks) {
+            disabled.add(hook);
+          }
         }
       }
     }

package/dist/{index-ngjmj6xx.js → index-rvwvdq59.js}

@@ -3,7 +3,7 @@ import {
 } from "./index-qp20p2py.js";
 import {
   shouldHoldIgnoredNotification
-} from "./index-a9ssj59b.js";
+} from "./index-ykg9sdzz.js";
 
 // src/shared/error-message.ts
 function getErrorMessage(error) {

package/dist/index-w2ety11c.js

@@ -0,0 +1,393 @@
+import {
+  sessionLog
+} from "./index-qp20p2py.js";
+import {
+  COMPARTMENT_LEASE_RENEWAL_MS,
+  acquireCompartmentLease,
+  renewCompartmentLease,
+  releaseCompartmentLeaseBestEffort,
+  getCompartments,
+  getLastCompartmentEndMessage,
+  getWrapupInProgressState,
+  acquireWrapupInProgress,
+  updateWrapupInProgress,
+  releaseWrapupInProgress,
+  getHistorianFailureState,
+  clearEmergencyRecovery,
+  describeBoundaryDiagnostics,
+  resolveWrapupProtectedTailBoundary,
+  hasRunnableCompartmentWindow,
+  runCompartmentAgent,
+  getActiveCompartmentRun,
+  markActiveCompartmentRunPublished,
+  registerActiveCompartmentRun,
+  setRecompStarting2,
+  setRecompTerminal2
+} from "./index-d0dh7v0f.js";
+import {
+  pushNotification2
+} from "./index-jdxxq8cz.js";
+import {
+  sendStatusNotification2
+} from "./index-rvwvdq59.js";
+
+// src/hooks/magic-context/wrapup-orchestrator.ts
+import * as crypto from "node:crypto";
+var WAIT_FOR_LEASE_MS = 1000;
+var MAX_WRAPUP_LEASE_WAIT_MS = 10 * 60 * 1000;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function plural(value, word) {
+  return `${value} ${word}${value === 1 ? "" : "s"}`;
+}
+function resolveWrapupLeaseWaitTimeout(ctx) {
+  const configured = ctx.wrapupLeaseWaitTimeoutMs ?? MAX_WRAPUP_LEASE_WAIT_MS;
+  return Number.isFinite(configured) && configured >= 0 ? configured : MAX_WRAPUP_LEASE_WAIT_MS;
+}
+async function waitForActiveRunWithin(promise, timeoutMs) {
+  if (timeoutMs <= 0)
+    return "timeout";
+  return Promise.race([
+    promise.then(() => "settled", () => "settled"),
+    sleep(timeoutMs).then(() => "timeout")
+  ]);
+}
+function formatAlreadyRunningMessage(state) {
+  if (!state)
+    return "/ctx-wrapup is already running for this session.";
+  const chunk = state.expectedChunks > 0 ? ` chunk ${state.chunkIndex}/${state.expectedChunks}` : "";
+  const through = state.lastCompartmentEnd > 0 ? ` through message ${state.lastCompartmentEnd}` : "";
+  return `/ctx-wrapup is already running for this session${chunk}${through}. Wait for it to finish, then run /ctx-wrapup again if more history remains.`;
+}
+function appendFlushHint(ctx, sessionId, message) {
+  if (ctx.hasPendingNaturalBust?.(sessionId))
+    return message;
+  return `${message} If you want it applied on the very next message, run /ctx-flush first.`;
+}
+function buildPlan(ctx, sessionId, messagesToKeep, anchorRawMessageCount) {
+  return resolveWrapupProtectedTailBoundary({
+    db: ctx.db,
+    sessionId,
+    mode: "manual-wrapup",
+    contextLimit: ctx.contextLimit,
+    executeThresholdPercentage: ctx.executeThresholdPercentage,
+    usage: null,
+    usageSource: "manual-none",
+    providerShapeVersion: "opencode-v1",
+    cacheNamespace: `opencode:${sessionId}`,
+    messagesToKeep,
+    anchorRawMessageCount
+  });
+}
+function emitWrapupProgress(ctx, sessionId, progress) {
+  const current = ctx.liveSessionState.recompProgressBySession.get(sessionId);
+  ctx.liveSessionState.recompProgressBySession.set(sessionId, {
+    sessionId,
+    kind: "wrapup",
+    phase: "recomp",
+    processedMessages: progress.processedMessages ?? current?.processedMessages ?? 0,
+    totalMessages: progress.totalMessages ?? current?.totalMessages ?? 0,
+    passCount: progress.passCount ?? current?.passCount ?? 0,
+    compartmentsCreated: progress.compartmentsCreated ?? current?.compartmentsCreated ?? 0,
+    startedAt: current?.startedAt ?? Date.now(),
+    updatedAt: Date.now(),
+    note: progress.note
+  });
+}
+async function waitForExistingIncrementalRun(sessionId, maxWaitMs) {
+  const active = getActiveCompartmentRun(sessionId);
+  if (!active)
+    return "ok";
+  if (active.kind === "recomp" || active.kind === "wrapup")
+    return "busy";
+  const outcome = await waitForActiveRunWithin(active.promise, maxWaitMs);
+  if (outcome === "timeout")
+    return "timeout";
+  return "ok";
+}
+async function acquireCompartmentLeaseForWrapup(ctx, sessionId, renewWrapupMarker) {
+  const holderId = crypto.randomUUID();
+  const waitStartedAt = Date.now();
+  const maxWaitMs = resolveWrapupLeaseWaitTimeout(ctx);
+  const remainingMs = () => Math.max(0, waitStartedAt + maxWaitMs - Date.now());
+  for (;; ) {
+    if (remainingMs() <= 0) {
+      sessionLog(sessionId, "wrapup: timed out waiting for the compartment-state lease");
+      return { ok: false, reason: "timeout" };
+    }
+    const active = getActiveCompartmentRun(sessionId);
+    if (active?.kind === "recomp" || active?.kind === "wrapup") {
+      return { ok: false, reason: "busy" };
+    }
+    if (active) {
+      emitWrapupProgress(ctx, sessionId, { note: "Waiting for the active historian run…" });
+      const outcome = await waitForActiveRunWithin(active.promise, remainingMs());
+      if (outcome === "timeout") {
+        sessionLog(sessionId, "wrapup: timed out waiting for the active historian run");
+        return { ok: false, reason: "timeout" };
+      }
+      continue;
+    }
+    const lease = acquireCompartmentLease(ctx.db, sessionId, holderId);
+    if (lease)
+      return { ok: true, holderId };
+    emitWrapupProgress(ctx, sessionId, { note: "Waiting for the compartment-state lease…" });
+    if (!renewWrapupMarker({}))
+      return { ok: false, reason: "ownership_lost" };
+    await sleep(Math.min(WAIT_FOR_LEASE_MS, remainingMs()));
+  }
+}
+async function runOneWrapupIteration(args) {
+  const { ctx, sessionId, plan, messagesToKeep, anchorRawMessageCount } = args;
+  const acquired = await acquireCompartmentLeaseForWrapup(ctx, sessionId, args.renewWrapupMarker);
+  if (!acquired.ok)
+    return { ran: false, reason: acquired.reason };
+  const leaseHolderId = acquired.holderId;
+  const renewal = setInterval(() => {
+    try {
+      if (!renewCompartmentLease(ctx.db, sessionId, leaseHolderId)) {
+        sessionLog(sessionId, "wrapup: compartment lease renewal failed");
+      }
+    } catch (err) {
+      sessionLog(sessionId, `wrapup: compartment lease renewal threw; continuing (${err instanceof Error ? err.message : String(err)})`);
+    }
+  }, COMPARTMENT_LEASE_RENEWAL_MS);
+  const runCompartmentAgentForWrapup = ctx.runCompartmentAgentForWrapup ?? runCompartmentAgent;
+  const runnerPromise = runCompartmentAgentForWrapup({
+    client: ctx.client,
+    hiddenCompletionExecutor: ctx.hiddenCompletionExecutor,
+    db: ctx.db,
+    sessionId,
+    historianChunkTokens: ctx.historianChunkTokens,
+    historianTimeoutMs: ctx.historianTimeoutMs,
+    boundarySnapshot: plan.snapshot,
+    currentContextLimit: ctx.contextLimit,
+    directory: ctx.directory,
+    model: ctx.historianModel,
+    fallbackModels: ctx.fallbackModels,
+    fallbackModelId: ctx.fallbackModelId,
+    language: ctx.language,
+    historianTwoPass: ctx.historianTwoPass,
+    memoryEnabled: ctx.memoryEnabled,
+    autoPromote: ctx.autoPromote,
+    experimentalUserMemories: ctx.userMemoriesEnabled,
+    ensureProjectRegistered: ctx.ensureProjectRegistered,
+    getNotificationParams: () => ctx.getNotificationParams(sessionId),
+    preserveInjectionCacheUntilConsumed: true,
+    compartmentLeaseHolderId: leaseHolderId,
+    forceDrainQuota: true,
+    forceKeepLastCompartment: plan.snapshot.eligibleEndOrdinal >= plan.targetEligibleEndOrdinal,
+    refreshBoundarySnapshot: () => buildPlan(ctx, sessionId, messagesToKeep, anchorRawMessageCount).snapshot,
+    onCompartmentStatePublished: (sid) => {
+      markActiveCompartmentRunPublished(sid);
+      ctx.liveSessionState.deferredHistoryRefreshSessions.add(sid);
+      ctx.liveSessionState.deferredMaterializationSessions.add(sid);
+    },
+    onDeferredMarkerPending: (sid) => {
+      ctx.liveSessionState.deferredHistoryRefreshSessions.add(sid);
+    }
+  });
+  registerActiveCompartmentRun(sessionId, runnerPromise, "wrapup");
+  try {
+    await runnerPromise;
+    return { ran: true };
+  } finally {
+    clearInterval(renewal);
+    releaseCompartmentLeaseBestEffort(ctx.db, sessionId, leaseHolderId, sessionLog);
+  }
+}
+async function runManagedWrapup2(ctx, sessionId, options) {
+  const messagesToKeep = Math.max(1, Math.floor(options.messagesToKeep));
+  setRecompStarting2(ctx.liveSessionState, sessionId, "Estimating wrapup…", "wrapup");
+  const existingWrapup = getWrapupInProgressState(ctx.db, sessionId);
+  if (existingWrapup) {
+    const message = formatAlreadyRunningMessage(existingWrapup);
+    setRecompTerminal2(ctx.liveSessionState, sessionId, "skipped", message);
+    return `## Magic Wrapup — Skipped
+
+${message}`;
+  }
+  const initialPlan = buildPlan(ctx, sessionId, messagesToKeep);
+  if (initialPlan.rawMessagesAboveLastCompartment <= messagesToKeep || !hasRunnableCompartmentWindow(initialPlan.snapshot)) {
+    const message = `Nothing to wrap up — only ${initialPlan.rawMessagesAboveLastCompartment} messages above the last compartment.`;
+    setRecompTerminal2(ctx.liveSessionState, sessionId, "done", message);
+    return message;
+  }
+  const expectedChunks = Math.max(1, Math.ceil(initialPlan.snapshot.trueRawEligibleTokens / Math.max(1, ctx.historianChunkTokens)));
+  const wrapupHolderId = crypto.randomUUID();
+  const acquired = acquireWrapupInProgress(ctx.db, sessionId, {
+    holderId: wrapupHolderId,
+    messagesToKeep,
+    anchorRawMessageCount: initialPlan.anchorRawMessageCount,
+    targetEligibleEndOrdinal: initialPlan.targetEligibleEndOrdinal,
+    lastCompartmentEnd: getLastCompartmentEndMessage(ctx.db, sessionId),
+    chunkIndex: 0,
+    expectedChunks
+  });
+  if (!acquired.ok) {
+    const message = formatAlreadyRunningMessage(acquired.state);
+    setRecompTerminal2(ctx.liveSessionState, sessionId, "skipped", message);
+    return `## Magic Wrapup — Skipped
+
+${message}`;
+  }
+  const startLastEnd = getLastCompartmentEndMessage(ctx.db, sessionId);
+  const startCompartmentCount = getCompartments(ctx.db, sessionId).length;
+  let chunkIndex = 0;
+  let lastEnd = startLastEnd;
+  let stoppedForFailure = false;
+  let stoppedReason = "";
+  let ownershipLost = false;
+  const ownershipLostReason = "another process took over this session's wrapup.";
+  const markOwnershipLost = () => {
+    if (ownershipLost)
+      return;
+    ownershipLost = true;
+    sessionLog(sessionId, "wrapup: durable marker ownership lost; aborting loop");
+  };
+  const renewWrapupMarker = (updates) => {
+    const updated = updateWrapupInProgress(ctx.db, sessionId, wrapupHolderId, updates);
+    if (!updated) {
+      markOwnershipLost();
+      return false;
+    }
+    return true;
+  };
+  const markerRenewal = setInterval(() => {
+    try {
+      renewWrapupMarker({
+        lastCompartmentEnd: getLastCompartmentEndMessage(ctx.db, sessionId),
+        chunkIndex
+      });
+    } catch (err) {
+      sessionLog(sessionId, `wrapup: marker renewal threw; continuing (${err instanceof Error ? err.message : String(err)})`);
+    }
+  }, 60000);
+  markerRenewal.unref?.();
+  try {
+    const activeAtStart = await waitForExistingIncrementalRun(sessionId, resolveWrapupLeaseWaitTimeout(ctx));
+    if (activeAtStart === "busy") {
+      const message = "Another Magic Context rebuild is already running for this session.";
+      setRecompTerminal2(ctx.liveSessionState, sessionId, "skipped", message);
+      return `## Magic Wrapup — Skipped
+
+${message}`;
+    }
+    if (activeAtStart === "timeout") {
+      stoppedForFailure = true;
+      stoppedReason = "Timed out waiting for the active historian run.";
+    }
+    if (!stoppedForFailure) {
+      try {
+        sendStatusNotification2(ctx.client, sessionId, `Magic Wrapup started — compacting about ${plural(expectedChunks, "chunk")} of history. This can take a few minutes; the result posts here when done.`, ctx.getNotificationParams(sessionId));
+      } catch {}
+      try {
+        pushNotification2("action", { action: "wrapup-progress-kick" }, sessionId);
+      } catch {}
+    }
+    if (!stoppedForFailure && ownershipLost) {
+      stoppedForFailure = true;
+      stoppedReason = ownershipLostReason;
+    } else if (!stoppedForFailure) {
+      emitWrapupProgress(ctx, sessionId, {
+        processedMessages: Math.max(0, lastEnd),
+        totalMessages: Math.max(0, initialPlan.targetEligibleEndOrdinal - 1),
+        passCount: 0,
+        compartmentsCreated: 0,
+        note: `Eligible ${plural(initialPlan.snapshot.trueRawEligibleTokens, "token")} across about ${plural(expectedChunks, "chunk")}.`
+      });
+      for (;; ) {
+        if (ownershipLost) {
+          stoppedForFailure = true;
+          stoppedReason = ownershipLostReason;
+          break;
+        }
+        if (!renewWrapupMarker({
+          lastCompartmentEnd: getLastCompartmentEndMessage(ctx.db, sessionId),
+          chunkIndex,
+          expectedChunks
+        })) {
+          stoppedForFailure = true;
+          stoppedReason = ownershipLostReason;
+          break;
+        }
+        const plan = buildPlan(ctx, sessionId, messagesToKeep, initialPlan.anchorRawMessageCount);
+        lastEnd = getLastCompartmentEndMessage(ctx.db, sessionId);
+        if (lastEnd + 1 >= plan.targetEligibleEndOrdinal)
+          break;
+        chunkIndex += 1;
+        sessionLog(sessionId, `wrapup chunk ${chunkIndex}: ${describeBoundaryDiagnostics(plan.snapshot)}`);
+        emitWrapupProgress(ctx, sessionId, {
+          processedMessages: Math.max(0, lastEnd),
+          totalMessages: Math.max(0, plan.targetEligibleEndOrdinal - 1),
+          passCount: chunkIndex - 1,
+          compartmentsCreated: Math.max(0, getCompartments(ctx.db, sessionId).length - startCompartmentCount),
+          note: `Chunk ${chunkIndex}/${expectedChunks}: messages ${plan.snapshot.offset}-${plan.snapshot.eligibleEndOrdinal - 1}…`
+        });
+        if (!renewWrapupMarker({
+          lastCompartmentEnd: lastEnd,
+          chunkIndex,
+          expectedChunks,
+          targetEligibleEndOrdinal: plan.targetEligibleEndOrdinal
+        })) {
+          stoppedForFailure = true;
+          stoppedReason = ownershipLostReason;
+          break;
+        }
+        const beforeEnd = lastEnd;
+        const beforeFailures = getHistorianFailureState(ctx.db, sessionId).failureCount;
+        const iteration = await runOneWrapupIteration({
+          ctx,
+          sessionId,
+          plan,
+          messagesToKeep,
+          anchorRawMessageCount: initialPlan.anchorRawMessageCount,
+          renewWrapupMarker
+        });
+        if (!iteration.ran) {
+          stoppedForFailure = true;
+          stoppedReason = ownershipLost || iteration.reason === "ownership_lost" ? ownershipLostReason : iteration.reason === "timeout" ? "Timed out waiting for another process to release the compartment-state lease." : "Another Magic Context rebuild started while wrapup was waiting.";
+          break;
+        }
+        const afterEnd = getLastCompartmentEndMessage(ctx.db, sessionId);
+        const afterFailures = getHistorianFailureState(ctx.db, sessionId).failureCount;
+        if (afterEnd <= beforeEnd) {
+          stoppedForFailure = true;
+          stoppedReason = afterFailures > beforeFailures ? "The historian failed on the current chunk." : "The historian made no forward progress on the current chunk.";
+          break;
+        }
+        lastEnd = afterEnd;
+        emitWrapupProgress(ctx, sessionId, {
+          processedMessages: Math.max(0, lastEnd),
+          totalMessages: Math.max(0, plan.targetEligibleEndOrdinal - 1),
+          passCount: chunkIndex,
+          compartmentsCreated: Math.max(0, getCompartments(ctx.db, sessionId).length - startCompartmentCount),
+          note: `Wrapped through message ${lastEnd}.`
+        });
+      }
+    }
+  } finally {
+    clearInterval(markerRenewal);
+    releaseWrapupInProgress(ctx.db, sessionId, wrapupHolderId);
+  }
+  const finalEnd = getLastCompartmentEndMessage(ctx.db, sessionId);
+  const compartmentsCreated = Math.max(0, getCompartments(ctx.db, sessionId).length - startCompartmentCount);
+  const messagesWrapped = Math.max(0, finalEnd - Math.max(0, startLastEnd));
+  if (stoppedForFailure) {
+    const message = `Wrapped up through message ${Math.max(0, finalEnd)} (${plural(messagesWrapped, "message")} into ${plural(compartmentsCreated, "compartment")}). ${stoppedReason} Run /ctx-wrapup again to continue.`;
+    setRecompTerminal2(ctx.liveSessionState, sessionId, "failed", message);
+    return `## Magic Wrapup — Partial
+
+${message}`;
+  }
+  try {
+    clearEmergencyRecovery(ctx.db, sessionId);
+  } catch {}
+  const base = `Wrapped up ${messagesWrapped} messages into ${compartmentsCreated} compartments. The compacted history is queued and materializes on your next message.`;
+  const message = appendFlushHint(ctx, sessionId, base);
+  setRecompTerminal2(ctx.liveSessionState, sessionId, "done", message);
+  return message;
+}
+
+export { runManagedWrapup2 };