pi-goosedump 0.12.14 → 0.12.15

package/README.md

@@ -23,8 +23,8 @@ report that they are unavailable.
 2. **Recall:** lexical and entity matches come first. Cosine-similar BGE vectors
    fill the remaining slots. There is no separate vector database.
 
-The extension queues remembering after its own successful compactions. Learning
-runs in the background and does not delay compaction.
+Explicit `goose_remember` requests and learning after successful compactions are
+queued in the background, so model extraction and embedding do not block Pi.
 
 ## Tools
 
@@ -32,8 +32,8 @@ runs in the background and does not delay compaction.
   entry IDs.
 - **`goose_get`** expands entry IDs returned by `goose_search` or `goose_grep`.
 - **`goose_grep`** filters session messages with a glob pattern.
-- **`goose_remember`** learns durable memory from a session. It defaults to the
-  current Pi session.
+- **`goose_remember`** queues durable memory learning from a session. It defaults
+  to the current Pi session and returns before extraction and embedding finish.
 - **`goose_recall`** recalls typed memories with source provenance. It searches
   active memories in the current project by default; `history` includes
   superseded statements and `allProjects` searches every project.
@@ -97,9 +97,12 @@ compaction. Each completed model response counts as one turn, including response
 that call tools. The countdown is restored when a session resumes and appears in
 the footer with a status dot (green when >25% turns remain, yellow when ≤25%, red
 when ≤12.5%) followed by a hexadecimal countdown. `● GD:0A` means ten turns
-remain, `● GD:00` is ready to compact, and `● GD:--` is disabled. If zero is
-reached during a tool loop, the extension waits for the agent run to settle and
-then compacts. A failed compaction leaves the counter armed at zero.
+remain, `● GD:00` is ready to compact, and `● GD:--` is disabled. Pi remains the
+sole scheduler for its normal context threshold. Whichever limit is reached first
+compacts once, and every successful compaction resets the countdown. A turn or
+tool request waits until the agent run is fully settled. A failed or cancelled
+compaction leaves the counter armed at zero and is not retried in the same
+settlement.
 
 `summaryMaxTokens` is an integer from 512 to 65536 (default 4096). The effective
 summary budget is the lower of this value and 80% of Pi's `compaction.reserveTokens`,
@@ -111,6 +114,8 @@ global setting.
 The extension uses `goosedump session compact` for manual, scheduled, and automatic
 compaction. It preserves the previous summary, summarizes only the new range, and
 passes the effective token budget. `keep:N` leaves the last N user turns verbatim.
+Tool requests are queued until Pi is idle; if Pi reaches its context threshold
+first, the queued request is coalesced into that compaction.
 
 After success, memory learning is queued in the background. A learning failure
 keeps the summary and displays a warning. Custom instructions use Pi's normal

package/dist/index.ts

