@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/dist/web/writes.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Panel write service (plan 11 P3) — the ONLY write path of the web panel.
+ *
+ * Scope guards (all enforced here, not by convention):
+ *  - D29 allowlist: every operation declares the tables it touches against
+ *    PANEL_WRITABLE_TABLES; `project_state` is reachable only through the
+ *    restore path's epoch bookkeeping. All panel writes MUST run through
+ *    runPanelWrite — no naked statements outside it in this module.
+ *  - D22 transaction shape: busy_timeout + short BEGIN IMMEDIATE + bounded
+ *    BUSY retry. Failures roll the whole transaction back (no partial writes).
+ *  - D21 CAS: optimistic concurrency on the SEMANTIC snapshot
+ *    (status + category + normalized content hash — never updated_at).
+ *  - D19/D20/D24 restore: current content stays (no beforeImage rollback);
+ *    expired / superseded / merge-canonical rows are refused inside the
+ *    transaction; success = guarded UPDATE + one 'update' mutation-log row +
+ *    project_state epoch UPSERT. FTS stays in sync via the production
+ *    triggers — guarded-UPDATE results are checked with `changes >= 1`
+ *    (trigger-fired writes inflate `changes`; see
+ *    scripts/restore-maintenance-archives.ts:364-368).
+ *  - D23: the restore result always carries the deferred-visibility notice —
+ *    storage-effective now, prompt-visible at the next natural HARD fold.
+ */
+import type { Memory } from "../features/magic-context/memory/types";
+import { Database } from "../shared/sqlite";
+export declare const PANEL_WRITABLE_TABLES: readonly ["memories", "memory_mutation_log", "project_state", "memory_verifications"];
+export declare const WRITE_TABLES_BY_OPERATION: {
+    readonly edit: readonly ["memories", "memory_mutation_log", "memory_verifications"];
+    readonly archive: readonly ["memories", "memory_mutation_log"];
+    readonly restore: readonly ["memories", "memory_mutation_log", "project_state"];
+};
+export type PanelWriteOperation = keyof typeof WRITE_TABLES_BY_OPERATION;
+export declare class PanelWriteError extends Error {
+    readonly code: string;
+    readonly status: number;
+    readonly extra: Record<string, unknown> | undefined;
+    constructor(code: string, status: number, extra: Record<string, unknown> | undefined, message: string);
+}
+export interface PanelWriteRetryOptions {
+    attempts: number;
+    busyTimeoutMs: number;
+    sleepMs: number;
+}
+export declare const DEFAULT_WRITE_RETRY: PanelWriteRetryOptions;
+/**
+ * Run one panel write as a short IMMEDIATE transaction with bounded BUSY
+ * retry. The operation name selects the allowlist entry; anything outside
+ * PANEL_WRITABLE_TABLES is refused before any SQL runs (declaration check),
+ * and the body's db is an execution-time proxy that re-checks every mutating
+ * statement against the SAME declared set (S1, gate review).
+ */
+export declare function runPanelWrite<T>(db: Database, operation: PanelWriteOperation, body: (guardedDb: Database) => T, retry?: PanelWriteRetryOptions): T;
+export declare function openContextStoreWrite(dbPath: string): {
+    status: {
+        kind: "ok";
+    };
+    db: Database;
+} | {
+    status: {
+        kind: string;
+        detail?: string;
+        persistedVersion?: number;
+        latestSupportedVersion?: number;
+    };
+    db: undefined;
+};
+export interface PanelSemanticSnapshot {
+    status: string;
+    category: string;
+    contentHash: string;
+}
+export declare function semanticSnapshotOf(memory: Memory): PanelSemanticSnapshot;
+export interface PanelWriteInput {
+    memoryId: number;
+    projectPath: string;
+    expected: PanelSemanticSnapshot;
+}
+export interface PanelEditInput extends PanelWriteInput {
+    content?: string;
+    category?: string;
+    importance?: number;
+}
+export declare function editMemoryForPanel(db: Database, input: PanelEditInput, retry?: PanelWriteRetryOptions): Record<string, unknown>;
+export declare function archiveMemoryForPanel(db: Database, input: PanelWriteInput, retry?: PanelWriteRetryOptions): Record<string, unknown>;
+export declare const RESTORE_VISIBILITY_NOTICE = "\u6062\u590D\u5DF2\u7ACB\u5373\u5199\u5165\u5B58\u50A8\uFF1B\u73B0\u5F79\u4F1A\u8BDD\u7684\u63D0\u793A\u8BCD\u8981\u7B49\u4E0B\u4E00\u6B21\u81EA\u7136 HARD fold \u624D\u4F1A\u5305\u542B\u8FD9\u6761\u8BB0\u5FC6\uFF08\u4E0D\u4F1A\u5F3A\u5236\u5237\u65B0\u7F13\u5B58\uFF09\u3002";
+export declare function restoreMemoryForPanel(db: Database, input: PanelWriteInput, retry?: PanelWriteRetryOptions): Record<string, unknown>;
+//# sourceMappingURL=writes.d.ts.map

