@cortexkit/opencode-magic-context 0.42.6 → 0.43.1

package/dist/index-1gtwrdc4.js

@@ -0,0 +1,393 @@
+import {
+  sessionLog
+} from "./index-wgzyeyf5.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-7wpwr2e2.js";
+import {
+  pushNotification2
+} from "./index-jdxxq8cz.js";
+import {
+  sendStatusNotification2
+} from "./index-yc81txp4.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 };

package/dist/{index-ntbmt6rq.js → index-4b30nf6z.js}

@@ -1,6 +1,6 @@
 import {
   getMagicContextStorageDir
-} from "./index-4ftb5hcq.js";
+} from "./index-6z9g64js.js";
 
 // src/shared/announcement.ts
 import * as fs from "node:fs";

package/dist/index-6w9p73jz.js

@@ -0,0 +1,170 @@
+import {
+  resolveDreamerTaskModel2
+} from "./index-7k55qm8a.js";
+
+// src/features/magic-context/dreamer/task-registry.ts
+var CANONICAL_DREAM_TASKS = [
+  "map-memories",
+  "verify",
+  "verify-broad",
+  "curate",
+  "compress-cues",
+  "classify-memories",
+  "retrospective",
+  "maintain-docs",
+  "evaluate-smart-notes",
+  "review-user-memories",
+  "promote-primers",
+  "refresh-primers"
+];
+var DREAM_TASK_CAPABILITIES = {
+  "map-memories": {
+    requiresTools: true,
+    transport: "tool-loop",
+    toolLoopPurpose: "needs read-only file tools to locate the code each memory describes"
+  },
+  verify: {
+    requiresTools: true,
+    transport: "tool-loop",
+    toolLoopPurpose: "needs read-only file tools to re-check each memory against the code"
+  },
+  "verify-broad": {
+    requiresTools: true,
+    transport: "tool-loop",
+    toolLoopPurpose: "needs read-only file tools to re-check each memory against the code"
+  },
+  curate: {
+    requiresTools: true,
+    transport: "tool-loop",
+    toolLoopPurpose: "needs the ctx_memory tool to apply its merge and archive decisions"
+  },
+  "compress-cues": { requiresTools: false, transport: "single-shot" },
+  "classify-memories": { requiresTools: false, transport: "single-shot" },
+  retrospective: {
+    requiresTools: true,
+    transport: "tool-loop",
+    toolLoopPurpose: "needs search tools to investigate the friction it finds in past sessions"
+  },
+  "maintain-docs": {
+    requiresTools: true,
+    transport: "tool-loop",
+    toolLoopPurpose: "needs read-only file tools to investigate documentation corrections"
+  },
+  "evaluate-smart-notes": { requiresTools: false, transport: "single-shot" },
+  "review-user-memories": { requiresTools: false, transport: "single-shot" },
+  "promote-primers": { requiresTools: false, transport: "host-only" },
+  "refresh-primers": {
+    requiresTools: true,
+    transport: "tool-loop",
+    toolLoopPurpose: "needs read-only investigation tools to answer each standing question"
+  }
+};
+function toolLoopDreamTasks() {
+  return CANONICAL_DREAM_TASKS.filter((task) => DREAM_TASK_CAPABILITIES[task].requiresTools);
+}
+function formatUnsupportedDreamTasks(tasks, code) {
+  return tasks.map((task) => {
+    const purpose = DREAM_TASK_CAPABILITIES[task].toolLoopPurpose;
+    return `- ${task}: unavailable on this host (${code})${purpose ? ` — ${purpose}` : ""}`;
+  }).join(`
+`);
+}
+function formatDreamTaskBacklogs(backlogs, tasks = CANONICAL_DREAM_TASKS) {
+  return tasks.filter((task) => backlogs[task] !== undefined).map((task) => {
+    const backlog = backlogs[task];
+    if (task === "curate" && backlog?.category) {
+      return `- curate: ${backlog.category} (${backlog.pending})`;
+    }
+    return `- ${task}: ${backlog?.pending ?? 0} pending / ${backlog?.total ?? 0} total`;
+  }).join(`
+`);
+}
+var FAILURE_TEXT_BUDGET = 180;
+function sinceLabel(lastSucceededAt, now) {
+  if (lastSucceededAt === null || lastSucceededAt <= 0)
+    return "never succeeded";
+  const hours = Math.max(0, Math.floor((now - lastSucceededAt) / 3600000));
+  if (hours < 1)
+    return "last succeeded under an hour ago";
+  if (hours < 48)
+    return `last succeeded ${hours}h ago`;
+  return `last succeeded ${Math.floor(hours / 24)}d ago`;
+}
+function formatDreamTaskFailures(failures, now = Date.now()) {
+  return failures.map((failure) => {
+    const error = failure.error.length > FAILURE_TEXT_BUDGET ? `${failure.error.slice(0, FAILURE_TEXT_BUDGET)}…` : failure.error;
+    return `- ${failure.task}: failing (${sinceLabel(failure.lastSucceededAt, now)}) — ${error}`;
+  }).join(`
+`);
+}
+function processedDreamTaskItems(startPending, endPending) {
+  return Math.max(0, startPending - endPending);
+}
+var MEMORY_DOMAIN_TASKS = [
+  "map-memories",
+  "verify",
+  "verify-broad",
+  "curate",
+  "compress-cues",
+  "classify-memories",
+  "retrospective",
+  "promote-primers",
+  "refresh-primers"
+];
+var MEMORY_DOMAIN_SET = new Set(MEMORY_DOMAIN_TASKS);
+function leaseKindFor(task) {
+  if (MEMORY_DOMAIN_SET.has(task))
+    return "memory";
+  switch (task) {
+    case "review-user-memories":
+      return "user-memories";
+    case "promote-primers":
+    case "refresh-primers":
+      return "memory";
+    case "maintain-docs":
+      return "maintain-docs";
+    case "evaluate-smart-notes":
+      return "evaluate-smart-notes";
+    default:
+      return "memory";
+  }
+}
+function leaseKeyFor(task, projectIdentity) {
+  const kind = leaseKindFor(task);
+  return kind === "user-memories" ? "user-memories" : `${kind}:${projectIdentity}`;
+}
+function isCanonicalDreamTask(value) {
+  return CANONICAL_DREAM_TASKS.includes(value);
+}
+function compareTaskOrder(a, b) {
+  return CANONICAL_DREAM_TASKS.indexOf(a) - CANONICAL_DREAM_TASKS.indexOf(b);
+}
+
+// src/features/magic-context/dreamer/task-config.ts
+function buildDreamTaskRuntimeConfigs2(dreamer, harness, language, muralModel) {
+  return CANONICAL_DREAM_TASKS.map((task) => {
+    const resolved = resolveDreamerTaskModel2({
+      config: { dreamer },
+      harness,
+      task,
+      muralModel
+    });
+    return {
+      task,
+      schedule: resolved.schedule ?? "",
+      model: resolved.primary,
+      fallbackModels: resolved.fallbacks,
+      thinkingLevel: harness === "pi" ? resolved.primary?.qualifier : undefined,
+      language,
+      timeoutMinutes: resolved.timeoutMinutes ?? 20,
+      promotionThreshold: resolved.promotionThreshold,
+      docsMaxTokens: task === "maintain-docs" ? dreamer?.tasks?.["maintain-docs"]?.max_tokens ?? 12000 : undefined,
+      retrospectiveRecencyDays: task === "retrospective" ? dreamer?.tasks?.retrospective?.recency_days ?? 30 : undefined
+    };
+  });
+}
+function userMemoryCollectionEnabled2(dreamer) {
+  const schedule = dreamer?.tasks?.["review-user-memories"]?.schedule;
+  return typeof schedule === "string" && schedule.trim() !== "";
+}
+export { CANONICAL_DREAM_TASKS, DREAM_TASK_CAPABILITIES, toolLoopDreamTasks, formatUnsupportedDreamTasks, formatDreamTaskBacklogs, formatDreamTaskFailures, processedDreamTaskItems, leaseKindFor, leaseKeyFor, isCanonicalDreamTask, compareTaskOrder, buildDreamTaskRuntimeConfigs2, userMemoryCollectionEnabled2 };

package/dist/{index-4ftb5hcq.js → index-6z9g64js.js}

@@ -13,9 +13,15 @@ function getHarness() {
 }
 
 // src/shared/data-path.ts
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+
+// src/shared/test-temp-dir.ts
+var STALE_TEMP_DIR_AGE_MS = 60 * 60 * 1000;
+var registeredTempDirs = new Set;
+
+// src/shared/data-path.ts
 function getDataDir() {
   return process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share");
 }