@huseynsnmz/pi-suite 0.2.2 → 0.2.4

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## [0.2.4]
+
+### Features
+
+- `/mastermind`: a strong model, chosen as the new `mastermind` role in `/router`, reads past conversations and writes a short playbook that other models get on every run. You approve every rule in an editor. `/mastermind compact` shortens it, and `/mastermind show` shows it.
+- New part, `subagent`: the `agent` tool hands a task to a fresh agent and gives back its answer. `explore` can only read, and also works in `plan` and `read-only`. `general` can do everything, and its permission asks come to your session.
+- A `cd` at the start of a bash command carries over to later commands while it stays in the project.
+- `/review-permissions` reports what the permission judge decided, and why it deferred.
+
+### Changes
+
+- `auto` no longer sends `edit` and `write` on ordinary project files to the judge. `.git`, `.pi`, `.claude`, `.husky`, `.github`, `.vscode`, `.envrc` and paths outside the project still go to it.
+- The first time you start Pi in a project, pi-modes allows `cd` inside that project in your bash rules, with a backup, so you aren't asked about each one. A `cd` elsewhere still asks.
+
+### Development
+
+- `npm test` takes seconds. Board's tests that start real processes moved to `npm run test:all`, and `npm run test:e2e` runs every suite at once.
+
+## [0.2.3]
+
+### Features
+
+- Router: each role can have its own reasoning level, chosen in `/router` from what that role's model offers.
+- Up and Down with one line typed go through past prompts that start with it. With nothing typed they also reach this folder's other sessions.
+- With `hideThinkingBlock` on, reasoning shows while it's written and collapses when the message is done. `Ctrl+T` opens it.
+- New part, off until you run `/suite on subscription`: Claude models on your Claude login, based on pi-claude-subscription. It asks before anything more is billed as extra usage. See its README for the limits and what Anthropic's terms say.
+
+- One settings file, `~/.pi/agent/suite.json`, with a section for each part. `/suite` now opens each part's settings as well as turning it on or off. Old files move in the first time Pi starts, and stay as `.bak`.
+
+### Fixes
+
+- `router/auto` is always listed in `/model`, and says to run `/router` until `plan` and `build` are set.
+- `/clear` keeps the current model and reasoning level.
+
 ## [0.2.2]
 
 ### Fixes

package/README.md

