@hassangameryt/freeflow 0.7.3 → 0.9.0

package/pi-extension/dist/provider-support/cache/keepalive.js

@@ -0,0 +1,222 @@
+import { isChatGPTSignIn } from "../routes.js";
+const responses = {
+  cap: (payload) => ({ ...payload, max_output_tokens: 16 }),
+  retention: (payload) =>
+    payload?.prompt_cache_retention === "24h" || payload?.prompt_cache_options?.ttl ? "long" : undefined,
+};
+const PROTOCOLS = {
+  "anthropic-messages": {
+    cap: (payload) => ({ ...payload, max_tokens: 1 }),
+    retention: (payload) => (JSON.stringify(payload).includes('"ttl":"1h"') ? "long" : "short"),
+    // Budget-based thinking must stay below max_tokens and is part of the cache key, so a one-token replay is
+    // rejected or writes a different entry. Adaptive thinking has no budget. Pi's own warmer skips these too.
+    replayable: (payload) => payload?.thinking?.type !== "enabled",
+  },
+  "openai-responses": responses,
+  "azure-openai-responses": responses,
+};
+/** Continuation is near-certain while a delegated worker runs: the requester resumes on its return. */
+const CONTINUATION = 0.9;
+/** Same threshold as Pi's own warmer: a refresh must be expected to save at least this much. */
+const MINIMUM_SAVINGS = 0.05;
+/** A refresh counts as reuse only when it reads nearly all of the prompt. */
+const REUSE = 0.9;
+const EXPIRY_MARGIN_MS = 10_000;
+/**
+ * Keeps a suspended requester's prompt cache warm while it is certain to resume, such as a Coordinator
+ * whose delegated worker is still running. Pi's own warmer only keeps the latest request warm, which
+ * during a worker run belongs to the worker. Eligibility and economics come from the model's declared
+ * cache lifetime and prices, so any provider that declares them is handled the same way.
+ */
+export class CacheKeepAlive {
+  options;
+  lanes = new Map();
+  holdSource = () => undefined;
+  requester = () => undefined;
+  active;
+  lastStop;
+  now;
+  setTimer;
+  clearTimer;
+  send;
+  constructor(options = {}) {
+    this.options = options;
+    this.now = options.now ?? Date.now;
+    // A refresh that throws ends the hold, rather than surfacing as an unhandled rejection.
+    this.setTimer =
+      options.setTimer ??
+      ((fn, ms) => setTimeout(() => void Promise.resolve(fn()).catch(() => this.stop("refresh failed")), ms).unref?.());
+    this.clearTimer = options.clearTimer ?? ((timer) => clearTimeout(timer));
+    this.send = options.send ?? sendThroughHost;
+  }
+  setHoldSource(source) {
+    this.holdSource = source;
+  }
+  /** Names who is sending the current request, so requesters sharing a model keep separate lanes. */
+  setRequesterSource(source) {
+    this.requester = () => {
+      try {
+        return source();
+      } catch {
+        return undefined;
+      }
+    };
+  }
+  reset() {
+    this.stop("reset");
+    this.lanes.clear();
+  }
+  status() {
+    if (this.active)
+      return `Keeping ${this.lanes.get(this.active.lane)?.model?.id} cache warm while its worker runs · $${this.active.spent.toFixed(3)} spent`;
+    return this.lastStop;
+  }
+  /** Remember the request just sent on its model; a hold keeps the latest one warm. */
+  record(payload, ctx) {
+    const key = laneKey(ctx, undefined, this.requester());
+    if (!key) return;
+    // Sign in with ChatGPT rejects max_output_tokens (live, 400), so a replay cannot be capped and is never sent. Its
+    // lanes carry no credential, so a request on it also drops what an API key on the same model left.
+    if (isChatGPTSignIn(ctx.model, ctx)) {
+      this.lanes.delete(key);
+      if (this.active?.lane === key) this.stop(SIGN_IN_STOP);
+      return;
+    }
+    const protocol = PROTOCOLS[ctx.model?.api];
+    if (!protocol) return;
+    if (protocol.replayable?.(payload) === false) {
+      this.lanes.delete(key);
+      if (this.active?.lane === key) this.stop("this request cannot be replayed with a capped output");
+      return;
+    }
+    const prior = this.lanes.get(key);
+    this.lanes.set(key, { key, model: ctx.model, payload, sentAt: this.now(), prompt: prior?.prompt });
+    if (this.active?.lane === key) this.schedule();
+  }
+  /** Provider-reported usage of the latest request on a model gives the prompt size to price. */
+  observe(ctx, usage, producer) {
+    const lane = this.lanes.get(laneKey(ctx, producer, this.requester()) ?? "");
+    if (lane && usage) lane.prompt = usage.input + usage.cacheRead + usage.cacheWrite;
+  }
+  /** Start or stop holding according to the current run and hold source. */
+  evaluate(ctx) {
+    const hold = this.currentHold(ctx);
+    const key = hold && laneKey(ctx, hold, hold.requester);
+    if (this.active && this.active.lane === key) {
+      this.active.ctx = ctx;
+      return;
+    }
+    this.stop(hold ? "hold changed" : "no suspended requester");
+    if (!key || !this.lanes.has(key)) return;
+    this.active = { lane: key, since: this.now(), spent: 0, ctx };
+    this.schedule();
+  }
+  currentHold(ctx) {
+    if (!(this.options.enabled?.() ?? true) || ctx?.isIdle?.() !== false) return;
+    try {
+      return this.holdSource();
+    } catch {
+      return;
+    }
+  }
+  stop(reason) {
+    if (this.active?.timer !== undefined) this.clearTimer(this.active.timer);
+    if (this.active) this.lastStop = `Cache keep-alive stopped: ${reason}`;
+    this.active = undefined;
+  }
+  ttlMs(lane) {
+    const protocol = PROTOCOLS[lane.model.api];
+    const env = this.options.env ?? process.env;
+    const retention = protocol?.retention(lane.payload) ?? (env.PI_CACHE_RETENTION === "long" ? "long" : "short");
+    const seconds = lane.model.promptCache?.[retention];
+    return typeof seconds === "number" && seconds > 0 ? seconds * 1000 : undefined;
+  }
+  schedule() {
+    const active = this.active;
+    if (!active) return;
+    if (active.timer !== undefined) this.clearTimer(active.timer);
+    active.timer = undefined;
+    const lane = this.lanes.get(active.lane);
+    const ttl = this.ttlMs(lane);
+    if (!ttl || ttl <= EXPIRY_MARGIN_MS) return this.stop("model declares no cache lifetime");
+    const at = lane.sentAt + refreshDelay(ttl);
+    active.timer = this.setTimer(() => this.refresh(active), Math.max(0, at - this.now()));
+  }
+  async refresh(active) {
+    if (this.active !== active) return;
+    active.timer = undefined;
+    const lane = this.lanes.get(active.lane);
+    const hold = this.currentHold(active.ctx);
+    if (!hold || laneKey(active.ctx, hold, hold.requester) !== active.lane)
+      return this.stop("requester resumed or run ended");
+    if (isChatGPTSignIn(lane.model, active.ctx)) return this.stop(SIGN_IN_STOP);
+    const now = this.now();
+    // Like Pi's warmer, a refresh later than halfway from its slot to expiry is likely a full rewrite.
+    const ttl = this.ttlMs(lane),
+      delay = refreshDelay(ttl);
+    if (now > lane.sentAt + delay + (ttl - delay) / 2) return this.stop("cache entry already expired");
+    if (now - active.since > (this.options.maxHoldMs ?? 6 * 3_600_000)) return this.stop("hold duration limit");
+    const economics = price(lane);
+    if (!economics) return this.stop("prompt size or prices unknown");
+    if (CONTINUATION * economics.miss - economics.warm < MINIMUM_SAVINGS)
+      return this.stop("refresh would not save money");
+    if (active.spent + economics.warm > (this.options.maxHoldCost ?? 2)) return this.stop("hold spend limit");
+    let usage;
+    try {
+      usage = await this.send(lane.model, PROTOCOLS[lane.model.api].cap(lane.payload), active.ctx);
+    } catch {
+      usage = undefined;
+    }
+    if (this.active !== active) return;
+    if (!usage) return this.stop("refresh failed");
+    const spent = cost(lane.model, usage);
+    active.spent += spent;
+    try {
+      this.options.onRefresh?.({ provider: lane.model.provider, model: lane.model.id, usage, cost: spent });
+    } catch {
+      // Attribution is diagnostic and never changes warming.
+    }
+    if (usage.cacheRead < REUSE * lane.prompt || usage.cacheWrite > (1 - REUSE) * lane.prompt)
+      return this.stop("refresh did not reuse the cache");
+    lane.sentAt = now;
+    this.schedule();
+  }
+}
+const SIGN_IN_STOP = "Sign in with ChatGPT is never replayed";
+/** Pi's refresh point: 90% of the lifetime, keeping at least ten seconds of margin. */
+const refreshDelay = (ttl) => Math.min(ttl * 0.9, ttl - EXPIRY_MARGIN_MS);
+function laneKey(ctx, hold, requester) {
+  const provider = hold?.provider ?? ctx?.model?.provider,
+    model = hold?.modelId ?? ctx?.model?.id;
+  if (!provider || !model) return;
+  return JSON.stringify([ctx?.sessionManager?.getSessionId?.() ?? "memory", provider, model, requester ?? ""]);
+}
+const perToken = (value) => (typeof value === "number" ? value / 1_000_000 : undefined);
+function price(lane) {
+  const c = lane.model.cost ?? {};
+  const read = perToken(c.cacheRead),
+    input = perToken(c.input),
+    output = perToken(c.output) ?? 0;
+  const write = perToken(c.cacheWrite) || input;
+  if (!lane.prompt || read === undefined || write === undefined) return;
+  return { warm: lane.prompt * read + output, miss: Math.max(0, lane.prompt * (write - read)) };
+}
+function cost(model, usage) {
+  const c = model.cost ?? {};
+  return (
+    usage.input * (perToken(c.input) ?? 0) +
+    usage.output * (perToken(c.output) ?? 0) +
+    usage.cacheRead * (perToken(c.cacheRead) ?? 0) +
+    usage.cacheWrite * (perToken(c.cacheWrite) ?? 0)
+  );
+}
+/** Replay through the host's own transport so provider auth and request shaping apply as usual. */
+async function sendThroughHost(model, payload, ctx) {
+  const stream = ctx.modelRegistry.streamSimple(
+    model,
+    { systemPrompt: "", messages: [{ role: "user", content: "cache keep-alive", timestamp: Date.now() }] },
+    { onPayload: () => payload, maxRetries: 0, maxTokens: 1 },
+  );
+  const message = await stream.result();
+  return message.stopReason === "error" || message.stopReason === "aborted" ? undefined : message.usage;
+}

