@cortexkit/opencode-magic-context 0.34.1 → 0.34.2

package/dist/index.js

@@ -138,6 +138,7 @@ import {
   getDroppedTagsBySession,
   getEmbeddingCoverageStatus,
   getEmergencyInputSample,
+  getEmergencyRecoveryArmedAt,
   getHistorianFailureState,
   getLastCompartmentEndMessage,
   getLastCompartmentEndMessageId,
@@ -279,6 +280,7 @@ import {
   recordHighPressureNoEligibleHead,
   recordMemoryMapping,
   recordMemoryVerifications,
+  recordMuralCueRejection,
   recordOverflowDetected,
   recordSessionProjectIdentity,
   recordToolDefinition,
@@ -372,7 +374,7 @@ import {
   upsertCommits,
   verificationFileExists,
   withContentLanguageDirective
-} from "./index-x8spt5wy.js";
+} from "./index-z70pxrq1.js";
 import {
   deriveHistorianChunkTokens,
   deriveTriggerBudget,
@@ -10469,6 +10471,15 @@ function formatFailClosedBlockingProcesses(processes) {
 }
 function formatFailClosedBlockingMessage(reason) {
   if (reason.kind === "migration_guard") {
+    if (reason.unreadableFile) {
+      const arm = reason.unreadableArm ?? "io";
+      const recovery = arm === "io" ? `If no OpenCode server is running, it is safe to delete ${reason.unreadableFile} and retry.` : `The file may be a recent incomplete write; retry after the file is older than the ten-minute grace window, or stop OpenCode before deleting it.`;
+      return [
+        `Magic Context cannot migrate the shared database because RPC discovery file ${reason.unreadableFile} is uncertain (${arm} arm), so the absence of a live OpenCode server cannot be proven.`,
+        recovery,
+        `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
+      ].join(" ");
+    }
     return [
       `Magic Context cannot migrate the shared database because ${formatFailClosedBlockingProcesses(reason.blockingProcesses)} may be running an older Magic Context build that would fail against the migrated database.`,
       "Restart the blocking process (it will pick up the new build and migrate on start), or shut it down and retry.",
@@ -12847,6 +12858,7 @@ function seedTaskScheduleState(db, projectPath, task, nextDueAt, lastRunAt, sche
   db.prepare("INSERT INTO task_schedule_state (project_path, task, last_run_at, next_due_at, schedule, last_status, last_error, retry_count) VALUES (?, ?, ?, ?, ?, NULL, NULL, 0) ON CONFLICT(project_path, task) DO NOTHING").run(projectPath, task, lastRunAt, nextDueAt, schedule);
 }
 function writeTaskScheduleState(db, row) {
+  const broadCycleUpdate = row.lastBroadRunAt === undefined ? "last_broad_run_at = task_schedule_state.last_broad_run_at" : "last_broad_run_at = excluded.last_broad_run_at";
   db.prepare(`INSERT INTO task_schedule_state
            (project_path, task, last_run_at, next_due_at, schedule, last_status, last_error, retry_count, last_checked_commit, last_broad_run_at, retrospective_watermark_ms)
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
@@ -12858,7 +12870,7 @@ function writeTaskScheduleState(db, row) {
            last_error           = excluded.last_error,
            retry_count          = excluded.retry_count,
            last_checked_commit  = COALESCE(excluded.last_checked_commit, task_schedule_state.last_checked_commit),
-           last_broad_run_at    = COALESCE(excluded.last_broad_run_at, task_schedule_state.last_broad_run_at),
+           ${broadCycleUpdate},
            retrospective_watermark_ms = COALESCE(excluded.retrospective_watermark_ms, task_schedule_state.retrospective_watermark_ms)`).run(row.projectPath, row.task, row.lastRunAt, row.nextDueAt, row.schedule, row.lastStatus, row.lastError, row.retryCount, row.lastCheckedCommit ?? null, row.lastBroadRunAt ?? null, row.retrospectiveWatermarkMs ?? null);
 }
 function isRetrospectiveWindowProcessed(db, projectPath, windowKey) {
@@ -12986,7 +12998,7 @@ function hasBalancedParentheses(cue) {
   }
   return depth === 0;
 }
-function validateCue(cue, importance) {
+function validateCue(cue, importance, ownId) {
   const trimmed = cue.trim();
   if (trimmed.length === 0)
     return { reason: "empty" };
@@ -12994,8 +13006,9 @@ function validateCue(cue, importance) {
   const length = [...trimmed].length;
   if (length > budget)
     return { reason: `over-budget ${length}>${budget}` };
-  if (/#\d+/.test(trimmed))
+  if (ownId !== undefined && new RegExp(`#${ownId}\\b`).test(trimmed)) {
     return { reason: "leaked-id" };
+  }
   if (!hasBalancedParentheses(trimmed))
     return { reason: "unbalanced-parens" };
   const markers = trimmed.split("⊘").length - 1;
@@ -13011,6 +13024,7 @@ function validateCue(cue, importance) {
 // src/features/magic-context/mural/compress-cues.ts
 var COMPRESS_CUES_CHUNK_SIZE = 40;
 var CHUNK_TIMEOUT_FLOOR_MS = 240000;
+var CUE_REJECTION_LATCH_THRESHOLD = 3;
 var CONSECUTIVE_TIMEOUT_LIMIT = 2;
 function toPromptMemory(candidate) {
   const memory = candidate.memory;
@@ -13021,6 +13035,38 @@ function toPromptMemory(candidate) {
     content: memory.content
   };
 }
+function stripOwnIdToken(value, ownId) {
+  return value.replace(new RegExp(`#${ownId}\\b`, "g"), "");
+}
+function truncateCue(value, budget) {
+  const trimmed = value.trim();
+  const codepoints = [...trimmed];
+  if (codepoints.length <= budget)
+    return trimmed;
+  const prefix = codepoints.slice(0, budget).join("");
+  const boundary = prefix.search(/\s+\S*$/);
+  return (boundary > 0 ? prefix.slice(0, boundary) : prefix).trim();
+}
+function sanitizeCue(value, candidate) {
+  return truncateCue(stripOwnIdToken(value, candidate.memory.id), cueBudgetFor(candidate.memory.importance ?? 50));
+}
+function deterministicFallbackCue(candidate, lastCandidate) {
+  const importance = candidate.memory.importance ?? 50;
+  const budget = cueBudgetFor(importance);
+  const sanitizedCandidate = sanitizeCue(lastCandidate, candidate);
+  if (validateCue(sanitizedCandidate, importance, candidate.memory.id) === null) {
+    return sanitizedCandidate;
+  }
+  const sourceSlice = sanitizeCue(candidate.memory.content, candidate);
+  if (validateCue(sourceSlice, importance, candidate.memory.id) === null) {
+    return sourceSlice;
+  }
+  const grammarSafe = truncateCue(sourceSlice.replaceAll("⊘", "").replace(/[()]/g, "").replace(/\b(?:must not|never|without|instead of|exclude|excludes)\b/gi, "").replace(/\s+/g, " "), budget);
+  if (validateCue(grammarSafe, importance, candidate.memory.id) === null) {
+    return grammarSafe;
+  }
+  return "memory";
+}
 function selectCandidates(db, projectIdentity) {
   const memories = getMemoriesByProject(db, projectIdentity, ["active", "permanent"]);
   const cueState = getMuralCueState(db, memories.map((memory) => memory.id));
@@ -13189,10 +13235,19 @@ function applyCues(args, chunk, manifestText) {
       const candidate = byId.get(entry.id);
       if (!candidate)
         throw new Error(`cues manifest contains unknown id ${entry.id}`);
-      const failure = validateCue(entry.cue, candidate.memory.importance ?? 50);
+      const importance = candidate.memory.importance ?? 50;
+      const failure = validateCue(entry.cue, importance, candidate.memory.id);
       if (failure) {
+        const rejectionCount = recordMuralCueRejection(args.db, args.projectIdentity, entry.id, candidate.contentHash);
+        if (rejectionCount >= CUE_REJECTION_LATCH_THRESHOLD) {
+          const fallback = deterministicFallbackCue(candidate, entry.cue);
+          setMuralCue(args.db, args.projectIdentity, entry.id, fallback, candidate.contentHash);
+          compressed += 1;
+          log(`[dreamer] compress-cues: fallback cue for memory ${entry.id} (${failure.reason}; ${rejectionCount} rejections; fallback)`);
+          continue;
+        }
         skipped += 1;
-        log(`[dreamer] compress-cues: skipped cue for memory ${entry.id} (${failure.reason})`);
+        log(`[dreamer] compress-cues: skipped cue for memory ${entry.id} (${failure.reason}; rejection ${rejectionCount}/${CUE_REJECTION_LATCH_THRESHOLD})`);
         continue;
       }
       setMuralCue(args.db, args.projectIdentity, entry.id, entry.cue.trim(), candidate.contentHash);
@@ -16954,6 +17009,19 @@ function countUnverifiedMappedMemories(db, projectPath) {
                 AND v.verified_at = 0`).get(projectPath);
   return row?.cnt ?? 0;
 }
+function countBroadCycleCandidates(db, projectPath, cycleStartAt) {
+  const row = db.prepare(`SELECT COUNT(*) AS cnt
+               FROM memories m
+              WHERE m.project_path = ?
+                AND m.status IN ('active','permanent')
+                AND (
+                    SELECT MAX(v.verified_at)
+                      FROM memory_verifications v
+                     WHERE v.memory_id = m.id
+                       AND v.file_path <> ''
+                ) < ?`).get(projectPath, cycleStartAt);
+  return row?.cnt ?? 0;
+}
 function countCueCandidates(db, projectPath) {
   if (!hasMuralCueColumns(db))
     return countActiveMemories(db, projectPath);
@@ -17009,7 +17077,9 @@ function getDreamTaskBacklog(db, projectPath, task, options = {}) {
     }
     case "verify-broad": {
       const total = countMappedMemories(db, projectPath);
-      return { pending: total, total };
+      const cycleStartAt = getTaskScheduleState(db, projectPath, "verify-broad")?.lastBroadRunAt;
+      const pending = cycleStartAt == null ? total : countBroadCycleCandidates(db, projectPath, cycleStartAt);
+      return { pending, total };
     }
     case "curate": {
       const total = countActiveMemories(db, projectPath);
@@ -17068,7 +17138,7 @@ function evaluateTaskGate(task, ctx) {
     case "verify":
       return countActiveMemories(db, project) > 0;
     case "verify-broad":
-      return countActiveMemories(db, project) > 0;
+      return getTaskScheduleState(db, project, "verify-broad")?.lastBroadRunAt != null || countActiveMemories(db, project) > 0;
     case "curate":
       return countActiveMemories(db, project) > 0;
     case "compress-cues":
@@ -17102,6 +17172,30 @@ import path4 from "node:path";
 function minOf(values) {
   return values.reduce((acc, v) => v < acc ? v : acc, Number.POSITIVE_INFINITY);
 }
+function ensureBroadCycleStart(args) {
+  const current = getTaskScheduleState(args.db, args.projectIdentity, "verify-broad");
+  if (current?.lastBroadRunAt != null && current.lastBroadRunAt > 0) {
+    return current.lastBroadRunAt;
+  }
+  if (!current)
+    return args.runStartedAt;
+  if (!args.holderId || !args.leaseKey) {
+    throw new Error("verify-broad cycle opening requires the task lease");
+  }
+  return runLeaseGuardedWrite(args.db, args.holderId, args.leaseKey, () => {
+    const latest = getTaskScheduleState(args.db, args.projectIdentity, "verify-broad");
+    if (!latest)
+      return args.runStartedAt;
+    if (latest.lastBroadRunAt != null && latest.lastBroadRunAt > 0) {
+      return latest.lastBroadRunAt;
+    }
+    writeTaskScheduleState(args.db, {
+      ...latest,
+      lastBroadRunAt: args.runStartedAt
+    });
+    return args.runStartedAt;
+  });
+}
 async function partitionVerifyScope(args) {
   const runStartedAt = args.now ?? Date.now();
   const active = getMemoriesByProject(args.db, args.projectIdentity);
@@ -17113,6 +17207,29 @@ async function partitionVerifyScope(args) {
     content: m.content,
     mappedFiles: verById.get(m.id)?.files ?? []
   });
+  if (args.forceBroad) {
+    const broadCycleStartAt = ensureBroadCycleStart({
+      db: args.db,
+      projectIdentity: args.projectIdentity,
+      holderId: args.holderId,
+      leaseKey: args.leaseKey,
+      runStartedAt
+    });
+    const broadCandidates = candidates.filter((m) => (verById.get(m.id)?.verifiedAt ?? 0) < broadCycleStartAt).sort((a, b) => {
+      const verifiedAtA = verById.get(a.id)?.verifiedAt ?? 0;
+      const verifiedAtB = verById.get(b.id)?.verifiedAt ?? 0;
+      return verifiedAtA - verifiedAtB || a.id - b.id;
+    });
+    return {
+      runStartedAt,
+      mode: "broad",
+      inScope: broadCandidates.map(toPrompt),
+      inScopeIds: broadCandidates.map((m) => m.id),
+      skippedIds: candidates.filter((m) => !broadCandidates.some((candidate) => candidate.id === m.id)).map((m) => m.id),
+      broadCycleStartAt,
+      reason: `broad cycle (${broadCandidates.length} remain; started ${broadCycleStartAt})`
+    };
+  }
   if (candidates.length === 0) {
     return {
       runStartedAt,
@@ -17123,16 +17240,6 @@ async function partitionVerifyScope(args) {
       reason: "no file-mapped memories in scope"
     };
   }
-  if (args.forceBroad) {
-    return {
-      runStartedAt,
-      mode: "broad",
-      inScope: candidates.map(toPrompt),
-      inScopeIds: candidates.map((m) => m.id),
-      skippedIds: [],
-      reason: "broad full-pool verification of file-mapped memories"
-    };
-  }
   const allInScope = (mode, reason) => ({
     runStartedAt,
     mode,
@@ -17251,7 +17358,25 @@ function parseVerifyManifest(text) {
 
 // src/features/magic-context/dreamer/verify.ts
 var VERIFY_BATCH_SIZE = 50;
+function closeBroadCycle(args, cycleStartAt) {
+  if (!args.forceBroad || cycleStartAt === undefined)
+    return;
+  if (!getTaskScheduleState(args.db, args.projectIdentity, "verify-broad"))
+    return;
+  runLeaseGuardedWrite(args.db, args.holderId, args.leaseKey, () => {
+    const current = getTaskScheduleState(args.db, args.projectIdentity, "verify-broad");
+    if (current?.lastBroadRunAt !== cycleStartAt)
+      return;
+    if (!current)
+      return;
+    writeTaskScheduleState(args.db, {
+      ...current,
+      lastBroadRunAt: null
+    });
+  });
+}
 async function runVerify(args) {
+  const runStartedAt = Date.now();
   const result = {
     verified: 0,
     updated: 0,
@@ -17266,14 +17391,20 @@ async function runVerify(args) {
     db: args.db,
     projectIdentity: args.projectIdentity,
     projectDirectory: args.sessionDirectory,
-    forceBroad: args.forceBroad
+    forceBroad: args.forceBroad,
+    now: runStartedAt,
+    holderId: args.holderId,
+    leaseKey: args.leaseKey
   });
   result.mode = gate.mode;
+  result.broadCycleStartAt = gate.broadCycleStartAt;
   result.inScope = gate.inScope.length;
   result.remaining = gate.inScope.length;
   log(`[dreamer] ${args.forceBroad ? "verify-broad" : "verify"} gate: mode=${gate.mode} in_scope=${gate.inScope.length} skipped=${gate.skippedIds.length} reason=${gate.reason}`);
-  if (gate.inScope.length === 0)
+  if (gate.inScope.length === 0) {
+    closeBroadCycle(args, gate.broadCycleStartAt);
     return result;
+  }
   const batches = [];
   for (let i = 0;i < gate.inScope.length; i += VERIFY_BATCH_SIZE) {
     batches.push(gate.inScope.slice(i, i + VERIFY_BATCH_SIZE));
@@ -17296,6 +17427,8 @@ async function runVerify(args) {
       args.onProgress?.(result.verified + result.updated + result.archived);
     }
     result.complete = result.remaining === 0;
+    if (result.complete)
+      closeBroadCycle(args, gate.broadCycleStartAt);
     log(`[dreamer] ${args.forceBroad ? "verify-broad" : "verify"}: verified=${result.verified} updated=${result.updated} archived=${result.archived} batches=${result.batches} remaining=${result.remaining} complete=${result.complete}`);
     return result;
   } finally {
@@ -17629,7 +17762,7 @@ function createDreamTaskExecutor(deps) {
               resultChars: 0,
               ...error ? { error } : {},
               backlog: (() => {
-                const end = getDreamTaskBacklog(db, projectIdentity, config.task);
+                const end = extra?.backlogAfter ?? getDreamTaskBacklog(db, projectIdentity, config.task);
                 const processed = processedDreamTaskItems(backlogAtStart.pending, end.pending);
                 const value = {
                   pendingAtStart: backlogAtStart.pending,
@@ -17764,19 +17897,31 @@ function createDreamTaskExecutor(deps) {
           fallbackModels: config.fallbackModels,
           language: config.language ?? deps.language,
           moduleRoute,
-          onProgress: (processed) => reportProgress(processed)
+          onProgress: (processed2) => reportProgress(processed2)
         });
+        const processed = result.verified + result.updated + result.archived;
+        const broadProgress = config.task === "verify-broad" ? `verify-broad cycle ${result.broadCycleStartAt ?? "open"}: verified ${processed}, ${result.remaining} remain` : null;
+        const backlogAfter = config.task === "verify-broad" ? { pending: result.remaining, total: backlogAtStart.total } : undefined;
         if (!result.complete) {
+          if (broadProgress && processed > 0) {
+            recordRun("completed", broadProgress, {
+              memoryChanges: computeMemoryDelta(memoryBefore),
+              backlogAfter
+            });
+            return { status: "completed", error: broadProgress };
+          }
           const error = incompleteMessage(result.remaining);
           recordRun("failed", error, {
-            memoryChanges: computeMemoryDelta(memoryBefore)
+            memoryChanges: computeMemoryDelta(memoryBefore),
+            backlogAfter
           });
           return { status: "failed", transient: true, error };
         }
-        recordRun("completed", null, {
-          memoryChanges: computeMemoryDelta(memoryBefore)
+        recordRun("completed", broadProgress, {
+          memoryChanges: computeMemoryDelta(memoryBefore),
+          backlogAfter
         });
-        return { status: "completed" };
+        return broadProgress ? { status: "completed", error: broadProgress } : { status: "completed" };
       }
       if (config.task === "classify-memories") {
         let moduleArgs;
@@ -25110,7 +25255,8 @@ function loadContextUsage(contextUsageMap, db, sessionId) {
     if (persisted) {
       contextUsageMap.set(sessionId, {
         ...persisted,
-        lastResponseTime: persistedLastResponseTime ?? persisted.updatedAt
+        lastResponseTime: persistedLastResponseTime ?? persisted.updatedAt,
+        hasUsageTokens: false
       });
       return persisted.usage;
     }
@@ -29599,6 +29745,19 @@ function passUsage(usage, limit) {
     context_limit_tokens: limit
   };
 }
+function shouldDisarmRustEmergencyRecovery(input) {
+  if (input.finalWireEstimate?.trusted === true && input.providerProvenLimitTokens > 0 && input.finalWireEstimate.tokens < input.providerProvenLimitTokens * 0.8) {
+    return "trusted-final-wire";
+  }
+  if (!input.materialized || input.usagePercentage >= 80)
+    return null;
+  if (input.recoveryOrigin !== "provider_overflow")
+    return "fresh-usage";
+  if (input.usageEntry?.hasUsageTokens === true && (input.recoveryArmedAt === null || input.usageEntry.updatedAt > input.recoveryArmedAt)) {
+    return "fresh-usage";
+  }
+  return null;
+}
 function directiveTextOf(response) {
   const directives = isRecord3(response.host_directives) ? response.host_directives : undefined;
   const channel2 = isRecord3(directives?.channel2_nudge) ? directives.channel2_nudge : undefined;
@@ -30078,6 +30237,7 @@ function createRustModeTransform(deps, options) {
       }
     }
     const reduceAvailability = resolveCtxReduceAvailability(sessionId);
+    resolveTodowriteAvailabilityFromMessages(sessionId, messages);
     const toolPresent = reduceAvailability.frozen && reduceAvailability.callable;
     try {
       if (preflightError)
@@ -30337,6 +30497,7 @@ function createRustModeTransform(deps, options) {
       const pages = buildPagedModuleTransformPayloads(body);
       logStage(sessionId, "wireBuild", wireBuildStartedAt, timings, wireDelta ? `mode=tail_delta input=${encodedInput.length}` : "mode=full");
       let response;
+      let servedFinalWireEstimate;
       for (const [index, page] of pages.entries()) {
         timings.transportBytes += Buffer.byteLength(JSON.stringify(page));
         const transportStartedAt = performance.now();
@@ -30484,6 +30645,15 @@ function createRustModeTransform(deps, options) {
         if (typeof boundaryId === "string" && boundaryId.length > 0) {
           assertNativeBoundary(appliedMessages, sessionId, boundaryId);
         }
+        if (passInputs.emergency_recovery_armed === true) {
+          servedFinalWireEstimate = estimateFinalWireInputTokens({
+            messages: appliedMessages,
+            systemPromptTokens: sessionMeta.systemPromptTokens,
+            providerID: model?.providerID,
+            modelID: model?.modelID,
+            agentName: deps.getNotificationParams?.(sessionId)?.agent
+          });
+        }
         logStage(sessionId, "apply", applyStartedAt, timings);
         const lkgSnapshotStartedAt = performance.now();
         const explicitDecision = typeof response.decision === "string" || typeof response.action === "string" || typeof response.cache_bust === "boolean";
@@ -30572,10 +30742,20 @@ function createRustModeTransform(deps, options) {
           sessionLog(sessionId, "rust compartment mirror-back failed (ignored):", error);
         }
       }
-      if (materializeReason !== "none" && passUsageSnapshot.percentage < 80 && getOverflowState(deps.db, sessionId).needsEmergencyRecovery) {
+      const currentOverflowState = getOverflowState(deps.db, sessionId, modelKey);
+      const disarmEvidence = currentOverflowState.needsEmergencyRecovery ? shouldDisarmRustEmergencyRecovery({
+        materialized: materializeReason !== "none",
+        usagePercentage: passUsageSnapshot.percentage,
+        recoveryOrigin: currentOverflowState.emergencyRecoveryOrigin,
+        recoveryArmedAt: getEmergencyRecoveryArmedAt(sessionId),
+        usageEntry: deps.contextUsageMap.get(sessionId),
+        finalWireEstimate: servedFinalWireEstimate,
+        providerProvenLimitTokens: currentOverflowState.detectedContextLimit
+      }) : null;
+      if (disarmEvidence) {
         try {
           clearEmergencyRecovery(deps.db, sessionId);
-          sessionLog(sessionId, `rust pass disarmed emergency recovery after ${materializeReason} at ${passUsageSnapshot.percentage.toFixed(1)}% usage`);
+          sessionLog(sessionId, `rust pass disarmed emergency recovery via ${disarmEvidence} after ${materializeReason} at ${passUsageSnapshot.percentage.toFixed(1)}% usage`);
         } catch {}
       }
       wireCaches.set(sessionId, pendingWireCache);
@@ -32143,7 +32323,8 @@ function createEventHandler2(deps) {
               inputTokens: totalInputTokens
             },
             updatedAt: now,
-            lastResponseTime: now
+            lastResponseTime: now,
+            hasUsageTokens: true
           });
           updates.lastContextPercentage = percentage;
           updates.lastInputTokens = totalInputTokens;
@@ -33335,11 +33516,13 @@ function createMagicContextHook(deps) {
       const fence = getSchemaFenceRejection();
       recordHookInitFailure({
         type: "storage",
-        reason: migration && blockingProcesses.length > 0 ? {
+        reason: migration && (blockingProcesses.length > 0 || migration.unreadableFile) ? {
           kind: "migration_guard",
           persistedVersion: migration.persistedVersion,
           supportedVersion: migration.supportedVersion,
-          blockingProcesses
+          blockingProcesses,
+          ...migration.unreadableFile ? { unreadableFile: migration.unreadableFile } : {},
+          ...migration.unreadableArm ? { unreadableArm: migration.unreadableArm } : {}
         } : fence ? {
           kind: "schema_fence",
           persistedVersion: fence.persistedVersion,
@@ -35024,7 +35207,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedRecomp: runManagedRecomp2 } = await import("./recomp-orchestrator-k72ejkkh.js");
+    const { runManagedRecomp: runManagedRecomp2 } = await import("./recomp-orchestrator-6cd3nrt7.js");
     const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-6njqewzk.js");
     log(`[rpc] recomp requested for session ${sessionId}`);
     const ctx = await buildManagedCtx(db);
@@ -35040,7 +35223,7 @@ function registerRpcHandlers(rpcServer, args) {
     const db = getDb();
     if (!db)
       return { ok: false, error: "db unavailable" };
-    const { runManagedUpgrade: runManagedUpgrade2 } = await import("./recomp-orchestrator-k72ejkkh.js");
+    const { runManagedUpgrade: runManagedUpgrade2 } = await import("./recomp-orchestrator-6cd3nrt7.js");
     const { sendIgnoredMessage: sendIgnoredMessage2 } = await import("./send-session-notification-6njqewzk.js");
     log(`[rpc] session-upgrade requested for session ${sessionId}`);
     const ctx = await buildManagedCtx(db);

package/dist/plugin/hooks/create-session-hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-session-hooks.d.ts","sourceRoot":"","sources":["../../../src/plugin/hooks/create-session-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAO7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+CAA+C,CAAC;AAC1F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC9C;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,wBAAwB;;;;;;;;;mBAC5C,CAAC;aAA2B,CAAC;aACnD,CAAC;eAA6B,CAAC;;;;;;;;;;;;;;;;;;;;eAsFq9gB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAzEpghB;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,GAAG,EAAE,aAAa,CAAC;IACnB,YAAY,EAAE,wBAAwB,CAAC;IACvC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC/C;;;;;;;;;qBAkE4zI,CAAC;;;;;;;;;;;;qBAA38C,CAAC;mBAAyB,CAAC;iBAAuB,CAAC;iBAAuB,CAAC;0BAAc,CAAC;uBAAiB,CAAC;;;;;;0BAAk1vD,CAAC;;;;;;;;;EArCjz1D;AAED,wBAAsB,uBAAuB,CAAC,IAAI,EAAE;IAChD,GAAG,EAAE,aAAa,CAAC;IACnB,YAAY,EAAE,wBAAwB,CAAC;IACvC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC/C;;;;;;;;;qBA8B4zI,CAAC;;;;;;;;;;;;qBAA38C,CAAC;mBAAyB,CAAC;iBAAuB,CAAC;iBAAuB,CAAC;0BAAc,CAAC;uBAAiB,CAAC;;;;;;0BAAk1vD,CAAC;;;;;;;;;GADjz1D"}
+{"version":3,"file":"create-session-hooks.d.ts","sourceRoot":"","sources":["../../../src/plugin/hooks/create-session-hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAO7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+CAA+C,CAAC;AAC1F,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAC9C;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,YAAY,EAAE,wBAAwB;;;;;;;;;mBAC5C,CAAC;aAA2B,CAAC;aACnD,CAAC;eAA6B,CAAC;;;;;;;;;;;;;;;;;;;;eAsFq9gB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAzEpghB;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE;IACrC,GAAG,EAAE,aAAa,CAAC;IACnB,YAAY,EAAE,wBAAwB,CAAC;IACvC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC/C;;;;;;;;;qBAkE4zI,CAAC;;;;;;;;;;;;qBAA38C,CAAC;mBAAyB,CAAC;iBAAuB,CAAC;iBAAuB,CAAC;0BAAc,CAAC;uBAAiB,CAAC;;;;;;0BAAutwD,CAAC;;;;;;;;;EArCtr2D;AAED,wBAAsB,uBAAuB,CAAC,IAAI,EAAE;IAChD,GAAG,EAAE,aAAa,CAAC;IACnB,YAAY,EAAE,wBAAwB,CAAC;IACvC,gBAAgB,EAAE,gBAAgB,CAAC;IACnC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC/C;;;;;;;;;qBA8B4zI,CAAC;;;;;;;;;;;;qBAA38C,CAAC;mBAAyB,CAAC;iBAAuB,CAAC;iBAAuB,CAAC;0BAAc,CAAC;uBAAiB,CAAC;;;;;;0BAAutwD,CAAC;;;;;;;;;GADtr2D"}

package/dist/{recomp-orchestrator-k72ejkkh.js → recomp-orchestrator-6cd3nrt7.js}

@@ -9,7 +9,7 @@ import {
   setRecompNote,
   setRecompStarting,
   setRecompTerminal
-} from "./index-x8spt5wy.js";
+} from "./index-z70pxrq1.js";
 import"./index-ry8rh8cv.js";
 import"./index-td9depx5.js";
 import"./index-cn960ffd.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cortexkit/opencode-magic-context",
-  "version": "0.34.1",
+  "version": "0.34.2",
   "type": "module",
   "description": "OpenCode plugin for Magic Context — cross-session memory and context management",
   "main": "dist/index.js",