feat: add ctx_reduce_enabled config flag and independent dreamer timer

ctx_reduce_enabled (default: true) fully disables the ctx_reduce tool,
all nudges (rolling, iteration, emergency 80%), sticky turn reminders,
and prompt guidance about ctx_reduce when set to false. Heuristic
cleanup, compartments, memory, and other features remain active.

Surfaces gated: tool-registry, magic-context-prompt, nudger (no-op),
hook-handlers (emergency + sticky), system-prompt-hash (prompt
injection).

Also: dreamer schedule checks now run on an independent 15-minute
setInterval at the plugin level (src/plugin/dream-timer.ts) instead
of piggybacking on message.updated events, so overnight dreaming
triggers even when the user isn't chatting.

Author: ualtinok

src/agents/magic-context-prompt.ts

@@ -26,6 +26,12 @@ NEVER drop user messages — they are short and will be summarized by compartmen
 NEVER drop assistant text messages unless they are exceptionally large. Your conversation messages are lightweight; only large tool outputs are worth dropping.
 Before your turn finishes, consider using \`ctx_reduce\` to drop large tool outputs you no longer need.`;
 
+/** Intro when ctx_reduce is disabled — no drop guidance, no ctx_reduce references. */
+const BASE_INTRO_NO_REDUCE = `Messages and tool outputs are tagged with §N§ identifiers (e.g., §1§, §42§).
+Use \`ctx_note\` for deferred intentions — things to tackle later, not right now. NOT for task tracking (use todos). Notes survive context compression and you'll be reminded at natural work boundaries (after commits, historian runs, todo completion).
+Use \`ctx_memory\` to manage cross-session project memories. Write new memories, delete stale ones, or search stored memories by category. Memories persist across sessions and are automatically injected into new sessions.
+Use \`ctx_expand\` to decompress a compartment range to see the original conversation transcript. Use \`start\`/\`end\` from \`<compartment start=N end=M>\` attributes. Returns the compacted U:/A: transcript for that message range, capped at ~15K tokens.`;
+
 const SISYPHUS_SECTION = `
 ### Reduction Triggers
 - After collecting background agent results (explore/librarian) — drop raw outputs once you extracted what you need.
@@ -182,7 +188,16 @@ export function detectAgentFromSystemPrompt(systemPrompt: string): AgentType | n
     return null;
 }
 
-export function buildMagicContextSection(agent: AgentType | null, protectedTags: number): string {
+export function buildMagicContextSection(
+    agent: AgentType | null,
+    protectedTags: number,
+    ctxReduceEnabled = true,
+): string {
+    if (!ctxReduceEnabled) {
+        return `## Magic Context
+
+${BASE_INTRO_NO_REDUCE}`;
+    }
     const section = agent ? AGENT_SECTIONS[agent] : GENERIC_SECTION;
     return `## Magic Context
 

src/config/schema/magic-context.test.ts