package/pi-extension/dist/provider-support/cache/monitor.js

@@ -0,0 +1,17 @@
+/**
+ * Prompt-cache diagnostics for /freeflow status. The footer only shows current Freeflow settings, so
+ * cache mechanics (keep-alive, context replay, effort baselines) report here instead.
+ */
+export class CacheMonitor {
+  entries = new Map();
+  set(key, text) {
+    if (text) this.entries.set(key, text);
+    else this.entries.delete(key);
+  }
+  lines() {
+    return [...this.entries.values()];
+  }
+  reset() {
+    this.entries.clear();
+  }
+}

package/pi-extension/dist/provider-support/cache/openai-responses.js

@@ -0,0 +1,48 @@
+import { createHash } from "node:crypto";
+/**
+ * OpenAI Responses on GPT-5.6+: the implicit breakpoint sits at the latest eligible message, and a
+ * lookup checks it, up to 20 earlier eligible message endings, and the latest explicit breakpoints.
+ * A position here is an eligible message ending: a user message, or the last tool output of a group.
+ */
+export const OPENAI_RESPONSES_LIMITS = { maxBreakpoints: 50, lookback: 20, margin: 5 };
+const OUTPUTS = new Set(["function_call_output", "custom_tool_call_output"]);
+const withoutMarkers = (value) =>
+  JSON.stringify(value, (key, v) => (key === "prompt_cache_breakpoint" ? undefined : v));
+/** Only routes whose documented cache protocol includes explicit breakpoints are adapted. */
+export const supportsExplicitBreakpoints = (model) => model?.compat?.supportsExplicitPromptCacheMode === true;
+export function responsesLayout(payload) {
+  if (!payload || !Array.isArray(payload.input)) return;
+  const chain = [],
+    handles = [],
+    breakpoints = [];
+  let hash = createHash("sha256")
+    .update(withoutMarkers([payload.instructions ?? null, payload.tools ?? null]))
+    .digest("hex");
+  let pending = "";
+  const input = payload.input;
+  input.forEach((item, i) => {
+    pending += withoutMarkers(item);
+    const user = item?.role === "user";
+    const lastOutput = OUTPUTS.has(item?.type) && !OUTPUTS.has(input[i + 1]?.type);
+    if (!user && !lastOutput) return;
+    hash = createHash("sha256").update(hash).update(pending).digest("hex");
+    pending = "";
+    const content = Array.isArray(item.content) ? item.content : undefined;
+    if (content?.some((block) => block?.prompt_cache_breakpoint)) breakpoints.push(chain.length);
+    chain.push(hash);
+    // Breakpoints go on message content blocks; tool outputs have no documented place for one.
+    handles.push(user && content?.length ? { item: i, block: content.length - 1 } : undefined);
+  });
+  // The implicit breakpoint: the latest eligible message ending.
+  if (chain.length && breakpoints.at(-1) !== chain.length - 1) breakpoints.push(chain.length - 1);
+  return { layout: { chain, breakpoints, yieldable: [] }, handles };
+}
+export function applyResponsesAnchor(payload, { handles }, plan) {
+  const handle = handles[plan.add];
+  if (!handle) return payload;
+  const input = [...payload.input];
+  const item = { ...input[handle.item], content: [...input[handle.item].content] };
+  item.content[handle.block] = { ...item.content[handle.block], prompt_cache_breakpoint: { mode: "explicit" } };
+  input[handle.item] = item;
+  return { ...payload, input };
+}

