pi-usereq 0.58.0 → 0.60.0

package/README.md

@@ -1,4 +1,4 @@
-# PI-useReq/pi-usereq (0.58.0)
+# PI-useReq/pi-usereq (0.60.0)
 
 <p align="center">
   <img src="https://img.shields.io/badge/python-3.11%2B-3776AB?style=flat-square&logo=python&logoColor=white" alt="Python 3.11+">
@@ -51,6 +51,7 @@ in sync with the repository. All capabilities are exposed as slash commands and
 - **Git repository** - every `req-*` command runs slash-command-owned git validation: the project must be inside a git work tree, the tracked working tree must be clean, and `HEAD` must resolve (a detached `HEAD` is tolerated; a working branch is recommended because the branch name is embedded in generated worktree names).
 - **Requirements documentation** - the configured `docs-dir` (default `pi-usereq/docs`) must contain the canonical documents required by each command (`REQUIREMENTS.md`, `WORKFLOW.md`, `REFERENCES.md`); commands such as `/req-write`, `/req-create`, and `/req-workflow` are the entry points that generate them.
 - **Static code checkers** - the bundled checkers (`pyright`, `ruff`, `eslint`) install automatically through the `postinstall` script; the native C/C++ checkers (`cppcheck`, `clang-format`) require a one-line system install (see [Install](#install)). Default configured languages: C, C++, JavaScript, Python, TypeScript.
+- **Models** - model selection and model configuration are managed by the pi client, not by pi-usereq: the extension bundles no model files and exposes no model-related configuration or management surface (custom providers and models are configured in the pi client, e.g. `~/.pi/agent/models.json`, and selected through its model picker). The tool is tested with the OpenRouter model `~deepseek/deepseek-v4-flash-latest`; the extension is model-agnostic and also works with other models exposed by the pi client.
 
 
 ## Feature Highlights
@@ -73,6 +74,17 @@ isolated worktree, render the bundled prompt with the project context, and on su
 repository clean. `/req-references` and `/req-reset` are non-agentic: they execute directly without starting an LLM session or
 creating a worktree.
 
+> **Clean context between commands** — every `/req-*` orchestration keeps the session context content in place when it
+> completes, so a subsequent command continues with the retained transcript. It is therefore recommended to start a new
+> session with a clean context (run `/new`, pi's `Start a new session` action) before each new `/req-*` command, unless you
+> actually need to keep the previous context (for example when the next command builds on the outputs of the previous one).
+
+> **Recommended context for analysis** — for the most effective analysis it is recommended to place the requirements,
+> reference, and workflow documents in the prompt context by enabling the `Context Files` toggles for `REQUIREMENTS.md`,
+> `REFERENCES.md`, and `WORKFLOW.md` (the settings-menu row then reads `Context Files  requirements:on • references:on • workflow:on`).
+> The enabled canonical documents are injected into every bundled prompt through `%%CONTEXT_FILES%%`, so the agent analyzes
+> the requirements, the reference index, and the workflow documentation together with the source code.
+
 | Command | Description | Required docs |
 | --- | --- | --- |
 | `/req-write` | Produce a *SRS* draft based on the User Request description | none |
@@ -269,7 +281,7 @@ The interactive configuration menu exposes every user-facing setting; changes ar
 - **Documentation directory** — `docs-dir` (default `pi-usereq/docs`) used for the canonical documents.
 - **Unit tests directory** — `tests-dir` (default `tests`).
 - **Source directories** — `src-dir` (default `["src"]`) used by the analysis tools.
-- **Context Files** — toggles to inject `REQUIREMENTS.md`, `WORKFLOW.md`, and `REFERENCES.md` into the prompt context through `%%CONTEXT_FILES%%`.
+- **Context Files** — toggles to inject `REQUIREMENTS.md`, `WORKFLOW.md`, and `REFERENCES.md` into the prompt context through `%%CONTEXT_FILES%%`. It is recommended to keep all three toggles enabled (`requirements:on • references:on • workflow:on`) so the analysis commands receive the canonical documents in their context.
 - **Auto git commit** — `enable` (default) injects git commit instructions into every prompt; `disable` forces read-only git behavior (`git_read-only.md`) and turns worktree orchestration off.
 - **Git worktree** / **Worktree prefix** — enable/disable prompt-command worktree isolation and set the name prefix (default `PI-useReq-`).
 - **Language static code checkers** — per-language `enable`/`disable` flags and the global `Command`-module checker definitions (view/remove/reset with confirmation).
@@ -278,6 +290,8 @@ The interactive configuration menu exposes every user-facing setting; changes ar
 - **Debug** — local debug logging: log file, log-on-status filter, status-change/workflow-event toggles, enabled tools/prompts, and `Enable debug commands for tools`.
 - **Show local/global configuration** — write the exact config file contents into the editor.
 - **Reset defaults** — restore the default configuration with a confirmation preview.
+- **Models** (not a setting) — the menu exposes no model management: models, custom providers, and authentication are configured at the pi client level and simply shared with pi-usereq commands at runtime.
+- **Editor/IDE** (not a setting) — the menu exposes no editor or IDE management: the extension bundles, generates, reads, and requires no Visual Studio Code files (e.g. `.vscode/settings.json`), and all settings are persisted only in `.pi-usereq.json` and `~/.config/pi-usereq/config.json`.
 
 ### Extension Side Features
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-usereq",
-  "version": "0.58.0",
+  "version": "0.60.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Ogekuri/PI-useReq.git"

package/scripts/lib/sdk-smoke.ts

@@ -1,7 +1,7 @@
 /**
  * @file
  * @brief Implements SDK-parity probing and comparison for the standalone debug harness.
- * @details Dynamically loads the official pi SDK when available, inventories extension-owned commands and tools from the runtime surface, passes the 0.80.4+ `authPath` and `modelsPath` `createAgentSession` options, probes support for the new 0.80.4+ event surface, normalizes provenance metadata, and compares the result against the offline recorder snapshot. Runtime is O(c + t + e) in command, tool, and probed-event counts plus the cost of SDK session creation. Side effects are limited to dynamic module loading, optional SDK-managed filesystem reads, and any extension-owned startup behavior triggered by the official runtime.
+ * @details Dynamically loads the official pi SDK when available, inventories extension-owned commands and tools from the runtime surface, probes support for the new 0.80.4+ event surface, normalizes provenance metadata, and compares the result against the offline recorder snapshot. Runtime is O(c + t + e) in command, tool, and probed-event counts plus the cost of SDK session creation. Side effects are limited to dynamic module loading, optional SDK-managed filesystem reads, and any extension-owned startup behavior triggered by the official runtime.
  */
 
 import path from "node:path";
@@ -469,7 +469,7 @@ export function buildParityReport(offline: OfflineContractSnapshot, sdk: SdkCont
 
 /**
  * @brief Loads the official pi SDK runtime and extracts the extension-owned command and tool inventories.
- * @details Dynamically imports `@earendil-works/pi-coding-agent`, creates a `DefaultResourceLoader` with the requested extension path, creates an SDK session with the 0.80.4+ `authPath` and `modelsPath` options, extracts inventory methods from the returned runtime surface, probes support for the new 0.80.4+ event surface, and filters to extension-owned commands and tools only. Runtime is dominated by SDK startup. Side effects include SDK-managed resource loading and extension startup behavior.
+ * @details Dynamically imports `@earendil-works/pi-coding-agent`, creates a `DefaultResourceLoader` with the requested extension path, creates an SDK session, extracts inventory methods from the returned runtime surface, probes support for the new 0.80.4+ event surface, and filters to extension-owned commands and tools only. Runtime is dominated by SDK startup. Side effects include SDK-managed resource loading and extension startup behavior.
  * @param[in] cwd {string | undefined} Requested working directory.
  * @param[in] extensionPath {string | undefined} Requested extension entry path.
  * @return {Promise<SdkContractSnapshot>} Normalized SDK inventory snapshot.
@@ -509,8 +509,6 @@ export async function probeSdkRuntime(cwd?: string, extensionPath?: string): Pro
       resourceLoader,
       sessionManager: SessionManager.inMemory(),
       settingsManager: typeof SettingsManager?.inMemory === "function" ? SettingsManager.inMemory({}) : undefined,
-      authPath: path.join(paths.cwd, ".pi-usereq-agent-auth.json"),
-      modelsPath: path.join(paths.cwd, ".pi-usereq-agent-models.json"),
     });
   } catch (error) {
     throw new ReqError(`Error: SDK parity loading failed: ${error instanceof Error ? error.message : String(error)}`, 1);

package/src/core/prompt-command-runtime.ts

@@ -692,7 +692,7 @@ function verifyPromptCommandClosureArtifacts(
  * @throws {ReqError} Throws when the context cannot switch sessions, when the host cancels the switch, or when later verification proves the target session never became active.
  * @satisfies REQ-068, REQ-271, REQ-272
  */
-async function switchPromptCommandSession(
+export async function switchPromptCommandSession(
   sessionFile: string,
   ctx?: PromptCommandSessionContext,
 ): Promise<PromptCommandSessionContext | undefined> {

package/src/core/req-reset-command.ts

@@ -7,6 +7,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { spawnSync, type SpawnSyncReturns } from "node:child_process";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
 import {
   normalizeGitWorktreePrefix,
   type UseReqConfig,
@@ -17,8 +18,14 @@ import {
   getPromptCommandErrorContext,
   preservePromptCommandExecutionTranscript,
   restorePromptCommandExecution,
+  switchPromptCommandSession,
   type PromptCommandExecutionPlan,
 } from "./prompt-command-runtime.js";
+import {
+  isSameOrAncestorPath,
+  setRuntimeContextPath,
+  setRuntimeWorktreePathState,
+} from "./path-context.js";
 import { resolveRuntimeGitPath } from "./runtime-project-paths.js";
 
 /**
@@ -282,6 +289,190 @@ function ensureReqResetMainBranch(gitRoot: string, worktreeNamePattern: RegExp):
   }
 }
 
+/**
+ * @brief Reads the persisted header record from one session file.
+ * @details Parses the first non-empty JSONL line and returns its `cwd` plus `parentSession` fields when the file is readable and the header is a JSON object. Runtime is O(n) in header size. No external state is mutated.
+ * @param[in] sessionFile {string} Absolute session-file path.
+ * @return {{ cwd?: string; parentSession?: string } | undefined} Parsed header fields or `undefined` when unreadable.
+ */
+function readReqResetSessionHeader(sessionFile: string): { cwd?: string; parentSession?: string } | undefined {
+  let raw: string;
+  try {
+    raw = fs.readFileSync(sessionFile, "utf8");
+  } catch {
+    return undefined;
+  }
+  const newlineIndex = raw.indexOf("\n");
+  const firstLine = newlineIndex >= 0 ? raw.slice(0, newlineIndex) : raw;
+  const trimmed = firstLine.trim();
+  if (trimmed === "") {
+    return undefined;
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return undefined;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return undefined;
+  }
+  const header = parsed as { cwd?: unknown; parentSession?: unknown };
+  const parsedCwd = typeof header.cwd === "string" ? header.cwd : undefined;
+  const parentSession = typeof header.parentSession === "string" ? header.parentSession : undefined;
+  return { cwd: parsedCwd, parentSession };
+}
+
+/**
+ * @brief Resolves the original base-path session file from the active session header.
+ * @details Reads the current session file exposed by the supplied command context, accepts only a persisted `parentSession` link whose own header `cwd` remains inside the main base path, and returns it so `req-reset` can switch the pi CLI back to the original session-backed base path. Runtime is O(n) in session-header size plus bounded filesystem probes. No external state is mutated.
+ * @param[in] activeContext {ReqResetCommandContext | undefined} Session-bound command context whose current session file links the base-path session.
+ * @param[in] basePath {string} Absolute main repository base path that must contain the parent session cwd.
+ * @return {string | undefined} Original base-path session file or `undefined` when unavailable.
+ */
+function resolveReqResetParentSessionFile(
+  activeContext: ReqResetCommandContext | undefined,
+  basePath: string,
+): string | undefined {
+  let currentSessionFile: string | undefined;
+  try {
+    currentSessionFile = typeof activeContext?.sessionManager?.getSessionFile === "function"
+      ? activeContext.sessionManager.getSessionFile()
+      : undefined;
+  } catch {
+    return undefined;
+  }
+  if (typeof currentSessionFile !== "string" || currentSessionFile === "") {
+    return undefined;
+  }
+  const header = readReqResetSessionHeader(path.resolve(currentSessionFile));
+  if (header?.parentSession === undefined || !fs.existsSync(header.parentSession)) {
+    return undefined;
+  }
+  const resolvedParentSession = path.resolve(header.parentSession);
+  const parentHeader = readReqResetSessionHeader(resolvedParentSession);
+  if (parentHeader?.cwd === undefined || !fs.existsSync(parentHeader.cwd)) {
+    return undefined;
+  }
+  return isSameOrAncestorPath(path.resolve(basePath), path.resolve(parentHeader.cwd))
+    ? resolvedParentSession
+    : undefined;
+}
+
+/**
+ * @brief Resolves the most recent persisted session file rooted at the main base path.
+ * @details Uses the pi SDK default session discovery for the supplied cwd and returns the persisted session file only when it already exists on disk, so the pi CLI can resume the recent base-path session instead of being created a fresh one. Runtime is O(s) in session-directory listing cost. No external state is mutated.
+ * @param[in] basePath {string} Absolute main repository base path.
+ * @return {string | undefined} Most recent persisted base-path session file or `undefined` when none exists.
+ */
+function resolveReqResetMainSessionFile(basePath: string): string | undefined {
+  try {
+    const sessionManager = SessionManager.continueRecent(path.resolve(basePath));
+    const sessionFile = sessionManager.getSessionFile();
+    return typeof sessionFile === "string" && fs.existsSync(sessionFile)
+      ? path.resolve(sessionFile)
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * @brief Tests whether one execution path must be re-anchored to the main base path before cleanup.
+ * @details Returns `true` when the path does not exist anymore, or when it is anchored inside any generated worktree root targeted by `req-reset` and the base path is not an ancestor of it. Existing paths already inside the main base path never need a redirect. Runtime is O(r) in matched-worktree count plus bounded filesystem probes. No external state is mutated.
+ * @param[in] executionPath {string | undefined} Live process or context execution path.
+ * @param[in] basePath {string} Absolute main repository base path.
+ * @param[in] matchingWorktreeRoots {string[]} Absolute generated worktree roots targeted for deletion.
+ * @return {boolean} `true` when the execution path must be switched to the main base path first.
+ */
+function reqResetExecutionPathNeedsRedirect(
+  executionPath: string | undefined,
+  basePath: string,
+  matchingWorktreeRoots: string[],
+): boolean {
+  if (typeof executionPath !== "string" || executionPath === "") {
+    return false;
+  }
+  const normalizedExecutionPath = path.resolve(executionPath);
+  const normalizedBasePath = path.resolve(basePath);
+  if (isSameOrAncestorPath(normalizedBasePath, normalizedExecutionPath)) {
+    return false;
+  }
+  if (!fs.existsSync(normalizedExecutionPath)) {
+    return true;
+  }
+  return matchingWorktreeRoots.some((worktreeRootPath) => {
+    const normalizedRoot = path.resolve(worktreeRootPath);
+    return normalizedExecutionPath === normalizedRoot
+      || normalizedExecutionPath.startsWith(`${normalizedRoot}${path.sep}`);
+  });
+}
+
+/**
+ * @brief Returns the pi CLI to the main base path before generated worktrees are removed.
+ * @details When the host process cwd or the supplied context cwd is still anchored inside a generated worktree targeted for deletion or points at a deleted path, best-effort switches the active pi session back to the original or recent base-path session, re-anchors `process.cwd()` and the context `cwd` mirror onto the main base path, and clears the runtime worktree path state so no post-cleanup surface keeps probing the removed worktree directory. Session switching failures are swallowed because the process and context surfaces remain authoritative for cleanup; session switching is skipped entirely when no `switchSession(...)` hook is available or no base-path session exists. Runtime is dominated by one optional session switch plus bounded filesystem probes. Side effects include active-session replacement, host-process cwd mutation, and optional context mirror mutation.
+ * @param[in] basePath {string} Absolute main repository base path.
+ * @param[in,out] activeContext {ReqResetCommandContext | undefined} Mutated session context mirror and potential replacement-session context.
+ * @param[in] matchingWorktreeRoots {string[]} Absolute generated worktree roots targeted for deletion.
+ * @return {Promise<ReqResetCommandContext | undefined>} Replacement-session context when the runtime provides one; otherwise the caller-supplied context.
+ * @satisfies REQ-257, REQ-307
+ */
+async function redirectReqResetExecutionToMainBranch(
+  basePath: string,
+  activeContext: ReqResetCommandContext | undefined,
+  matchingWorktreeRoots: string[],
+): Promise<ReqResetCommandContext | undefined> {
+  const normalizedBasePath = path.resolve(basePath);
+  let processCwd: string | undefined;
+  try {
+    processCwd = path.resolve(process.cwd());
+  } catch {
+    processCwd = undefined;
+  }
+  const contextCwd = typeof activeContext?.cwd === "string" ? activeContext.cwd : undefined;
+  const processNeedsRedirect = reqResetExecutionPathNeedsRedirect(
+    processCwd,
+    normalizedBasePath,
+    matchingWorktreeRoots,
+  );
+  const contextNeedsRedirect = reqResetExecutionPathNeedsRedirect(
+    contextCwd,
+    normalizedBasePath,
+    matchingWorktreeRoots,
+  );
+  if (!processNeedsRedirect && !contextNeedsRedirect) {
+    return activeContext;
+  }
+  if (typeof activeContext?.switchSession === "function") {
+    const mainSessionFile = resolveReqResetParentSessionFile(activeContext, normalizedBasePath)
+      ?? resolveReqResetMainSessionFile(normalizedBasePath);
+    if (mainSessionFile !== undefined) {
+      try {
+        activeContext = await switchPromptCommandSession(mainSessionFile, activeContext);
+      } catch {
+        // Best-effort; host process and context surfaces below remain authoritative.
+      }
+    }
+  }
+  try {
+    process.chdir(normalizedBasePath);
+  } catch {
+    // Best-effort; cleanup facts remain authoritative.
+  }
+  if (activeContext !== undefined) {
+    try {
+      if (path.resolve(activeContext.cwd ?? "") !== normalizedBasePath) {
+        Reflect.set(activeContext, "cwd", normalizedBasePath);
+      }
+    } catch {
+      // Best-effort context mirror mutation.
+    }
+  }
+  setRuntimeContextPath(normalizedBasePath);
+  setRuntimeWorktreePathState({});
+  return activeContext;
+}
+
 /**
  * @brief Restores live process and context cwd surfaces after worktree removal.
  * @details Best-effort re-points `process.cwd()` and the supplied context `cwd` mirror to the main repository base path when the previously live cwd was removed by `req-reset` cleanup, so subsequent status rendering and notifications never probe deleted worktree paths. Runtime is O(1) plus bounded filesystem probes. Side effects include process cwd mutation and optional context mirror mutation.
@@ -356,7 +547,7 @@ export function prepareReqResetCommandExecution(
 
 /**
  * @brief Executes the specialized `req-reset` recovery and cleanup workflow.
- * @details Preserves the execution-session transcript into the original session file when a worktree-backed prompt execution plan is still available, restores the original session-backed `base-path` through the shared prompt-command restoration helper, ensures the main repository HEAD is on the main branch so generated branch deletion cannot hit git's checked-out-worktree guard, force-removes every matching sibling worktree directory, force-removes every remaining matching local branch, restores deleted live cwd surfaces, and aggregates any failure diagnostics without rolling back successful cleanup steps. Runtime is dominated by session switching plus git subprocess execution. Side effects include session-file reads and writes, active-session replacement, host-process cwd mutation, branch switching, worktree deletion, branch deletion, and filesystem reads.
+ * @details Preserves the execution-session transcript into the original session file when a worktree-backed prompt execution plan is still available, restores the original session-backed `base-path` through the shared prompt-command restoration helper, ensures the main repository HEAD is on the main branch so generated branch deletion cannot hit git's checked-out-worktree guard, enumerates every matching sibling worktree, returns the pi CLI execution surfaces to the main base path before any matching worktree directory is removed, force-removes every matching sibling worktree directory, force-removes every remaining matching local branch, restores deleted live cwd surfaces, and aggregates any failure diagnostics without rolling back successful cleanup steps. Runtime is dominated by session switching plus git subprocess execution. Side effects include session-file reads and writes, active-session replacement, host-process cwd mutation, branch switching, worktree deletion, branch deletion, and filesystem reads.
  * @param[in] plan {ReqResetCommandPlan} Prepared recovery and cleanup plan.
  * @param[in] ctx {ReqResetCommandContext | undefined} Optional session-bound command context.
  * @return {Promise<ReqResetCommandExecutionResult>} Recovery and cleanup outcome facts.
@@ -413,6 +604,12 @@ export async function executeReqResetCommandExecution(
     errorMessages.push(error instanceof Error ? error.message : String(error));
   }
 
+  activeContext = await redirectReqResetExecutionToMainBranch(
+    plan.basePath,
+    activeContext,
+    matchingWorktreeRoots,
+  );
+
   for (const worktreeRootPath of matchingWorktreeRoots) {
     const worktreeDir = path.basename(worktreeRootPath);
     try {

package/src/index.ts

@@ -1160,6 +1160,29 @@ function notifyContextSafely(
   }
 }
 
+/**
+ * @brief Emits the final context-retention reminder info notification for a successfully completed `/req-*` orchestration.
+ * @details Builds one message stating that the session context content was retained, recommending a clean-context session start before the next `/req-*` command, and appending the current context-usage percentage when the controller holds a normalized snapshot. Delivers exclusively through `notifyContextSafely(...)`, so stale replacement-session contexts are suppressed, and performs no session message send and no session switch. Runtime is O(1). Side effect is user notification delivery only when the supplied context is still active.
+ * @param[in] statusController {PiUsereqStatusController} Mutable status controller supplying the latest normalized context-usage snapshot.
+ * @param[in] ctx {(ExtensionContext | ExtensionCommandContext) | undefined} Candidate UI context for notification delivery.
+ * @return {void} No return value.
+ * @satisfies REQ-360, REQ-361, REQ-362, REQ-363, REQ-364, REQ-365
+ */
+function notifyContextRetentionReminder(
+  statusController: PiUsereqStatusController,
+  ctx: (ExtensionContext | ExtensionCommandContext) | undefined,
+): void {
+  const percent = statusController.state.contextUsage?.percent;
+  const percentText = typeof percent === "number" && Number.isFinite(percent)
+    ? ` Current context usage: ${Math.round(percent)}%.`
+    : "";
+  notifyContextSafely(
+    ctx,
+    `Context retained.${percentText} Start a new session with a clean context (/new) before the next /req-* command.`,
+    "info",
+  );
+}
+
 /**
  * @brief Rejects one non-`idle` req-command invocation and records the workflow error state.
  * @details Builds a deterministic busy-state diagnostic from the current workflow state, transitions the shared workflow state to `error`, preserves any pending or active prompt execution metadata for later closure handling, emits an error notification, and throws `ReqError`. Bundled prompt commands reuse `transitionPromptWorkflowState(...)` when cached configuration is available so prompt debug logging captures the actual state transition; specialized non-prompt commands fall back to direct status mutation. Runtime is O(1). Side effects include workflow-state mutation, status-bar rendering, optional debug-log writes, and user notification delivery.
@@ -1375,6 +1398,9 @@ async function finalizeMatchedPromptSuccess(
   } else {
     setPiUsereqWorkflowState(statusController, "idle", promptContext);
   }
+  if (!finalization.errorMessage) {
+    notifyContextRetentionReminder(statusController, promptContext);
+  }
 }
 
 /**
@@ -1595,6 +1621,9 @@ async function handleExtensionStatusEvent(
         } else {
           setPiUsereqWorkflowState(statusController, "idle", promptContext);
         }
+        if (outcome === "completed") {
+          notifyContextRetentionReminder(statusController, promptContext);
+        }
       }
     }
   }
@@ -3106,6 +3135,7 @@ function registerReqResetCommand(
         ? `SUCCESS: req-reset restored base-path and removed ${executionResult.removedWorktreeDirs.length} worktree(s) plus ${executionResult.removedBranchNames.length} branch(es).`
         : `SUCCESS: req-reset removed ${executionResult.removedWorktreeDirs.length} worktree(s) plus ${executionResult.removedBranchNames.length} branch(es) and restored idle state.`;
       notifyContextSafely(resetContext, successMessage, "info");
+      notifyContextRetentionReminder(statusController, resetContext);
     },
   });
 }
@@ -3148,6 +3178,7 @@ function registerReqReferencesCommand(
           `SUCCESS: Updated ${formatRuntimePathForDisplay(executionPlan.referencesPath)} and committed changes.`,
           "info",
         );
+        notifyContextRetentionReminder(statusController, ctx);
       } catch (error) {
         statusController.state.pendingPromptRequest = undefined;
         statusController.state.activePromptRequest = undefined;