@@ -47,6 +47,7 @@ describe("MagicContextConfigSchema", () => {
         it("parses an enabled config without stale reduction-specific keys", () => {
             const input = {
                 enabled: true,
+                ctx_reduce_enabled: true,
                 cache_ttl: "10m",
                 protected_tags: 3,
                 nudge_interval_tokens: 15_000,

src/config/schema/magic-context.ts

@@ -124,6 +124,10 @@ export type DreamingConfig = z.infer<typeof DreamingConfigSchema>;
 
 export interface MagicContextConfig {
     enabled: boolean;
+    /** When false, ctx_reduce tool is not registered, all nudges are disabled,
+     *  and prompt guidance about ctx_reduce is stripped. Heuristic cleanup,
+     *  compartments, memory, and other features continue to work. Default: true. */
+    ctx_reduce_enabled: boolean;
     historian?: z.infer<typeof AgentOverrideConfigSchema>;
     dreamer?: DreamerConfig;
     cache_ttl: string | { default: string; [modelKey: string]: string };
@@ -150,6 +154,10 @@ export const MagicContextConfigSchema = z
     .object({
         /** Enable magic context (default: false) */
         enabled: z.boolean().default(false),
+        /** When false, ctx_reduce tool is hidden, all nudges disabled, and prompt
+         *  guidance about ctx_reduce stripped. Heuristic cleanup, compartments,
+         *  memory, and other features still work. (default: true) */
+        ctx_reduce_enabled: z.boolean().default(true),
         /** Historian agent configuration (model, fallback_models, variant, temperature, maxTokens, permission, etc.) */
         historian: AgentOverrideConfigSchema.optional(),
         /** Dreamer agent + scheduling configuration (model, fallback_models, enabled, schedule, tasks, etc.) */

src/hooks/magic-context/hook-handlers.ts

@@ -50,22 +50,27 @@ export function createChatMessageHook(args: {
     variantBySession: VariantBySession;
     flushedSessions: FlushedSessions;
     lastHeuristicsTurnId: LastHeuristicsTurnId;
+    ctxReduceEnabled?: boolean;
 }) {
     return async (input: { sessionID?: string; variant?: string }) => {
         const sessionId = input.sessionID;
         if (!sessionId) return;
 
-        const sessionMeta = getOrCreateSessionMeta(args.db, sessionId);
-        const turnUsage = args.toolUsageSinceUserTurn.get(sessionId);
-        const agentAlreadyReduced = args.recentReduceBySession.has(sessionId);
-        if (
-            !sessionMeta.isSubagent &&
-            !agentAlreadyReduced &&
-            getPersistedStickyTurnReminder(args.db, sessionId) === null &&
-            turnUsage !== undefined &&
-            turnUsage >= TOOL_HEAVY_TURN_REMINDER_THRESHOLD
-        ) {
-            setPersistedStickyTurnReminder(args.db, sessionId, TOOL_HEAVY_TURN_REMINDER_TEXT);
+        // Only set sticky turn reminders when ctx_reduce is enabled — the reminder
+        // tells the agent to use ctx_reduce, which doesn't exist when disabled.
+        if (args.ctxReduceEnabled !== false) {
+            const sessionMeta = getOrCreateSessionMeta(args.db, sessionId);
+            const turnUsage = args.toolUsageSinceUserTurn.get(sessionId);
+            const agentAlreadyReduced = args.recentReduceBySession.has(sessionId);
+            if (
+                !sessionMeta.isSubagent &&
+                !agentAlreadyReduced &&
+                getPersistedStickyTurnReminder(args.db, sessionId) === null &&
+                turnUsage !== undefined &&
+                turnUsage >= TOOL_HEAVY_TURN_REMINDER_THRESHOLD
+            ) {
+                setPersistedStickyTurnReminder(args.db, sessionId, TOOL_HEAVY_TURN_REMINDER_TEXT);
+            }
         }
         args.toolUsageSinceUserTurn.set(sessionId, 0);
 
@@ -103,6 +108,7 @@ export function createEventHook(args: {
     commitSeenLastPass?: Map<string, boolean>;
     client: PluginContext["client"];
     protectedTags: number;
+    ctxReduceEnabled?: boolean;
 }) {
     return async (input: { event: { type: string; properties?: unknown } }) => {
         await args.eventHandler(input);
@@ -141,6 +147,10 @@ export function createEventHook(args: {
             return;
         }
 
+        // Skip 80% emergency nudge when ctx_reduce is disabled — it tells the
+        // agent to "STOP AND COMPRESS" which requires ctx_reduce.
+        if (args.ctxReduceEnabled === false) return;
+
         if (args.emergencyNudgeFired.has(sessionId)) return;
 
         const meta = getOrCreateSessionMeta(args.db, sessionId);

src/hooks/magic-context/hook.ts

@@ -56,6 +56,7 @@ export interface MagicContextDeps {
     compactionHandler: ReturnType<typeof createCompactionHandler>;
     config: {
         protected_tags: number;
+        ctx_reduce_enabled?: boolean;
         nudge_interval_tokens?: number;
         auto_drop_tool_age?: number;
         clear_reasoning_age?: number;
@@ -146,13 +147,17 @@ export function createMagicContextHook(deps: MagicContextDeps) {
     const liveModelBySession = new Map<string, { providerID: string; modelID: string }>();
     const recentReduceBySession = new Map<string, number>();
     const toolUsageSinceUserTurn = new Map<string, number>();
-    const nudgerWithRecentReduce = createNudger({
-        protected_tags: deps.config.protected_tags,
-        nudge_interval_tokens: deps.config.nudge_interval_tokens ?? DEFAULT_NUDGE_INTERVAL_TOKENS,
-        iteration_nudge_threshold: deps.config.iteration_nudge_threshold ?? 15,
-        execute_threshold_percentage: deps.config.execute_threshold_percentage ?? 65,
-        recentReduceBySession,
-    });
+    const ctxReduceEnabled = deps.config.ctx_reduce_enabled !== false;
+    const nudgerWithRecentReduce = ctxReduceEnabled
+        ? createNudger({
+              protected_tags: deps.config.protected_tags,
+              nudge_interval_tokens:
+                  deps.config.nudge_interval_tokens ?? DEFAULT_NUDGE_INTERVAL_TOKENS,
+              iteration_nudge_threshold: deps.config.iteration_nudge_threshold ?? 15,
+              execute_threshold_percentage: deps.config.execute_threshold_percentage ?? 65,
+              recentReduceBySession,
+          })
+        : () => null;
 
     const transform = createTransform({
         tagger: deps.tagger,
@@ -278,6 +283,7 @@ export function createMagicContextHook(deps: MagicContextDeps) {
     const systemPromptHashHandler = createSystemPromptHashHandler({
         db,
         protectedTags: deps.config.protected_tags,
+        ctxReduceEnabled,
         flushedSessions,
         lastHeuristicsTurnId,
     });
@@ -296,6 +302,7 @@ export function createMagicContextHook(deps: MagicContextDeps) {
         commitSeenLastPass,
         client: deps.client,
         protectedTags: deps.config.protected_tags,
+        ctxReduceEnabled,
     });
 
     return {
@@ -309,6 +316,7 @@ export function createMagicContextHook(deps: MagicContextDeps) {
             variantBySession,
             flushedSessions,
             lastHeuristicsTurnId,
+            ctxReduceEnabled,
         }),
         event: async (input: { event: { type: string; properties?: unknown } }) => {
             await eventHook(input);

src/hooks/magic-context/system-prompt-hash.ts

@@ -27,6 +27,7 @@ const MAGIC_CONTEXT_MARKER = "## Magic Context";
 export function createSystemPromptHashHandler(deps: {
     db: ContextDatabase;
     protectedTags: number;
+    ctxReduceEnabled: boolean;
     flushedSessions: Set<string>;
     lastHeuristicsTurnId: Map<string, string>;
 }): (input: { sessionID?: string }, output: { system: string[] }) => Promise<void> {
@@ -38,7 +39,11 @@ export function createSystemPromptHashHandler(deps: {
         const fullPrompt = output.system.join("\n");
         if (fullPrompt.length > 0 && !fullPrompt.includes(MAGIC_CONTEXT_MARKER)) {
             const detectedAgent = detectAgentFromSystemPrompt(fullPrompt);
-            const guidance = buildMagicContextSection(detectedAgent, deps.protectedTags);
+            const guidance = buildMagicContextSection(
+                detectedAgent,
+                deps.protectedTags,
+                deps.ctxReduceEnabled,
+            );
             output.system.push(guidance);
             sessionLog(
                 sessionId,

src/index.ts

@@ -7,6 +7,7 @@ import { getMagicContextBuiltinCommands } from "./features/builtin-commands/comm
 import { DREAMER_SYSTEM_PROMPT } from "./features/magic-context/dreamer/task-prompts";
 import { SIDEKICK_SYSTEM_PROMPT } from "./features/magic-context/sidekick/agent";
 import { COMPARTMENT_AGENT_SYSTEM_PROMPT } from "./hooks/magic-context/compartment-prompt";
+import { startDreamScheduleTimer } from "./plugin/dream-timer";
 import { createEventHandler } from "./plugin/event";
 import { createSessionHooks } from "./plugin/hooks/create-session-hooks";
 import { createMessagesTransformHandler } from "./plugin/messages-transform";
@@ -31,6 +32,15 @@ const plugin: Plugin = async (ctx) => {
         pluginConfig,
     });
 
+    // Start independent dream schedule timer at plugin level (not inside hooks)
+    // so overnight dreaming works even when the user isn't chatting.
+    if (pluginConfig.dreamer) {
+        startDreamScheduleTimer({
+            client: ctx.client,
+            dreamerConfig: pluginConfig.dreamer,
+        });
+    }
+
     return {
         tool: tools,
         event: createEventHandler({ magicContext: hooks.magicContext }),

src/plugin/dream-timer.ts

@@ -0,0 +1,54 @@
+import type { DreamerConfig } from "../config/schema/magic-context";
+import { checkScheduleAndEnqueue, processDreamQueue } from "../features/magic-context/dreamer";
+import { openDatabase } from "../features/magic-context/storage";
+import { log } from "../shared/logger";
+import type { PluginContext } from "./types";
+
+/** Check interval for dream schedule (15 minutes). */
+const DREAM_TIMER_INTERVAL_MS = 15 * 60 * 1000;
+
+/**
+ * Start an independent timer that checks the dreamer schedule and processes
+ * the dream queue. This runs regardless of user activity so overnight
+ * dreaming triggers even when the user isn't chatting.
+ *
+ * The timer is unref'd so it doesn't prevent the process from exiting.
+ */
+export function startDreamScheduleTimer(args: {
+    client: PluginContext["client"];
+    dreamerConfig: DreamerConfig;
+}): void {
+    const { client, dreamerConfig } = args;
+
+    if (!dreamerConfig.enabled || !dreamerConfig.schedule?.trim()) {
+        return;
+    }
+
+    const timer = setInterval(() => {
+        try {
+            const db = openDatabase();
+            checkScheduleAndEnqueue(db, dreamerConfig.schedule);
+
+            void processDreamQueue({
+                db,
+                client,
+                tasks: dreamerConfig.tasks,
+                taskTimeoutMinutes: dreamerConfig.task_timeout_minutes,
+                maxRuntimeMinutes: dreamerConfig.max_runtime_minutes,
+            }).catch((error: unknown) => {
+                log("[dreamer] timer-triggered queue processing failed:", error);
+            });
+        } catch (error) {
+            log("[dreamer] timer-triggered schedule check failed:", error);
+        }
+    }, DREAM_TIMER_INTERVAL_MS);
+
+    // Unref so the timer doesn't prevent the process from exiting.
+    if (typeof timer === "object" && "unref" in timer) {
+        timer.unref();
+    }
+
+    log(
+        `[dreamer] started independent schedule timer (every ${DREAM_TIMER_INTERVAL_MS / 60_000}m)`,
+    );
+}

src/plugin/tool-registry.ts

@@ -69,11 +69,14 @@ export function createToolRegistry(args: {
         }
     }
 
+    const ctxReduceEnabled = pluginConfig.ctx_reduce_enabled !== false;
     const allTools: Record<string, ToolDefinition> = {
-        ...createCtxReduceTools({
-            db,
-            protectedTags: pluginConfig.protected_tags ?? DEFAULT_PROTECTED_TAGS,
-        }),
+        ...(ctxReduceEnabled
+            ? createCtxReduceTools({
+                  db,
+                  protectedTags: pluginConfig.protected_tags ?? DEFAULT_PROTECTED_TAGS,
+              })
+            : {}),
         ...createCtxExpandTools(),
         ...createCtxNoteTools({ db }),
         ...(memoryEnabled