package/dist/web/writes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writes.d.ts","sourceRoot":"","sources":["../../src/web/writes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAMH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wCAAwC,CAAC;AAMrE,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAK5C,eAAO,MAAM,qBAAqB,uFAKxB,CAAC;AAEX,eAAO,MAAM,yBAAyB;;;;CAI5B,CAAC;AAEX,MAAM,MAAM,mBAAmB,GAAG,MAAM,OAAO,yBAAyB,CAAC;AAEzE,qBAAa,eAAgB,SAAQ,KAAK;IAElC,QAAQ,CAAC,IAAI,EAAE,MAAM;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS;gBAF1C,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EACnD,OAAO,EAAE,MAAM;CAItB;AAcD,MAAM,WAAW,sBAAsB;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,eAAO,MAAM,mBAAmB,EAAE,sBAIjC,CAAC;AAWF;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAC3B,EAAE,EAAE,QAAQ,EACZ,SAAS,EAAE,mBAAmB,EAC9B,IAAI,EAAE,CAAC,SAAS,EAAE,QAAQ,KAAK,CAAC,EAChC,KAAK,GAAE,sBAA4C,GACpD,CAAC,CA+EH;AAKD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAC9C;IAAE,MAAM,EAAE;QAAE,IAAI,EAAE,IAAI,CAAA;KAAE,CAAC;IAAC,EAAE,EAAE,QAAQ,CAAA;CAAE,GACxC;IACI,MAAM,EAAE;QACJ,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,gBAAgB,CAAC,EAAE,MAAM,CAAC;QAC1B,sBAAsB,CAAC,EAAE,MAAM,CAAC;KACnC,CAAC;IACF,EAAE,EAAE,SAAS,CAAC;CACjB,CA0DN;AAKD,MAAM,WAAW,qBAAqB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,qBAAqB,CAMxE;AAoBD,MAAM,WAAW,eAAe;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,qBAAqB,CAAC;CACnC;AAkDD,MAAM,WAAW,cAAe,SAAQ,eAAe;IACnD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,kBAAkB,CAC9B,EAAE,EAAE,QAAQ,EACZ,KAAK,EAAE,cAAc,EACrB,KAAK,GAAE,sBAA4C,GACpD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA8EzB;AAKD,wBAAgB,qBAAqB,CACjC,EAAE,EAAE,QAAQ,EACZ,KAAK,EAAE,eAAe,EACtB,KAAK,GAAE,sBAA4C,GACpD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAoCzB;AAKD,eAAO,MAAM,yBAAyB,wRACuB,CAAC;AAE9D,wBAAgB,qBAAqB,CACjC,EAAE,EAAE,QAAQ,EACZ,KAAK,EAAE,eAAe,EACtB,KAAK,GAAE,sBAA4C,GACpD,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA8EzB"}

package/dist/wrapup-orchestrator-z9sqpqjf.js