@@ -27,9 +27,7 @@ import { dirname, join } from "node:path";
 import {
   Input,
   Key,
-  SettingsList,
   decodeKittyPrintable,
-  getKeybindings,
   matchesKey,
   truncateToWidth,
   visibleWidth,
@@ -66,9 +64,6 @@ function isTurnsBeforeCompact(value) {
 function isSummaryMaxTokens(value) {
   return typeof value === "number" && Number.isSafeInteger(value) && value >= SUMMARY_MAX_TOKENS_MIN && value <= SUMMARY_MAX_TOKENS_MAX;
 }
-function isGoosedumpSettingValue(key, value) {
-  return key === "turnsBeforeCompact" ? isTurnsBeforeCompact(value) : isSummaryMaxTokens(value);
-}
 function piAgentDir() {
   return process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".pi", "agent");
 }
@@ -81,6 +76,10 @@ function projectSettingsPath(cwd) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function projectSettingsTrusted(ctx) {
+  const trustContext = ctx;
+  return trustContext.isProjectTrusted?.() ?? true;
+}
 function readJsonObject(path) {
   if (!existsSync(path))
     return {};
@@ -148,15 +147,19 @@ function validateGoosedumpSettings(path) {
     throw new Error(`${path}: goosedump.summaryMaxTokens must be an integer from ` + `${SUMMARY_MAX_TOKENS_MIN} to ${SUMMARY_MAX_TOKENS_MAX}`);
   }
 }
-function resolveGoosedumpSettings(cwd) {
+function resolveGoosedumpSettings(cwd, includeProject) {
   return {
     ...DEFAULT_GOOSEDUMP_SETTINGS,
     ...readGoosedumpSettingsFrom(globalSettingsPath()),
-    ...readGoosedumpSettingsFrom(projectSettingsPath(cwd))
+    ...includeProject ? readGoosedumpSettingsFrom(projectSettingsPath(cwd)) : {}
   };
 }
 function notifyInvalidSettings(ctx) {
-  for (const path of [globalSettingsPath(), projectSettingsPath(ctx.cwd)]) {
+  const paths = [
+    globalSettingsPath(),
+    ...projectSettingsTrusted(ctx) ? [projectSettingsPath(ctx.cwd)] : []
+  ];
+  for (const path of paths) {
     try {
       validateGoosedumpSettings(path);
     } catch (error) {
@@ -400,8 +403,9 @@ var GOOSEDUMP_UNAVAILABLE_MESSAGE = "goosedump is not available. Install with: n
 function goosedumpUnavailableResult() {
   return textResult(GOOSEDUMP_UNAVAILABLE_MESSAGE);
 }
-function compactStartedMessage(keep) {
-  return keep !== null ? `Compacting with goosedump; keeping the last ${keep} user turn${keep === 1 ? "" : "s"}.` : "Compacting with goosedump up to Pi's token-based cut.";
+function compactStartedMessage(keep, queued = false) {
+  const action = queued ? "Compaction queued with goosedump" : "Compacting with goosedump";
+  return keep !== null ? `${action}; keeping the last ${keep} user turn${keep === 1 ? "" : "s"}.` : `${action} up to Pi's token-based cut.`;
 }
 function runGoosedumpAsync(args, signal, executablePath = resolveNativeGoosedumpBinary()) {
   return new Promise((resolve, reject) => {
@@ -593,8 +597,9 @@ function isCompletedAssistant(message) {
   return message.role === "assistant" && message.stopReason !== "error" && message.stopReason !== "aborted";
 }
 var SUMMARIZABLE_ENTRY_TYPES = new Set(["message", "custom_message", "branch_summary"]);
-function piKeepRecentTokens(cwd) {
-  for (const path of [projectSettingsPath(cwd), globalSettingsPath()]) {
+function piKeepRecentTokens(cwd, includeProject) {
+  const paths = includeProject ? [projectSettingsPath(cwd), globalSettingsPath()] : [globalSettingsPath()];
+  for (const path of paths) {
     const compaction = readJsonObject(path).compaction;
     if (isRecord(compaction) && typeof compaction.keepRecentTokens === "number") {
       return compaction.keepRecentTokens;
@@ -602,8 +607,9 @@ function piKeepRecentTokens(cwd) {
   }
   return DEFAULT_COMPACTION_SETTINGS.keepRecentTokens;
 }
-function piReserveTokens(cwd) {
-  for (const path of [projectSettingsPath(cwd), globalSettingsPath()]) {
+function piReserveTokens(cwd, includeProject) {
+  const paths = includeProject ? [projectSettingsPath(cwd), globalSettingsPath()] : [globalSettingsPath()];
+  for (const path of paths) {
     const compaction = readJsonObject(path).compaction;
     if (isRecord(compaction) && typeof compaction.reserveTokens === "number") {
       return compaction.reserveTokens;
@@ -611,9 +617,9 @@ function piReserveTokens(cwd) {
   }
   return DEFAULT_COMPACTION_SETTINGS.reserveTokens;
 }
-function effectiveSummaryMaxTokens(cwd) {
-  const configured = resolveGoosedumpSettings(cwd).summaryMaxTokens;
-  const reserveTokens = piReserveTokens(cwd);
+function effectiveSummaryMaxTokens(cwd, includeProject) {
+  const configured = resolveGoosedumpSettings(cwd, includeProject).summaryMaxTokens;
+  const reserveTokens = piReserveTokens(cwd, includeProject);
   if (reserveTokens <= 0)
     return configured;
   return Math.max(1, Math.min(configured, Math.floor(reserveTokens * 0.8)));
@@ -625,7 +631,7 @@ function hasCompactableHistory(ctx) {
   if (branch[branch.length - 1].type === "compaction")
     return false;
   const boundaryStart = activeHistoryStartIndex(branch);
-  const cut = findCutPoint(branch, boundaryStart, branch.length, piKeepRecentTokens(ctx.cwd));
+  const cut = findCutPoint(branch, boundaryStart, branch.length, piKeepRecentTokens(ctx.cwd, projectSettingsTrusted(ctx)));
   if (!branch[cut.firstKeptEntryIndex]?.id)
     return false;
   const historyEnd = cut.isSplitTurn ? cut.turnStartIndex : cut.firstKeptEntryIndex;
@@ -782,8 +788,7 @@ class NumberInputSubmenu {
     this.hint = getSettingsListTheme().hint;
   }
   handleInput(data) {
-    const kb = getKeybindings();
-    if (kb.matches(data, "tui.select.confirm") || data === `
+    if (matchesKey(data, Key.enter) || matchesKey(data, Key.return) || data === `
 `) {
       const value = this.input.getValue();
       if (value === "") {
@@ -805,7 +810,7 @@ class NumberInputSubmenu {
       this.onSubmitValue(parsed);
       return;
     }
-    if (kb.matches(data, "tui.select.cancel")) {
+    if (matchesKey(data, Key.escape)) {
       this.onCancelEdit();
       return;
     }
@@ -836,109 +841,190 @@ function makeRow(content, innerW, border) {
 async function runSettingsEditor(ctx) {
   const OVERLAY_WIDTH = 84;
   const location = ctx.cwd;
+  const projectTrusted = projectSettingsTrusted(ctx);
+  const specs = [
+    {
+      key: "turnsBeforeCompact",
+      description: "LLM turns before compaction; 0 disables.",
+      min: TURNS_BEFORE_COMPACT_MIN,
+      max: TURNS_BEFORE_COMPACT_MAX
+    },
+    {
+      key: "summaryMaxTokens",
+      description: "Maximum estimated tokens in each summary.",
+      min: SUMMARY_MAX_TOKENS_MIN,
+      max: SUMMARY_MAX_TOKENS_MAX
+    }
+  ];
+  const helpRows = [
+    ["Tab", "Next tab"],
+    ["Shift+Tab / S", "Switch scope in Settings"],
+    ["↑ / ↓", "Select setting"],
+    ["Enter", "Edit setting or submit value"],
+    ["Esc", "Cancel edit or close"],
+    ["Ctrl+C", "Close"],
+    ["Empty + Enter", "Use the Global value in Project scope"]
+  ];
   await ctx.ui.custom((tui, theme, _kb, done) => {
-    let settingsList;
-    function settingLabel(scope, key) {
-      const scopeLabel = scope === "global" ? "Global" : "Project";
+    let tab = "settings";
+    let scope = projectTrusted ? "project" : "global";
+    let selectedSetting = 0;
+    let editor;
+    let globalSettings = { ...DEFAULT_GOOSEDUMP_SETTINGS };
+    let projectSettings = {};
+    function settingLabel(editScope, key) {
+      const scopeLabel = editScope === "global" ? "Global" : "Project";
       return `${scopeLabel} ${key}`;
     }
-    function buildSettingItems() {
-      const global = readScopedGoosedumpSettings(location, "global");
-      const projectPath = projectSettingsPath(location);
-      const projectRaw = readJsonObjectStrict(projectPath).goosedump;
-      const project = isRecord(projectRaw) ? projectRaw : {};
-      const specs = [
-        {
-          key: "turnsBeforeCompact",
-          description: "LLM turns before compaction; 0 disables.",
-          min: TURNS_BEFORE_COMPACT_MIN,
-          max: TURNS_BEFORE_COMPACT_MAX
-        },
-        {
-          key: "summaryMaxTokens",
-          description: "Maximum estimated tokens in each summary.",
-          min: SUMMARY_MAX_TOKENS_MIN,
-          max: SUMMARY_MAX_TOKENS_MAX
-        }
-      ];
-      return ["global", "project"].flatMap((scope) => specs.map(({ key, description, min, max }) => {
-        const projectValue = isGoosedumpSettingValue(key, project[key]) ? project[key] : undefined;
-        return {
-          id: `${scope}:${key}`,
-          label: settingLabel(scope, key),
-          description: scope === "project" ? `${description} Empty inherits Global.` : description,
-          currentValue: String(scope === "project" ? projectValue ?? "" : global[key]),
-          submenu: (currentValue, subDone) => new NumberInputSubmenu(settingLabel(scope, key), currentValue === "" ? null : Number(currentValue), (value) => subDone(String(value)), () => subDone(), {
-            min,
-            max,
-            onClear: scope === "project" ? () => subDone("") : undefined,
-            onInvalid: (message) => ctx.ui.notify(message, "error")
-          })
-        };
-      }));
+    function reloadSettings() {
+      globalSettings = readScopedGoosedumpSettings(location, "global");
+      projectSettings = {};
+      if (!projectTrusted)
+        return;
+      const projectRaw = readJsonObjectStrict(projectSettingsPath(location)).goosedump;
+      if (!isRecord(projectRaw))
+        return;
+      if (isTurnsBeforeCompact(projectRaw.turnsBeforeCompact)) {
+        projectSettings.turnsBeforeCompact = projectRaw.turnsBeforeCompact;
+      }
+      if (isSummaryMaxTokens(projectRaw.summaryMaxTokens)) {
+        projectSettings.summaryMaxTokens = projectRaw.summaryMaxTokens;
+      }
     }
-    function rebuildSettingsList() {
-      settingsList = new SettingsList(buildSettingItems(), 10, getSettingsListTheme(), (id, newValue) => {
-        const [scope, key] = id.split(":");
-        if (scope === "project" && newValue === "") {
-          try {
-            clearScopedGoosedumpSetting(location, scope, key);
-            settingsList.updateValue(id, "");
-            ctx.ui.notify(`${settingLabel(scope, key)} inherits Global`, "info");
-            tui.requestRender();
-          } catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            ctx.ui.notify(`goosedump settings error: ${message}`, "error");
-          }
-          return;
-        }
-        const parsed = Number(newValue);
-        if (!isGoosedumpSettingValue(key, parsed))
-          return;
+    function finishEdit() {
+      editor = undefined;
+      reloadSettings();
+      tui.requestRender();
+    }
+    function reportSettingsError(error) {
+      const message = error instanceof Error ? error.message : String(error);
+      ctx.ui.notify(`goosedump settings error: ${message}`, "error");
+    }
+    function openEditor() {
+      const spec = specs[selectedSetting];
+      if (!spec)
+        return;
+      const editScope = scope;
+      const currentValue = editScope === "global" ? globalSettings[spec.key] : projectSettings[spec.key] ?? null;
+      editor = new NumberInputSubmenu(settingLabel(editScope, spec.key), currentValue, (value) => {
         try {
-          writeScopedGoosedumpSetting(location, scope, key, parsed);
-          settingsList.updateValue(id, newValue);
-          ctx.ui.notify(`${settingLabel(scope, key)} = ${key === "turnsBeforeCompact" ? formatCompactSetting(parsed) : parsed}`, "info");
-          tui.requestRender();
+          writeScopedGoosedumpSetting(location, editScope, spec.key, value);
+          ctx.ui.notify(`${settingLabel(editScope, spec.key)} = ${spec.key === "turnsBeforeCompact" ? formatCompactSetting(value) : value}`, "info");
+          finishEdit();
         } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          ctx.ui.notify(`goosedump settings error: ${message}`, "error");
+          reportSettingsError(error);
         }
-        tui.requestRender();
       }, () => {
-        done(undefined);
+        editor = undefined;
+        tui.requestRender();
+      }, {
+        min: spec.min,
+        max: spec.max,
+        onClear: editScope === "project" ? () => {
+          try {
+            clearScopedGoosedumpSetting(location, editScope, spec.key);
+            ctx.ui.notify(`${settingLabel(editScope, spec.key)} inherits Global`, "info");
+            finishEdit();
+          } catch (error) {
+            reportSettingsError(error);
+          }
+        } : undefined,
+        onInvalid: (message) => ctx.ui.notify(message, "error")
       });
     }
-    rebuildSettingsList();
+    reloadSettings();
     return {
       render(width) {
-        const innerW = width - 4;
+        const innerW = Math.max(1, width - 4);
         const border = theme.fg("border", "│");
-        const borderFg = (s) => theme.fg("border", s);
-        const accent = (s) => theme.fg("accent", s);
-        const dim = (s) => theme.fg("dim", s);
-        const lines = [];
+        const borderFg = (text2) => theme.fg("border", text2);
+        const accent = (text2) => theme.fg("accent", text2);
+        const dim = (text2) => theme.fg("dim", text2);
+        const text = (value) => theme.fg("text", value);
+        const pad = (value, cellWidth) => {
+          const clipped = truncateToWidth(value, cellWidth);
+          return `${clipped}${" ".repeat(Math.max(0, cellWidth - visibleWidth(clipped)))}`;
+        };
+        const tabLabel = (label, active) => active ? accent(theme.bold(`[${label}]`)) : theme.fg("muted", label);
+        const tabs = `${tabLabel("Settings", tab === "settings")}  ${tabLabel("Help", tab === "help")}${dim(`  ·  Scope: ${scope === "project" ? "Project" : "Global"}`)}`;
+        const content = [tabs, ""];
+        if (editor) {
+          content.push(...editor.render(innerW));
+        } else if (tab === "help") {
+          const shortcutWidth = Math.max(visibleWidth("Shortcut"), ...helpRows.map(([shortcut]) => visibleWidth(shortcut)));
+          const descriptionWidth = Math.max(1, innerW - shortcutWidth - 4);
+          content.push(dim(`  ${pad("Shortcut", shortcutWidth)}  Description`), ...helpRows.map(([shortcut, description]) => `  ${accent(pad(shortcut, shortcutWidth))}  ${text(truncateToWidth(description, descriptionWidth))}`));
+        } else {
+          for (const [index, spec] of specs.entries()) {
+            const selected = index === selectedSetting;
+            const inherited = scope === "project" && projectSettings[spec.key] === undefined;
+            const value = scope === "global" ? globalSettings[spec.key] : projectSettings[spec.key] ?? globalSettings[spec.key];
+            const valueText = `[ ${value} ]`;
+            const renderedValue = inherited ? dim(valueText) : selected ? accent(valueText) : text(valueText);
+            const cursor = selected ? accent("›") : " ";
+            content.push(`${cursor} ${renderedValue} ${text(spec.key)}`);
+          }
+          const selectedSpec = specs[selectedSetting];
+          if (selectedSpec) {
+            const inherited = scope === "project" && projectSettings[selectedSpec.key] === undefined;
+            content.push("", dim(inherited ? `${selectedSpec.description} Using the Global value.` : selectedSpec.description));
+          }
+          const effective = resolveGoosedumpSettings(location, projectTrusted);
+          content.push("", dim(`Effective: turns=${formatCompactSetting(effective.turnsBeforeCompact)} · summary=${effectiveSummaryMaxTokens(location, projectTrusted)} tokens`));
+        }
         const title = accent(" Goosedump Settings ");
         const topFill = borderFg("─".repeat(Math.max(0, width - 4 - visibleWidth(title))));
-        lines.push(`${borderFg("╭─")}${title}${topFill}${borderFg("─╮")}`);
-        for (const line of settingsList.render(innerW))
-          lines.push(makeRow(line, innerW, border));
-        lines.push(makeRow("", innerW, border));
-        const effective = resolveGoosedumpSettings(location);
-        lines.push(makeRow(dim(`Effective: turns=${formatCompactSetting(effective.turnsBeforeCompact)} · summary=${effectiveSummaryMaxTokens(location)} tokens`), innerW, border));
-        lines.push(makeRow(dim("↑↓ select  enter/space edit  esc close"), innerW, border));
-        lines.push(`${borderFg("╰")}${borderFg("─".repeat(width - 2))}${borderFg("╯")}`);
-        return lines;
+        return [
+          `${borderFg("╭─")}${title}${topFill}${borderFg("─╮")}`,
+          ...content.map((line) => makeRow(line, innerW, border)),
+          `${borderFg("╰")}${borderFg("─".repeat(Math.max(0, width - 2)))}${borderFg("╯")}`
+        ];
       },
       handleInput(data) {
-        if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+        if (matchesKey(data, Key.ctrl("c"))) {
           done(undefined);
           return;
         }
-        settingsList.handleInput(data);
+        if (editor) {
+          editor.handleInput(data);
+          tui.requestRender();
+          return;
+        }
+        if (matchesKey(data, Key.tab)) {
+          tab = tab === "settings" ? "help" : "settings";
+          tui.requestRender();
+          return;
+        }
+        if (tab === "settings" && (matchesKey(data, Key.shift(Key.tab)) || data.toLowerCase() === "s")) {
+          if (!projectTrusted && scope === "global") {
+            ctx.ui.notify("Project settings require a trusted project", "warning");
+            return;
+          }
+          scope = scope === "project" ? "global" : "project";
+          reloadSettings();
+          tui.requestRender();
+          return;
+        }
+        if (matchesKey(data, Key.escape)) {
+          done(undefined);
+          return;
+        }
+        if (tab === "help")
+          return;
+        if (matchesKey(data, Key.up)) {
+          selectedSetting = selectedSetting === 0 ? specs.length - 1 : Math.max(0, selectedSetting - 1);
+        } else if (matchesKey(data, Key.down)) {
+          selectedSetting = (selectedSetting + 1) % specs.length;
+        } else if (matchesKey(data, Key.enter) || matchesKey(data, Key.return)) {
+          openEditor();
+        } else {
+          return;
+        }
         tui.requestRender();
       },
-      invalidate() {}
+      invalidate() {
+        editor?.invalidate();
+      }
     };
   }, {
     overlay: true,
@@ -1319,9 +1405,12 @@ function createGoosedumpIntegration(options = {}) {
   let compactSettings = DEFAULT_GOOSEDUMP_SETTINGS;
   let turnsRemaining = 0;
   let counterTriggered = false;
-  let compactionQueued = false;
-  let compactionHookActive = false;
-  let pendingKeep = null;
+  let compactionState = { phase: "idle" };
+  let sessionGeneration = 0;
+  let settlementGeneration = 0;
+  let operationGeneration = 0;
+  let activeSessionFile = null;
+  let sessionActive = false;
   const rememberQueue = [];
   let rememberRunning = null;
   function enqueueRemember(target, reportError) {
@@ -1357,13 +1446,11 @@ function createGoosedumpIntegration(options = {}) {
     while (rememberRunning)
       await rememberRunning;
   }
-  function syncCompactCounters(ctx, clearPending = false) {
-    compactSettings = resolveGoosedumpSettings(ctx.cwd);
+  function syncCompactCounters(ctx) {
+    compactSettings = resolveGoosedumpSettings(ctx.cwd, projectSettingsTrusted(ctx));
     const completedTurns = completedTurnsSinceCompaction(ctx.sessionManager.getBranch());
     turnsRemaining = Math.max(0, compactSettings.turnsBeforeCompact - completedTurns);
     counterTriggered = compactSettings.turnsBeforeCompact > 0 && completedTurns >= compactSettings.turnsBeforeCompact;
-    if (clearPending)
-      pendingKeep = null;
   }
   function updateStatus(ctx) {
     if (!goosedumpAvailable)
@@ -1388,14 +1475,7 @@ function createGoosedumpIntegration(options = {}) {
       return;
     syncCompactCounters(ctx);
     updateStatus(ctx);
-  }
-  function normalThresholdTriggered(ctx) {
-    if (compactSettings.turnsBeforeCompact <= 0)
-      return false;
-    const usage = ctx.getContextUsage();
-    if (!usage || usage.tokens === null || usage.contextWindow <= 0)
-      return false;
-    return usage.tokens > usage.contextWindow - piReserveTokens(ctx.cwd);
+    queueTurnCompaction(ctx, settlementGeneration + 1);
   }
   function checkGoosedump(ctx) {
     try {
@@ -1408,34 +1488,100 @@ function createGoosedumpIntegration(options = {}) {
       return false;
     }
   }
-  function requestCompaction(ctx, keep) {
-    if (compactionQueued || compactionHookActive)
-      return "busy";
-    if (keep === null && !hasCompactableHistory(ctx))
-      return "nothing-to-compact";
-    compactionQueued = true;
-    pendingKeep = keep;
+  function requestIsCurrent(request) {
+    return request.sessionGeneration === sessionGeneration && request.sessionFile === activeSessionFile;
+  }
+  function contextIsCurrent(ctx) {
+    return sessionActive && (ctx.sessionManager.getSessionFile?.() ?? null) === activeSessionFile;
+  }
+  function runningOperationIsCurrent(operation, generation, sessionFile) {
+    return generation === sessionGeneration && sessionFile === activeSessionFile && compactionState.phase === "running" && compactionState.operation === operation;
+  }
+  function requestHasCompactableHistory(ctx, keep) {
+    return keep === null ? hasCompactableHistory(ctx) : keepBoundaryId(ctx.sessionManager.getBranch(), keep) !== undefined;
+  }
+  function queueTurnCompaction(ctx, eligibleSettlement) {
+    if (!counterTriggered || compactionState.phase !== "idle")
+      return;
+    if (!hasCompactableHistory(ctx))
+      return;
+    compactionState = {
+      phase: "queued",
+      request: {
+        keep: null,
+        origin: "turn",
+        sessionGeneration,
+        sessionFile: activeSessionFile,
+        eligibleSettlement
+      }
+    };
+  }
+  function startQueuedCompaction(ctx) {
+    if (compactionState.phase !== "queued")
+      return false;
+    const request = compactionState.request;
+    if (!requestIsCurrent(request)) {
+      compactionState = { phase: "idle" };
+      return false;
+    }
+    if (!ctx.isIdle() || ctx.hasPendingMessages())
+      return false;
+    if (!requestHasCompactableHistory(ctx, request.keep)) {
+      compactionState = { phase: "idle" };
+      return false;
+    }
+    const operation = ++operationGeneration;
+    const generation = request.sessionGeneration;
+    const sessionFile = request.sessionFile;
+    compactionState = {
+      phase: "running",
+      request,
+      owner: "extension",
+      operation,
+      sessionGeneration: generation,
+      sessionFile,
+      hookActive: false
+    };
     ctx.compact({
       onComplete: () => {
-        compactionQueued = false;
-        pendingKeep = null;
+        if (!runningOperationIsCurrent(operation, generation, sessionFile))
+          return;
+        compactionState = { phase: "idle" };
       },
       onError: (error) => {
-        compactionQueued = false;
-        pendingKeep = null;
+        if (!runningOperationIsCurrent(operation, generation, sessionFile))
+          return;
+        compactionState = { phase: "idle" };
         const message = error instanceof Error ? error.message : String(error);
         if (ctx.hasUI)
           ctx.ui.notify(`goosedump compaction failed: ${message}`, "error");
       }
     });
-    return "started";
+    return true;
+  }
+  function requestCompaction(ctx, keep, origin) {
+    if (compactionState.phase !== "idle")
+      return "busy";
+    if (!requestHasCompactableHistory(ctx, keep))
+      return "nothing-to-compact";
+    compactionState = {
+      phase: "queued",
+      request: {
+        keep,
+        origin,
+        sessionGeneration,
+        sessionFile: activeSessionFile,
+        eligibleSettlement: settlementGeneration + 1
+      }
+    };
+    return startQueuedCompaction(ctx) ? "started" : "queued";
   }
   function register(pi) {
     if (shouldRegisterTool) {
       pi.registerTool(defineTool({
         name: "goose_remember",
         label: "goose_remember",
-        description: "Use local gpt-oss-20b to extract typed memories and provenance from a session; store BGE embeddings in SQLite. Defaults to the current Pi session.",
+        description: "Queue local gpt-oss-20b memory extraction and BGE embedding in the background. Defaults to the current Pi session.",
         promptSnippet: "Persist important context from the current or another session into durable memory",
         promptGuidelines: [
           "Use goose_remember after a milestone when important facts, decisions, preferences, procedures, or lessons should be retained.",
@@ -1445,20 +1591,19 @@ function createGoosedumpIntegration(options = {}) {
           provider: historyProviderParam("read"),
           session: historySessionParam()
         }),
-        async execute(_id, params, signal, _onUpdate, ctx) {
+        async execute(_id, params, _signal, _onUpdate, ctx) {
           if (!goosedumpAvailable)
             return goosedumpUnavailableResult();
-          try {
-            const provider = params.provider ?? "pi";
-            const target = resolveTarget(ctx, provider, params.session);
-            if (!target)
-              return missingSessionId("goose_remember", provider);
-            const report = await goosedumpMemoryRemember(target, signal, nativeExecutablePath);
-            return textResult(report);
-          } catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            return textResult(`goosedump error: ${message}`);
-          }
+          const provider = params.provider ?? "pi";
+          const target = resolveTarget(ctx, provider, params.session);
+          if (!target)
+            return missingSessionId("goose_remember", provider);
+          enqueueRemember(target, (message) => {
+            if (ctx.hasUI) {
+              ctx.ui.notify(`goosedump memory learning failed: ${message}`, "warning");
+            }
+          });
+          return textResult(`Memory learning queued for ${target}.`);
         }
       }));
       pi.registerTool(defineTool({
@@ -1703,13 +1848,13 @@ function createGoosedumpIntegration(options = {}) {
           if (!goosedumpAvailable)
             return goosedumpUnavailableResult();
           const keep = params.keep ?? null;
-          const result = requestCompaction(ctx, keep);
+          const result = requestCompaction(ctx, keep, "tool");
           if (result === "busy")
             return textResult("Compaction already in progress.");
           if (result === "nothing-to-compact") {
             return textResult("Nothing to compact (session too small).");
           }
-          return textResult(compactStartedMessage(keep));
+          return textResult(compactStartedMessage(keep, result === "queued"));
         }
       }));
       pi.registerTool(defineTool({
@@ -1779,99 +1924,182 @@ ${lines.join(`
         }
       }));
     }
-    function maybeAutoCompact(ctx) {
+    function handleAgentSettled(ctx) {
       if (!goosedumpAvailable || !shouldOverrideDefaultCompaction)
         return;
-      if (!counterTriggered && !normalThresholdTriggered(ctx))
-        return;
-      if (compactionQueued)
-        return;
-      if (ctx.hasPendingMessages())
-        return;
-      if (!ctx.isIdle())
-        return;
-      if (!hasCompactableHistory(ctx))
+      settlementGeneration += 1;
+      if (compactionState.phase === "running" && compactionState.owner === "pi") {
+        const request = compactionState.request;
+        compactionState = request && requestIsCurrent(request) ? {
+          phase: "queued",
+          request: { ...request, eligibleSettlement: settlementGeneration + 1 }
+        } : { phase: "idle" };
         return;
-      syncCompactCounters(ctx, true);
-      updateStatus(ctx);
-      compactionQueued = true;
-      ctx.compact({
-        onComplete: () => {
-          compactionQueued = false;
-          syncCompactCounters(ctx, true);
-          updateStatus(ctx);
-        },
-        onError: (error) => {
-          compactionQueued = false;
-          syncCompactCounters(ctx, true);
-          updateStatus(ctx);
-          const message = error instanceof Error ? error.message : String(error);
-          if (ctx.hasUI)
-            ctx.ui.notify(`goosedump compaction failed: ${message}`, "error");
-        }
-      });
+      }
+      if (compactionState.phase === "queued" && !requestIsCurrent(compactionState.request)) {
+        compactionState = { phase: "idle" };
+      }
+      if (compactionState.phase === "idle") {
+        queueTurnCompaction(ctx, settlementGeneration);
+      }
+      if (compactionState.phase === "queued" && compactionState.request.eligibleSettlement <= settlementGeneration) {
+        startQueuedCompaction(ctx);
+      }
     }
     pi.on("session_start", async (_event, ctx) => {
+      sessionGeneration += 1;
+      settlementGeneration = 0;
+      activeSessionFile = ctx.sessionManager.getSessionFile?.() ?? null;
+      sessionActive = true;
+      compactionState = { phase: "idle" };
       goosedumpAvailable = checkGoosedump(ctx);
       notifyInvalidSettings(ctx);
-      syncCompactCounters(ctx, true);
+      syncCompactCounters(ctx);
       updateStatus(ctx);
+      queueTurnCompaction(ctx, 1);
+    });
+    pi.on("session_shutdown", async () => {
+      sessionGeneration += 1;
+      settlementGeneration = 0;
+      activeSessionFile = null;
+      sessionActive = false;
+      compactionState = { phase: "idle" };
     });
     pi.on("turn_end", async (event, ctx) => {
       if (isCompletedAssistant(event.message))
         noteCompletedTurn(ctx);
     });
     pi.on("agent_settled", async (_event, ctx) => {
-      maybeAutoCompact(ctx);
+      handleAgentSettled(ctx);
     });
     pi.on("session_before_compact", async (event, ctx) => {
       if (!shouldOverrideDefaultCompaction || !goosedumpAvailable)
         return;
-      if (event.customInstructions?.trim())
-        return;
-      if (event.signal.aborted)
-        return;
-      const { messagesToSummarize, turnPrefixMessages } = event.preparation;
-      if (pendingKeep === null && messagesToSummarize.length === 0 && turnPrefixMessages.length === 0) {
+      if (event.customInstructions?.trim()) {
+        if (compactionState.phase === "running")
+          return { cancel: true };
+        if (compactionState.phase === "queued") {
+          if (compactionState.request.origin !== "turn")
+            return { cancel: true };
+          compactionState = {
+            phase: "queued",
+            request: {
+              ...compactionState.request,
+              eligibleSettlement: Math.max(compactionState.request.eligibleSettlement, settlementGeneration + 2)
+            }
+          };
+        }
         return;
       }
-      const target = currentSessionTarget(ctx);
-      if (!target)
+      if (event.signal.aborted) {
+        if (compactionState.phase === "queued" && requestIsCurrent(compactionState.request)) {
+          compactionState = event.reason === "manual" ? { phase: "idle" } : {
+            phase: "queued",
+            request: {
+              ...compactionState.request,
+              eligibleSettlement: Math.max(compactionState.request.eligibleSettlement, settlementGeneration + 2)
+            }
+          };
+        }
         return;
-      if (compactionHookActive)
-        return { cancel: true };
-      compactionHookActive = true;
+      }
+      let operation;
+      let generation;
+      let sessionFile;
+      let request;
+      let owner;
+      if (compactionState.phase === "running") {
+        if (compactionState.hookActive || compactionState.owner === "pi") {
+          return { cancel: true };
+        }
+        operation = compactionState.operation;
+        generation = compactionState.sessionGeneration;
+        sessionFile = compactionState.sessionFile;
+        request = compactionState.request;
+        owner = "extension";
+        compactionState = { ...compactionState, hookActive: true };
+      } else {
+        request = compactionState.phase === "queued" && requestIsCurrent(compactionState.request) ? compactionState.request : null;
+        operation = ++operationGeneration;
+        generation = sessionGeneration;
+        sessionFile = activeSessionFile;
+        owner = "pi";
+        compactionState = {
+          phase: "running",
+          request,
+          owner,
+          operation,
+          sessionGeneration: generation,
+          sessionFile,
+          hookActive: true
+        };
+      }
       try {
-        const keep = pendingKeep ?? undefined;
-        const compaction = await buildGoosedumpCompaction(target, event.preparation, event.branchEntries, effectiveSummaryMaxTokens(ctx.cwd), keep, event.signal, nativeExecutablePath);
+        const { messagesToSummarize, turnPrefixMessages } = event.preparation;
+        if ((request?.keep ?? null) === null && messagesToSummarize.length === 0 && turnPrefixMessages.length === 0) {
+          return;
+        }
+        const target = currentSessionTarget(ctx);
+        if (!target)
+          return;
+        let keep = request?.keep ?? undefined;
+        if (keep !== undefined && keepBoundaryId(event.branchEntries, keep) === undefined) {
+          if (ctx.hasUI) {
+            ctx.ui.notify(`fewer than ${keep} user turns; using Pi's token-based cut`, "info");
+          }
+          keep = undefined;
+          if (runningOperationIsCurrent(operation, generation, sessionFile)) {
+            compactionState = { ...compactionState, request: null };
+          }
+        }
+        const compaction = await buildGoosedumpCompaction(target, event.preparation, event.branchEntries, effectiveSummaryMaxTokens(ctx.cwd, projectSettingsTrusted(ctx)), keep, event.signal, nativeExecutablePath);
+        if (!runningOperationIsCurrent(operation, generation, sessionFile)) {
+          return { cancel: true };
+        }
         if (compaction && "cancel" in compaction) {
           if (ctx.hasUI)
             ctx.ui.notify(compaction.reason, "info");
-          return { cancel: true };
+          return owner === "pi" && event.reason === "manual" ? { cancel: true } : undefined;
         }
         const warning = compaction?.details?.warning;
         if (warning && ctx.hasUI) {
           ctx.ui.notify(warning, "warning");
         }
-        return compaction ? { compaction } : undefined;
+        if (compaction)
+          return { compaction };
+        return owner === "pi" && event.reason === "manual" ? { cancel: true } : undefined;
       } catch (err) {
+        if (!runningOperationIsCurrent(operation, generation, sessionFile)) {
+          return { cancel: true };
+        }
         if (event.signal.aborted)
           return { cancel: true };
+        const useFallback = owner === "extension" || event.reason !== "manual";
         if (ctx.hasUI) {
           const message = err instanceof Error ? err.message : String(err);
-          ctx.ui.notify(`goosedump compaction failed; falling back to Pi compaction: ${message}`, "error");
+          const action = useFallback ? "; falling back to Pi compaction" : "";
+          ctx.ui.notify(`goosedump compaction failed${action}: ${message}`, "error");
         }
-        return;
+        return useFallback ? undefined : { cancel: true };
       } finally {
-        compactionHookActive = false;
-        pendingKeep = null;
+        if (runningOperationIsCurrent(operation, generation, sessionFile)) {
+          compactionState = owner === "pi" && event.reason === "manual" ? { phase: "idle" } : { ...compactionState, hookActive: false };
+        }
       }
     });
     pi.on("session_compact", async (event, ctx) => {
-      if (!goosedumpAvailable || !shouldOverrideDefaultCompaction)
+      if (!shouldOverrideDefaultCompaction)
+        return;
+      if (!contextIsCurrent(ctx))
         return;
-      syncCompactCounters(ctx, true);
+      if (compactionState.phase === "queued" && compactionState.request.keep !== null && ctx.hasUI) {
+        ctx.ui.notify("Queued keep request was superseded by another compaction.", "info");
+      }
+      compactionState = { phase: "idle" };
+      syncCompactCounters(ctx);
       updateStatus(ctx);
+      if (!goosedumpAvailable)
+        return;
       const compactionEntry = event.compactionEntry;
       if (!event.fromExtension || !compactionEntry || !isRecord(compactionEntry.details) || compactionEntry.details.source !== "goosedump") {
         return;
@@ -1930,13 +2158,13 @@ ${lines.join(`
             return;
           }
         }
-        const result = requestCompaction(ctx, keep);
+        const result = requestCompaction(ctx, keep, "command");
         if (result === "busy") {
           ctx.ui.notify("Compaction already in progress", "info");
         } else if (result === "nothing-to-compact") {
           ctx.ui.notify("Nothing to compact (session too small)", "info");
         } else {
-          ctx.ui.notify(compactStartedMessage(keep), "info");
+          ctx.ui.notify(compactStartedMessage(keep, result === "queued"), "info");
         }
       }
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goosedump",
-  "version": "0.12.14",
+  "version": "0.12.15",
   "description": "Pi extension for goosedump session search, durable memory, and compaction",
   "keywords": [
     "compaction",
@@ -38,7 +38,7 @@
   },
   "dependencies": {
     "@earendil-works/pi-tui": "^0.82.1",
-    "@jarkkojs/goosedump": "^0.12.14",
+    "@jarkkojs/goosedump": "^0.12.15",
     "@sinclair/typebox": "^0.34.49"
   },
   "devDependencies": {