paseo-smart-session 3.4.0 → 3.6.0

package/README.md

@@ -20,7 +20,7 @@ Screenshots use synthetic usage history and sessions.
 paseo plugin install paseo-smart-session
 ```
 
-On first load it registers its Claude Code hooks, touching only entries that point at its own scripts. Paseo attaches its MCP server when an interactive session opens.
+On first load it registers its Claude Code hooks, touching only entries that point at its own scripts. Its agent tools are attached when an interactive session opens: on Paseo 0.15+ they are served through the agent's own Paseo MCP (`smart_checkpoint`, `smart_request_compaction`, …) with no process per agent, and on 0.14 each session gets its own `mcp.mjs` stdio server. Nothing is registered globally; an older version's global `smart-session` entry is removed on load, with a backup beside the file.
 
 ## Use
 
@@ -31,7 +31,7 @@ On first load it registers its Claude Code hooks, touching only entries that poi
 - **Smart Compact and Pause at the limit.** One switch each, what they will do next, and the sessions you changed from your default.
 - **Tokens, last 30 days.** Billable tokens, the cache hit rate and the subagent share, per day, by hour of the week, by workspace and by model, reconstructed from Claude Code's transcripts.
 
-Each session has one pill above its message box: a ring of its context, with a tick at its compact line. Press it to see the detail, when it last saved its task state and compacted, and to switch Smart Compact and Pause at the limit for that session. When the session is paused at the limit the same pill turns amber and says when it resumes, and it stays up even if you hide the pill.
+Each session has one pill above its message box: a ring of its context, with a tick at each of its two compact lines. Press it to see the detail, when it last saved its task state and compacted, and to switch Smart Compact and Pause at the limit for that session. When the session is paused at the limit the same pill turns amber and says when it resumes, and it stays up even if you hide the pill.
 
 ![Pressing the context ring above the message box, then following it to the Smart Session screen and sweeping the window chart: recorded usage up to now, the projection at this pace, and the stretch after it runs out](docs/media/smart-session-flow.gif)
 
@@ -53,7 +53,7 @@ The usual flow is `context_status → checkpoint → request_compaction`, then s
 
 ## How Smart Compact works
 
-As a session fills, hooks send context notices. At the compact line, the agent is asked at the end of its turn whether it wants to compact. Nothing is forced: the agent can compact, defer with a reason, or keep working. A request is delivered only when the agent is idle and its state file is current; `request_compaction` refuses a missing or stale one.
+As a session fills, hooks send context notices. Each window size has two lines. Past the first (the end-of-turn line), the agent is asked at the end of its turn whether it wants to compact. Past the second (the mid-turn line), it is asked straight away, to finish only the step it is on, checkpoint, request the compaction and end its turn so the compaction can land. Nothing is forced: the agent can compact, defer with a reason, or keep working. A request is delivered only when the agent is idle and its state file is current; `request_compaction` refuses a missing or stale one.
 
 After compaction, the agent chooses to stop (`continue_after_compaction: false`), continue with the default prompt to re-read its state, or continue with its own `continue_message`. A `/compact` typed by a person never gets a plugin continuation.
 
@@ -97,8 +97,10 @@ Everything is on one screen, **Settings → Plugins → Smart Session**, in the
 | --- | --- | --- | --- |
 | Smart Compact | Smart Compact | On | Context notices and agent-requested compaction |
 | | Enrol sessions automatically | On | Enrol a session once it writes task state |
-| When to ask | Windows of 400k or more | 30% | Where large windows are asked to compact |
-| | Smaller windows | 85% | Where smaller windows are asked to compact |
+| When to ask | 400k+ windows · end of turn | 30% | Where large windows are asked when a turn ends |
+| | 400k+ windows · mid-turn | 40% | Where large windows are asked mid-turn; must be above the end-of-turn line |
+| | Smaller windows · end of turn | 85% | Where smaller windows are asked when a turn ends |
+| | Smaller windows · mid-turn | 90% | Where smaller windows are asked mid-turn |
 | Pause at the limit (Session Guard) | Pause at the limit (Session Guard) | Off | Pause sessions at the session limit |
 | | Sessions | Every session | Or only the ones you turn on from their pill |
 | | Continue after the reset | On | Off, you continue each one by hand |

package/client/charts.tsx

@@ -36,11 +36,11 @@ function hover(set: (value: number | null) => void, index: number) {
 
 /**
  * A meter: the used share, an optional faint projection of where it lands at the
- * reset, an optional muted pace tick (where an even spend would be) and an optional
- * mark (the compact line on a context bar).
+ * reset, an optional muted pace tick (where an even spend would be) and optional
+ * marks (the two compact lines on a context bar).
  */
-export function Meter({ theme, pct, tone = "default", projected, pace, mark, height = 8, label }: {
-  theme: Theme; pct: number; tone?: Tone; projected?: number | null; pace?: number | null; mark?: number | null; height?: number; label: string;
+export function Meter({ theme, pct, tone = "default", projected, pace, mark, upper, height = 8, label }: {
+  theme: Theme; pct: number; tone?: Tone; projected?: number | null; pace?: number | null; mark?: number | null; upper?: number | null; height?: number; label: string;
 }) {
   const c = theme.colors;
   const used = Math.max(0, Math.min(100, pct));
@@ -57,13 +57,14 @@ export function Meter({ theme, pct, tone = "default", projected, pace, mark, hei
     </View>
     {pace !== null && pace !== undefined ? tick(pace, c.foregroundMuted, "pace") : null}
     {mark !== null && mark !== undefined ? tick(mark, c.foreground, "mark") : null}
+    {upper !== null && upper !== undefined && upper !== mark ? tick(upper, c.foreground, "upper") : null}
   </View>;
 }
 
 /** The context ring glyph, the same object as the composer pill's icon. */
-export function Ring({ size, color, fraction, mark }: { size: number; color: string; fraction: number; mark: number | null }) {
+export function Ring({ size, color, fraction, mark, upper = null }: { size: number; color: string; fraction: number; mark: number | null; upper?: number | null }) {
   // A stronger track at pill size, so the ring reads as a gauge and not as the host's spinner.
-  return <Icon icon={{ svg: contextRing(fraction, mark, size <= 18 ? 0.5 : 0.28) }} size={size} color={color} />;
+  return <Icon icon={{ svg: contextRing(fraction, mark, size <= 18 ? 0.5 : 0.28, mark === null ? null : upper) }} size={size} color={color} />;
 }
 
 /** The percentage held at `t`: readings only climb within a window, so the last one before it stands. */

package/client/overview.tsx

@@ -4,6 +4,7 @@ import { useQuery, useQueryClient } from "@tanstack/react-query";
 import { useEffect, useRef, useSyncExternalStore, type ReactNode } from "react";
 import { Platform, ScrollView, Text, View, type ScrollView as ScrollViewType } from "react-native";
 
+import { outlookShort } from "../shared/compact-lines";
 import { formatCompactTokens, formatDay, formatDuration, formatRelative, isInteresting } from "../shared/format";
 import {
   budgetLine, contextOutlook, forecastWindow, formatMoment, headline, leadWindow, paceLine, resetLine,
@@ -215,11 +216,12 @@ export function makeOverview(client: PluginClientContext, live: Live) {
           : null;
     const notice = guard === undefined ? null : governorNotice(guard);
     // One line each, paired with its moment where there is one.
-    const pastLine = agents.filter((agent) => enrolled.has(agent.agentId) && contextOutlook(agent).past).length;
+    const pastLine = agents.filter((agent) => enrolled.has(agent.agentId) && contextOutlook(agent).past && !contextOutlook(agent).pastNow).length;
+    const pastUpper = agents.filter((agent) => enrolled.has(agent.agentId) && contextOutlook(agent).pastNow).length;
     const compactLine: ReactNode = settings === undefined ? "…" : !settings.enabled ? "Off · nothing is asked or compacted"
       // Only the clause that is state wears the state colour.
-      : pastLine > 0 ? <>{`${enrolled.size} enrolled · `}<Text style={{ color: c.statusWarning }}>{`${pastLine} past ${pastLine === 1 ? "its" : "their"} compact line, asked at the end of a turn`}</Text></>
-        : `${enrolled.size} enrolled · asked past ${settings.thresholds.large.compact}% of a ${formatCompactTokens(settings.thresholds.largeWindowFrom)}+ window, ${settings.thresholds.small.compact}% of a smaller one`;
+      : pastUpper + pastLine > 0 ? <>{`${enrolled.size} enrolled`}{pastUpper > 0 ? <Text style={{ color: c.statusDanger }}>{` · ${pastUpper} asked mid-turn`}</Text> : null}{pastLine > 0 ? <Text style={{ color: c.statusWarning }}>{` · ${pastLine} asked at the end of a turn`}</Text> : null}</>
+        : `${enrolled.size} enrolled · asked at ${settings.thresholds.large.compact}% / ${settings.thresholds.large.now}% of a ${formatCompactTokens(settings.thresholds.largeWindowFrom)}+ window, ${settings.thresholds.small.compact}% / ${settings.thresholds.small.now}% of a smaller one`;
     const guardState: { line: string; tone: Tone } = (() => {
       if (guardOn === null) return { line: "…", tone: "default" };
       if (!guardOn) return { line: paused.length > 0 ? `Off · ${paused.length} paused still ${paused.length === 1 ? "waits" : "wait"} for the reset` : "Off · sessions run into the limit", tone: "default" };
@@ -308,10 +310,13 @@ export function makeOverview(client: PluginClientContext, live: Live) {
               : <Card theme={theme}>{agents.map((agent, i) => {
                 const outlook = contextOutlook(agent);
                 const on = enrolled.has(agent.agentId);
-                const parts = [`${formatCompactTokens(agent.usedTokens)} of ${formatCompactTokens(agent.maxTokens)}`, `compacts at ${agent.compactAtPct}%`];
+                const upper = agent.compactNowAtPct ?? null;
+                // A session nobody enrolled is never asked, so it gets no lines and no ticks.
+                const parts = [`${formatCompactTokens(agent.usedTokens)} of ${formatCompactTokens(agent.maxTokens)}`];
+                if (!on) { if (compact) parts.push("not enrolled"); }
+                else parts.push(upper === null ? `compacts at ${agent.compactAtPct}%` : `asks at ${agent.compactAtPct}%, mid-turn at ${upper}%`);
                 if (agent.growthTokensPerHour !== null && agent.growthTokensPerHour > 0) parts.push(`+${formatCompactTokens(agent.growthTokensPerHour)}/h`);
-                const outlookLine = outlook.past ? (on ? "Past its compact line · asked at the end of a turn" : "Past its compact line · not enrolled")
-                  : outlook.untilCompactMs !== null ? `Reaches it in ~${formatDuration(outlook.untilCompactMs)}` : null;
+                const outlookLine = outlookShort(outlook, on);
                 return <CardRow key={agent.agentId} theme={theme} first={i === 0} style={{ gap: 6 }}
                   onPress={navigation ? () => navigation.openAgent({ agentId: agent.agentId }) : undefined} accessibilityLabel={`Open ${agent.title ?? "session"}`}>
                   <View style={{ flexDirection: "row", alignItems: "center", gap: 8 }}>
@@ -320,10 +325,10 @@ export function makeOverview(client: PluginClientContext, live: Live) {
                     <View style={{ flex: 1 }} />
                     {governed.some((p) => p.agentId === agent.agentId) ? <Chip theme={theme} icon="Pause" label="Paused" color={c.statusWarning} /> : null}
                     {on ? <Chip theme={theme} label="Smart Compact" /> : compact ? null : <Text style={t.small}>Not enrolled</Text>}
-                    <Ring size={16} color={outlook.tone !== "default" ? toneFill(c, outlook.tone) : on ? c.foreground : c.foregroundMuted} fraction={outlook.pct / 100} mark={on ? agent.compactAtPct / 100 : null} />
+                    <Ring size={16} color={outlook.tone !== "default" ? toneFill(c, outlook.tone) : on ? c.foreground : c.foregroundMuted} fraction={outlook.pct / 100} mark={on ? agent.compactAtPct / 100 : null} upper={upper === null ? null : upper / 100} />
                     <Text style={{ color: c.foreground, fontSize: 15, lineHeight: 20, fontWeight: "600", minWidth: 36, textAlign: "right", ...tabular }}>{`${Math.round(outlook.pct)}%`}</Text>
                   </View>
-                  <Meter theme={theme} pct={outlook.pct} tone={outlook.tone} mark={agent.compactAtPct} height={6} label={`${agent.title ?? "Session"}: ${Math.round(outlook.pct)}% of its context, compacts at ${agent.compactAtPct}%`} />
+                  <Meter theme={theme} pct={outlook.pct} tone={outlook.tone} mark={on ? agent.compactAtPct : null} upper={on ? upper : null} height={6} label={`${agent.title ?? "Session"}: ${Math.round(outlook.pct)}% of its context${on ? `, asked at ${agent.compactAtPct}%${upper === null ? "" : ` and mid-turn at ${upper}%`}` : ", not enrolled"}`} />
                   <View style={{ flexDirection: "row", flexWrap: "wrap", columnGap: 10, rowGap: 2 }}>
                     <Text style={t.meta}>{parts.join(" · ")}</Text>
                     {outlookLine ? <Text style={{ ...t.meta, color: outlook.past ? toneColor(c, outlook.tone) : c.foregroundMuted }}>{outlookLine}</Text> : null}

package/client/pill-view.ts

@@ -18,16 +18,17 @@ export function pillPresentation(agent: Pick<DirectoryAgent, "usedTokens" | "max
     return {
       label: compactOn ? "Smart Compact" : "Context",
       title: `${compactWords ?? "Smart Compact on"} · no context reading yet`,
-      fraction: 0, mark: null as number | null, tone: "default" as const, pct: null as number | null,
+      fraction: 0, mark: null as number | null, upper: null as number | null, tone: "default" as const, pct: null as number | null,
     };
   }
-  const compactAtPct = profileFor(agent.maxTokens!, thresholds ?? undefined).compact;
-  const outlook = contextOutlook({ usedTokens: agent.usedTokens!, maxTokens: agent.maxTokens!, compactAtPct });
+  const profile = profileFor(agent.maxTokens!, thresholds ?? undefined);
+  const outlook = contextOutlook({ usedTokens: agent.usedTokens!, maxTokens: agent.maxTokens!, compactAtPct: profile.compact, compactNowAtPct: profile.now });
   const pct = Math.round(outlook.pct);
+  // Short on purpose: the phone sheet uses the title as its one-line header.
   return {
     label: `${pct}%`,
-    title: `Context ${pct}% full · ${compactWords ?? `Smart Compact asks at ${compactAtPct}%`}`,
-    fraction: outlook.pct / 100, mark: compactAtPct / 100, tone: outlook.tone, pct,
+    title: `Context ${pct}% full · ${compactWords ?? `asks at ${profile.compact}%, mid-turn at ${profile.now}%`}`,
+    fraction: outlook.pct / 100, mark: profile.compact / 100, upper: profile.now / 100 as number | null, tone: outlook.tone, pct,
   };
 }
 

package/client/pill.tsx

@@ -4,7 +4,7 @@
  *
  * Normally it answers how full this session's context is and whether Smart Compact
  * will ask it to compact itself: the icon is a ring that fills with the context and
- * carries a tick at the compact line, the label is the percentage. Protection adds
+ * carries a tick at each compact line (end of turn, then mid-turn), the label is the percentage. Protection adds
  * nothing while it simply protects; the quiet case stays quiet. When this session is
  * paused at the session limit the pill turns into the pause itself, an amber pause
  * glyph and the moment it resumes, and it stays on the composer even when the pill
@@ -56,7 +56,7 @@ function makeIcon(agents: AgentDirectory) {
     const enrolled = current.compactOn && current.enrolled.has(agentId);
     const view = pillPresentation(agents.current().get(agentId), enrolled, current.thresholds, current.compactOn);
     const color = view.tone !== "default" ? toneFill(c, view.tone) : enrolled ? c.foreground : c.foregroundMuted;
-    return <Ring size={props.size} color={color} fraction={view.fraction} mark={enrolled ? view.mark : null} />;
+    return <Ring size={props.size} color={color} fraction={view.fraction} mark={enrolled ? view.mark : null} upper={view.upper} />;
   };
 }
 

package/client/popover.tsx

@@ -5,6 +5,7 @@ import { useRpc, type PluginButtonContentProps, type PluginClientContext } from
 import { useQuery } from "@tanstack/react-query";
 
 import { formatClock, formatCompactTokens, formatDuration, formatRelative } from "../shared/format";
+import { linesSummary, outlookSentence } from "../shared/compact-lines";
 import { contextOutlook } from "../shared/forecast";
 import { listCompactions, setEnrolment, type CompactionRequest } from "../shared/governor";
 import { cancelResumeRpc, dismissPauseRpc, resumeNowRpc, setProtectionRpc, statusRpc } from "../shared/guard/contracts";
@@ -99,16 +100,14 @@ export function makeContextPopover(client: PluginClientContext, agents: AgentDir
 
     const head = (() => {
       if (used === null || max === null) return null;
-      const compactAtPct = row?.compactAtPct ?? profileFor(max, pills.thresholds ?? undefined).compact;
-      return { compactAtPct, outlook: contextOutlook({ usedTokens: used, maxTokens: max, compactAtPct, growthTokensPerHour: row?.growthTokensPerHour ?? null }) };
+      const profile = profileFor(max, pills.thresholds ?? undefined);
+      const compactAtPct = row?.compactAtPct ?? profile.compact;
+      const nowAtPct = row?.compactNowAtPct ?? profile.now;
+      return { compactAtPct, nowAtPct, outlook: contextOutlook({ usedTokens: used, maxTokens: max, compactAtPct, compactNowAtPct: nowAtPct, growthTokensPerHour: row?.growthTokensPerHour ?? null }) };
     })();
     const sentence = head === null
       ? { line: "No context reading yet. A session reports one after its first turn.", tone: "default" as const }
-      : head.outlook.past
-        ? { line: enrolled ? "Past its compact line. Smart Compact asks it at the end of a turn whether to compact." : compactOn ? "Past its compact line, but not enrolled, so nothing will ask it." : "Past its compact line. Smart Compact is off, so nothing will ask it.", tone: head.outlook.tone }
-        : head.outlook.untilCompactMs !== null
-          ? { line: `Reaches its compact line in about ${formatDuration(head.outlook.untilCompactMs)} at +${formatCompactTokens(row!.growthTokensPerHour!)}/h.`, tone: "default" as const }
-          : { line: "Below its compact line and not growing right now.", tone: "default" as const };
+      : outlookSentence(head.outlook, { enrolled, compactOn, growthPerHour: row?.growthTokensPerHour ?? null });
     const latest = compactions.data?.items[0];
     const state = row?.stateWrittenAt ?? null;
     const facts: [string, string][] = [
@@ -205,16 +204,16 @@ export function makeContextPopover(client: PluginClientContext, agents: AgentDir
       {pausePart}
       <View style={[{ gap: 12 }, pausePart === null ? null : part]}>
         <View style={{ flexDirection: "row", alignItems: "center", gap: 12 }}>
-          <Ring size={pausePart === null ? 40 : 28} color={ringColor} fraction={head === null ? 0 : head.outlook.pct / 100} mark={head === null || !enrolled ? null : head.compactAtPct / 100} />
+          <Ring size={pausePart === null ? 40 : 28} color={ringColor} fraction={head === null ? 0 : head.outlook.pct / 100} mark={head === null || !enrolled ? null : head.compactAtPct / 100} upper={head === null ? null : head.nowAtPct / 100} />
           <View style={{ flex: 1, gap: 1 }}>
             <View style={{ flexDirection: "row", alignItems: "baseline", gap: 6 }}>
               <Text style={{ color: c.foreground, fontSize: pausePart === null ? 22 : 15, lineHeight: pausePart === null ? 28 : 20, fontWeight: "600", ...tabular }}>{head === null ? "—" : `${Math.round(head.outlook.pct)}%`}</Text>
               <Text style={t.meta}>{max === null ? "context" : `of ${formatCompactTokens(max)} context`}</Text>
             </View>
-            <Text style={t.meta}>{head === null || used === null ? "Waiting for a reading" : `${formatCompactTokens(used)} tokens · compacts at ${head.compactAtPct}% (${formatCompactTokens(head.outlook.compactTokens)})`}</Text>
+            <Text style={t.meta}>{head === null || used === null ? "Waiting for a reading" : `${formatCompactTokens(used)} tokens · ${linesSummary(head.compactAtPct, head.nowAtPct)}`}</Text>
           </View>
         </View>
-        {head === null || pausePart !== null ? null : <Meter theme={theme} pct={head.outlook.pct} tone={head.outlook.tone} mark={head.compactAtPct} height={6} label={`Context ${Math.round(head.outlook.pct)}% full, compacts at ${head.compactAtPct}%`} />}
+        {head === null || pausePart !== null ? null : <Meter theme={theme} pct={head.outlook.pct} tone={head.outlook.tone} mark={head.compactAtPct} upper={head.nowAtPct} height={6} label={`Context ${Math.round(head.outlook.pct)}% full. Smart Compact ${linesSummary(head.compactAtPct, head.nowAtPct)}`} />}
         {pausePart !== null ? null : <Text style={{ ...t.body, color: sentence.tone === "default" ? c.foreground : toneColor(c, sentence.tone) }}>{sentence.line}</Text>}
       </View>
       {pausePart !== null ? null : <View style={part}>
@@ -228,7 +227,7 @@ export function makeContextPopover(client: PluginClientContext, agents: AgentDir
         {compactOn ? <View style={{ flexDirection: "row", alignItems: "center", gap: 12 }}>
           <View style={{ flex: 1, gap: 2 }}>
             <Text style={t.label}>Smart Compact</Text>
-            <Text style={t.meta}>{enrolled ? `Asked once past ${head?.compactAtPct ?? "its"}%${head === null ? " line" : ""}. Never forced.` : "Never asked to compact. The agent can still request it."}</Text>
+            <Text style={t.meta}>{enrolled ? "Asked at the end of a turn, then mid-turn. Never forced." : "Never asked to compact. The agent can still request it."}</Text>
           </View>
           <Switch theme={theme} label="Smart Compact for this session" hideLabel value={enrolled} disabled={saving !== null} compact={compact} onChange={(next) => void toggleCompact(next)} />
         </View> : <View style={{ flexDirection: "row", alignItems: "center", gap: 8 }}>

package/client/settings.tsx

@@ -12,13 +12,20 @@ import { isPending, type Policy } from "../shared/guard/policy";
 import { checkTiming, timingOf, type Timing } from "../shared/guard/timing";
 import { governorNotice } from "../shared/guard/presentation";
 import { getSettings, installStatus, setSettings } from "../shared/smart-session";
-import { withCompactThreshold } from "../shared/thresholds";
+import { DEFAULT_THRESHOLDS, linesProblem, withCompactThreshold } from "../shared/thresholds";
 import { broadcastDisplay } from "./display";
 import { guardSnapshot, refreshGuard, subscribeGuard } from "./guard/status";
 import { Button, errorText } from "./kit";
 import { refreshPills } from "./pill-store";
 
 /** A whole number from 1 to 99, or null. */
+/** The four editable lines: the end-of-turn and mid-turn line for each window size. */
+interface Lines<T> { large: T; largeNow: T; small: T; smallNow: T }
+
+function stringLines(lines: Lines<number>): Lines<string> {
+  return { large: String(lines.large), largeNow: String(lines.largeNow), small: String(lines.small), smallNow: String(lines.smallNow) };
+}
+
 function percent(value: string): number | null {
   const parsed = Number(value.trim());
   return Number.isInteger(parsed) && parsed >= 1 && parsed <= 99 ? parsed : null;
@@ -47,12 +54,12 @@ export function makeSettings(client: PluginClientContext) {
     const display = useSettings(displayPreferences);
     const status = useSyncExternalStore(subscribeGuard, guardSnapshot, guardSnapshot);
     const [saving, setSaving] = useState(false);
-    const [draft, setDraft] = useState<{ large: string; small: string } | null>(null);
+    const [draft, setDraft] = useState<Lines<string> | null>(null);
     const [inputKey, setInputKey] = useState(0);
     const [timing, setTiming] = useState<{ draft: Timing; revision: string } | null>(null);
     const [timingTried, setTimingTried] = useState(false);
     const settings = query.data?.settings;
-    useEffect(() => { setDraft(null); }, [settings?.thresholds.large.compact, settings?.thresholds.small.compact]);
+    useEffect(() => { setDraft(null); }, [settings?.thresholds.large.compact, settings?.thresholds.small.compact, settings?.thresholds.large.now, settings?.thresholds.small.now]);
 
     // The pill and sidebar follow these documents; `useSettings` hears every client's change.
     const guardValues = guard.status === "ready" ? guard.values : undefined;
@@ -93,9 +100,22 @@ export function makeSettings(client: PluginClientContext) {
       else toast.show(next ? "Pill shown on every session" : "Pill hidden");
     }
 
-    const large = draft === null ? settings.thresholds.large.compact : percent(draft.large);
-    const small = draft === null ? settings.thresholds.small.compact : percent(draft.small);
-    const changed = draft !== null && large !== null && small !== null && (large !== settings.thresholds.large.compact || small !== settings.thresholds.small.compact);
+    const savedLines: Lines<number> = {
+      large: settings.thresholds.large.compact, largeNow: settings.thresholds.large.now,
+      small: settings.thresholds.small.compact, smallNow: settings.thresholds.small.now,
+    };
+    const lines: Lines<number | null> = draft === null ? savedLines
+      : { large: percent(draft.large), largeNow: percent(draft.largeNow), small: percent(draft.small), smallNow: percent(draft.smallNow) };
+    const { large, largeNow, small, smallNow } = lines;
+    // A blank or fractional field is its own error; an upper line not above its lower one is the pair's.
+    const fieldProblem = (value: number | null) => (draft !== null && value === null ? "Enter a whole number from 1 to 99." : null);
+    const pairProblem = (lower: number | null, upper: number | null) => (draft !== null && lower !== null && upper !== null ? linesProblem(lower, upper) : null);
+    const largePair = pairProblem(large, largeNow);
+    const smallPair = pairProblem(small, smallNow);
+    const valid = large !== null && largeNow !== null && small !== null && smallNow !== null && largePair === null && smallPair === null;
+    const changed = draft !== null && valid && (Object.keys(savedLines) as (keyof Lines<number>)[]).some((key) => lines[key] !== savedLines[key]);
+    const edit = (key: keyof Lines<string>) => (value: string) =>
+      setDraft((previous) => ({ ...(previous ?? stringLines(savedLines)), [key]: value }));
     const off = !settings.enabled || saving;
     const report = install.data?.report;
     const hooksHint = report === undefined ? "Keeps this plugin's context and compaction hooks in ~/.claude/settings.json."
@@ -127,26 +147,28 @@ export function makeSettings(client: PluginClientContext) {
     const pillOn = settings.showPill && (display.status !== "ready" || display.values.enable_composer_button);
 
     return <ScrollView style={{ flex: 1 }} contentContainerStyle={{ paddingVertical: 8, gap: 24 }}>
-      <SettingsSection title="Smart Compact" info="A session is never compacted unless it agrees. At the end of a turn past its line, it is asked whether to compact; it can compact, put it off with a reason, or keep working.">
+      <SettingsSection title="Smart Compact" info="A session is never compacted unless it agrees. Past its end-of-turn line it is asked when its turn ends; past its mid-turn line it is asked straight away and told not to start anything new. Either way it can compact, put it off with a reason, or keep working.">
         <SettingsCard>
-          <SettingsSwitch label="Smart Compact" hint={settings.enabled ? "On. Context notices, and the question at the compact line." : "Off. Nothing is asked and nothing is compacted."}
+          <SettingsSwitch label="Smart Compact" hint={settings.enabled ? "On. Context notices, and the question at the end-of-turn and mid-turn lines." : "Off. Nothing is asked and nothing is compacted."}
             value={settings.enabled} disabled={saving} onValueChange={(enabled) => void save({ enabled }, enabled ? "Smart Compact on" : "Smart Compact off")} />
           <SettingsSwitch label="Enrol sessions automatically" hint="A session that saves its task state with the checkpoint tool is enrolled by that alone. Off, enrol each one from its pill."
             value={settings.autoEnrol} disabled={off} onValueChange={(autoEnrol) => void save({ autoEnrol }, autoEnrol ? "Sessions enrol themselves" : "Sessions are enrolled one at a time")} />
         </SettingsCard>
       </SettingsSection>
 
-      <SettingsSection title="When to ask" info="What wears a session down is its absolute size, not its share of the window, so large windows are asked much earlier. Earlier context notices move down with the line.">
+      <SettingsSection title="When to ask" info="Two lines per window size: the end-of-turn line, where a session is asked when its turn ends, and the mid-turn line above it, where it is asked straight away. What wears a session down is its absolute size, not its share of the window, so large windows are asked much earlier.">
         <SettingsCard>
-          <SettingsInput key={`large-${inputKey}`} label={`Windows of ${from} or more (%)`} hint={`Asked at ${large ?? "—"}%, about ${large === null ? "—" : formatCompactTokens((large / 100) * 1_000_000)} tokens of a 1M window. Default 30.`}
-            initialValue={String(settings.thresholds.large.compact)} disabled={off} error={draft !== null && large === null ? "Enter a whole number from 1 to 99." : null}
-            onChangeText={(value) => setDraft((previous) => ({ large: value, small: previous?.small ?? String(settings.thresholds.small.compact) }))} />
-          <SettingsInput key={`small-${inputKey}`} label="Smaller windows (%)" hint={`Asked at ${small ?? "—"}% of a window under ${from}. Default 85.`}
-            initialValue={String(settings.thresholds.small.compact)} disabled={off} error={draft !== null && small === null ? "Enter a whole number from 1 to 99." : null}
-            onChangeText={(value) => setDraft((previous) => ({ small: value, large: previous?.large ?? String(settings.thresholds.large.compact) }))} />
+          <SettingsInput key={`large-${inputKey}`} label={`${from}+ windows · end of turn (%)`} hint={`At ${large ?? "—"}% (about ${large === null ? "—" : formatCompactTokens((large / 100) * 1_000_000)} tokens of a 1M window) a session is asked whether to compact when its turn ends. Default ${DEFAULT_THRESHOLDS.large.compact}.`}
+            initialValue={String(savedLines.large)} disabled={off} error={fieldProblem(large)} onChangeText={edit("large")} />
+          <SettingsInput key={`largeNow-${inputKey}`} label={`${from}+ windows · mid-turn (%)`} hint={`At ${largeNow ?? "—"}% (about ${largeNow === null ? "—" : formatCompactTokens((largeNow / 100) * 1_000_000)} tokens) it is asked straight away to finish its step and compact. Default ${DEFAULT_THRESHOLDS.large.now}.`}
+            initialValue={String(savedLines.largeNow)} disabled={off} error={fieldProblem(largeNow) ?? largePair} onChangeText={edit("largeNow")} />
+          <SettingsInput key={`small-${inputKey}`} label="Smaller windows · end of turn (%)" hint={`At ${small ?? "—"}% (about ${small === null ? "—" : formatCompactTokens((small / 100) * 200_000)} tokens of a 200k window) a session is asked when its turn ends. Default ${DEFAULT_THRESHOLDS.small.compact}.`}
+            initialValue={String(savedLines.small)} disabled={off} error={fieldProblem(small)} onChangeText={edit("small")} />
+          <SettingsInput key={`smallNow-${inputKey}`} label="Smaller windows · mid-turn (%)" hint={`At ${smallNow ?? "—"}% (about ${smallNow === null ? "—" : formatCompactTokens((smallNow / 100) * 200_000)} tokens) it is asked straight away to finish its step and compact. Default ${DEFAULT_THRESHOLDS.small.now}.`}
+            initialValue={String(savedLines.smallNow)} disabled={off} error={fieldProblem(smallNow) ?? smallPair} onChangeText={edit("smallNow")} />
           {draft !== null ? <>
-            <SettingsAction label="Apply the new lines" hint={changed ? `Large ${large}% · small ${small}%` : "Nothing to apply yet"} actionLabel="Save" disabled={!changed || off}
-              onPress={() => void save({ thresholds: { ...settings.thresholds, large: withCompactThreshold(settings.thresholds.large, large!), small: withCompactThreshold(settings.thresholds.small, small!) } }, `Smart Compact asks at ${large}% and ${small}%`)} />
+            <SettingsAction label="Apply the new lines" hint={changed ? `Large ${large}% then ${largeNow}% · small ${small}% then ${smallNow}%` : valid ? "Nothing to apply yet" : "Fix the lines above first"} actionLabel="Save" disabled={!changed || off}
+              onPress={() => void save({ thresholds: { ...settings.thresholds, large: withCompactThreshold(settings.thresholds.large, large!, largeNow!), small: withCompactThreshold(settings.thresholds.small, small!, smallNow!) } }, `Smart Compact asks at ${large}% / ${largeNow}% and ${small}% / ${smallNow}%`)} />
             <SettingsAction label="Keep the saved lines" actionLabel="Discard" disabled={saving} onPress={() => { setDraft(null); setInputKey((k) => k + 1); }} />
           </> : null}
         </SettingsCard>

package/hooks/ask-compact.mjs

@@ -19,102 +19,13 @@
  *     session is done" from "this session is waiting on work still in flight".
  *
  * It stays completely silent unless there is something worth stopping for.
- */
-
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-import { isEnrolled, occupancy, readSettings } from "./context.mjs";
-import { pluginDir, stateAgeSeconds, statePath } from "./pointer.mjs";
-import { readLedger, recordAsk, shouldAsk } from "./asks.mjs";
-
-/**
- * A compaction that had to be repeated within minutes is not solving the problem —
- * something in the loop is refilling the window as fast as it is emptied, and
- * another compaction just burns tokens on summarizing. Claude Code detects the same
- * pathology and calls it thrashing.
- */
-const THRASH_WINDOW_MS = 15 * 60_000;
-
-/** The governor's queue, read directly: a hook must not open a daemon connection. */
-function compactions() {
-  try {
-    const parsed = JSON.parse(readFileSync(join(pluginDir(), "compactions.json"), "utf8"));
-    return Array.isArray(parsed?.items) ? parsed.items : [];
-  } catch {
-    return [];
-  }
-}
-
-/** Already asked and waiting to be delivered: there is nothing to add. */
-function alreadyQueued(items, agentId) {
-  return items.some(
-    (item) => item.agentId === agentId && (item.state === "pending" || item.state === "sending"),
-  );
-}
-
-function thrashing(items, agentId, now = Date.now()) {
-  return items.some(
-    (item) =>
-      item.agentId === agentId &&
-      item.state === "sent" &&
-      item.settledAt !== null &&
-      now - Date.parse(item.settledAt) < THRASH_WINDOW_MS,
-  );
-}
-
-/**
- * The question.
- *
- * On a large window the headline is the token count, not the percentage: "30% full"
- * sounds like there is plenty of room, and 300,000 tokens does not.
  *
- * It has to be answerable in one turn, so it names the tools and says what to do
- * with each, and it has to be refusable, or it is not a question — hence the
- * deferral, which the agent is told about in the same breath.
+ * This is the lower of Smart Compact's two lines. The upper one asks mid-turn from
+ * `context-threshold.mjs`; the text and the guards both use are in `ask.mjs`.
  */
-function ask({ used, max, pct }, path, age, freshMinutes) {
-  const stale = age === null || age > freshMinutes * 60;
-  const lines = [
-    `Smart Compact: this session holds ${used.toLocaleString()} tokens (${pct}% of a ${max.toLocaleString()}-token window).`,
-    max >= 400_000
-      ? "That is worth compacting now even though the window is nowhere near full — what costs you is the prefix re-read on every turn, not the ceiling."
-      : "This is the point where recall degrades noticeably and every turn re-reads an expensive prefix.",
-    "Compacting is your call, not this plugin's, and nothing will happen unless you ask. Do one of these before you stop:",
-  ];
 
-  if (stale) {
-    lines.push(
-      age === null
-        ? `1. There is no task state on disk yet. Call checkpoint — goal, the step in progress and its exact next action, decisions and why, and every approach already tried and rejected — then call request_compaction. Anything you do not write down is gone after the compaction.`
-        : `1. Your task state at ${path} was last written ${Math.round(age / 60)} minutes ago, so it may predate recent work. Call checkpoint to bring it up to date, then call request_compaction.`,
-    );
-  } else {
-    lines.push(
-      `1. Your task state at ${path} is current, so this is cheap: call request_compaction with a one-line reason. If work remains, ask it to continue (and optionally choose the follow-up message); if the task is finished, ask it not to continue.`,
-    );
-  }
-
-  lines.push(
-    "2. Or, if this is the wrong moment — mid-refactor, a tool sequence half finished, an answer the user is waiting on — call defer_compaction with a reason and you will not be asked again for a while.",
-    "Either way, do it now and then stop. A queued compaction is delivered as a real /compact once this session goes idle; a follow-up turn is sent only if you requested one.",
-  );
-  return lines.join("\n");
-}
-
-/**
- * What to say instead, when compacting is not the answer.
- *
- * Said once, as an ask, so it counts against the same latch: repeating it every
- * turn would be the nagging this hook exists to avoid.
- */
-function thrashAdvice({ used, pct }) {
-  return [
-    `Smart Compact: this session refilled to ${used.toLocaleString()} tokens (${pct}%) within minutes of its last compaction.`,
-    "Compacting again would not help — something in this loop is reading far more than it keeps, so the window would refill just as fast and you would pay for another summary.",
-    "Write what you have learned to your state file with checkpoint, then either change the approach so it stops re-reading the same material, or finish and let a fresh session take the rest.",
-  ].join("\n");
-}
+import { askable, compose } from "./ask.mjs";
+import { recordAsk, shouldAsk } from "./asks.mjs";
 
 function emit(text) {
   process.stdout.write(
@@ -152,35 +63,18 @@ async function main() {
   // Compacting through the second one discards the context that work reports into.
   if (Array.isArray(event.background_tasks) && event.background_tasks.length > 0) return;
 
-  const transcriptPath = event.transcript_path;
-  const sessionId = event.session_id;
-  if (typeof transcriptPath !== "string" || typeof sessionId !== "string") return;
-
-  const settings = readSettings();
-  if (!settings.enabled) return;
-
-  const agentId = process.env.PASEO_AGENT_ID ?? null;
-  if (!isEnrolled(agentId, settings)) return;
-
-  const now = occupancy(transcriptPath, settings);
-  if (now === null || now.pct < now.profile.compact) return;
-
-  const ledger = readLedger(sessionId);
-  if (!shouldAsk(ledger, now.pct)) return;
-
-  const queue = compactions();
-  if (alreadyQueued(queue, agentId)) return;
-
-  const path = statePath();
-  const age = stateAgeSeconds(path);
-  const text = thrashing(queue, agentId)
-    ? thrashAdvice(now)
-    : ask(now, path, age, settings.freshStateMinutes);
+  // The lower line, "when convenient". Past the upper one the agent was already
+  // asked mid-turn by `context-threshold.mjs`; this is the turn-end follow-up, under
+  // this line's own back-off, unless that ask was answered.
+  const context = askable(event);
+  if (context === null) return;
+  const decision = compose(context, "compact", shouldAsk);
+  if (decision === null) return;
 
   // Recorded only after it has reached stdout: a latch set on an ask that was never
   // delivered would silence the next one for nothing.
-  emit(text);
-  recordAsk(sessionId, ledger, now.pct);
+  emit(decision.text);
+  recordAsk(context.sessionId, decision.ledger, context.reading.pct);
 }
 
 void main();