paseo-smart-session 3.4.0 → 3.5.0

package/README.md

@@ -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();

package/hooks/ask.mjs

@@ -0,0 +1,193 @@
+/**
+ * Smart Compact's question, shared by the two hooks that put it.
+ *
+ * There are two lines per window. Past the lower one, `ask-compact.mjs` on `Stop`
+ * asks at the end of a turn, when it is convenient. Past the upper one,
+ * `context-threshold.mjs` on `PostToolUse` asks right away, mid-turn, because a
+ * session that far along should not start anything new before compacting. Both
+ * read the same settings, the same enrolment, the same queue and the same ledger,
+ * and the guards live here so the two can never disagree about whether to speak.
+ *
+ * Either way the plugin only asks. The agent answers with its own tool call, and
+ * a queued compaction is still delivered once the session goes idle.
+ */
+
+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 } 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.
+ */
+export const THRASH_WINDOW_MS = 15 * 60_000;
+
+/** The governor's queue, read directly: a hook must not open a daemon connection. */
+export 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. */
+export function alreadyQueued(items, agentId) {
+  return items.some(
+    (item) => item.agentId === agentId && (item.state === "pending" || item.state === "sending"),
+  );
+}
+
+export 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,
+  );
+}
+
+function headline({ used, max, pct }) {
+  return `this session holds ${used.toLocaleString()} tokens (${pct}% of a ${max.toLocaleString()}-token window)`;
+}
+
+function why(max) {
+  return 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.";
+}
+
+/** The checkpoint half of either ask, which depends on how old the state file is. */
+function checkpointStep(path, age, freshMinutes, then) {
+  if (age === null) {
+    return `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 ${then} Anything you do not write down is gone after the compaction.`;
+  }
+  if (age > freshMinutes * 60) {
+    return `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 ${then}`;
+  }
+  return null;
+}
+
+/**
+ * The end-of-turn question, at the lower line.
+ *
+ * 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.
+ */
+export function askAtTurnEnd(reading, path, age, freshMinutes) {
+  const lines = [
+    `Smart Compact: ${headline(reading)}.`,
+    why(reading.max),
+    "Compacting is your call, not this plugin's, and nothing will happen unless you ask. Do one of these before you stop:",
+  ];
+  const stale = checkpointStep(path, age, freshMinutes, "call request_compaction.");
+  lines.push(
+    stale !== null
+      ? `1. ${stale}`
+      : `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");
+}
+
+/**
+ * The mid-turn question, at the upper line.
+ *
+ * It arrives after a tool call, in the middle of the agent's work, so it says what
+ * to finish (only the step already under way) and what not to start. The compaction
+ * still lands only once the session is idle, which is why it ends with "then end
+ * your turn": without that the agent would queue it and carry on for an hour.
+ */
+export function askRightAway(reading, upper, path, age, freshMinutes) {
+  const lines = [
+    `Smart Compact: ${headline(reading)}, past its upper line of ${upper}%.`,
+    `This is the line where you should not push on. ${why(reading.max)}`,
+    "Finish only the atomic step you are on — the edit half applied, the command already running — and do not start a new step, read a large file or begin another tool sequence. Then:",
+  ];
+  const stale = checkpointStep(path, age, freshMinutes, "go on to step 2.");
+  lines.push(stale !== null ? `1. ${stale}` : `1. Your task state at ${path} is current, so go straight to step 2.`);
+  lines.push(
+    "2. Call request_compaction with continue_after_compaction set to true and a one-line reason. If you know the next action, put it in continue_message so the follow-up names it.",
+    "3. End your turn. The compaction is delivered as a real /compact once this session goes idle, so it cannot land while you keep working.",
+    "If stopping now would leave something broken that the next turn could not pick up, call defer_compaction with that reason instead — you will be asked again when it runs out. Do not defer just to keep going.",
+  );
+  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 these hooks exist to avoid.
+ */
+export 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");
+}
+
+/**
+ * Whether there is anyone to ask, and how full they are.
+ *
+ * The guards both hooks share: a subagent is never asked (its window is its own),
+ * Smart Compact must be on, the session must be enrolled, and the transcript must
+ * have a reading. Returns null whenever the answer is "say nothing".
+ */
+export function askable(event) {
+  if (event.agent_id !== undefined && event.agent_id !== null) return null;
+  const transcriptPath = event.transcript_path;
+  const sessionId = event.session_id;
+  if (typeof transcriptPath !== "string" || typeof sessionId !== "string") return null;
+
+  const settings = readSettings();
+  if (!settings.enabled) return null;
+
+  const agentId = process.env.PASEO_AGENT_ID ?? null;
+  if (!isEnrolled(agentId, settings)) return null;
+
+  const reading = occupancy(transcriptPath, settings);
+  if (reading === null) return null;
+  return { sessionId, agentId, settings, reading };
+}
+
+/**
+ * The text to put to the agent at one of the two lines, or null for silence.
+ *
+ * `line` is "compact" (end of turn) or "now" (right away). `allowed` is that
+ * line's own back-off rule over the ledger. The queue is read last because it is
+ * the most expensive check and the others usually decide first.
+ */
+export function compose(context, line, allowed) {
+  const { sessionId, agentId, settings, reading } = context;
+  if (reading.pct < reading.profile[line]) return null;
+
+  const ledger = readLedger(sessionId);
+  if (!allowed(ledger, reading.pct)) return null;
+
+  const queue = compactions();
+  if (alreadyQueued(queue, agentId)) return null;
+
+  const path = statePath();
+  const age = stateAgeSeconds(path);
+  let text;
+  if (thrashing(queue, agentId)) text = thrashAdvice(reading);
+  else if (line === "now") text = askRightAway(reading, reading.profile.now, path, age, settings.freshStateMinutes);
+  else text = askAtTurnEnd(reading, path, age, settings.freshStateMinutes);
+  return { text, ledger };
+}

package/hooks/asks.mjs

@@ -28,7 +28,22 @@ export const MAX_ASKS = 3;
  */
 export const RE_ASK_GROWTH_PCT = 10;
 
-const EMPTY = { askCount: 0, lastAskedAt: null, askedAtPct: null, deferredUntil: null, deferReason: null };
+/**
+ * `now*` is the upper line's own record. It is kept apart from the end-of-turn ask
+ * so that having been asked politely at the lower line never silences the one ask
+ * that says "stop pushing on", and `deferredAt` survives an answered ask so the
+ * upper line can tell "deferred after I asked" from "never answered".
+ */
+const EMPTY = {
+  askCount: 0,
+  lastAskedAt: null,
+  askedAtPct: null,
+  deferredUntil: null,
+  deferReason: null,
+  deferredAt: null,
+  nowAskCount: 0,
+  nowAskedAt: null,
+};
 
 /**
  * Keyed by Paseo agent id where there is one, because that survives compaction
@@ -84,7 +99,7 @@ export function resetLedger(sessionId) {
 export function defer(sessionId, minutes, reason) {
   const ledger = readLedger(sessionId);
   const until = new Date(Date.now() + minutes * 60_000).toISOString();
-  writeLedger(sessionId, { ...ledger, deferredUntil: until, deferReason: reason });
+  writeLedger(sessionId, { ...ledger, deferredUntil: until, deferReason: reason, deferredAt: new Date().toISOString() });
   return until;
 }
 
@@ -93,11 +108,14 @@ export function defer(sessionId, minutes, reason) {
  *
  * `pct` is the occupancy now; `askedAtPct` the occupancy the last ask was about.
  */
+function deferred(ledger, now) {
+  if (ledger.deferredUntil === null) return false;
+  const until = Date.parse(ledger.deferredUntil);
+  return Number.isFinite(until) && now < until;
+}
+
 export function shouldAsk(ledger, pct, now = Date.now()) {
-  if (ledger.deferredUntil !== null) {
-    const until = Date.parse(ledger.deferredUntil);
-    if (Number.isFinite(until) && now < until) return false;
-  }
+  if (deferred(ledger, now)) return false;
   if (ledger.askCount >= MAX_ASKS) return false;
   if (ledger.askedAtPct === null) return true;
   return pct >= ledger.askedAtPct + RE_ASK_GROWTH_PCT;
@@ -115,3 +133,32 @@ export function recordAsk(sessionId, ledger, pct) {
     deferReason: null,
   });
 }
+
+/**
+ * Whether to ask right away, mid-turn, at the upper line.
+ *
+ * Once per compaction epoch. It comes back only if the agent answered the last one
+ * with a deferral and that deferral has run out — ignoring it earns no repeat, so a
+ * long turn hears it once rather than after every tool call — and never more than
+ * `MAX_ASKS` times in all. Any live deferral, from either ask, holds it off: the
+ * agent's "not now" is one answer, not one per line.
+ */
+export function shouldAskNow(ledger, now = Date.now()) {
+  if (deferred(ledger, now)) return false;
+  if (ledger.nowAskCount === 0 || ledger.nowAskedAt === null) return true;
+  if (ledger.nowAskCount >= MAX_ASKS) return false;
+  const asked = Date.parse(ledger.nowAskedAt);
+  const answered = ledger.deferredAt === null ? Number.NaN : Date.parse(ledger.deferredAt);
+  return Number.isFinite(asked) && Number.isFinite(answered) && answered >= asked;
+}
+
+/** Records that the upper line's question was put to the model. */
+export function recordNowAsk(sessionId, ledger) {
+  writeLedger(sessionId, {
+    ...ledger,
+    nowAskCount: ledger.nowAskCount + 1,
+    nowAskedAt: new Date().toISOString(),
+    deferredUntil: null,
+    deferReason: null,
+  });
+}

package/hooks/context-threshold.mjs

@@ -8,8 +8,11 @@
  * short line the moment context crosses each band. Each level fires once per
  * compaction epoch, so a long session gets three sentences, not three hundred.
  *
- * It describes; it never asks for anything. Deciding that a session should compact
- * belongs at a turn boundary, and that is `ask-compact.mjs` on `Stop`.
+ * Below Smart Compact's upper line it only describes; the end-of-turn question at
+ * the lower line is `ask-compact.mjs` on `Stop`. Past the upper line it asks right
+ * away, because that is the line where the agent should not start anything new —
+ * once per compaction epoch, again only after a deferral runs out, and through the
+ * same guards as the `Stop` hook (`ask.mjs`).
  *
  * It reads the transcript rather than asking Paseo, so it works in any Claude Code
  * session, and it reads only the tail of it, because this runs on the hot path.
@@ -18,6 +21,8 @@
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 
+import { askable, compose } from "./ask.mjs";
+import { recordNowAsk, shouldAskNow } from "./asks.mjs";
 import { BANDS, DEFAULT_THRESHOLDS, occupancy, readSettings } from "./context.mjs";
 import { clearPending, pluginDir, readPending, statePath } from "./pointer.mjs";
 
@@ -117,20 +122,36 @@ async function main() {
 
   const reached = BANDS.filter((band) => now.pct >= now.profile[band]);
   const crossed = reached.filter((band) => !latch.fired.includes(band));
-  if (crossed.length === 0) {
-    writeLatch(latchPath, latch);
-    return emit(sessionId, parts, pending);
-  }
-
-  // A session that jumped two bands in one turn hears the more urgent one.
-  const band = crossed[crossed.length - 1];
   latch.fired = [...new Set([...latch.fired, ...crossed])];
   writeLatch(latchPath, latch);
 
-  parts.push(advice(band, now.pct, now.used, now.max, statePath()));
+  // Past the upper line, the question replaces the description: it says everything
+  // the band line would, and two messages about the same moment read as two.
+  const asked = now.pct >= now.profile.now ? askNow(event) : null;
+  if (asked !== null) {
+    parts.push(asked.text);
+    emit(sessionId, parts, pending);
+    // Recorded only once it has reached stdout, like the `Stop` hook's ask.
+    recordNowAsk(sessionId, asked.ledger);
+    return;
+  }
+
+  // A session that jumped two bands in one turn hears the more urgent one.
+  if (crossed.length > 0) parts.push(advice(crossed[crossed.length - 1], now.pct, now.used, now.max, statePath()));
   return emit(sessionId, parts, pending);
 }
 
+/** The upper line's question, or null when one of the shared guards says no. */
+function askNow(event) {
+  try {
+    const context = askable(event);
+    if (context === null) return null;
+    return compose(context, "now", (ledger) => shouldAskNow(ledger));
+  } catch {
+    return null; // The ask is never worth failing the tool call it rides on.
+  }
+}
+
 /**
  * Writes whatever there is to say, and only then forgets the pending pointer:
  * clearing it before it reaches stdout would lose it on any later failure.

package/hooks/context.mjs

@@ -29,8 +29,8 @@ const TAIL_BYTES = 256 * 1024;
  */
 export const DEFAULT_THRESHOLDS = {
   largeWindowFrom: 400_000,
-  large: { notice: 15, closing: 22, compact: 30 },
-  small: { notice: 60, closing: 75, compact: 85 },
+  large: { notice: 15, closing: 22, compact: 30, now: 40 },
+  small: { notice: 60, closing: 75, compact: 85, now: 90 },
 };
 
 export const BANDS = ["notice", "closing", "compact"];
@@ -60,8 +60,8 @@ export function readSettings() {
           : DEFAULT_SETTINGS.freshStateMinutes,
       thresholds: {
         largeWindowFrom: merged.largeWindowFrom ?? DEFAULT_THRESHOLDS.largeWindowFrom,
-        large: { ...DEFAULT_THRESHOLDS.large, ...(merged.large ?? {}) },
-        small: { ...DEFAULT_THRESHOLDS.small, ...(merged.small ?? {}) },
+        large: withUpperLine(merged.large, DEFAULT_THRESHOLDS.large),
+        small: withUpperLine(merged.small, DEFAULT_THRESHOLDS.small),
       },
     };
   } catch {
@@ -69,6 +69,20 @@ export function readSettings() {
   }
 }
 
+/**
+ * A saved profile, with the upper line filled in when it predates one.
+ *
+ * Mirrors `normalizeProfile` in thresholds.ts: the saved lower line is kept, and an
+ * absent upper line keeps the default's distance above it, never falling below it.
+ */
+export function withUpperLine(saved, fallback) {
+  const profile = { ...fallback, ...(saved ?? {}) };
+  const compact = profile.compact;
+  const migrated = Math.min(99, Math.max(fallback.now, compact + (fallback.now - fallback.compact)));
+  const raw = typeof saved?.now === "number" && Number.isFinite(saved.now) ? saved.now : migrated;
+  return { ...profile, now: Math.min(99, Math.max(Math.min(99, compact + 1), raw)) };
+}
+
 export function profileFor(maxTokens, thresholds) {
   return maxTokens >= thresholds.largeWindowFrom ? thresholds.large : thresholds.small;
 }

package/index.server.ts

@@ -141,6 +141,8 @@ export default function contribute(server: PluginServerContext) {
           growthTokensPerHour: growth.get(row.id) ?? null,
           projectedFullAt: projectFull(row.usedTokens!, row.maxTokens!, growth.get(row.id) ?? null, thresholds),
           compactAtPct: profileFor(row.maxTokens!, thresholds).compact,
+          compactNowAtPct: profileFor(row.maxTokens!, thresholds).now,
+          projectedNowAt: projectFull(row.usedTokens!, row.maxTokens!, growth.get(row.id) ?? null, thresholds, "now"),
           stateWrittenAt: stateWrittenAt(row.id),
         }))
         .sort((a, b) => b.usedPct - a.usedPct);

package/mcp.mjs

@@ -338,7 +338,17 @@ const TOOLS = {
       if (mine.growthTokensPerHour !== null) {
         lines.push(`Filling at roughly ${Math.round(mine.growthTokensPerHour).toLocaleString()} tokens/hour.`);
       }
-      if (mine.usedPct >= mine.compactAtPct) {
+      const upper = typeof mine.compactNowAtPct === "number" ? mine.compactNowAtPct : null;
+      if (upper !== null) {
+        lines.push(
+          `Its upper line is ${upper}% (${Math.round((upper / 100) * mine.maxTokens).toLocaleString()} tokens): past that, Smart Compact asks right away, mid-turn, and you should not start new work before compacting.`,
+        );
+      }
+      if (upper !== null && mine.usedPct >= upper) {
+        lines.push(
+          "You are past the upper line. Finish only the step you are on, call checkpoint, call request_compaction with continue_after_compaction true, and end your turn.",
+        );
+      } else if (mine.usedPct >= mine.compactAtPct) {
         // Already past it: a projection of when it will arrive reads as nonsense.
         lines.push(
           "You are already past that point. Check your task state is on disk and current, then compact at the next clean boundary — call request_compaction when the step you are on is finished.",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "paseo-smart-session",
   "type": "module",
-  "version": "3.4.0",
+  "version": "3.5.0",
   "license": "MIT",
   "description": "Records Claude plan-usage history and lets a Paseo agent manage its own context.",
   "repository": {

package/server/growth.ts

@@ -59,9 +59,10 @@ export function projectFull(
   maxTokens: number,
   ratePerHour: number | null,
   thresholds?: Thresholds,
+  line: "compact" | "now" = "compact",
 ): string | null {
   if (ratePerHour === null || ratePerHour <= 0) return null;
-  const room = maxTokens * (profileFor(maxTokens, thresholds).compact / 100) - usedTokens;
+  const room = maxTokens * (profileFor(maxTokens, thresholds)[line] / 100) - usedTokens;
   if (room <= 0) return new Date().toISOString();
   return new Date(Date.now() + (room / ratePerHour) * 3_600_000).toISOString();
 }

package/shared/compact-lines.ts

@@ -0,0 +1,60 @@
+/**
+ * What the views say about Smart Compact's two lines, as plain functions.
+ *
+ * The lower line is the **end-of-turn line**: past it, the `Stop` hook asks the
+ * agent at the end of a turn whether to compact. The upper line is the
+ * **mid-turn line**: past it, the `PostToolUse` hook asks mid-turn, and the agent
+ * is told to finish only the step it is on. The pill, its popover and the overview
+ * all read these, so they cannot describe the same session two ways.
+ */
+
+import { formatCompactTokens, formatDuration } from "./format.ts";
+import type { ContextOutlook, Tone } from "./forecast.ts";
+
+/** "asks at 30%, mid-turn at 40%", or the lower line alone when there is no upper one. */
+export function linesSummary(lower: number, upper: number | null | undefined): string {
+  return typeof upper === "number" ? `asks at ${lower}%, mid-turn at ${upper}%` : `asks at ${lower}%`;
+}
+
+/** The popover's one sentence about where this session stands. */
+export function outlookSentence(
+  outlook: ContextOutlook,
+  { enrolled, compactOn, growthPerHour }: { enrolled: boolean; compactOn: boolean; growthPerHour: number | null },
+): { line: string; tone: Tone } {
+  const pace = growthPerHour !== null && growthPerHour > 0 ? ` at +${formatCompactTokens(growthPerHour)}/h` : "";
+  if (outlook.past && !enrolled) {
+    return {
+      line: 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: outlook.tone,
+    };
+  }
+  if (outlook.pastNow) {
+    return { line: "Past its mid-turn line. Smart Compact is asking it to finish the step it is on and compact.", tone: outlook.tone };
+  }
+  if (outlook.past) {
+    const next = outlook.untilNowMs !== null
+      ? ` Reaches its mid-turn line in about ${formatDuration(outlook.untilNowMs)}${pace}.`
+      : outlook.nowAt !== null ? ` From ${outlook.nowAt}% it is asked mid-turn.` : "";
+    return { line: `Past its end-of-turn line, so it is asked at the end of each turn whether to compact.${next}`, tone: outlook.tone };
+  }
+  if (outlook.untilCompactMs !== null) {
+    const upper = outlook.untilNowMs !== null ? ` and its mid-turn line in about ${formatDuration(outlook.untilNowMs)}` : "";
+    return { line: `Reaches its end-of-turn line in about ${formatDuration(outlook.untilCompactMs)}${upper}${pace}.`, tone: "default" };
+  }
+  return { line: outlook.nowAt !== null ? "Below both compact lines and not growing right now." : "Below its compact line and not growing right now.", tone: "default" };
+}
+
+/** The overview row's short line, or null when there is nothing to add. */
+export function outlookShort(outlook: ContextOutlook, enrolled: boolean): string | null {
+  if (outlook.past && !enrolled) return "Past its compact line · not enrolled";
+  if (outlook.pastNow) return "Past its mid-turn line · asked now";
+  if (outlook.past) {
+    return outlook.untilNowMs !== null
+      ? `Past its end-of-turn line · mid-turn in ~${formatDuration(outlook.untilNowMs)}`
+      : "Past its end-of-turn line · asked at the end of a turn";
+  }
+  if (outlook.untilCompactMs === null) return null;
+  return outlook.untilNowMs !== null && outlook.nowAt !== null
+    ? `${outlook.compactAt}% in ~${formatDuration(outlook.untilCompactMs)} · ${outlook.nowAt}% in ~${formatDuration(outlook.untilNowMs)}`
+    : `Reaches it in ~${formatDuration(outlook.untilCompactMs)}`;
+}

package/shared/forecast.ts

@@ -181,18 +181,29 @@ export function leadWindow(windows: readonly WindowForecast[]): WindowForecast |
 export interface ContextReading {
   readonly usedTokens: number;
   readonly maxTokens: number;
+  /** The lower line: Smart Compact asks at the end of a turn. */
   readonly compactAtPct: number;
+  /** The upper line: Smart Compact asks mid-turn. Absent from older daemons. */
+  readonly compactNowAtPct?: number | null;
   readonly growthTokensPerHour?: number | null;
 }
 
 export interface ContextOutlook {
   readonly pct: number;
   readonly compactAt: number;
-  /** Tokens at the compact line. */
+  /** Tokens at the lower line. */
   readonly compactTokens: number;
+  /** Past the lower line. */
   readonly past: boolean;
-  /** Time until the compact line at the measured growth; null when not growing or already past. */
+  /** Time until the lower line at the measured growth; null when not growing or already past. */
   readonly untilCompactMs: number | null;
+  /** The upper line, or null when the reading has none. */
+  readonly nowAt: number | null;
+  readonly nowTokens: number | null;
+  /** Past the upper line, where the agent is asked mid-turn. */
+  readonly pastNow: boolean;
+  /** Time until the upper line at the measured growth; null when not growing, already past or unknown. */
+  readonly untilNowMs: number | null;
   readonly tone: Tone;
 }
 
@@ -201,17 +212,24 @@ export function contextOutlook(reading: ContextReading): ContextOutlook {
   const compactTokens = Math.round((reading.compactAtPct / 100) * reading.maxTokens);
   const past = pct >= reading.compactAtPct;
   const growth = reading.growthTokensPerHour ?? null;
-  const untilCompactMs = past || growth === null || growth <= 0 ? null : ((compactTokens - reading.usedTokens) / growth) * HOUR;
-  return { pct, compactAt: reading.compactAtPct, compactTokens, past, untilCompactMs, tone: pct >= 90 ? "danger" : past ? "warning" : "default" };
+  const growing = growth !== null && growth > 0;
+  const untilCompactMs = past || !growing ? null : ((compactTokens - reading.usedTokens) / growth) * HOUR;
+  const nowAt = typeof reading.compactNowAtPct === "number" ? reading.compactNowAtPct : null;
+  const nowTokens = nowAt === null ? null : Math.round((nowAt / 100) * reading.maxTokens);
+  const pastNow = nowAt !== null && pct >= nowAt;
+  const untilNowMs = nowTokens === null || pastNow || !growing ? null : ((nowTokens - reading.usedTokens) / growth) * HOUR;
+  // Amber past the lower line, red past the upper one (or a nearly full window).
+  const tone = pct >= 90 || pastNow ? "danger" : past ? "warning" : "default";
+  return { pct, compactAt: reading.compactAtPct, compactTokens, past, untilCompactMs, nowAt, nowTokens, pastNow, untilNowMs, tone };
 }
 
 /**
  * The context ring: a faint full track, an arc for the share of the window used, and a
- * tick across the ring at the compact line. Inline SVG in the surface's own colour, so
+ * tick at each compact line: inward at the end-of-turn line, outward at the mid-turn line. Inline SVG in the surface's own colour, so
  * the host `Icon` can draw it anywhere a Lucide glyph fits. Quantized to 1/48 so a
  * ticking view rarely redraws.
  */
-export function contextRing(fraction: number, mark: number | null, track = 0.28): string {
+export function contextRing(fraction: number, mark: number | null, track = 0.28, upper: number | null = null): string {
   const steps = 48;
   const f = Math.round(Math.min(1, Math.max(0, fraction)) * steps) / steps;
   const r = 8.5;
@@ -223,11 +241,19 @@ export function contextRing(fraction: number, mark: number | null, track = 0.28)
     const [x, y] = point(f, r);
     arc = `<path d="M${c} ${c - r}A${r} ${r} 0 ${f > 0.5 ? 1 : 0} 1 ${x} ${y}"/>`;
   }
-  let tick = "";
-  if (mark !== null && mark > 0 && mark < 1) {
-    const [x1, y1] = point(mark, r - 3.6);
-    const [x2, y2] = point(mark, r + 3.2);
-    tick = `<path d="M${x1} ${y1}L${x2} ${y2}" stroke-width="1.8"/>`;
-  }
+  // The end-of-turn tick points inward from the ring and the mid-turn tick outward, so the pair sits
+  // on opposite sides of the stroke and stays apart at pill size, where two ticks 36° apart that
+  // both crossed the ring merged with the arc's end into one hooked smudge.
+  const tickAt = (at: number | null, from: number, to: number) => {
+    if (at === null || !(at > 0 && at < 1)) return "";
+    const [x1, y1] = point(at, from);
+    const [x2, y2] = point(at, to);
+    return `<path d="M${x1} ${y1}L${x2} ${y2}" stroke-width="1.8"/>`;
+  };
+  // A muted ring (no lower line) has no upper one either.
+  const inward = tickAt(mark, r - 3.8, r);
+  // r + 2.6 plus the 0.9 round cap ends exactly at the 24-unit box edge, so the stub is never clipped.
+  const outward = upper !== null && upper !== mark ? tickAt(upper, r, r + 2.6) : "";
+  const tick = mark === null ? "" : inward + outward;
   return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.6" stroke-linecap="round"><circle cx="${c}" cy="${c}" r="${r}" stroke-opacity="${track}"/>${arc}${tick}</svg>`;
 }

package/shared/smart-session.ts

@@ -155,6 +155,10 @@ export const ContextStatusSchema = z.object({
   projectedFullAt: z.string().nullable(),
   /** The percentage at which this window is considered ready to compact. */
   compactAtPct: z.number(),
+  /** The upper line: past it, Smart Compact asks mid-turn. Optional for older daemons. */
+  compactNowAtPct: z.number().optional(),
+  /** When this agent would reach the upper line, at that rate. */
+  projectedNowAt: z.string().nullable().optional(),
   /** When this agent's task state file was last written; null when it has none. */
   stateWrittenAt: z.string().nullable().optional(),
 });
@@ -174,6 +178,8 @@ const ThresholdProfileSchema = z.object({
   notice: z.number().finite().min(1).max(99),
   closing: z.number().finite().min(1).max(99),
   compact: z.number().finite().min(1).max(99),
+  /** The upper line, where Smart Compact asks mid-turn. */
+  now: z.number().finite().min(1).max(99),
 });
 
 export const ThresholdsSchema = z.object({

package/shared/thresholds.ts

@@ -19,8 +19,16 @@ export interface ThresholdProfile {
   readonly notice: number;
   /** Percentage at which to stop opening new work. */
   readonly closing: number;
-  /** Percentage at which to recommend compacting. */
+  /**
+   * The lower line, "when convenient": the `Stop` hook asks at the end of a turn.
+   * Kept under its old name so saved settings and older daemons still read it.
+   */
   readonly compact: number;
+  /**
+   * The upper line, "mid-turn": the `PostToolUse` hook asks mid-turn, and the
+   * agent is told to finish only the step it is on. Always at or above `compact`.
+   */
+  readonly now: number;
 }
 
 export interface Thresholds {
@@ -42,10 +50,21 @@ export interface Thresholds {
  */
 export const DEFAULT_THRESHOLDS: Thresholds = {
   largeWindowFrom: 400_000,
-  large: { notice: 15, closing: 22, compact: 30 },
-  small: { notice: 60, closing: 75, compact: 85 },
+  large: { notice: 15, closing: 22, compact: 30, now: 40 },
+  small: { notice: 60, closing: 75, compact: 85, now: 90 },
 };
 
+/**
+ * Where the upper line goes when a saved profile predates it.
+ *
+ * The saved lower line is kept as it is, and the upper line keeps the default's
+ * distance above it, so a person who moved their compact line to 50% does not get
+ * an upper line at 40% — below it — the moment they upgrade.
+ */
+export function defaultNowFor(compact: number, fallback: ThresholdProfile): number {
+  return Math.min(99, Math.max(fallback.now, compact + (fallback.now - fallback.compact)));
+}
+
 export function profileFor(maxTokens: number, thresholds: Thresholds = DEFAULT_THRESHOLDS): ThresholdProfile {
   return maxTokens >= thresholds.largeWindowFrom ? thresholds.large : thresholds.small;
 }
@@ -77,7 +96,17 @@ export function normalizeProfile(raw: Partial<ThresholdProfile> | undefined, fal
   const compact = clamp(raw?.compact, fallback.compact);
   const closing = Math.min(compact, clamp(raw?.closing, fallback.closing));
   const notice = Math.min(closing, clamp(raw?.notice, fallback.notice));
-  return { notice, closing, compact };
+  // The upper line must stay above the lower one; a saved file from before it
+  // existed gets the default distance above whatever lower line it kept.
+  const now = Math.max(Math.min(99, compact + 1), clamp(raw?.now, defaultNowFor(compact, fallback)));
+  return { notice, closing, compact, now: Math.min(99, now) };
+}
+
+/** Why a pair of lines cannot be saved, or null when it can. */
+export function linesProblem(lower: number | null, upper: number | null): string | null {
+  if (lower === null || upper === null) return "Enter a whole number from 1 to 99.";
+  if (upper <= lower) return "The mid-turn line has to be above the end-of-turn line.";
+  return null;
 }
 
 /**
@@ -87,9 +116,14 @@ export function normalizeProfile(raw: Partial<ThresholdProfile> | undefined, fal
  * compact all fire together. Scale the earlier bands with it when necessary;
  * raising it leaves the existing advance notice intact.
  */
-export function withCompactThreshold(profile: ThresholdProfile, value: number): ThresholdProfile {
+export function withCompactThreshold(profile: ThresholdProfile, value: number, nowValue?: number): ThresholdProfile {
   const compact = Number.isFinite(value) ? Math.round(Math.min(99, Math.max(1, value))) : profile.compact;
-  if (compact >= profile.closing) return { ...profile, compact };
+  // An explicit upper line wins; otherwise it keeps its distance above the lower one.
+  const now =
+    nowValue !== undefined && Number.isFinite(nowValue)
+      ? Math.round(Math.min(99, Math.max(1, nowValue)))
+      : Math.min(99, Math.max(profile.now, compact + (profile.now - profile.compact)));
+  if (compact >= profile.closing) return normalizeProfile({ ...profile, compact, now }, profile);
 
   const scale = compact / profile.compact;
   return normalizeProfile(
@@ -97,6 +131,7 @@ export function withCompactThreshold(profile: ThresholdProfile, value: number):
       notice: Math.max(1, Math.round(profile.notice * scale)),
       closing: Math.max(1, Math.round(profile.closing * scale)),
       compact,
+      now,
     },
     profile,
   );