@@ -0,0 +1,420 @@
+import {
+  sessionLog
+} from "./index-qbkzdkk0.js";
+import {
+  COMPARTMENT_LEASE_RENEWAL_MS,
+  acquireCompartmentLease,
+  renewCompartmentLease,
+  releaseCompartmentLeaseBestEffort,
+  getCompartments,
+  getLastCompartmentEndMessage,
+  getWrapupInProgressState,
+  acquireWrapupInProgress,
+  updateWrapupInProgress,
+  releaseWrapupInProgress,
+  getHistorianFailureState,
+  clearEmergencyRecovery,
+  describeBoundaryDiagnostics,
+  resolveWrapupProtectedTailBoundary,
+  hasRunnableCompartmentWindow,
+  runCompartmentAgent,
+  getActiveCompartmentRun,
+  markActiveCompartmentRunPublished,
+  registerActiveCompartmentRun
+} from "./index-by6h2pav.js";
+import"./index-fg34g6a5.js";
+import"./index-wgt4gamw.js";
+import"./index-977gxfz0.js";
+import"./index-3wagyrnj.js";
+import {
+  pushNotification2
+} from "./index-jdxxq8cz.js";
+import"./index-zx63j2e2.js";
+import"./index-53g38ggt.js";
+import {
+  sendStatusNotification2
+} from "./index-5pg0acf7.js";
+import {
+  setRecompStarting2,
+  setRecompTerminal2
+} from "./index-1vs6anwz.js";
+import"./index-e1q8002h.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";
+  let timer;
+  const timedOut = new Promise((resolve) => {
+    timer = setTimeout(() => resolve("timeout"), timeoutMs);
+  });
+  try {
+    return await Promise.race([
+      promise.then(() => "settled", () => "settled"),
+      timedOut
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function formatAlreadyRunningMessage(state) {
+  if (!state)
+    return "/mmc-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 `/mmc-wrapup is already running for this session${chunk}${through}. Wait for it to finish, then run /mmc-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 /mmc-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,
+    historianExpandTools: ctx.historianExpandTools,
+    memoryEnabled: ctx.memoryEnabled,
+    autoPromote: ctx.autoPromote,
+    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").promise.catch(() => {});
+  try {
+    await runnerPromise;
+    return { ran: true };
+  } finally {
+    clearInterval(renewal);
+    releaseCompartmentLeaseBestEffort(ctx.db, sessionId, leaseHolderId, sessionLog);
+  }
+}
+async function runManagedWrapup(ctx, sessionId, options) {
+  const messagesToKeep = Math.max(1, Math.floor(options.messagesToKeep));
+  setRecompStarting2(ctx.liveSessionState, sessionId, "Estimating wrapup…", "wrapup");
+  try {
+    return await runStartedWrapup(ctx, sessionId, messagesToKeep);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    setRecompTerminal2(ctx.liveSessionState, sessionId, "failed", `Wrapup stopped: ${reason}. Run /mmc-wrapup again to continue.`);
+    throw error;
+  }
+}
+async function runStartedWrapup(ctx, sessionId, messagesToKeep) {
+  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 /mmc-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 {
+  runManagedWrapup
+};

package/index.js

@@ -0,0 +1 @@
+export { default } from "./dist/index.js";

package/package.json

@@ -1,6 +1,86 @@
 {
   "name": "@retaw106/mmc-oc",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.2.2",
+  "type": "module",
+  "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": "ualtinok",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/retaw106/moon-magic-context.git",
+    "directory": "packages/plugin"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "context",
+    "memory",
+    "ai",
+    "llm",
+    "prompt-caching",
+    "session-history"
+  ],
+  "files": [
+    "dist",
+    "index.js",
+    "src/shared",
+    "src/config",
+    "src/agents",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "bun ../../scripts/check-bun.mjs && bun ../../scripts/clean-dist-chunks.mjs dist index.js && rm -rf dist/web && bun build src/index.ts --outdir dist --target node --format esm --splitting --external @opencode-ai/plugin --external bun:sqlite --external node:sqlite && bun run build:v2 && bun run build:web && tsc --emitDeclarationOnly",
+    "build:v2": "bun build src/v2/server.ts --outfile dist/v2/server.js --target node --format esm --external @opencode/plugin && bun test src/v2/server.test.ts",
+    "build:web": "bun build src/web/main.ts --outfile dist/web/main.js --target node --format esm --external bun:sqlite --external node:sqlite && mkdir -p dist/web/ui && cp src/web/ui/* dist/web/ui/",
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.scripts.json",
+    "test": "bun ../../scripts/check-bun.mjs && bun install --frozen-lockfile && bun test --parallel=4 --timeout 30000",
+    "test:serial": "bun install --frozen-lockfile && bun test --timeout 30000",
+    "test:parallel:probe": "bun scripts/verify-parallel-db-isolation.ts",
+    "lint": "bun ../../scripts/check-bun.mjs && biome check .",
+    "lint:fix": "biome check --write .",
+    "format": "biome format --write .",
+    "format:check": "biome format .",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.17.11",
+    "@opencode-ai/sdk": "^1.17.11",
+    "ai-tokenizer": "^1.0.6",
+    "comment-json": "^5.0.0",
+    "jsonc-parser": "^3.3.1",
+    "zod": "^4.1.8"
+  },
+  "devDependencies": {
+    "@opencode/plugin": "2.0.22",
+    "@opencode/ai": "2.0.22",
+    "@opencode/cli": "2.0.22",
+    "@opencode/client": "2.0.22",
+    "effect": "4.0.0-rc.112",
+    "@ai-sdk/anthropic": "3.0.82",
+    "@ai-sdk/openai-compatible": "2.0.41",
+    "@biomejs/biome": "^2.5.1",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/bun": "^1.3.10",
+    "@types/node": "^22.20.0",
+    "bun-types": "^1.3.10",
+    "typescript": "^5.8.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "oc-plugin": [
+    "server"
+  ],
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.15.0"
+  }
+}

package/src/agents/historian.ts

@@ -0,0 +1,3 @@
+export const HISTORIAN_AGENT = "historian";
+export const HISTORIAN_RECOMP_AGENT = "historian-recomp";
+export const HISTORIAN_EDITOR_AGENT = "historian-editor";