@hypercarrier/rarebit 0.1.0-alpha.5 → 0.2.0

package/src/extension.mjs

@@ -1,8 +1,6 @@
-import { readFile } from "node:fs/promises";
+import { readFile, rm } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join, resolve } from "node:path";
-import { complete } from "@earendil-works/pi-ai/compat";
-
 export * from "./rarebit-core.mjs";
 export * from "./rarebit-model.mjs";
 export * from "./automatic-summary-policy.mjs";
@@ -15,6 +13,7 @@ import {
 } from "./rarebit-service.mjs";
 import {
   DEFAULT_RAREBIT_SUMMARY_POLICY,
+  normalizeRarebitSummaryPrompt,
   selectRarebits,
   sha256,
 } from "./rarebit-core.mjs";
@@ -25,7 +24,14 @@ import {
   getRarebitArgumentCompletions,
   parseRarebitCommand,
   rarebitCommandDescription,
+  rarebitCommandUsage,
 } from "./rarebit-command.mjs";
+import {
+  buildRarebitForkPlan,
+  createRarebitForkEntries,
+  sessionFilenameFor,
+  writeRarebitForkFile,
+} from "./rarebit-fork.mjs";
 import {
   RAREBIT_CONVERSATION_SCHEMA_VERSION,
   RAREBIT_RECALL_SCHEMA_VERSION,
@@ -35,6 +41,12 @@ import {
   createDetachedMaterializer,
   registerRarebitLifecycle,
 } from "./lifecycle.mjs";
+import { createRarebitRecapController } from "./rarebit-recap.mjs";
+import {
+  openRarebitPalette,
+  openRarebitSettings,
+  rarebitPaletteCommand,
+} from "./rarebit-settings-ui.mjs";
 import {
   automaticSummaryInhibitionIdentity,
   queryAutomaticSummaryPolicy,
@@ -49,6 +61,17 @@ async function readSettings(path) {
   }
 }
 
+function resolveReserveTokens(globalSettings, projectSettings, model) {
+  const globalCompaction = globalSettings?.compaction ?? {};
+  const projectCompaction = projectSettings?.compaction ?? {};
+  const compaction = { ...globalCompaction, ...projectCompaction };
+  const modelOverrides = { ...(globalCompaction.modelOverrides ?? {}), ...(projectCompaction.modelOverrides ?? {}) };
+  const key = model?.provider && model?.id ? `${model.provider}/${model.id}` : null;
+  const override = key ? modelOverrides[key] : undefined;
+  const value = override?.reserveTokens ?? (Object.hasOwn(projectCompaction, "reserveTokens") ? projectCompaction.reserveTokens : compaction.reserveTokens) ?? 16_384;
+  return Number.isSafeInteger(value) && value >= 0 ? value : 16_384;
+}
+
 function configuredAgentDir(env = process.env) {
   return env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent");
 }
@@ -56,6 +79,7 @@ function configuredAgentDir(env = process.env) {
 export async function readConfiguredRarebitSettings({
   cwd,
   projectTrusted,
+  model,
   agentDir = configuredAgentDir(),
 } = {}) {
   const global = await readSettings(join(agentDir, "settings.json"));
@@ -88,6 +112,11 @@ export async function readConfiguredRarebitSettings({
     },
     summaryPolicy: resolved.summaryPolicy,
     autoTitle: resolved.autoTitle,
+    maxInputTokens: resolved.maxInputTokens,
+    summaryPrompt: resolved.summaryPrompt,
+    diagnostics: resolved.diagnostics,
+    recap: resolved.recap,
+    reserveTokens: resolveReserveTokens(global.value, project.value, model),
   };
 }
 
@@ -104,10 +133,17 @@ export default function registerPiRarebit(pi, config = {}) {
     });
   const activityReporter =
     explicit.activityReporter ?? createHerdrActivityReporter();
-  const projectActivity = (ctx) =>
-    projectRarebitSessionActivity(
-      selectRarebits(ctx?.sessionManager?.getBranch?.() ?? []),
-    );
+  const recapController = createRarebitRecapController({
+    delayMs: explicit.recap?.delayMs,
+    timezone: explicit.recap?.timezone,
+  });
+  const projectActivity = (ctx) => {
+    const entries = ctx?.sessionManager?.getBranch?.() ?? [];
+    return projectRarebitSessionActivity({
+      ...selectRarebits(entries),
+      entries,
+    });
+  };
 
   const notify = (ctx, text, level = "info") => {
     if (!ctx?.hasUI || typeof ctx?.ui?.notify !== "function") return;
@@ -135,10 +171,11 @@ export default function registerPiRarebit(pi, config = {}) {
       ? `${name} tokens: ${value}`
       : `${name} tokens: unavailable`;
 
-  const notifyOutcome = (ctx, result, triggered) => {
-    if (!triggered || result?.duplicate || result?.inFlight) return;
+  const notifyOutcome = (ctx, result, triggered, diagnostics = {}) => {
+    if (result?.duplicate || result?.inFlight) return;
     switch (result?.record?.status) {
       case "ok":
+        if (!triggered || diagnostics.summaryUpdated !== true) return;
         notify(
           ctx,
           `Rarebit Summary updated (${tokenLabel("input", result.record.synthesis?.usage?.inputTokens)} · ${tokenLabel("output", result.record.synthesis?.usage?.outputTokens)} · model ${resultModelLabel(result)})`,
@@ -179,6 +216,7 @@ export default function registerPiRarebit(pi, config = {}) {
         injected = await settingsLoader({
           cwd: ctx?.cwd,
           projectTrusted: ctx?.isProjectTrusted?.() === true,
+          model: ctx?.model,
         });
       } catch (error) {
         injected = {
@@ -200,15 +238,40 @@ export default function registerPiRarebit(pi, config = {}) {
       ...injected,
       ...explicit,
       summaryPolicy,
-      piAi: explicit.piAi ?? { complete },
+      maxInputTokens: explicit.maxInputTokens ?? injected.maxInputTokens,
+      summaryPrompt: explicit.summaryPrompt ?? injected.summaryPrompt,
+      diagnostics: {
+        ...(injected.diagnostics ?? {}),
+        ...(explicit.diagnostics ?? {}),
+      },
+      recap: {
+        ...(injected.recap ?? {}),
+        ...(explicit.recap ?? {}),
+      },
+      piAi: explicit.piAi ?? {
+        complete: async (...args) => (await import("@earendil-works/pi-ai/compat")).complete(...args),
+      },
     };
   };
 
   const materialize = async (ctx, { force = false } = {}) => {
+    const recapToken = recapController.captureMaterialization(ctx);
     let synthesisTriggered = false;
     const effective = await loadEffective(ctx);
+    let summaryPrompt;
+    try {
+      summaryPrompt = normalizeRarebitSummaryPrompt(effective.summaryPrompt).guidance;
+    } catch (error) {
+      notify(
+        ctx,
+        `Invalid rarebit.summary_prompt: ${error?.message ?? error}`,
+        "error",
+      );
+      return { record: { status: "invalid_configuration" } };
+    }
     const result = await processRarebitSummary(ctx, {
       ...effective,
+      summaryPrompt,
       forceSynthesis: force,
       lifecycleBoundary: force ? "manual" : ctx?.lifecycleBoundary,
       queryAutomaticSummaryPolicy:
@@ -216,14 +279,26 @@ export default function registerPiRarebit(pi, config = {}) {
       onSynthesisTriggered: (detail) => {
         synthesisTriggered = true;
         const count = detail.rarebitCount ?? detail.rarebitCount;
-        notify(
-          ctx,
-          `Rarebit Summary triggered (${count} Rarebits · input tokens: ~${detail.estimatedInputTokens} estimated (chars/4) · model ${modelLabel(detail.model)})`,
-          "info",
-        );
+        if (effective.diagnostics?.summaryTriggered === true)
+          notify(
+            ctx,
+            `Rarebit Summary triggered (${count} Rarebits · input tokens: ~${detail.estimatedInputTokens} estimated (chars/4) · model ${modelLabel(detail.model)})`,
+            "info",
+          );
       },
     });
-    notifyOutcome(ctx, result, synthesisTriggered);
+    notifyOutcome(ctx, result, synthesisTriggered, effective.diagnostics);
+    recapController.offer({
+      ctx,
+      result,
+      token: recapToken,
+      recapEnabled: effective.recap?.enabled !== false,
+      recapDelayMs: effective.recap?.delayMs,
+      recapTimezone: effective.recap?.timezone,
+      sessionRoot: effective.sessionRoot,
+      rarebitRoot: effective.rarebitRoot,
+      allowExternalSession: effective.allowExternalSession === true,
+    });
     return result;
   };
   const schedule = createDetachedMaterializer(materialize, (_error, ctx) => {
@@ -331,20 +406,33 @@ export default function registerPiRarebit(pi, config = {}) {
   );
 
   registerRarebitLifecycle(pi, schedule, {
-    onSessionStart: (ctx) => {
+    onSessionStart: (ctx, generation) => {
+      recapController.invalidate(ctx, generation);
       activeSession = identityFrom(ctx);
       activityReporter.start(projectActivity(ctx));
     },
-    onSessionTree: (ctx) => {
+    onAgentStart: (ctx, generation) => {
+      recapController.invalidate(ctx, generation);
+    },
+    onTurnStart: (ctx, generation) => {
+      recapController.invalidate(ctx, generation);
+    },
+    onInputSent: (ctx, generation) => {
+      recapController.invalidate(ctx, generation);
+    },
+    onSessionTree: (ctx, _event, generation) => {
+      recapController.invalidate(ctx, generation);
       activityReporter.update(projectActivity(ctx));
     },
     onSelectedUserPersisted: (ctx) => {
       activityReporter.update(projectActivity(ctx));
     },
     onAgentSettled: (ctx) => {
+      recapController.updateContext(ctx);
       activityReporter.update(projectActivity(ctx));
     },
-    onSessionShutdown: () => {
+    onSessionShutdown: (ctx, generation) => {
+      recapController.invalidate(ctx, generation);
       activeSession = undefined;
       activityReporter.stop();
     },
@@ -422,7 +510,35 @@ ${fence(requestText)}`;
     description: rarebitCommandDescription(),
     getArgumentCompletions: getRarebitArgumentCompletions,
     handler: async (args, ctx) => {
-      const command = parseRarebitCommand(args);
+      let commandInput = String(args ?? "");
+      const trimmedCommandInput = commandInput.trim();
+      if (!trimmedCommandInput || trimmedCommandInput === "menu") {
+        const currentUiState = () => ({
+          ...identityFrom(ctx),
+          branchLeafId: ctx?.sessionManager?.getBranch?.()?.at(-1)?.id ?? null,
+          cwd: ctx?.cwd ?? process.cwd(),
+          projectTrusted: ctx?.isProjectTrusted?.() === true,
+        });
+        const initial = currentUiState();
+        const selection = await openRarebitPalette(ctx, {
+          isCurrent: () => {
+            const current = currentUiState();
+            return current.sessionId === initial.sessionId &&
+              current.sessionFile === initial.sessionFile &&
+              current.branchLeafId === initial.branchLeafId &&
+              current.cwd === initial.cwd &&
+              current.projectTrusted === initial.projectTrusted;
+          },
+        });
+        commandInput = rarebitPaletteCommand(selection) ?? "";
+        if (!commandInput) return;
+        if (selection?.id === "recall") {
+          const prompt = await ctx.ui.input?.("Rarebit recall prompt", "");
+          if (prompt === undefined || !String(prompt).trim()) return;
+          commandInput = `recall ${prompt}`;
+        }
+      }
+      const command = parseRarebitCommand(commandInput);
       if (!command.ok) {
         notify(
           ctx,
@@ -434,6 +550,127 @@ ${fence(requestText)}`;
         return;
       }
       const { subcommand, arguments: rest } = command;
+      if (subcommand === "help") {
+        notify(
+          ctx,
+          [
+            rarebitCommandUsage(),
+            ...(commandInput.trim().split(/\s+/).length === 1
+              ? ["Use /rarebit to open the interactive command palette."]
+              : []),
+          ].join("\n"),
+          "info",
+        );
+        return;
+      }
+      if (subcommand === "settings") {
+        const currentUiState = () => ({
+          ...identityFrom(ctx),
+          branchLeafId: ctx?.sessionManager?.getBranch?.()?.at(-1)?.id ?? null,
+          cwd: ctx?.cwd ?? process.cwd(),
+          projectTrusted: ctx?.isProjectTrusted?.() === true,
+        });
+        const initial = currentUiState();
+        await openRarebitSettings(ctx, {
+          initialScope: rest[0] === "project" ? "project" : "global",
+          projectTrusted: initial.projectTrusted,
+          isCurrent: () => {
+            const current = currentUiState();
+            return current.sessionId === initial.sessionId &&
+              current.sessionFile === initial.sessionFile &&
+              current.branchLeafId === initial.branchLeafId &&
+              current.cwd === initial.cwd &&
+              current.projectTrusted === initial.projectTrusted;
+          },
+          onSaved: async ({ namespace, document }) => {
+            const previous = document?.namespace ?? {};
+            const changed = (path) => {
+              const read = (value) => path.reduce((current, key) => current?.[key], value);
+              return JSON.stringify(read(previous)) !== JSON.stringify(read(namespace));
+            };
+            if (changed(["max_rarebit_ratio"])) {
+              const next = { ...policyOverrides };
+              delete next.maxRarebitRatio;
+              policyOverrides = next;
+            }
+            if (changed(["min_total_length"])) {
+              const next = { ...policyOverrides };
+              delete next.minTotalLength;
+              policyOverrides = next;
+            }
+            if (changed(["auto_title"])) autoTitleOverride = undefined;
+            const effective = await loadEffective(ctx);
+            if (effective.recap?.enabled === false) recapController.invalidate(ctx);
+          },
+        });
+        return;
+      }
+      if (subcommand === "fork") {
+        if (typeof ctx?.switchSession !== "function") {
+          notify(ctx, "Rarebit fork is unavailable in this Pi runtime", "error");
+          return;
+        }
+        let destination;
+        let switchStarted = false;
+        try {
+          await ctx.waitForIdle?.();
+          const sourceFile = ctx.sessionManager?.getSessionFile?.();
+          const branch = ctx.sessionManager?.getBranch?.();
+          const sourceHeader = ctx.sessionManager?.getHeader?.();
+          if (typeof sourceFile !== "string" || !Array.isArray(branch))
+            throw new Error("the current Pi Session must be persisted before forking");
+          const maxTokenLength = Number(rest[1] ?? 64_000);
+          const model = ctx.model ?? null;
+          if (!model || typeof model.provider !== "string" || !model.provider || typeof model.id !== "string" || !model.id || !Number.isFinite(model.contextWindow) || model.contextWindow <= 0)
+            throw new Error("destination model/context window is unavailable; select a target Pi model before forking");
+          const effective = await loadEffective(ctx);
+          const promptOverheadTokens = Math.ceil(String(ctx.getSystemPrompt?.() ?? "").length / 4);
+          const activeToolNames = new Set(pi.getActiveTools?.() ?? []);
+          const activeToolSchema = (pi.getAllTools?.() ?? [])
+            .filter((tool) => activeToolNames.has(tool.name))
+            .map(({ name, description, parameters }) => ({ name, description, parameters }));
+          const toolOverheadTokens = Math.ceil(JSON.stringify(activeToolSchema).length / 4);
+          const plan = buildRarebitForkPlan({
+            header: sourceHeader, sessionFile: sourceFile, cwd: ctx.cwd, branch,
+            targetCwd: ctx.cwd, maxTokenLength, targetModel: model,
+            reserveTokens: effective.reserveTokens ?? 16_384,
+            promptOverheadTokens,
+            toolOverheadTokens,
+          });
+          const currentLeaf = ctx.sessionManager.getLeafId?.() ?? branch.at(-1)?.id ?? null;
+          if (currentLeaf !== (plan.branchLeafId ?? null))
+            throw new Error("the active source branch changed during fork preparation; retry without switching branches");
+          const session = createRarebitForkEntries(plan);
+          const sessionDir = ctx.sessionManager.getSessionDir?.();
+          if (typeof sessionDir !== "string" || !sessionDir)
+            throw new Error("the current Pi Session store is unavailable");
+          destination = sessionFilenameFor({ sessionDir, forkCreatedAt: plan.forkCreatedAt, sessionId: session.sessionId });
+          await writeRarebitForkFile(destination, session);
+          const currentSourceFile = ctx.sessionManager.getSessionFile?.();
+          const currentSourceId = ctx.sessionManager.getHeader?.()?.id;
+          const currentSourceLeaf = ctx.sessionManager.getLeafId?.() ?? ctx.sessionManager.getBranch?.()?.at(-1)?.id ?? null;
+          if (resolve(currentSourceFile ?? "") !== resolve(sourceFile) || currentSourceId !== sourceHeader?.id || currentSourceLeaf !== (plan.branchLeafId ?? null))
+            throw new Error("the active source Session or branch changed during fork preparation; retry without switching branches");
+          switchStarted = true;
+          const switched = await ctx.switchSession(destination, {
+            withSession: async (next) => {
+              notify(next, `Rarebit fork opened (${plan.importedTokens} imported tokens; ${plan.omittedOccurrences} omitted occurrences)`, "info");
+            },
+          });
+          if (switched?.cancelled) {
+            await rm(destination, { force: true });
+            destination = undefined;
+            notify(ctx, "Rarebit fork cancelled before switching", "warning");
+          }
+        } catch (error) {
+          if (destination && !switchStarted) await rm(destination, { force: true }).catch(() => {});
+          const retained = destination && switchStarted
+            ? ` Destination retained at ${destination}; resume it if the replacement is active.`
+            : "";
+          notify(ctx, `Rarebit fork failed: ${error?.message ?? error}.${retained}`, "error");
+        }
+        return;
+      }
       if (subcommand === "recall") {
         const prompt = rest[0];
         if (typeof pi.sendUserMessage !== "function") {
@@ -491,7 +728,7 @@ ${fence(requestText)}`;
           : "settings_or_default";
         notify(
           ctx,
-          `Rarebit ${subcommand}: auto-title=${autoTitleOverride ?? effective.autoTitle ?? true}; max_rarebit_ratio=${policy.maxRarebitRatio} (${ratioSource}); min_total_length=${policy.minTotalLength} estimated tokens via ceil(chars/4) (${lengthSource}); measurement=${policy.measurementVersion}; model=${modelLabel(effective.model)} from ${effective.modelProvenance?.settingsKey ?? "explicit config"}${policyStatus}`,
+          `Rarebit ${subcommand}: auto-title=${autoTitleOverride ?? effective.autoTitle ?? true}; recap=${effective.recap?.enabled !== false ? "on" : "off"} after ${effective.recap?.delayMs ?? 60000}ms (${effective.recap?.timezone ?? "host"}); diagnostics=triggered:${effective.diagnostics?.summaryTriggered === true ? "on" : "off"},updated:${effective.diagnostics?.summaryUpdated === true ? "on" : "off"}; max_input_tokens=${effective.maxInputTokens ?? 64000}; max_rarebit_ratio=${policy.maxRarebitRatio} (${ratioSource}); min_total_length=${policy.minTotalLength} estimated tokens via ceil(chars/4) (${lengthSource}); measurement=${policy.measurementVersion}; model=${modelLabel(effective.model)} from ${effective.modelProvenance?.settingsKey ?? "explicit config"}${policyStatus}`,
           "info",
         );
         return;
@@ -521,6 +758,28 @@ ${fence(requestText)}`;
         );
         return;
       }
+      if (subcommand === "recap") {
+        if (effective.recap?.enabled === false) {
+          recapController.invalidate(ctx);
+          notify(ctx, "Rarebit Recap is disabled in settings", "info");
+          return;
+        }
+        const recap = await recapController.showExisting(ctx, {
+          sessionRoot: effective.sessionRoot,
+          rarebitRoot: effective.rarebitRoot,
+          recapTimezone: effective.recap?.timezone,
+          allowExternalSession: effective.allowExternalSession === true,
+        });
+        if (!recap.shown)
+          notify(
+            ctx,
+            recap.reason === "no_current_summary"
+              ? "Rarebit has no current Summary for this Session branch"
+              : "Rarebit Recap is unavailable in this UI",
+            "warning",
+          );
+        return;
+      }
       if (subcommand === "title") {
         void generateTitle(ctx, { manual: true }).catch(() =>
           notify(ctx, "Rarebit title generation failed", "error"),

package/src/index.mjs

@@ -8,6 +8,7 @@ export * from "./rarebit-service.mjs";
 export * from "./rarebit-session.mjs";
 export * from "./rarebit-store.mjs";
 export * from "./rarebit-artifact-state.mjs";
+export * from "./rarebit-fork-lineage.mjs";
 export * from "./rarebit-visual-language.mjs";
 export * from "./rarebit-settings.mjs";
 export { default } from "./extension.mjs";

package/src/lifecycle.mjs

@@ -16,7 +16,12 @@ function messageText(event) {
     .join("\n");
 }
 
-function snapshotMaterializationContext(ctx, mayNotify, lifecycleBoundary) {
+function snapshotMaterializationContext(
+  ctx,
+  mayNotify,
+  lifecycleBoundary,
+  rarebitLifecycleGeneration,
+) {
   const sessionManager = ctx?.sessionManager;
   const header = sessionManager?.getHeader?.();
   const branch = sessionManager?.getBranch?.();
@@ -39,6 +44,7 @@ function snapshotMaterializationContext(ctx, mayNotify, lifecycleBoundary) {
     modelRegistry: ctx?.modelRegistry,
     sessionId: ctx?.sessionId,
     lifecycleBoundary,
+    rarebitLifecycleGeneration,
     isProjectTrusted: () => projectTrusted,
     sessionManager: {
       getHeader: () => header,
@@ -126,6 +132,7 @@ export function registerRarebitLifecycle(pi, schedule, options = {}) {
   let ownerMessageSeen = false;
   let sessionGeneration = 0;
   let sessionLive = false;
+  let rarebitLifecycleGeneration = 0;
   const MAX_PENDING_INPUT_ORIGINS = 256;
 
   const clearInputOrigins = () => {
@@ -169,7 +176,8 @@ export function registerRarebitLifecycle(pi, schedule, options = {}) {
   };
 
   pi.on("session_start", (_event, ctx) => {
-    options.onSessionStart?.(ctx);
+    rarebitLifecycleGeneration += 1;
+    options.onSessionStart?.(ctx, rarebitLifecycleGeneration);
     clearInputOrigins();
     persistedUserInputAwaitingProvider = false;
     selectedUserMessageAwaitingProvider = false;
@@ -185,13 +193,26 @@ export function registerRarebitLifecycle(pi, schedule, options = {}) {
     // the selected Session evidence.
   });
 
-  pi.on("agent_start", () => {
+  pi.on("agent_start", (_event, ctx) => {
+    rarebitLifecycleGeneration += 1;
+    options.onAgentStart?.(ctx, rarebitLifecycleGeneration);
     // A retry, compaction pass, or queued continuation starts a new agent run;
     // an earlier stop is not the fully settled branch.
     normalStopAwaitingSettlement = false;
   });
 
-  pi.on("input", (event) => {
+  pi.on("turn_start", (_event, ctx) => {
+    rarebitLifecycleGeneration += 1;
+    options.onTurnStart?.(ctx, rarebitLifecycleGeneration);
+  });
+
+  pi.on("input", (event, ctx) => {
+    rarebitLifecycleGeneration += 1;
+    try {
+      options.onInputSent?.(ctx, rarebitLifecycleGeneration);
+    } catch {
+      // Human-facing cancellation is optional and must not alter input delivery.
+    }
     const bucket =
       event?.streamingBehavior === "steer"
         ? "steer"
@@ -235,8 +256,9 @@ export function registerRarebitLifecycle(pi, schedule, options = {}) {
   });
 
   pi.on("session_tree", (event, ctx) => {
+    rarebitLifecycleGeneration += 1;
     try {
-      options.onSessionTree?.(ctx, event);
+      options.onSessionTree?.(ctx, event, rarebitLifecycleGeneration);
     } catch {
       // Tree recency is an optional projection, not materialization truth.
     }
@@ -261,6 +283,7 @@ export function registerRarebitLifecycle(pi, schedule, options = {}) {
       ctx,
       () => sessionLive && sessionGeneration === generation,
       pendingLifecycleBoundary,
+      rarebitLifecycleGeneration,
     );
     pendingLifecycleBoundary = "owner_request";
     schedule(snapshot);
@@ -306,17 +329,19 @@ export function registerRarebitLifecycle(pi, schedule, options = {}) {
         ctx,
         () => sessionLive && sessionGeneration === generation,
         "agent_settled",
+        rarebitLifecycleGeneration,
       ),
     );
   });
 
-  pi.on("session_shutdown", () => {
+  pi.on("session_shutdown", (_event, ctx) => {
+    rarebitLifecycleGeneration += 1;
     clearInputOrigins();
     persistedUserInputAwaitingProvider = false;
     selectedUserMessageAwaitingProvider = false;
     firstOwnerInputAwaitingProvider = undefined;
     normalStopAwaitingSettlement = false;
     sessionLive = false;
-    options.onSessionShutdown?.();
+    options.onSessionShutdown?.(ctx, rarebitLifecycleGeneration);
   });
 }