volute 0.54.0 → 0.55.0

package/templates/_base/src/lib/codex-session-seed.ts

@@ -278,49 +278,6 @@ export function buildSeededRollout(
   return emitFromKept(p.meta, p.kept, tailStartByBudget(p.kept, seedTokens), threadId, now);
 }
 
-/**
- * A pinned cut point for rotation. Codex `response_item` message lines carry no
- * stable id, so we pin the boundary by its top-level `timestamp` (millisecond
- * precision — unique in practice). Rotation locates the same turn by matching it.
- */
-export type CodexSeedCut = { boundaryTimestamp: string };
-
-/**
- * Compute the cut point (the first-kept turn's timestamp) for a `seedTokens` budget,
- * from raw jsonl. Parsed leniently because the live rollout may still be mid-write
- * when this runs at warn time. Returns null if there's no genuine turn or the chosen
- * boundary lacks a timestamp to pin on.
- */
-export function computeCodexSeedCut(jsonl: string, seedTokens: number): CodexSeedCut | null {
-  const p = parseRollout(jsonl, true);
-  if (!p || p.kept.length === 0) return null;
-  if (keptBoundaries(p.kept).length === 0) return null;
-  const boundary = p.kept[tailStartByBudget(p.kept, seedTokens)].obj;
-  if (typeof boundary.timestamp !== "string") return null;
-  return { boundaryTimestamp: boundary.timestamp };
-}
-
-/**
- * Build the seeded rollout starting at a pinned boundary timestamp (the whole tail
- * from that turn through EOF). Used by rotation to honor the cut point the mind was
- * warned about, regardless of how much the rollout grew after the warning. Returns
- * null if the boundary isn't found or a line is corrupt.
- */
-export function buildSeededRolloutFromCut(
-  jsonl: string,
-  threadId: string,
-  boundaryTimestamp: string,
-  now: Date = new Date(),
-): SeededRollout | null {
-  const p = parseRollout(jsonl, false);
-  if (!p || p.kept.length === 0) return null;
-  const startIdx = p.kept.findIndex(
-    (k) => isTurnBoundary(k.obj) && k.obj.timestamp === boundaryTimestamp,
-  );
-  if (startIdx < 0) return null;
-  return emitFromKept(p.meta, p.kept, startIdx, threadId, now);
-}
-
 /** Two-digit zero-padded string for date/time components. */
 function pad2(n: number): string {
   return String(n).padStart(2, "0");
@@ -417,32 +374,26 @@ export function writeCodexRotationArchivePointer(
 
 /**
  * Rotate a codex session in place at the context limit. Reads the live rollout, builds
- * a seeded tail from the pinned `cut` (falling back to a budget-based tail when the pin
- * can't be honored), writes it as a new synthetic rollout next to the source, and — for
- * persistent sessions — archives the rotated-out thread pointer so the full transcript
- * stays findable. Returns the new thread id, or null if rotation can't proceed (the
- * caller then leaves the old thread in place). Never throws.
+ * a seeded budget-based tail, writes it as a new synthetic rollout next to the source,
+ * and — for persistent sessions — archives the rotated-out thread pointer so the full
+ * transcript stays findable. Returns the new thread id, or null if rotation can't proceed
+ * (the caller then leaves the old thread in place). Never throws.
  */
 export function rotateCodexSession(opts: {
   mindDir: string;
   name: string;
   oldThreadId: string;
-  cut: CodexSeedCut | null;
   seedTokens: number;
   now?: Date;
 }): string | null {
-  const { mindDir, name, oldThreadId, cut, seedTokens } = opts;
+  const { mindDir, name, oldThreadId, seedTokens } = opts;
   const now = opts.now ?? new Date();
   try {
     const sourcePath = findCodexSessionFile(oldThreadId, mindDir);
     if (!sourcePath) return null; // live rollout not found — leave the old thread
     const jsonl = readFileSync(sourcePath, "utf-8");
     const threadId = generateThreadId(now);
-    // Honor the pinned boundary the mind was warned about; only fall back to a
-    // budget-based tail if the pin can't be resolved (missing/renamed boundary).
-    const seeded =
-      (cut ? buildSeededRolloutFromCut(jsonl, threadId, cut.boundaryTimestamp, now) : null) ??
-      buildSeededRollout(jsonl, threadId, seedTokens, now);
+    const seeded = buildSeededRollout(jsonl, threadId, seedTokens, now);
     if (!seeded) return null;
 
     writeSeededRollout(sourcePath, seeded, now);

package/templates/_base/src/lib/pi-session-seed.ts

@@ -239,49 +239,6 @@ export function buildSeededPiTranscript(
   return emitPiTail(h.header, h.entries, h.entryRaws, startIdx, opts.cwd, opts.sourcePath);
 }
 
-/** A pinned cut point for rotation: where the verbatim tail begins. */
-export type PiSeedCut = { boundaryId: string; boundaryTimestamp: string | null };
-
-/**
- * Compute the cut point (the first-kept turn's identity) for a `seedTokens` budget,
- * from raw jsonl. Parsed leniently because the live transcript may still be mid-write
- * when this runs at warn time. Returns null if there's no genuine turn or the chosen
- * boundary entry lacks an id.
- */
-export function computePiSeedCut(jsonl: string, seedTokens: number): PiSeedCut | null {
-  const p = parsePiJsonl(jsonl, true);
-  if (!p) return null;
-  const h = splitPiHeader(p.parsed, p.raws);
-  if (!h) return null;
-  const startIdx = tailStartByBudget(h.entries, h.entryRaws, seedTokens);
-  if (startIdx < 0) return null;
-  const boundary = h.entries[startIdx];
-  if (typeof boundary.id !== "string") return null;
-  return {
-    boundaryId: boundary.id,
-    boundaryTimestamp: typeof boundary.timestamp === "string" ? boundary.timestamp : null,
-  };
-}
-
-/**
- * Build the seeded transcript starting at a pinned boundary entry id (the whole tail
- * from that entry through EOF). Used by rotation to honor the cut point the mind was
- * warned about, regardless of how much the transcript grew after the warning.
- * Returns null if the boundary id isn't found or a line is corrupt.
- */
-export function buildSeededPiTranscriptFromCut(
-  jsonl: string,
-  opts: { cwd: string; boundaryId: string; sourcePath?: string },
-): SeededPiTranscript | null {
-  const p = parsePiJsonl(jsonl, false);
-  if (!p) return null;
-  const h = splitPiHeader(p.parsed, p.raws);
-  if (!h) return null;
-  const startIdx = h.entries.findIndex((e) => e.id === opts.boundaryId);
-  if (startIdx < 0) return null;
-  return emitPiTail(h.header, h.entries, h.entryRaws, startIdx, opts.cwd, opts.sourcePath);
-}
-
 /**
  * True if `<piSessionsDir>/<name>/` already holds a live pi `.jsonl` session —
  * in which case continueRecent will resume it and we must not seed over it.
@@ -379,30 +336,24 @@ function archiveRotatedPiFile(
 
 /**
  * Rotate a pi session in place at the context limit. Reads the live session file,
- * builds a seeded tail from the pinned `cut` (falling back to a budget-based tail
- * when the pin can't be honored), writes it as a new session file in the same live
- * dir, and — for persistent sessions — archives the rotated-out file so the full
- * transcript stays findable. Returns the new session file **path** (the caller
- * switches the running SessionManager to it), or null if rotation can't proceed
- * (the caller then falls back to a fresh session). Never throws.
+ * builds a budget-based tail (as many whole trailing turns as fit in `seedTokens`),
+ * writes it as a new session file in the same live dir, and — for persistent
+ * sessions — archives the rotated-out file so the full transcript stays findable.
+ * Returns the new session file **path** (the caller switches the running
+ * SessionManager to it), or null if rotation can't proceed (the caller then falls
+ * back to a fresh session). Never throws.
  */
 export function rotatePiSession(opts: {
   cwd: string;
   sessionsDir: string;
   name: string;
   sourcePath: string;
-  cut: PiSeedCut | null;
   seedTokens: number;
 }): string | null {
-  const { cwd, sessionsDir, name, sourcePath, cut, seedTokens } = opts;
+  const { cwd, sessionsDir, name, sourcePath, seedTokens } = opts;
   try {
     const jsonl = readFileSync(sourcePath, "utf-8");
-    // Honor the pinned boundary the mind was warned about; only fall back to a
-    // budget-based tail if the pin can't be resolved (missing/renamed id).
-    const seeded =
-      (cut
-        ? buildSeededPiTranscriptFromCut(jsonl, { cwd, boundaryId: cut.boundaryId, sourcePath })
-        : null) ?? buildSeededPiTranscript(jsonl, { cwd, seedTokens, sourcePath });
+    const seeded = buildSeededPiTranscript(jsonl, { cwd, seedTokens, sourcePath });
     if (!seeded) return null;
 
     const liveDir = resolve(sessionsDir, name);

package/templates/_base/src/lib/seed-note.ts

@@ -21,12 +21,12 @@ export const SEEDED_SESSION_NOTE_BASE =
   "Note: this session continues from your previous session's transcript (restored after archival). The conversation above happened before the break; a fresh session begins here.";
 
 /**
- * Note for the "rotation" cause. No gap clause (the break is instantaneous — the
- * context limit, not a sleep). Points at `volute mind history` for the collapsed
- * turns, whose summaries the mind was asked to author at warn time.
+ * Note for the "rotation" cause. One line, low-salience by design: rotation is
+ * meant to be near-invisible — no gap clause (the break is instantaneous), no
+ * task, just an honest pointer to where the collapsed turns' summaries live.
  */
 export const ROTATED_SESSION_NOTE =
-  "Note: this session was rotated in place at the context limit. The turns above are your most recent, kept verbatim; earlier turns have been collapsed — your summaries of them are in your history (`volute mind history`). A fresh session continues from here.";
+  "Note: this session was consolidated at the context limit — the turns above are kept verbatim; summaries of older turns are in your history (`volute mind history`).";
 
 /**
  * Parse an archive-pointer timestamp into epoch millis, or null if it doesn't

package/templates/_base/src/lib/session-seed.ts

@@ -117,8 +117,7 @@ function estimateTokens(raw: string): number {
  * Parse jsonl into aligned parsed/raw arrays. In strict mode a corrupt line aborts
  * (returns null — used when copying verbatim, where a broken line means we can't
  * faithfully reconstruct the chain). In lenient mode corrupt lines are skipped
- * (used when reading a transcript that may still be mid-write, e.g. computing the
- * cut point while the SDK is streaming).
+ * (tolerating a transcript that may still be mid-write).
  */
 function parseJsonl(
   jsonl: string,
@@ -200,9 +199,6 @@ function emitTail(parsed: JsonlLine[], startLine: number): SeededTranscript {
 
 export type SeededTranscript = { sessionId: string; lines: string[] };
 
-/** A pinned cut point for rotation: where the verbatim tail begins. */
-export type SeedCut = { boundaryUuid: string; boundaryTimestamp: string | null };
-
 /**
  * Build the seeded transcript from an old transcript's raw jsonl text: take as
  * many whole trailing turns as fit in `seedTokens` (always at least the final
@@ -218,42 +214,6 @@ export function buildSeededTranscript(jsonl: string, seedTokens: number): Seeded
   return emitTail(p.parsed, startLine);
 }
 
-/**
- * Compute the cut point (the first-kept turn's identity) for a `seedTokens` budget,
- * from raw jsonl. Parsed leniently because the live transcript may still be
- * mid-write when this runs at warn time. Returns null if there's no genuine turn
- * or the chosen boundary lacks a uuid.
- */
-export function computeSeedCut(jsonl: string, seedTokens: number): SeedCut | null {
-  const p = parseJsonl(jsonl, true);
-  if (!p || p.parsed.length === 0) return null;
-  if (turnBoundaries(p.parsed).length === 0) return null;
-  const startLine = tailStartByBudget(p.parsed, p.raws, seedTokens);
-  const boundary = p.parsed[startLine];
-  if (typeof boundary.uuid !== "string") return null;
-  return {
-    boundaryUuid: boundary.uuid,
-    boundaryTimestamp: typeof boundary.timestamp === "string" ? boundary.timestamp : null,
-  };
-}
-
-/**
- * Build the seeded transcript starting at a pinned boundary uuid (the whole tail
- * from that line through EOF). Used by rotation to honor the cut point the mind
- * was warned about, regardless of how much the transcript grew after the warning.
- * Returns null if the boundary uuid isn't found or a line is corrupt.
- */
-export function buildSeededTranscriptFromCut(
-  jsonl: string,
-  boundaryUuid: string,
-): SeededTranscript | null {
-  const p = parseJsonl(jsonl, false);
-  if (!p || p.parsed.length === 0) return null;
-  const startLine = p.parsed.findIndex((o) => o.uuid === boundaryUuid);
-  if (startLine < 0) return null;
-  return emitTail(p.parsed, startLine);
-}
-
 /** Result of a successful seed: the new session id and when the source was archived. */
 export type SeedOutcome = { sessionId: string; archivedAt: number | null };
 
@@ -328,30 +288,25 @@ export function writeRotationArchivePointer(
 
 /**
  * Rotate a session in place at the context limit. Reads the live transcript, builds
- * a seeded tail from the pinned `cut` (falling back to a budget-based tail when the
- * pin can't be honored), writes it as a new synthetic session file next to the
- * source, and — for persistent sessions — archives the rotated-out pointer so the
- * full transcript stays findable. Returns the new session id, or null if rotation
- * can't proceed (the caller then falls back to a fresh session). Never throws.
+ * a budget-based tail (as many whole trailing turns as fit in `seedTokens`), writes
+ * it as a new synthetic session file next to the source, and — for persistent
+ * sessions — archives the rotated-out pointer so the full transcript stays findable.
+ * Returns the new session id, or null if rotation can't proceed (the caller then
+ * falls back to a fresh session). Never throws.
  */
 export function rotateSession(opts: {
   cwd: string;
   sessionsDir: string;
   name: string;
   oldSessionId: string;
-  cut: SeedCut | null;
   seedTokens: number;
 }): string | null {
-  const { cwd, sessionsDir, name, oldSessionId, cut, seedTokens } = opts;
+  const { cwd, sessionsDir, name, oldSessionId, seedTokens } = opts;
   try {
     const sourcePath = findClaudeSessionFile(cwd, oldSessionId);
     if (!sourcePath) return null; // live transcript not found — fall back to fresh
     const jsonl = readFileSync(sourcePath, "utf-8");
-    // Honor the pinned boundary the mind was warned about; only fall back to a
-    // budget-based tail if the pin can't be resolved (missing/renamed uuid).
-    const seeded =
-      (cut ? buildSeededTranscriptFromCut(jsonl, cut.boundaryUuid) : null) ??
-      buildSeededTranscript(jsonl, seedTokens);
+    const seeded = buildSeededTranscript(jsonl, seedTokens);
     if (!seeded) return null;
 
     writeFileSync(

package/templates/_base/src/lib/startup.ts

@@ -40,7 +40,6 @@ export type EffortLevel = "low" | "medium" | "high" | "xhigh" | "max";
 export type MindConfig = {
   model?: string;
   logLevel?: "error" | "warn" | "info" | "debug";
-  compactionMessage?: string;
   compaction?: { maxContextTokens?: number };
   /** Idle minutes before a session's SDK subprocess is reaped. 0 disables. Default 30. */
   sessionIdleMinutes?: number;
@@ -103,21 +102,6 @@ export function memorySizeLabel(): string {
   return formatTokens(estimateTokens(loadFile(resolve("home/MEMORY.md")).length));
 }
 
-/**
- * Render the compaction warning for sending: substitute ${date} and
- * ${memory_size} with current values. Called per send — the date rolls over
- * and MEMORY.md changes as the mind edits it.
- */
-export function renderCompactionWarning(template: string): string {
-  return (
-    template
-      // biome-ignore lint/suspicious/noTemplateCurlyInString: literal ${date} placeholder
-      .replaceAll("${date}", new Date().toLocaleDateString("en-CA"))
-      // biome-ignore lint/suspicious/noTemplateCurlyInString: literal ${memory_size} placeholder
-      .replaceAll("${memory_size}", memorySizeLabel())
-  );
-}
-
 function headAtLineBoundary(text: string, maxChars: number): string {
   const cut = text.lastIndexOf("\n", maxChars);
   // Prefer a whole-line cut, but not when the nearest newline is so far back
@@ -251,7 +235,6 @@ export async function getStartupContext(): Promise<string | null> {
 }
 
 export type MindPrompts = {
-  compaction_warning: string;
   compaction_instructions: string;
   reply_instructions: string;
   event_instructions: string;
@@ -264,9 +247,6 @@ export type MindPrompts = {
  * (the copy the Prompt Library UI edits); test/prompts.test.ts fails if they drift.
  */
 export const DEFAULT_PROMPTS: MindPrompts = {
-  compaction_warning:
-    // biome-ignore lint/suspicious/noTemplateCurlyInString: literal ${cutoff}/${date}/${memory_size} prompt template
-    "Context limit approaching — this session will rotate shortly. Turns before ${cutoff} will be collapsed to their summaries; turns from ${cutoff} on are kept verbatim in the continued session, so there's no need to re-describe them.\n\nFor the turns that will collapse, make sure they read the way you'd want: `volute mind history --provisional` shows the provisional summaries, and `volute mind history --write --turn <id> --text \"...\"` replaces any with your own account. Also save anything important to your files (memory/journal/${date}.md, or a memory/ file). Provisional summaries are kept if you write nothing — nothing blocks on this.\n\nYour MEMORY.md is currently ${memory_size}. It is loaded into every request, so consolidate rather than append — distill detail into memory/ files and keep MEMORY.md lean (see the memory skill).",
   compaction_instructions:
     "Preserve your sense of who you are, what matters to you, what happened in this conversation, and the threads of thought and connection you'd want to return to.",
   // Quoted: `${channel}` is `#garden` for a Volute channel, and an unquoted `#` starts a

package/templates/claude/package.json

@@ -9,12 +9,12 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.3.207",
+    "@anthropic-ai/claude-agent-sdk": "^0.3.217",
     "@anthropic-ai/tokenizer": "^0.0.4",
     "tsx": "^4.23.1"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.5.3",
+    "@biomejs/biome": "2.5.5",
     "@types/node": "^26.1.1",
     "typescript": "^6.0.3"
   }

package/templates/claude/src/agent.ts

@@ -14,7 +14,6 @@ import {
   readSkillDescriptions,
 } from "./lib/context-breakdown.js";
 import { daemonEmit, daemonNotice } from "./lib/daemon-client.js";
-import { compactTimestamp } from "./lib/format-prefix.js";
 import { runHooks } from "./lib/hook-loader.js";
 import { createAutoCommitHook } from "./lib/hooks/auto-commit.js";
 import { createIdentityReloadHook } from "./lib/hooks/identity-reload.js";
@@ -30,16 +29,9 @@ import {
   reapSessionQuery,
   reapSessionsForShutdown,
 } from "./lib/session-reaper.js";
-import {
-  computeSeedCut,
-  DEFAULT_SEED_TOKENS,
-  rotateSession,
-  type SeedCut,
-  seedSession,
-} from "./lib/session-seed.js";
+import { DEFAULT_SEED_TOKENS, rotateSession, seedSession } from "./lib/session-seed.js";
 import { createSessionStore } from "./lib/session-store.js";
-import type { EffortLevel, ThinkingConfig } from "./lib/startup.js";
-import { loadPrompts, renderCompactionWarning, type SubagentConfig } from "./lib/startup.js";
+import type { EffortLevel, SubagentConfig, ThinkingConfig } from "./lib/startup.js";
 import { consumeStream, type MessageIdEntry } from "./lib/stream-consumer.js";
 import type {
   HandlerMeta,
@@ -77,12 +69,6 @@ type Session = {
   seededArchivedAt: number | null;
   /** Why the tail is seeded — picks the boundary note's wording. Last cause wins. */
   seededCause: SeedCause;
-  /**
-   * The cut point pinned at warn time (the first-kept turn the mind was told would
-   * survive verbatim). Honored at rotation so the promise in the warning holds even
-   * though the transcript grows after the warning. Null until a warning fires.
-   */
-  rotationCut: SeedCut | null;
   /**
    * Back-to-back rotations that did NOT bring context under the threshold (reset by
    * any healthy turn). Guards against a runaway loop when the tail alone can't fit —
@@ -91,20 +77,15 @@ type Session = {
    */
   consecutiveRotations: number;
   /**
-   * Rotation state machine (undefined = idle). The warning is pushed and the mind
-   * takes a wrap-up turn — with FULL context of the turns it's summarizing — before
-   * the session rotates:
-   *   - "warned": a turn was mid-flight when we warned; it must finish before the
-   *     wrap-up turn (which consumes the warning) runs.
-   *   - "rotateAfterTurn": the wrap-up turn is the current/next turn; rotate when it ends.
-   * Lives on the session (not a map) so it can't leak into a resumed session if the
-   * stream dies mid-flight — a fresh session starts idle.
+   * True when this session crossed the context threshold (or the SDK tried to
+   * auto-compact) and should rotate in place when the current turn ends. Rotation
+   * is deliberately silent: no warning, no wrap-up turn — the auto summarizer's
+   * turn summaries are the record of collapsed turns, and the one-line
+   * ROTATED_SESSION_NOTE marks the boundary on the next turn.
    */
-  rotationPhase?: RotationPhase;
+  rotationPending: boolean;
 };
 
-type RotationPhase = "warned" | "rotateAfterTurn";
-
 /** Stop self-rotating after this many back-to-back rotations that didn't reduce context. */
 const MAX_CONSECUTIVE_ROTATIONS = 3;
 
@@ -116,7 +97,6 @@ export function createMind(options: {
   thinking?: ThinkingConfig;
   effort?: EffortLevel;
   sessionsDir: string;
-  compactionMessage?: string;
   maxContextTokens?: number;
   subagents?: Record<string, SubagentConfig>;
   onIdentityReload?: () => Promise<void>;
@@ -139,9 +119,6 @@ export function createMind(options: {
   ];
 
   const sessions = new Map<string, Session>();
-  const prompts = loadPrompts();
-  const compactionMessage = () =>
-    options.compactionMessage ?? renderCompactionWarning(prompts.compaction_warning);
   const maxContextTokens = options.maxContextTokens;
   const seedTokens = options.seedTokens ?? DEFAULT_SEED_TOKENS;
 
@@ -396,60 +373,19 @@ export function createMind(options: {
       let currentSessionId = savedSessionId;
       let streamAbort = new AbortController();
 
-      /**
-       * Warn the mind that the session will rotate at the context limit and pin the
-       * cut point it's told about. Computes which whole turns fit in `seedTokens`
-       * from the live transcript, pins the first-kept turn (so rotation honors the
-       * same boundary even as the transcript grows), interpolates its time into the
-       * `${cutoff}` placeholder, enters the rotation state machine, and pushes the
-       * warning as the wrap-up prompt. Shared by the threshold and PreCompact paths.
-       *
-       * Crucially it does NOT abort here: the mind takes a wrap-up turn (reading the
-       * pinned cutoff and authoring `volute mind history` summaries with full context
-       * of the turns being collapsed) before rotation. The entry phase depends on
-       * whether a turn is mid-flight: if one is (threshold path fires on an assistant
-       * message), it must finish before the queued warning runs, so we start "warned";
-       * if we're between turns (PreCompact fired at a boundary), the warning IS the
-       * next turn, so we start "rotateAfterTurn".
-       */
-      function warnAndPinRotation() {
-        let cutoffLabel = "the cutoff";
-        session.rotationCut = null;
-        if (currentSessionId) {
-          try {
-            const path = findClaudeSessionFile(options.cwd, currentSessionId);
-            const cut = path ? computeSeedCut(readFileSync(path, "utf-8"), seedTokens) : null;
-            if (cut) {
-              session.rotationCut = cut;
-              if (cut.boundaryTimestamp) {
-                const d = new Date(cut.boundaryTimestamp);
-                if (!Number.isNaN(d.getTime())) cutoffLabel = compactTimestamp(d);
-              }
-            }
-          } catch (err) {
-            log("mind", `session "${session.name}": failed to pin rotation cut:`, err);
-          }
-        }
-        // biome-ignore lint/suspicious/noTemplateCurlyInString: literal ${cutoff} prompt placeholder
-        const warning = compactionMessage().replaceAll("${cutoff}", cutoffLabel);
-        session.rotationPhase =
-          session.currentMessageId !== undefined ? "warned" : "rotateAfterTurn";
-        const seq = session.channel.push({
-          type: "user",
-          session_id: "",
-          message: { role: "user", content: [{ type: "text", text: warning }] },
-          parent_tool_use_id: null,
-        });
-        session.messageIds.push({ id: undefined, seq });
+      /** Mark the session to rotate in place when the current turn ends. */
+      function scheduleRotation() {
+        session.rotationPending = true;
       }
 
-      // PreCompact backstop: first fire warns + pins + enters the rotation machine
-      // (unless already warned, or the rotation cap is hit) and blocks; second fire
-      // allows the SDK's native compaction — the emergency backstop when rotation never
-      // intervened (a hung turn, or a system prompt too large for rotation to relieve).
+      // PreCompact backstop: first fire schedules a rotation (unless one is already
+      // pending, or the rotation cap is hit) and blocks; second fire allows the SDK's
+      // native compaction — the emergency backstop when rotation never intervened
+      // (a hung turn, or a system prompt too large for rotation to relieve).
       const preCompact = createPreCompactHook(() => {
-        if (!session.rotationPhase && session.consecutiveRotations < MAX_CONSECUTIVE_ROTATIONS) {
-          warnAndPinRotation();
+        if (!session.rotationPending && session.consecutiveRotations < MAX_CONSECUTIVE_ROTATIONS) {
+          log("mind", `session "${session.name}": native compaction — scheduling rotation`);
+          scheduleRotation();
         }
       });
 
@@ -471,13 +407,12 @@ export function createMind(options: {
           // the closest-to-arrival signal available without reading the transcript back.
           session.seeded = false;
           await autoCommit.flushFileChanges();
-          if (session.rotationPhase === "warned") {
-            // The mid-flight turn finished; the queued warning runs next as the wrap-up
-            // turn. Advance — do NOT abort yet, so the mind summarizes with full context.
-            session.rotationPhase = "rotateAfterTurn";
-          } else if (session.rotationPhase === "rotateAfterTurn") {
-            // The wrap-up turn is done (summaries authored) — abort to rotate in place.
-            log("mind", `session "${session.name}": wrap-up turn done — aborting to rotate`);
+          if (session.rotationPending) {
+            // The turn that crossed the threshold is done — abort to rotate in place.
+            log(
+              "mind",
+              `session "${session.name}": turn ended over context limit — aborting to rotate`,
+            );
             streamAbort.abort(new CompactionAbort());
           } else {
             // A healthy turn (context under the threshold) — the rotation streak, if
@@ -491,14 +426,14 @@ export function createMind(options: {
           if (
             maxContextTokens &&
             tokens >= maxContextTokens &&
-            !session.rotationPhase &&
+            !session.rotationPending &&
             session.consecutiveRotations < MAX_CONSECUTIVE_ROTATIONS
           ) {
             log(
               "mind",
-              `session "${session.name}": ${tokens} tokens >= ${maxContextTokens} — warning + pinning rotation`,
+              `session "${session.name}": ${tokens} tokens >= ${maxContextTokens} — rotation pending at turn end`,
             );
-            warnAndPinRotation();
+            scheduleRotation();
           }
         },
       };
@@ -546,17 +481,15 @@ export function createMind(options: {
               currentSessionId
             ) {
               // Stream was aborted to rotate: replace the session with a synthetic one
-              // holding the verbatim recent tail (from the pinned cut), then resume it.
+              // holding the verbatim recent tail (the seedTokens-budget tail), then resume it.
               const rotatedId = rotateSession({
                 cwd: options.cwd,
                 sessionsDir: options.sessionsDir,
                 name: session.name,
                 oldSessionId: currentSessionId,
-                cut: session.rotationCut,
                 seedTokens,
               });
-              session.rotationCut = null;
-              session.rotationPhase = undefined; // state machine consumed
+              session.rotationPending = false;
               if (!rotatedId) {
                 // Rotation couldn't proceed — fall back to a fresh session (no seed).
                 // Unlike a successful rotation (boundary note, verbatim tail, archived
@@ -602,8 +535,8 @@ export function createMind(options: {
               preCompact.reset();
               streamAbort = new AbortController();
               // Recover input the aborted stream had already pulled but not finished
-              // (the wrap-up warning plus anything that arrived mid-turn) so nothing is
-              // dropped when the killed subprocess takes its buffer with it.
+              // (anything that arrived mid-turn) so nothing is dropped when the killed
+              // subprocess takes its buffer with it.
               const pending = session.channel.recover();
               const oldMessageIds = session.messageIds;
               session.channel = createMessageChannel();
@@ -637,8 +570,7 @@ export function createMind(options: {
           // conversation continued when the seeded transcript failed to resume,
           // and don't let a half-entered rotation leak into the fresh session.
           session.seeded = false;
-          session.rotationPhase = undefined;
-          session.rotationCut = null;
+          session.rotationPending = false;
           streamAbort = new AbortController();
           session.channel = createMessageChannel();
           try {
@@ -682,8 +614,8 @@ export function createMind(options: {
       seeded: false,
       seededArchivedAt: null,
       seededCause: "restored",
-      rotationCut: null,
       consecutiveRotations: 0,
+      rotationPending: false,
     };
     sessions.set(name, session);
 
@@ -798,7 +730,7 @@ export function createMind(options: {
           s,
           now,
           idleTimeoutMs,
-          (name) => sessions.get(name)?.rotationPhase !== undefined,
+          (name) => sessions.get(name)?.rotationPending === true,
         ),
       );
       // Reaps run independently; each awaits its own subprocess exit internally.

package/templates/claude/src/lib/hooks/pre-compact.ts

@@ -8,9 +8,9 @@ import { log } from "../logger.js";
  * session in place. This hook covers the case where the SDK decides to auto-compact
  * before (or instead of) that threshold firing:
  *
- *   - First fire: run `onCompact` (warn the mind + pin the rotation boundary, same
- *     as the threshold path) and BLOCK the SDK's native compaction. The wrap-up
- *     turn then ends and the session rotates.
+ *   - First fire: run `onCompact` (schedule a rotation — mark the session to rotate
+ *     at turn end) and BLOCK the SDK's native compaction, so the session rotates
+ *     instead of being natively compacted.
  *   - Second fire: allow the SDK's native compaction as an emergency backstop —
  *     only reachable if rotation never happened (a hung turn, or rotation failed).
  *
@@ -32,10 +32,10 @@ export function createPreCompactHook(onCompact: () => void) {
       return {};
     }
 
-    // Auto-compaction: first pass warns + marks for rotation and blocks; second
-    // pass allows the native compaction as the emergency backstop.
+    // Auto-compaction: first pass schedules a rotation and blocks; second pass
+    // allows the native compaction as the emergency backstop.
     if (!compactBlocked) {
-      log("mind", "blocking auto-compaction — warning mind + marking session for rotation");
+      log("mind", "blocking auto-compaction — marking session for rotation");
       try {
         onCompact();
         compactBlocked = true;

package/templates/claude/src/server.ts

@@ -33,7 +33,6 @@ const mind = createMind({
   thinking: config.thinking,
   effort: config.effort,
   sessionsDir,
-  compactionMessage: config.compactionMessage,
   maxContextTokens: config.compaction?.maxContextTokens,
   sessionIdleMinutes: config.sessionIdleMinutes,
   seedTokens: config.continuity?.seedTokens,