paseo-smart-session 3.4.0 → 3.6.0

package/server/session-mcp.ts

@@ -1,26 +1,63 @@
-import type { PluginServerContext } from "@getpaseo/plugin/server";
+import type { PluginServerContext, PluginSessionOpenRequest } from "@getpaseo/plugin/server";
+import { randomUUID } from "node:crypto";
+import { mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { mcpDefinition, resolvePluginDir } from "./install.ts";
+import { type Invoke, nativeTools, nativeToolsAvailable } from "./native-tools.ts";
 import { readSettings } from "./settings.ts";
 
-/** MCP is a launch contribution, so it never writes global provider settings. */
-export function contributeSessionMcp(server: PluginServerContext) {
+const paseoHome = () => process.env.PASEO_HOME ?? join(homedir(), ".paseo");
+
+async function paseoConfig(): Promise<Record<string, any> | null> {
+  try { return JSON.parse(await readFile(join(paseoHome(), "config.json"), "utf8")); } catch { return null; }
+}
+
+/** Providers whose sessions get the tools. A test harness may widen it to its fixture provider. */
+const providers = () => (process.env.SMART_SESSION_TOOL_PROVIDERS ?? "claude,codex").split(",").map((name) => name.trim());
+
+/**
+ * The agent tools are a launch contribution, so nothing global is written. On Paseo 0.15+ they go
+ * on `request.tools` and the daemon serves them through the agent's own Paseo MCP; otherwise this
+ * launch alone gets `mcp.mjs` as a stdio server. `SMART_SESSION_TOOLS` tells the hooks which names
+ * the agent has (`smart_checkpoint` or `checkpoint`).
+ */
+export function contributeSessionMcp(server: PluginServerContext, invoke: Invoke) {
+  // A reload or update detaches native tools from open sessions until each reopens. This worker's instance, and the
+  // instance that attached each session, let the hooks tell a detached session how to reach the tools meanwhile
+  // (hooks/context.mjs toolsMode). Written synchronously, before any session can open.
+  const instance = randomUUID();
+  const data = join(paseoHome(), "plugin-data", "smart-session");
+  try {
+    mkdirSync(join(data, "tools"), { recursive: true });
+    writeFileSync(join(data, `tools-instance.json.${instance}`), JSON.stringify({ instance }));
+    renameSync(join(data, `tools-instance.json.${instance}`), join(data, "tools-instance.json"));
+  } catch { /* Without it the hooks assume the tools are attached. */ }
   return server.before("agent.session_open", async ({ request }) => {
-    if (request.purpose !== "interactive" || !["claude", "codex"].includes(request.provider)
+    if (request.purpose !== "interactive" || !providers().includes(request.provider)
       || request.labels["plugin-tools/enabled"] === "false" || !(await readSettings()).enabled) return;
-    const directory = await resolvePluginDir();
-    if (!directory) return;
-    const definition = mcpDefinition(directory);
-    return {
-      ...request,
-      mcpServers: { ...request.mcpServers, "smart-session": { ...definition, env: {
-        ...definition.env, PASEO_AGENT_ID: request.agentId,
-        PASEO_HOME: process.env.PASEO_HOME ?? join(homedir(), ".paseo"), SMART_SESSION_MCP_SCOPE: "paseo",
-        ...(process.env.PASEO_DAEMON_URL ? { PASEO_DAEMON_URL: process.env.PASEO_DAEMON_URL } : {}),
-        ...(process.env.PASEO_PASSWORD ? { PASEO_PASSWORD: process.env.PASEO_PASSWORD } : {}),
-        ...(process.env.PASEO_PASSWORD_FILE ? { PASEO_PASSWORD_FILE: process.env.PASEO_PASSWORD_FILE } : {}),
-      } } },
-    };
+    if (process.env.SMART_SESSION_FORCE_STDIO !== "1" && nativeToolsAvailable(request, await paseoConfig())) {
+      await writeFile(join(data, "tools", `native-${request.agentId.replace(/[^A-Za-z0-9_-]/g, "_")}.json`), JSON.stringify({ instance })).catch(() => undefined);
+      return { ...request, env: { ...request.env, SMART_SESSION_TOOLS: "native" }, tools: [...request.tools, ...nativeTools(invoke)] };
+    }
+    return withStdio(request);
   });
 }
+
+async function withStdio(request: PluginSessionOpenRequest): Promise<PluginSessionOpenRequest | void> {
+  const directory = await resolvePluginDir();
+  if (!directory) return;
+  const definition = mcpDefinition(directory);
+  return {
+    ...request,
+    env: { ...request.env, SMART_SESSION_TOOLS: "stdio" },
+    mcpServers: { ...request.mcpServers, "smart-session": { ...definition, env: {
+      ...definition.env, PASEO_AGENT_ID: request.agentId,
+      PASEO_HOME: paseoHome(), SMART_SESSION_MCP_SCOPE: "paseo",
+      ...(process.env.PASEO_DAEMON_URL ? { PASEO_DAEMON_URL: process.env.PASEO_DAEMON_URL } : {}),
+      ...(process.env.PASEO_PASSWORD ? { PASEO_PASSWORD: process.env.PASEO_PASSWORD } : {}),
+      ...(process.env.PASEO_PASSWORD_FILE ? { PASEO_PASSWORD_FILE: process.env.PASEO_PASSWORD_FILE } : {}),
+    } } },
+  };
+}

package/shared/chat.ts

@@ -31,9 +31,13 @@ export const PromptCardSchema = z.object({
 });
 export type PromptCard = z.infer<typeof PromptCardSchema>;
 
-/** Claude records mcp__smart-session__context_status; Codex records smart-session.context_status. */
+/**
+ * Claude records mcp__smart-session__context_status and Codex smart-session.context_status from the
+ * stdio server; served natively through Paseo's MCP they are mcp__paseo__smart_context_status and
+ * paseo.smart_context_status.
+ */
 export function smartSessionTool(name: string): SmartSessionTool | null {
-  const match = /^(?:mcp__)?smart-session(?:__|\.|\/|:)([a-z_]+)$/.exec(name);
+  const match = /^(?:mcp__)?(?:smart-session(?:__|\.|\/|:)|paseo(?:__|\.|\/|:)smart_)([a-z_]+)$/.exec(name);
   return match && (SMART_SESSION_TOOLS as readonly string[]).includes(match[1]!) ? (match[1] as SmartSessionTool) : null;
 }
 

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,
   );