package/pi-extension/dist/provider-support/effort.js

@@ -0,0 +1,13 @@
+import { effortHistoryRoute } from "./openai/adapter.js";
+import { isChatGPTSignIn } from "./routes.js";
+/**
+ * Whether changing effort on this route keeps its prompt cache. Freeflow's effort history keeps it on qualified
+ * GPT-6 routes; Pi keeps it natively on Claude models that take per-message effort, where a request-level
+ * effort change would otherwise invalidate every cached message.
+ */
+export function keepsCacheAcrossEffort(model, ctx) {
+  // Sign in with ChatGPT rejects effort-history items, and a plain effort change rereads the context (live, S-006).
+  if (isChatGPTSignIn(model, ctx)) return false;
+  if (effortHistoryRoute(model) !== undefined) return true;
+  return model?.api === "anthropic-messages" && model.compat?.supportsMidConvoEffort === true;
+}

package/pi-extension/dist/provider-support/index.js

@@ -1,4 +1,45 @@
-import { registerAstraSupport } from "./astra/index.js";
-export function registerProviderSupport(pi) {
-  registerAstraSupport(pi);
+import { CacheAnchorAdapter } from "./cache/index.js";
+import { CacheKeepAlive } from "./cache/keepalive.js";
+import { registerOpenAIEffortSupport } from "./openai/index.js";
+export function registerProviderSupport(pi, enabled, monitor) {
+  registerOpenAIEffortSupport(pi, enabled, monitor);
+  const anchor = new CacheAnchorAdapter(enabled);
+  const report = () => monitor?.set("keep-alive", keepAlive.status());
+  const keepAlive = new CacheKeepAlive({
+    enabled,
+    onRefresh: (record) => {
+      try {
+        // Pi's session usage totals are host-owned; keep-alive spend is recorded for Freeflow attribution.
+        pi.appendEntry?.("freeflow-cache-keepalive-v1", { ...record, at: Date.now() });
+      } catch {}
+      report();
+    },
+  });
+  const evaluate = (ctx) => {
+    keepAlive.evaluate(ctx);
+    report();
+  };
+  pi.on("session_shutdown", () => {
+    anchor.reset();
+    keepAlive.reset();
+    report();
+  });
+  pi.on("before_provider_request", (event, ctx) => {
+    const sent = anchor.adapt(event.payload, ctx);
+    try {
+      keepAlive.record(sent, ctx);
+      evaluate(ctx);
+    } catch {
+      // Keep-alive bookkeeping never affects the request being sent.
+    }
+    return sent;
+  });
+  pi.on("message_end", (event, ctx) => {
+    const message = event?.message;
+    if (message?.role === "assistant" && message.provider && message.model)
+      keepAlive.observe(ctx, message.usage, { provider: message.provider, modelId: message.model });
+  });
+  pi.on("agent_start", (_event, ctx) => evaluate(ctx));
+  pi.on("agent_end", (_event, ctx) => evaluate(ctx));
+  return { keepAlive };
 }

package/pi-extension/dist/provider-support/{astra → openai}/adapter.js

@@ -1,22 +1,11 @@
 import { assemble, EFFORTS } from "./history.js";
 import { SessionState } from "./session-state.js";
-export function requestKey(payload, model) {
-  if (
-    !payload ||
-    payload.model !== "gpt-6-astra" ||
-    model?.id !== payload.model ||
-    payload.store !== false ||
-    !Array.isArray(payload.input) ||
-    !EFFORTS.includes(payload.reasoning?.effort) ||
-    payload.previous_response_id ||
-    payload.conversation ||
-    payload.context_management ||
-    (payload.truncation && payload.truncation !== "disabled") ||
-    (payload.reasoning.mode && payload.reasoning.mode !== "standard") ||
-    payload.agents ||
-    payload.input.some((x) => x?.type === "configuration_update" || x?.type === "compaction_trigger")
-  )
-    return;
+import { isChatGPTSignIn } from "../routes.js";
+// Only these qualified official routes receive effort-history adaptation; keys isolate models.
+const SUPPORTED_MODELS = new Set(["gpt-6-astra", "gpt-6-luna", "gpt-6-sol"]);
+/** The effort-history key for a qualified official GPT-6 route, or undefined when the route is not supported. */
+export function effortHistoryRoute(model) {
+  if (!model || !SUPPORTED_MODELS.has(model.id)) return;
   const codex = model.provider === "openai-codex" && model.api === "openai-codex-responses";
   const api = model.provider === "openai" && model.api === "openai-responses";
   if (!codex && !api) return;
@@ -35,15 +24,43 @@ export function requestKey(payload, model) {
   if (!allowed.includes(base)) return;
   return `${model.provider}/${model.api}/${model.id}`;
 }
-export class AstraAdapter {
+export function requestKey(payload, model) {
+  if (
+    !payload ||
+    !SUPPORTED_MODELS.has(payload.model) ||
+    model?.id !== payload.model ||
+    payload.store !== false ||
+    !Array.isArray(payload.input) ||
+    !EFFORTS.includes(payload.reasoning?.effort) ||
+    payload.previous_response_id ||
+    payload.conversation ||
+    payload.context_management ||
+    (payload.truncation && payload.truncation !== "disabled") ||
+    (payload.reasoning.mode && payload.reasoning.mode !== "standard") ||
+    payload.agents ||
+    payload.input.some((x) => x?.type === "configuration_update" || x?.type === "compaction_trigger")
+  )
+    return;
+  return effortHistoryRoute(model);
+}
+export class OpenAIEffortAdapter {
   pi;
+  enabled;
+  monitor;
   session;
   generation = 0;
   compacting = false;
   queue = Promise.resolve();
   statusSignature;
-  constructor(pi) {
+  constructor(
+    pi,
+    // Global Freeflow disablement leaves provider requests and session history untouched.
+    enabled = () => true,
+    monitor,
+  ) {
     this.pi = pi;
+    this.enabled = enabled;
+    this.monitor = monitor;
   }
   reset(ctx) {
     this.generation++;
@@ -54,22 +71,22 @@ export class AstraAdapter {
   setCompacting(value) {
     this.compacting = value;
   }
-  status(ctx, label) {
+  status(_ctx, label) {
     if (this.statusSignature === label) return;
     this.statusSignature = label;
-    // Diagnostics must never turn a completed payload transformation into an exception.
-    try {
-      ctx.ui?.setStatus?.("freeflow-astra-effort", label);
-    } catch {}
+    // A cache diagnostic, reported to /freeflow status rather than the settings footer.
+    this.monitor?.set("openai-effort", label);
   }
   async adapt(payload, ctx) {
     const generation = this.generation;
     const operation = this.queue.then(async () => {
-      const key = requestKey(payload, ctx.model);
-      if (generation !== this.generation || this.compacting || !key) {
+      // Sign in with ChatGPT rejects configuration_update items (live, 400), so effort history cannot apply.
+      const key = isChatGPTSignIn(ctx.model, ctx) ? undefined : requestKey(payload, ctx.model);
+      if (generation !== this.generation || this.compacting || !key || !this.enabled()) {
         this.status(ctx, undefined);
         return payload;
       }
+      const label = ctx.model.id === "gpt-6-astra" ? "Astra" : ctx.model.id;
       try {
         const reader = ctx.sessionManager;
         if (
@@ -92,15 +109,15 @@ export class AstraAdapter {
           this.session?.store !== store ||
           key !== requestKey(payload, ctx.model)
         )
-          throw new Error("Astra request changed during preparation");
+          throw new Error("OpenAI effort request changed during preparation");
         const result = assemble(payload, key, store.generation(), basis, records);
         if (result.record) store.append(result.record);
-        this.status(ctx, `Astra ${result.effective} · cache baseline ${result.baseline}`);
+        this.status(ctx, `${label} ${result.effective} · cache baseline ${result.baseline}`);
         return result.payload;
       } catch {
         // Pi swallows hook exceptions. Return the untouched full-history request,
         // including its requested effort, instead of a partially pinned request.
-        this.status(ctx, "Astra cache adaptation unavailable · native effort");
+        this.status(ctx, `${label} cache adaptation unavailable · native effort`);
         return payload;
       }
     });

package/pi-extension/dist/provider-support/{astra → openai}/history.js

@@ -1,5 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
-export const ENTRY_TYPE = "freeflow-astra-effort-v1";
+// This namespace starts a fresh effort chain; old Astra entries are deliberately ignored.
+export const ENTRY_TYPE = "freeflow-openai-effort-v1";
 export const EFFORTS = ["low", "medium", "high", "xhigh", "max"];
 export const hash = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
 const digest = (x) => typeof x === "string" && /^[a-f0-9]{64}$/.test(x);
@@ -45,7 +46,7 @@ export function parseAttempt(value) {
         ].includes(k),
     )
   )
-    throw new Error("Invalid Astra effort history");
+    throw new Error("Invalid OpenAI effort history");
   return value;
 }
 // Hash complete serialized items, including opaque reasoning; never persist their bodies.
@@ -72,16 +73,16 @@ export function assemble(payload, key, generation, basis, records) {
   const seen = new Set();
   let cursor = prior;
   while (cursor) {
-    if (seen.has(cursor.id)) throw new Error("Cyclic Astra history");
+    if (seen.has(cursor.id)) throw new Error("Cyclic OpenAI effort history");
     seen.add(cursor.id);
     if (cursor.update) {
-      if (hashes[cursor.update.at] !== cursor.update.prefixHash) throw new Error("Astra anchor changed");
+      if (hashes[cursor.update.at] !== cursor.update.prefixHash) throw new Error("OpenAI effort anchor changed");
       updates.unshift(cursor.update);
     }
     if (cursor.parent === null) break;
     const parent = byId.get(cursor.parent);
     if (!parent || parent.key !== key || parent.generation !== generation || parent.baseline !== baseline)
-      throw new Error("Astra history parent unavailable");
+      throw new Error("OpenAI effort history parent unavailable");
     cursor = parent;
   }
   let update;
@@ -90,10 +91,10 @@ export function assemble(payload, key, generation, basis, records) {
     const last = payload.input.length - 1;
     const at = payload.input[last]?.role === "user" && last >= (prior?.length ?? 0) ? last : payload.input.length;
     update = { at, prefixHash: hashes[at], effort: desired };
-    if (updates.at(-1)?.at === at) throw new Error("Adjacent Astra effort updates");
+    if (updates.at(-1)?.at === at) throw new Error("Adjacent OpenAI effort updates");
     updates.push(update);
   }
-  if (updates.some((u, i) => i > 0 && u.at <= updates[i - 1].at)) throw new Error("Invalid Astra update order");
+  if (updates.some((u, i) => i > 0 && u.at <= updates[i - 1].at)) throw new Error("Invalid OpenAI effort update order");
   const output = structuredClone(payload);
   output.input = [];
   let nextUpdate = 0;
@@ -104,7 +105,8 @@ export function assemble(payload, key, generation, basis, records) {
     if (i < payload.input.length) output.input.push(structuredClone(payload.input[i]));
   }
   output.reasoning.effort = baseline;
-  const identical = prior?.length === payload.input.length && prior.effective === desired;
+  // Records mark baselines and effort changes; a longer input under the same effort needs none.
+  const identical = !!prior && !update;
   const record = identical
     ? undefined
     : {

package/pi-extension/dist/provider-support/{astra → openai}/index.js

@@ -1,7 +1,11 @@
-import { AstraAdapter } from "./adapter.js";
-export function registerAstraSupport(pi) {
-  const adapter = new AstraAdapter(pi);
-  pi.on("session_start", (_event, ctx) => adapter.reset(ctx));
+import { OpenAIEffortAdapter } from "./adapter.js";
+import { trustStartedSession } from "../../host/read-only-session.js";
+export function registerOpenAIEffortSupport(pi, enabled, monitor) {
+  const adapter = new OpenAIEffortAdapter(pi, enabled, monitor);
+  pi.on("session_start", (event, ctx) => {
+    trustStartedSession(event?.reason, ctx.sessionManager);
+    adapter.reset(ctx);
+  });
   pi.on("session_shutdown", (_event, ctx) => adapter.reset(ctx));
   pi.on("session_tree", (_event, ctx) => adapter.reset(ctx));
   pi.on("session_before_compact", () => adapter.setCompacting(true));