@@ -11,13 +11,21 @@ One package for [Pi](https://pi.dev): modes and permissions, a framed screen, a
 | `frame` | The start card, framed editor, tool boxes, footer and the agent's todo list | [README](packages/frame/README.md) |
 | `board` | A board for starting, watching and attaching to background sessions | [README](packages/board/README.md) |
 | `commands` | `/clear` and `/security-review` | [README](packages/commands/README.md) |
+| `subagent` | The `agent` tool: hand a task to a fresh agent, and get its answer back | [README](packages/subagent/README.md) |
+| `subscription` | Off until you turn it on. Claude models on your Claude login, asking before anything more is billed as extra usage | [README](packages/subscription/README.md) |
+
+## Settings
+
+Run `/suite` to turn parts on or off and change their settings. They're all kept in `~/.pi/agent/suite.json`, with a section for each part, so you can also edit it by hand. Older files such as `router.json` and `web.json` move in the first time Pi starts, and stay beside it as `.bak`. If one can't be read it stays where it is, and you're told, so a broken file can't silently turn off a setting.
+
+There's no setting per project, so a repository can't choose where your code goes. The only exception is the frame's look, in `.pi/extensions/pi-harness/settings.json`, once you trust the project. Pi's own files, and the settings of other packages, such as `pi-permission-system`, stay where they are.
 
 ## Install
 
 Requires Pi 1.5 or newer.
 
 ```bash
-pi install npm:@huseynsnmz/pi-suite@0.2.2
+pi install npm:@huseynsnmz/pi-suite@0.2.4
 ```
 
 If you installed any of these separately, remove them first:
@@ -82,8 +90,9 @@ Each part has its own limits, listed in its README or `SECURITY.md`. None of thi
 ```bash
 npm install --ignore-scripts
 npm run check
-npm test
-npm run test:e2e
+npm test           # seconds: logic only
+npm run test:all   # adds board's tests that start real processes
+npm run test:e2e   # real Pi in a real terminal with a fake model, every suite at once
 ```
 
-Each part keeps its own tests under `packages/<part>/test`. `frame` needs [bun](https://bun.sh) for its unit tests. `npm run test:e2e` drives real Pi in a real terminal with a fake model.
+Each part keeps its own tests under `packages/<part>/test`. `frame` needs [bun](https://bun.sh) for its unit tests. To run some end-to-end suites, name them: `python3 test/e2e/all.py router web`. Run `test:all` and `test:e2e` before a release.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huseynsnmz/pi-suite",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "One Pi package for all of it: modes and permissions, a framed screen, an agent board, memory, web tools with a separate page reader, and a model router. Turn off what you don't want with /suite.",
   "type": "module",
   "license": "MIT",
@@ -28,10 +28,18 @@
     "README.md",
     "CHANGELOG.md",
     "LICENSE",
+    "packages/subscription/src",
+    "packages/subscription/package.json",
+    "packages/subscription/README.md",
+    "packages/subscription/LICENSE",
     "packages/commands/src",
     "packages/commands/package.json",
     "packages/commands/README.md",
     "packages/commands/LICENSE",
+    "packages/subagent/src",
+    "packages/subagent/package.json",
+    "packages/subagent/README.md",
+    "packages/subagent/LICENSE",
     "packages/board/src",
     "packages/board/runner",
     "packages/board/docs",
@@ -88,9 +96,11 @@
   "scripts": {
     "check": "tsc --noEmit && npm run --workspaces --if-present check && npm run -w packages/board typecheck",
     "test": "node --test test/*.test.ts && npm run --workspaces --if-present test",
-    "test:e2e": "python3 test/e2e/run.py"
+    "test:all": "npm test && npm run -w packages/board test:integration",
+    "test:e2e": "python3 test/e2e/all.py"
   },
   "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "0.3.308",
     "@xterm/headless": "6.0.0",
     "node-pty": "1.1.0",
     "@mozilla/readability": "0.6.0",

package/packages/board/README.md

@@ -26,7 +26,7 @@ Requires Pi 1.5 or newer.
 1. Install it:
 
    ```bash
-   pi install npm:@huseynsnmz/pi-suite@0.2.2
+   pi install npm:@huseynsnmz/pi-suite@0.2.4
    ```
 
 2. Restart Pi, and press `Left` twice on an empty prompt, or run `/agent-board`.

package/packages/board/package.json

@@ -45,9 +45,10 @@
   "scripts": {
     "typecheck": "tsc --noEmit",
     "test": "node scripts/run-tests.mjs",
+    "test:integration": "node scripts/run-tests.mjs --integration",
     "test:perf": "node scripts/run-perf-gate.mjs",
     "pack:dry": "npm pack --dry-run",
-    "verify": "npm run typecheck && npm run test:perf && npm test && npm run pack:dry"
+    "verify": "npm run typecheck && npm run test:perf && npm test && npm run test:integration && npm run pack:dry"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",

package/packages/commands/README.md

@@ -4,7 +4,7 @@ Two commands for Pi. Part of [pi-suite](../../README.md); turn them off with `/s
 
 ## /clear
 
-Clears the conversation and starts a new session, as `/new` does. If the agent is working, it stops first. The old session is kept, and `/resume` brings it back.
+Clears the conversation and starts a new session, keeping the model and reasoning level you have selected. `/new` goes back to your saved default instead. If the agent is working, it stops first. The old session is kept, and `/resume` brings it back.
 
 ## /security-review
 

package/packages/commands/src/index.ts

@@ -5,6 +5,14 @@ import { changesToReview, type GitRun, reviewPrompt } from "./security-review.ts
 
 const REVIEW_MESSAGE = "security-review";
 
+/** The model /clear hands to the session it starts. Pi's own new session would take the saved default. */
+const KEPT = Symbol.for("pi-suite:clear-keeps");
+interface Kept {
+  provider: string;
+  id: string;
+  thinking: ReturnType<ExtensionAPI["getThinkingLevel"]>;
+}
+
 export default function piCommands(pi: ExtensionAPI): void {
   pi.registerCommand("clear", {
     description: "Clear the conversation and start a new session",
@@ -13,10 +21,24 @@ export default function piCommands(pi: ExtensionAPI): void {
         ctx.abort();
         await ctx.waitForIdle();
       }
+      const store = globalThis as Record<symbol, Kept | undefined>;
+      if (ctx.model) store[KEPT] = { provider: ctx.model.provider, id: ctx.model.id, thinking: pi.getThinkingLevel() };
       await ctx.newSession();
+      delete store[KEPT]; // Still here only if it was cancelled.
     },
   });
 
+  // Runs in the new session, where this extension is a new instance, so what /clear kept can't live in it.
+  pi.on("session_start", async (event, ctx) => {
+    const store = globalThis as Record<symbol, Kept | undefined>;
+    const kept = store[KEPT];
+    delete store[KEPT];
+    if (event.reason !== "new" || kept === undefined) return;
+    const model = ctx.modelRegistry.find(kept.provider, kept.id);
+    if (model !== undefined) await pi.setModel(model);
+    pi.setThinkingLevel(kept.thinking);
+  });
+
   // The diff goes to the model, and only this one line goes on screen.
   pi.registerMessageRenderer<{ summary: string }>(REVIEW_MESSAGE, (message, _options, theme) =>
     new Text(theme.fg("muted", message.details?.summary ?? "Security review"), 1, 0),

package/packages/frame/README.md

@@ -19,7 +19,7 @@ Requires Pi 1.5 or newer.
 2. Install it:
 
    ```bash
-   pi install npm:@huseynsnmz/pi-suite@0.2.2
+   pi install npm:@huseynsnmz/pi-suite@0.2.4
    ```
 
 3. Restart Pi. The start card says `π-frame`.
@@ -44,6 +44,8 @@ Some pieces, such as rooms, boards, peers and the remote page, appear only with
 |---|---|
 | `Ctrl+C` | Stops a run and says `Aborted`. With nothing running, it clears the editor and says to press it again within 2 seconds to exit |
 | `Ctrl+R` | Search what you've typed, here and in this folder's other sessions. `Ctrl+R` again goes further back, `Enter` sends, `Esc` cancels, any other key keeps the match to edit. It replaces Pi's Rename on this key; `/name` still renames |
+| `Up` / `Down` | With nothing typed, browse past prompts, including this folder's other sessions. With one line typed, go through prompts that start with it, as in a shell |
+| `Ctrl+T` | Open or collapse finished reasoning |
 | `Alt+O` | Scroll through the session's tool output, one call at a time |
 | `Ctrl+O` | Expand every call in the transcript |
 | `/todos` | Show the agent's todo list. `/todos clear` empties it and tells the agent |
@@ -78,7 +80,7 @@ More detail is in [How it works](docs/how-it-works.md) and the [reference](docs/
 - **`gh` and `glab` still run in their repositories,** and they call `git` for reads such as the remote list.
 - **`glab` needs a host with `gitlab` in its name.** It starts for that remote, and if a token is set in the environment (`GITLAB_TOKEN`), only for `gitlab.com` or `GITLAB_HOST`, because a repository picks its own remote.
 - **The `git status` protections cover the ways to run code that I know of.** New Git options could add others.
-- **The parts of `@adeildo/pi-kit` 6.0.0 that frame uses are copied into `src/kit`,** with its license, so upstream fixes have to be copied in by hand. Its settings stay in `~/.pi/agent/extensions/pi-harness/settings.json`.
+- **The parts of `@adeildo/pi-kit` 6.0.0 that frame uses are copied into `src/kit`,** with its license, so upstream fixes have to be copied in by hand. Its settings stay in `~/.pi/agent/suite.json`.
 - **Another session's view isn't fully covered.** Opening one needs other pi-harness packages, and that view hasn't been tested.
 
 ## Development
@@ -103,3 +105,7 @@ MIT. See [LICENSE](LICENSE), which keeps the original copyright notice.
 - [pi-look and pi-harness](https://github.com/felipeadeildo/pi-harness) by [adeildo](https://adeildo.dev)
 - The framed editor comes from [pi-open-tui](https://github.com/OldSuns/pi-open-tui), by way of pi-look.
 - The segments with priorities come from [oh-my-pi](https://github.com/can1357/oh-my-pi), by way of pi-look.
+
+## Reasoning
+
+Set `"hideThinkingBlock": true` in `~/.pi/agent/settings.json`, or press `Ctrl+T` until reasoning is collapsed. It then shows while the model is writing it and collapses to one line once the message is done. `Ctrl+T` opens it again, or click it to open just that one. `Ctrl+T` is Pi's own setting, so it applies to every message and stays set in later sessions.

package/packages/frame/docs/reference.md

@@ -27,7 +27,7 @@ Syntax tokens are borrowed on purpose: a theme spends its hues there, so they gi
 
 ## Settings
 
-They live in the file `@adeildo/pi-kit` keeps, `~/.pi/agent/extensions/pi-harness/settings.json`, under `frame.`.
+They live under `frame` in `~/.pi/agent/suite.json`.
 
 | Key           | Default     | Does                                                                                                                                   |
 | ------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------- |

package/packages/frame/src/index.ts

@@ -1,4 +1,4 @@
-import { dirname, join } from "node:path";
+import { join } from "node:path";
 
 import {
 	ACCOUNT,
@@ -23,7 +23,7 @@ import type {
 	ExtensionContext,
 	ReadonlyFooterDataProvider,
 } from "@earendil-works/pi-coding-agent";
-import { keyText, parseSkillBlock } from "@earendil-works/pi-coding-agent";
+import { getAgentDir, keyText, parseSkillBlock } from "@earendil-works/pi-coding-agent";
 import { Key, type KeyId, type TUI } from "@earendil-works/pi-tui";
 
 import { type GitState, readGit } from "./data/git.ts";
@@ -157,7 +157,7 @@ export const frameFeature = defineFeature({
 
 		for (const entry of FRAME_SETTINGS) entry.listen(scope, repaint);
 		frame.listen(scope, () => live.ctx && installEditor(live.ctx, screen, live, scope));
-		const visitsFile = join(dirname(scope.settings.globalPath), "frame-visits.json");
+		const visitsFile = join(getAgentDir(), "extensions", "pi-harness", "frame-visits.json");
 		let visited = false;
 		let lastVisit: LastVisit | undefined;
 
@@ -527,6 +527,9 @@ function pressCtrlC(live: Live, clearEditor: () => void): void {
 	live.repaint?.();
 }
 
+/** Everything collapsed has finished, because live reasoning stays open. */
+const THOUGHT_LABEL = "Thought · ctrl+t to expand";
+
 function installEditor(
 	ctx: ExtensionContext,
 	screen: Screen,
@@ -535,9 +538,11 @@ function installEditor(
 ): void {
 	if (ctx.mode !== "tui") return;
 	if (frame.get(scope) === "off") {
+		ctx.ui.setHiddenThinkingLabel(undefined);
 		ctx.ui.setEditorComponent(undefined);
 		return;
 	}
+	ctx.ui.setHiddenThinkingLabel(THOUGHT_LABEL);
 	ctx.ui.setEditorComponent((tui, theme, keybindings) => {
 		live.tui = tui;
 		applyCursor(tui, cursor);

package/packages/frame/src/kit/settings/files.ts

@@ -1,5 +1,5 @@
 // Every app shares the settings files, so a write keeps every key it does not know.
-import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 
 import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
@@ -14,7 +14,7 @@ export interface SettingsFile {
 }
 
 export function globalSettingsPath(): string {
-	return join(getAgentDir(), "extensions", "pi-harness", "settings.json");
+	return join(getAgentDir(), "suite.json");
 }
 
 export function projectSettingsPath(cwd: string): string {
@@ -40,12 +40,12 @@ export function writeSettingsFile(
 	options: { mode?: number } = {},
 ): void {
 	mkdirSync(dirname(path), { recursive: true });
-	const temporary = `${path}.${process.pid}.tmp`;
-	writeFileSync(temporary, `${JSON.stringify(data, null, "\t")}\n`, {
-		encoding: "utf8",
-		mode: options.mode,
-	});
-	renameSync(temporary, path);
+	// A linked file stays linked, and a private one stays private. Other parts' settings share it.
+	const target = existsSync(path) ? realpathSync(path) : path;
+	const mode = options.mode ?? (existsSync(target) ? statSync(target).mode & 0o777 : undefined);
+	const temporary = `${target}.${process.pid}.tmp`;
+	writeFileSync(temporary, `${JSON.stringify(data, null, "\t")}\n`, { encoding: "utf8", mode });
+	renameSync(temporary, target);
 }
 
 export function lookup(data: SettingsData, id: string): unknown {

package/packages/frame/src/kit/settings/store.ts

@@ -135,7 +135,9 @@ export class SettingsStore {
 	}
 
 	#edit(path: string, change: (data: SettingsData) => void): string | undefined {
-		const { data } = readSettingsFile(path);
+		const { data, warnings } = readSettingsFile(path);
+		// Reading a broken file gives nothing, and writing that would wipe what else it holds.
+		if (warnings.length > 0) return warnings[0];
 		change(data);
 		try {
 			writeSettingsFile(path, data);

package/packages/frame/src/ui/editor.ts

@@ -15,7 +15,15 @@ import { BOXES, border } from "../render/frame.ts";
 import { paintLead, promptLead } from "../render/lead.ts";
 import { SETTINGS_KEY, SETTINGS_SHORTCUT_INPUT } from "../render/keys.ts";
 import type { CursorStyle } from "../settings.ts";
-import { findPrompt, type HistorySearch, shownText, startSearch } from "./history-search.ts";
+import {
+	findPrompt,
+	type HistorySearch,
+	type PrefixSearch,
+	shownText,
+	startPrefix,
+	startSearch,
+	stepPrefix,
+} from "./history-search.ts";
 import { type Screen, type SlotName, slotPieces } from "./screen.ts";
 
 type WorkingIndicator = Parameters<CustomEditor["setWorkingStatusIndicator"]>[0];
@@ -44,6 +52,8 @@ export class FrameEditor extends CustomEditor {
 	#hiddenBelow = 0;
 	#inset = 0;
 	#search: HistorySearch | undefined;
+	#prefix: PrefixSearch | undefined;
+	#seeded = false;
 
 	constructor(
 		tui: TUI,
@@ -77,13 +87,9 @@ export class FrameEditor extends CustomEditor {
 			this.#searchKey(this.#search, data);
 			return;
 		}
+		if (this.#prefixKey(data)) return;
 		if (matchesKey(data, SEARCH_KEY) && !this.isShowingAutocomplete()) {
-			// What Up browses, then what was typed in this folder's other sessions.
-			const own: unknown = Reflect.get(this, "history");
-			this.#search = startSearch(this.getText(), [
-				...(Array.isArray(own) ? (own as string[]) : []),
-				...this.#screen.pastPrompts(),
-			]);
+			this.#search = startSearch(this.getText(), this.#history());
 			return;
 		}
 		if (this.#keybindings.matches(data, "app.clear") && !this.isShowingAutocomplete()) {
@@ -101,6 +107,51 @@ export class FrameEditor extends CustomEditor {
 		if (skillQueryAt(this.getLines(), line, col) !== undefined) openAutocomplete(this);
 	}
 
+	/** What Up browses, then what was typed in this folder's other sessions. Read once, on first use. */
+	#history(): readonly string[] {
+		const own: unknown = Reflect.get(this, "history");
+		if (!Array.isArray(own)) return this.#screen.pastPrompts();
+		const entries = own as string[];
+		if (!this.#seeded) {
+			this.#seeded = true;
+			for (const prompt of this.#screen.pastPrompts()) {
+				if (!entries.includes(prompt)) entries.push(prompt);
+			}
+		}
+		return entries;
+	}
+
+	/**
+	 * Up with one line typed looks back through prompts that start with it, and Down comes forward
+	 * again. Any other key keeps what's showing. An empty prompt is left to pi's own browsing.
+	 */
+	#prefixKey(data: string): boolean {
+		const up = this.#keybindings.matches(data, "tui.editor.cursorUp");
+		const down = this.#keybindings.matches(data, "tui.editor.cursorDown");
+		if (!up && !down) {
+			this.#prefix = undefined;
+			return false;
+		}
+		if (this.isShowingAutocomplete()) return false;
+		if (this.#prefix === undefined) {
+			const typed = this.getText();
+			const entries = this.#history();
+			const browsing = Reflect.get(this, "historyIndex") !== -1;
+			if (down || typed === "" || typed.includes("\n") || browsing || !onFirstVisualLine(this)) return false;
+			const search = startPrefix(typed, entries);
+			// With nothing to go through, the arrows stay pi's.
+			if (search.matches.length === 0) return false;
+			this.#prefix = search;
+		}
+		const text = stepPrefix(this.#prefix, up ? 1 : -1);
+		if (text === undefined && down) {
+			this.#prefix = undefined;
+			return false;
+		}
+		if (text !== undefined) this.setText(text);
+		return true;
+	}
+
 	/** Enter sends the match, Esc goes back, and any other key keeps the match to edit. */
 	#searchKey(search: HistorySearch, data: string): void {
 		if (matchesKey(data, SEARCH_KEY)) {
@@ -248,6 +299,12 @@ export class FrameEditor extends CustomEditor {
 	}
 }
 
+/** The method is private. If a pi release renames it, Up just moves the cursor as before. */
+function onFirstVisualLine(editor: CustomEditor): boolean {
+	const check: unknown = Reflect.get(editor, "isOnFirstVisualLine");
+	return typeof check === "function" && check.call(editor) === true;
+}
+
 /** The method is private; nothing opens if a pi release renames it. */
 function openAutocomplete(editor: CustomEditor): void {
 	const open: unknown = Reflect.get(editor, "tryTriggerAutocomplete");

package/packages/frame/src/ui/history-search.ts

@@ -21,3 +21,24 @@ export function findPrompt(search: HistorySearch, from: number): number {
 export function shownText(search: HistorySearch): string {
 	return search.at < 0 ? search.draft : (search.entries[search.at] as string);
 }
+
+/** Up with text typed: older prompts that start with it, as in a shell. */
+export interface PrefixSearch {
+	typed: string;
+	matches: readonly string[];
+	at: number;
+}
+
+export function startPrefix(typed: string, entries: readonly string[]): PrefixSearch {
+	const wanted = typed.toLowerCase();
+	const matches = [...new Set(entries)].filter((entry) => entry !== typed && entry.toLowerCase().startsWith(wanted));
+	return { typed, matches, at: -1 };
+}
+
+/** One step older (1) or newer (-1), ending back on what was typed. Undefined past either end. */
+export function stepPrefix(search: PrefixSearch, step: 1 | -1): string | undefined {
+	const next = search.at + step;
+	if (next < -1 || next >= search.matches.length) return undefined;
+	search.at = next;
+	return next < 0 ? search.typed : search.matches[next];
+}

package/packages/frame/src/ui/pi-entries.ts

@@ -1,5 +1,6 @@
 // Pi's own transcript entries in the harness frame instead of a background. Pi has no hook for
 // drawing them, so this wraps each component's render.
+import { showThinkingWhileLive } from "./thinking.ts";
 import { CHANGES_CUT, CHANGES_X, entryFrame, type EntryFrame, GLYPH } from "../kit/index.ts";
 import {
 	BashExecutionComponent,
@@ -63,6 +64,7 @@ export function framePiEntries(source: EntryPaint): void {
 	paint = source;
 	if (installed) return;
 	installed = true;
+	showThinkingWhileLive(() => paint() !== undefined);
 	wrap(UserMessageComponent, (self, look) =>
 		look.you ? youFrame(look, fromOf(self, look), sentInOf(self, look)) : undefined,
 	);

package/packages/frame/src/ui/thinking.ts

@@ -0,0 +1,34 @@
+import { AssistantMessageComponent } from "@earendil-works/pi-coding-agent";
+
+/** Private in pi. If a release renames them, reasoning just follows pi's setting again. */
+interface Message {
+	updateContent(message: { content: readonly { type: string }[] }, isStreaming?: boolean): void;
+	isStreaming?: boolean;
+	thinkingVisibilityOverrides?: Map<number, boolean>;
+}
+
+const live = new WeakSet<object>();
+let isActive: () => boolean = () => false;
+let installed = false;
+
+/**
+ * With pi's setting that collapses reasoning on, it still shows while it's being written, and
+ * collapses once the message is done. Ctrl+T or a click opens it again.
+ */
+export function showThinkingWhileLive(active: () => boolean): void {
+	isActive = active;
+	if (installed) return;
+	installed = true;
+	const prototype = AssistantMessageComponent.prototype as unknown as Message;
+	const own = prototype.updateContent;
+	prototype.updateContent = function updateContent(this: Message, message, isStreaming = this.isStreaming) {
+		const overrides = this.thinkingVisibilityOverrides;
+		if (overrides !== undefined && isActive() && isStreaming === true) {
+			live.add(this);
+			message.content.forEach((_part, run) => overrides.set(run, false));
+		} else if (overrides !== undefined && live.delete(this)) {
+			overrides.clear();
+		}
+		own.call(this, message, isStreaming);
+	};
+}

package/packages/memory/README.md

@@ -9,7 +9,7 @@ Long-term memory for [Pi](https://pi.dev). It reviews your past conversations, k
 Requires Pi 1.5 or newer, on Node 22.18 or newer.
 
 ```bash
-pi install npm:@huseynsnmz/pi-suite@0.2.2
+pi install npm:@huseynsnmz/pi-suite@0.2.4
 ```
 
 ## Use
@@ -23,6 +23,25 @@ pi install npm:@huseynsnmz/pi-suite@0.2.2
 
 Or just ask: "remember that I deploy from main", "review our past conversations".
 
+## Teaching weaker models
+
+| Command | What it does |
+| --- | --- |
+| `/mastermind` | A strong model reads past conversations, one batch at a time, and writes rules for your other models |
+| `/mastermind compact` | Shortens the playbook, keeping what each rule means |
+| `/mastermind show` | The rules in force in this folder |
+
+Choose the model and its reasoning as `mastermind` in `/router`. It looks for what you corrected, mistakes that came back, and what the model should have read or checked first.
+
+The result is a playbook, one global and one per folder, of up to 1,000 characters each. It goes in the system prompt of every run, up to about 500 tokens, except when the mastermind itself is the selected model. Each review rewrites it to fit, so it can't keep growing.
+
+- **You approve every word:** the rules open in an editor, where you can delete or change them, and nothing is saved until you do. This matters because a session can contain text copied from files or web pages, and the playbook is followed as instructions. A secret is refused.
+- **Your session stays small:** the strong model is called directly, so what it reads never enters your conversation, and there are no extra tools.
+- **Separate from `/memory review`:** each keeps its own place in your sessions. Memories are facts, and the playbook is how to work.
+- **Cost:** a batch sends up to about 15,000 tokens of input to the model you chose, so your past conversations go to that provider. It doesn't run on its own, and once 10 sessions are waiting, Pi mentions it after your first message.
+
+Playbooks are in `~/.pi/agent/memory/playbook/`, with the last version of each kept as `.bak`.
+
 ## How it works
 
 - **Review:** the `review-memory` skill reads a batch of about 60,000 characters, proposes memories, and saves the ones you keep. It remembers how far it read in each session file, so a session you continue later gets read from where it stopped.

package/packages/memory/src/index.ts

@@ -2,10 +2,15 @@
 import { join } from "node:path";
 import { getAgentDir, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
+import { compact, type Mastermind, review, REVIEWED_KEY } from "./mastermind.ts";
+import { GLOBAL, playbookSection, readPlaybook } from "./playbook.ts";
 import { promptSection } from "./prompt.ts";
 import { countUnreviewed, nextBatch, sessionFiles, type ReviewBatch } from "./review.ts";
 import { CATEGORIES, MemoryStore, type Category, type Memory } from "./store.ts";
 
+/** Enough new material for a review to be worth what it costs. */
+const NUDGE_SESSIONS = 10;
+
 const text = (value: string, details: Record<string, unknown> = {}) => ({ content: [{ type: "text" as const, text: value }], details });
 
 function line(memory: Memory): string {
@@ -22,14 +27,37 @@ export default function piMemory(pi: ExtensionAPI): void {
   let lastBatch: ReviewBatch | null = null;
   // Worked out once a session: a system prompt that changes mid-session would throw away the provider's prompt cache.
   let section: string | null = null;
+  let playbook: string | null = null;
+  let nudged = false;
 
   const store = () => (storePromise ??= MemoryStore.open(dbPath));
 
   pi.on("session_start", () => {
     section = null;
+    playbook = null;
     lastBatch = null;
   });
 
+  /** The strong model the router has for this, whichever part loads first. */
+  const mastermind = (): Mastermind | undefined => {
+    const probe: { model?: string; thinking?: string } = {};
+    pi.events.emit("pi-router:mastermind-model", probe);
+    return probe.model === undefined ? undefined : { model: probe.model, thinking: probe.thinking };
+  };
+
+  // After the first reply rather than at start, as it walks every session file.
+  pi.on("agent_end", async (_event, ctx) => {
+    if (nudged || !ctx.hasUI || mastermind() === undefined) return;
+    nudged = true;
+    try {
+      const memories = await store();
+      const waiting = countUnreviewed(sessionFiles(roots), (path) => memories.reviewedBytes(REVIEWED_KEY + path), ctx.sessionManager.getSessionFile());
+      if (waiting >= NUDGE_SESSIONS) ctx.ui.notify(`${waiting} sessions haven't been reviewed. /mastermind can turn them into rules for your models.`, "info");
+    } catch {
+      // A reminder isn't worth an error.
+    }
+  });
+
   pi.on("session_shutdown", async () => {
     const open = storePromise;
     storePromise = null;
@@ -44,7 +72,10 @@ export default function piMemory(pi: ExtensionAPI): void {
       section = "";
       ctx.ui.notify(`pi-memory: ${err instanceof Error ? err.message : String(err)}`, "warning");
     }
-    return section ? { systemPrompt: event.systemPrompt + section } : undefined;
+    playbook ??= playbookSection(readPlaybook(agentDir, GLOBAL), readPlaybook(agentDir, ctx.cwd));
+    // The model that writes the playbook doesn't need it.
+    const rules = ctx.model !== undefined && `${ctx.model.provider}/${ctx.model.id}` === mastermind()?.model ? "" : playbook;
+    return section || rules ? { systemPrompt: event.systemPrompt + section + rules } : undefined;
   });
 
   pi.registerTool({
@@ -141,6 +172,34 @@ export default function piMemory(pi: ExtensionAPI): void {
     ctx.ui.notify(`${body}\n\nSessions not reviewed yet: ${pending}. /memory review goes through them.`, "info");
   };
 
+  let reviewing = false;
+
+  pi.registerCommand("mastermind", {
+    description: "A strong model turns past conversations into rules for your other models. Or: compact | show",
+    handler: async (args, ctx) => {
+      if (!ctx.hasUI) return;
+      const action = args.trim();
+      if (action === "show") {
+        const shown = [GLOBAL, ctx.cwd].map((scope) => `${scope}:\n${readPlaybook(agentDir, scope) || "(empty)"}`).join("\n\n");
+        return ctx.ui.notify(shown, "info");
+      }
+      if (action !== "" && action !== "compact") return ctx.ui.notify("Usage: /mastermind [compact | show]", "warning");
+      const chosen = mastermind();
+      if (chosen === undefined) return ctx.ui.notify("Choose a strong model first: set mastermind in /router.", "warning");
+      if (reviewing) return ctx.ui.notify("/mastermind is already running.", "warning");
+      reviewing = true;
+      try {
+        if (action === "compact") await compact(ctx, agentDir, chosen, [GLOBAL, ctx.cwd]);
+        else await review(ctx, agentDir, chosen, await store(), sessionFiles(roots));
+        playbook = null;
+      } catch (err) {
+        ctx.ui.notify(`/mastermind: ${err instanceof Error ? err.message : String(err)}`, "error");
+      } finally {
+        reviewing = false;
+      }
+    },
+  });
+
   pi.registerCommand("memory", {
     description: "Show memories, or: /memory <words> | review | forget <id>",
     handler: async (args, ctx) => {