@grrrck/pi-clear 0.4.0 → 0.5.0

package/CHANGELOG.md

@@ -5,6 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.5.0] - 2026-11-05
+
+### Added
+
+- A **same-or-pick dialog** after the writer picker: *Same model and thinking level* (first, so Enter re-uses the current settings) or *Pick a model and thinking level…*, which opens the destination pickers.
+- Flag `--same`: skips the same-or-pick dialog and re-uses the current session's model and thinking level, as if the first option was chosen.
+
+### Changed
+
+- `/hand-off <instructions>` uses the inline steering text as-is: the steering editor only opens when no instructions were typed after the command, so passing steering on the command line no longer adds a dialog to confirm or edit it.
+
 ## [0.4.0] - 2026-10-30
 
 ### Added

package/README.md

@@ -29,7 +29,7 @@ pi -e npm:@grrrck/pi-clear
 
 ```text
 /clear
-/hand-off [--fresh | --live] [steering instructions]
+/hand-off [--fresh | --live] [--same] [steering instructions]
 ```
 
 ## `/clear` behavior
@@ -50,7 +50,7 @@ When `/hand-off` runs, the extension:
 
 0. **chooses who writes the hand-off prompt** — see [Choosing the writer](#choosing-the-writer). The picker is skipped when `--fresh` or `--live` was passed
 1. waits for the agent to become idle if needed
-2. opens a model picker, then a thinking level picker, then a steering editor pre-filled with any text you typed after `/hand-off` (and its flags). Defaults are sensible: the current model and thinking level are preselected, so pressing Enter at each step keeps them. The model picker respects your session's model scoping (`--models` / `enabledModels`, the same set `/scoped-models` shows) and offers a Tab toggle between scoped and all models. In non-TUI modes it falls back to plain dialogs: the scoped list when configured, otherwise a two-level provider → model pick so the dialog never floods the screen
+2. asks whether the next session keeps the current model and thinking level — the first option, so pressing Enter keeps them — or opens a model picker, then a thinking level picker, then collects steering instructions: text you typed after `/hand-off` (and its flags) is used as-is, and the steering editor only opens when you passed none. `--same` skips the same-or-pick dialog and re-uses the current model and thinking level. The model picker respects your session's model scoping (`--models` / `enabledModels`, the same set `/scoped-models` shows) and offers a Tab toggle between scoped and all models. In non-TUI modes it falls back to plain dialogs: the scoped list when configured, otherwise a two-level provider → model pick so the dialog never floods the screen
 3. writes the hand-off prompt with the chosen writer — the live agent, or a single off-screen model call over a minimal reconstruction of the conversation
 4. prepends a provenance comment naming the source session, starts a new session, applies the model and thinking level you picked, and inserts the prompt into the editor via `ctx.ui.setEditorText()`
 5. stops there: the prompt sits in the editor for you to review, edit, and submit yourself
@@ -78,6 +78,8 @@ When the writer model supports reasoning, the fresh pass also asks for its **thi
 Fresh pass flags and limits:
 
 - `--fresh` skips the writer picker and uses the fresh pass; `--live` skips it and uses the current agent. Passing both is refused before any dialog opens.
+- `--same` skips the same-or-pick dialog and re-uses the current session's model and thinking level. It combines freely with `--fresh` / `--live` and inline steering.
+- Flags are only recognized at the front of the command args: `/hand-off --same fix the tests` parses the flag, but `/hand-off fix the tests --same` passes `--same` through as steering text. Anything after the first non-flag token is steering.
 - There is no command-arg model flag: if you want a specific model to write the prompt, set it in the [config file](#configuration) (or pick it from the menu).
 - The source is the post-compaction view of the session, so a compacted conversation is summarized from its summary rather than from nothing.
 - Trimming keeps the opening message, the newest turns, and a contiguous run after the opening message; the middle is replaced by `[... <n> turns omitted — <k> chars ...]` and you get a notification saying how much was dropped. Raise the budget with the settings below if that happens.
@@ -152,7 +154,10 @@ node --test scripts/minimal-transcript.test.mjs    # offline: fresh-pass transcr
 node --test scripts/fresh-pass-flow.test.mjs       # offline: /hand-off flow, both writers
 ```
 
-The RPC smoke tests require at least two models with configured auth, and they make **real, billed model requests**. The `node --test` scripts need neither.
+The RPC smoke tests need at least two models with configured auth.
+`rpc-handoff-smoke-test.py` makes **real, billed model requests** (the agent
+writes the hand-off prompt); `rpc-smoke-test.py` only drives local RPC state
+and makes none. The `node --test` scripts need neither auth nor a pi process.
 
 ## Related extensions
 

package/index.ts

@@ -13,13 +13,17 @@
  * `/clear` starts an equally fresh session, then restores the model and
  * thinking level that were active when you cleared.
  *
- * `/hand-off`: hand the conversation to another model.
+ * `/hand-off`: hand the conversation to another model (or back to the same
+ * one, with `--same`).
  *
  * 1. The user runs `/hand-off`, optionally with `--fresh` or `--live` and
  *    steering text after them.
- * 2. A dialog flow asks who writes the hand-off prompt, then collects the
- *    destination model and thinking level, then opens an editor pre-filled
- *    with the remaining command args.
+ * 2. A dialog flow asks who writes the hand-off prompt, then asks whether the
+ *    next session keeps the current model and thinking level (first option,
+ *    so Enter keeps them) or opens the destination pickers — `--same` skips
+ *    that dialog and re-uses the current values. Then steering instructions:
+ *    text typed inline after `/hand-off` is used as-is, and an editor opens
+ *    only when no inline steering was passed.
  * 3. The hand-off prompt is written by one of two writers:
  *    - the **live agent** (default, first in the picker): the extension sends
  *      the current agent a custom message asking it to write its next message
@@ -170,6 +174,24 @@ async function selectModel(
 	return index === -1 ? undefined : ordered[index];
 }
 
+/**
+ * Same-or-pick picker between the writer and destination dialogs. The first
+ * option re-uses the current session's model and thinking level in one Enter
+ * press; the second opens the destination pickers. Without a current model
+ * there is nothing to re-use, so the destination pickers open directly.
+ */
+async function chooseSameOrPick(ctx: ExtensionContext): Promise<"same" | "pick" | undefined> {
+	if (!ctx.model) return "pick";
+	const labels = [
+		`${SAME_SETTINGS_LABEL}  (${ctx.model.provider}/${ctx.model.id}${ctx.thinkingLevel ? ` · ${ctx.thinkingLevel}` : ""})`,
+		PICK_SETTINGS_LABEL,
+	];
+	const chosen = await ctx.ui.select("Model for the next session", labels);
+	if (chosen === undefined) return undefined;
+	const index = labelIndex(chosen, labels);
+	return index === 0 ? "same" : index === 1 ? "pick" : undefined;
+}
+
 /**
  * Thinking level picker with the active level preselected, so Enter accepts
  * the current setting.
@@ -913,6 +935,8 @@ async function generateFreshPassPrompt(
 
 interface ParsedHandoffArgs {
 	writer?: "live" | "fresh";
+	/** `--same`: skip the destination pickers and reuse the current session's model and thinking level. */
+	same?: boolean;
 	/** Everything after the leading flags: the steering-editor prefill. */
 	steering: string;
 	error?: string;
@@ -934,6 +958,10 @@ export function parseHandoffArgs(args: string): ParsedHandoffArgs {
 			parsed.writer = writer;
 			continue;
 		}
+		if (token === "--same") {
+			parsed.same = true;
+			continue;
+		}
 		break;
 	}
 
@@ -1057,6 +1085,8 @@ interface WriterOptions {
 
 const WRITER_LIVE_LABEL = "This agent — full context and tools";
 const WRITER_FRESH_OTHER_LABEL = "Fresh pass — another model…";
+const SAME_SETTINGS_LABEL = "Same model and thinking level";
+const PICK_SETTINGS_LABEL = "Pick a model and thinking level…";
 
 /** Pick the hand-off writer: the live agent, or a fresh pass with a chosen model. */
 async function chooseWriter(ctx: ExtensionContext, options: WriterOptions): Promise<WriterChoice | undefined> {
@@ -1314,21 +1344,39 @@ export default function (pi: ExtensionAPI) {
 					writerReasoning = chosen.reasoning;
 				}
 
-				// 2. Pick the destination model.
-				const target = await pickTargetModel(ctx);
-				if (!target) return;
-
-				// 3. Pick the thinking level (a scoped `model:level` entry pins it).
-				const level = target.thinkingLevel ?? (await selectThinkingLevel(ctx));
-				if (level === undefined) return;
+				// 2–3. Destination model and thinking level. The same-or-pick picker's
+				// first option re-uses the current session's values in one Enter press;
+				// `--same` skips that dialog. On the picked-model path a scoped
+				// `model:level` entry pins the level.
+				const reuse = parsed.same ? "same" : await chooseSameOrPick(ctx);
+				if (!reuse) return;
+				let target: PickedModel | undefined;
+				let level: ThinkingLevel | undefined;
+				if (reuse === "same") {
+					if (!ctx.model) {
+						ctx.ui.notify("--same: the current session has no model to reuse", "error");
+						return;
+					}
+					target = { model: ctx.model };
+					level = ctx.thinkingLevel;
+				} else {
+					target = await pickTargetModel(ctx);
+					if (!target) return;
+					level = target.thinkingLevel ?? (await selectThinkingLevel(ctx));
+					if (level === undefined) return;
+				}
 
-				// 4. Collect steering instructions, pre-filled from the remaining args.
-				const steering = await ctx.ui.editor(
-					writer.kind === "live"
-						? "Steering for the hand-off prompt (sent to the current agent)"
-						: "Steering for the hand-off prompt (sent to the hand-off writer)",
-					parsed.steering.trim(),
-				);
+				// 4. Steering instructions: when passed inline as `/hand-off <instructions>`
+				// they are used as-is; only an empty steering text opens the editor.
+				const inlineSteering = parsed.steering.trim();
+				const steering =
+					inlineSteering ||
+					(await ctx.ui.editor(
+						writer.kind === "live"
+							? "Steering for the hand-off prompt (sent to the current agent)"
+							: "Steering for the hand-off prompt (sent to the hand-off writer)",
+						"",
+					));
 				if (steering === undefined) return;
 
 				// 5. Write the hand-off prompt with the chosen writer.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@grrrck/pi-clear",
-	"version": "0.4.0",
+	"version": "0.5.0",
 	"description": "Pi extension that starts a fresh session with /clear while keeping your current model and thinking level, and hands conversations off between models with /hand-off",
 	"keywords": [
 		"pi-package",