one-code-extension 0.4.1 → 0.5.0

package/extensions/memory/index.ts

@@ -22,32 +22,41 @@
 
 import { mkdirSync, readFileSync } from "node:fs";
 import os from "node:os";
-import { isAbsolute, join, resolve, sep } from "node:path";
+import { join } from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { claudeMdLimitWarning, combinedLimitWarning, projectMemoryDir } from "../lib/memory.ts";
 import {
-	claudeMdLimitWarning,
-	combinedLimitWarning,
 	INDEX_NEAR_LIMIT_REMINDER,
 	INDEX_OVER_LIMIT_ERROR,
 	indexLimitStatus,
-	projectMemoryDir,
 	stampFrontmatter,
-} from "../lib/memory.ts";
-import { claudeConfigDir, oneCodeStateDir } from "../lib/paths.ts";
+} from "../lib/memory-content.ts";
+import { type ConfigMode, CONFIG_MODE_KEY, claudeSourcesOn, configMode, configModeFromEnv, savedConfigMode } from "../lib/config-mode.ts";
+import { isClaudeLocation } from "../lib/claude-context.ts";
+import { oneCodeSettingsPath, readSettingsForWrite, writeSettings } from "../lib/one-code-settings.ts";
+import { claudeConfigDir, comparablePath, isPathAtOrUnder, oneCodeStateDir, tildify, tryRealpath } from "../lib/paths.ts";
+import { resolveThroughLinks } from "../auto-mode/paths.ts";
+import { resolveToolPath } from "../lib/tool-path.ts";
 import { tryReadFile } from "../lib/plugins.ts";
 import { REMINDER_CHANNEL } from "../lib/reminders.ts";
 import { boundedDockHeight, safeThemeBold, safeThemePaint, truncateLine } from "../lib/tui-render.ts";
 import { buildMemoryEntries, entryName, type MemoryEntry } from "./entries.ts";
-import { openPath } from "./open-external.ts";
-import { applyMemoryKey, decodeMemoryKey, initialMemoryState, renderMemoryPanel } from "./panel.ts";
+import { editorHint, memoryDisplayPath, openPath } from "./open-external.ts";
+import { applyMemoryKey, type AutoMemoryView, decodeMemoryKey, initialMemoryState, type ModeView, renderMemoryPanel, settingChanges } from "./panel.ts";
+import { AUTO_MEMORY_KEY, autoMemoryEnabled, autoMemoryFromEnv, savedAutoMemory, savedAutoMemorySource } from "../lib/auto-memory.ts";
 import { registerLocalCommand } from "../lib/local-command.ts";
+import { canShowCustomUi } from "../lib/headless-output.ts";
+import { panelUi } from "../lib/panel-focus.ts";
 
 const MEMORY_PANEL_MAX_HEIGHT = 20;
 
-function inputPath(input: unknown, cwd: string): string | undefined {
+/** `root` is the memory directory's real path, resolved once per session. */
+function inputPath(input: unknown, cwd: string, root: string): string | undefined {
 	const raw = (input as { path?: unknown })?.path;
 	if (typeof raw !== "string" || !raw.trim()) return undefined;
-	return isAbsolute(raw) ? raw : resolve(cwd, raw);
+	// Match the file pi touches, including aliases and not-yet-created leaves.
+	const path = resolveThroughLinks(resolveToolPath(raw, cwd));
+	return path && isPathAtOrUnder(path, root) && comparablePath(path) !== comparablePath(root) ? path : undefined;
 }
 
 /** All the panel/warning entries for `cwd`, from One Code's real state dirs. */
@@ -57,15 +66,20 @@ function memoryEntriesFor(cwd: string): MemoryEntry[] {
 		home: os.homedir(),
 		homeClaudeDir: claudeConfigDir(),
 		homeOneCodeDir: oneCodeStateDir(),
-		memoryDir: projectMemoryDir(cwd),
+		memoryDir: autoMemoryEnabled(cwd) ? projectMemoryDir(cwd) : undefined,
 	});
 }
 
 export default function memoryExtension(pi: ExtensionAPI) {
 	let dir: string | undefined;
+	let dirReal = "";
 
 	pi.on("session_start", (_event, ctx) => {
+		dir = undefined;
 		const candidate = projectMemoryDir(ctx.cwd);
+		// An independent state directory can contain links into Claude's tree.
+		// Resolve missing leaves through their parents before creating anything.
+		if (!claudeSourcesOn() && isClaudeLocation(resolveThroughLinks(candidate) ?? candidate, claudeConfigDir())) return;
 
 		// Claude Code's startup warning: an instruction file over the char limit
 		// bloats every turn's context. Warn once, pointing at /memory to trim it.
@@ -92,6 +106,9 @@ export default function memoryExtension(pi: ExtensionAPI) {
 			}
 		}
 
+		// Auto-memory off (lib/auto-memory.ts): no folder, no stamping.
+		if (!autoMemoryEnabled(ctx.cwd)) return;
+
 		// Like Claude Code: one memory dir per git repo (shared by worktrees and
 		// subdirectories); outside a repo, per cwd.
 		try {
@@ -102,6 +119,7 @@ export default function memoryExtension(pi: ExtensionAPI) {
 			return;
 		}
 		dir = candidate;
+		dirReal = tryRealpath(candidate) ?? candidate;
 
 		// The MEMORY.md index is injected by the claude-context extension, folded
 		// into the `# claudeMd` block exactly as Claude Code does — not as a
@@ -111,8 +129,8 @@ export default function memoryExtension(pi: ExtensionAPI) {
 
 	pi.on("tool_call", (event, ctx) => {
 		if (event.toolName !== "write" || !dir) return undefined;
-		const path = inputPath(event.input, ctx.cwd);
-		if (!path?.startsWith(dir + sep)) return undefined;
+		const path = inputPath(event.input, ctx.cwd, dirReal);
+		if (!path) return undefined;
 		const input = event.input as { content?: unknown };
 		if (typeof input.content !== "string") return undefined;
 		input.content = stampFrontmatter(input.content, ctx.sessionManager.getSessionId(), new Date().toISOString());
@@ -122,7 +140,9 @@ export default function memoryExtension(pi: ExtensionAPI) {
 	pi.on("tool_result", (event, ctx) => {
 		if (event.isError || !dir) return undefined;
 		if (event.toolName !== "write" && event.toolName !== "edit") return undefined;
-		if (inputPath(event.input, ctx.cwd) !== join(dir, "MEMORY.md")) return undefined;
+		const path = inputPath(event.input, ctx.cwd, dirReal);
+		const indexPath = join(dir, "MEMORY.md");
+		if (!path || comparablePath(path) !== comparablePath(tryRealpath(indexPath) ?? indexPath)) return undefined;
 
 		let index: string;
 		try {
@@ -144,30 +164,69 @@ export default function memoryExtension(pi: ExtensionAPI) {
 
 	// ---- /memory: Claude Code's Memory picker --------------------------------
 	// Pick a memory-related file (or the auto-memory folder) and open it in the
-	// external editor, matching CC. Pure panel logic lives in ./panel.ts.
+	// external editor, matching CC. Pure panel logic lives in ./panel.ts. The
+	// returned text is the model's `<local-command-stdout>`, worded as CC's.
 	registerLocalCommand(pi, "memory", {
 		description: "View or edit CLAUDE.md and memory files",
-		handler: async (args, ctx) => {
+		reportsResult: true,
+		handler: async (_args, ctx): Promise<string | undefined> => {
 			const entries = memoryEntriesFor(ctx.cwd);
-			if (!ctx.hasUI) {
+			if (!canShowCustomUi(ctx)) {
+				const limitation = ctx.mode === "rpc" ? "/memory editing is unavailable in RPC; use the TUI or open a listed path in your editor.\n\n" : "";
 				const lines = entries.map(
 					(e, i) => `${i + 1}. ${e.title}${e.description ? ` — ${e.description}` : ""}  [${e.path}]`,
 				);
-				ctx.ui.notify(`Memory / CLAUDE.md files:\n${lines.join("\n")}`, "info");
-				return;
+				const stdout = `${limitation}Memory / CLAUDE.md files:\n${lines.join("\n")}`;
+				ctx.ui.notify(stdout, "info");
+				return ctx.mode === "rpc" ? limitation.trim() : undefined;
+			}
+			const mode: ModeView = { running: configMode(), saved: savedConfigMode(), fromEnv: configModeFromEnv() !== undefined };
+			const autoMemory: AutoMemoryView = {
+				running: autoMemoryEnabled(ctx.cwd),
+				saved: savedAutoMemory(ctx.cwd),
+				fromEnv: autoMemoryFromEnv() !== undefined,
+			};
+			const before = { mode: mode.saved, autoMemory: autoMemory.saved };
+			const chosen = await openMemoryPanel(pi.events, ctx, entries, mode, autoMemory);
+			// A toggle's line leads CC's result when it changed something.
+			const changes = settingChanges(before, mode, autoMemory);
+			const modeLine = changes ? `${changes}\n\n` : "";
+			if (!chosen) {
+				// Closing after a change reports the change, not a cancel.
+				ctx.ui.notify(changes || CANCELLED, "info");
+				return changes || CANCELLED;
 			}
-			const chosen = await openMemoryPanel(ctx, entries);
-			if (!chosen) return;
-			const result = await openPath(chosen.path, chosen.kind);
-			ctx.ui.notify(result.message, result.ok ? "info" : "error");
-			if (result.ok && result.hint) ctx.ui.notify(result.hint, "info");
+			const shown = memoryDisplayPath(chosen.path, ctx.cwd, os.homedir());
+			const result = await openPath(chosen.path, "file");
+			const stdout = result.ok ? `Opened ${shown}\n${editorHint()}` : `Couldn't open ${shown}: ${result.error}`;
+			ctx.ui.notify(stdout, result.ok ? "info" : "error");
+			return `${modeLine}${stdout}`;
 		},
 	});
 }
 
-/** Show the Memory panel as a focused overlay; resolve to the chosen entry or null. */
-function openMemoryPanel(ctx: ExtensionContext, entries: MemoryEntry[]): Promise<MemoryEntry | null> {
-	return ctx.ui.custom<MemoryEntry | null>((tui, theme, _keybindings, done) => {
+/** Claude Code's `/memory` result when the panel closes without a pick. */
+const CANCELLED = "Cancelled memory editing";
+
+/** Save one key to One Code's user settings; the running process keeps its value. */
+function saveUserSetting(key: string, value: unknown): void {
+	const path = oneCodeSettingsPath(os.homedir());
+	writeSettings(path, { ...readSettingsForWrite(path), [key]: value });
+}
+
+/**
+ * Show the Memory panel as a focused overlay; resolve to the chosen entry or
+ * null. The toggle rows save into `autoMemory.saved` and `mode.saved` (the
+ * config-sources row after a confirming second Enter) and keep the panel up.
+ */
+function openMemoryPanel(
+	events: ExtensionAPI["events"],
+	ctx: ExtensionContext,
+	entries: MemoryEntry[],
+	mode: ModeView,
+	autoMemory: AutoMemoryView,
+): Promise<MemoryEntry | null> {
+	return panelUi(events, ctx.ui).custom<MemoryEntry | null>((tui, theme, _keybindings, done) => {
 		const paint = { fg: safeThemePaint(theme), bold: safeThemeBold(theme) };
 		const state = initialMemoryState();
 		let cache: { width: number; lines: string[] } | undefined;
@@ -180,7 +239,7 @@ function openMemoryPanel(ctx: ExtensionContext, entries: MemoryEntry[]): Promise
 				if (cache?.width === width) return cache.lines;
 				const termRows = (tui as { terminal: { rows: number } }).terminal.rows;
 				const height = boundedDockHeight(termRows, MEMORY_PANEL_MAX_HEIGHT);
-				const lines = renderMemoryPanel({ state, entries, width, height }, paint).map((line) =>
+				const lines = renderMemoryPanel({ state, entries, width, height, mode, autoMemory }, paint).map((line) =>
 					truncateLine(line, width),
 				);
 				cache = { width, lines };
@@ -190,10 +249,57 @@ function openMemoryPanel(ctx: ExtensionContext, entries: MemoryEntry[]): Promise
 				const key = decodeMemoryKey(data);
 				if (!key) return;
 				const effect = applyMemoryKey(state, key, entries);
+				if (effect?.kind === "confirm-mode" && mode.fromEnv) {
+					// The variable outranks the saved setting, so a write here would never apply.
+					state.confirmingMode = false;
+					ctx.ui.notify("Config sources are set by ONECODE_CONFIG_MODE. Unset it to switch here.", "info");
+					repaint();
+					return;
+				}
+				if (effect?.kind === "toggle-auto-memory") {
+					if (autoMemory.fromEnv) {
+						ctx.ui.notify("Auto-memory is set by CLAUDE_CODE_DISABLE_AUTO_MEMORY. Unset it to switch here.", "info");
+						repaint();
+						return;
+					}
+					try {
+						const wanted = !autoMemory.saved;
+						saveUserSetting(AUTO_MEMORY_KEY, wanted);
+						// Re-read the ladder: a project or managed file can still outrank the user file.
+						const decided = savedAutoMemorySource(ctx.cwd);
+						autoMemory.saved = decided.enabled;
+						if (decided.enabled !== wanted && decided.path) {
+							ctx.ui.notify(`${tildify(decided.path, os.homedir())} sets ${AUTO_MEMORY_KEY}: ${decided.enabled}, which outranks your user setting. Change it there.`, "info");
+						}
+					} catch (error) {
+						ctx.ui.notify(`Couldn't save the auto-memory setting: ${error instanceof Error ? error.message : error}`, "error");
+					}
+					repaint();
+					return;
+				}
+				if (effect?.kind === "toggle-mode") {
+					const next: ConfigMode = mode.saved === "independent" ? "claude-compatible" : "independent";
+					try {
+						saveUserSetting(CONFIG_MODE_KEY, next);
+						mode.saved = next;
+					} catch (error) {
+						ctx.ui.notify(`Couldn't save the config sources setting: ${error instanceof Error ? error.message : error}`, "error");
+					}
+					repaint();
+					return;
+				}
 				if (effect?.kind === "close") {
 					done(null);
 					return;
 				}
+				if (effect?.kind === "open" && effect.entry.kind === "folder") {
+					// CC opens the folder and keeps the picker up; only a file or Esc ends it.
+					const { path } = effect.entry;
+					void openPath(path, "folder").then((result) => {
+						if (!result.ok) ctx.ui.notify(`Couldn't open ${memoryDisplayPath(path, ctx.cwd, os.homedir())}: ${result.error}`, "error");
+					});
+					return;
+				}
 				if (effect?.kind === "open") {
 					done(effect.entry);
 					return;

package/extensions/memory/open-external.ts

@@ -2,8 +2,8 @@
  * Open a memory file or folder in the user's editor / OS opener, matching Claude
  * Code's `/memory`: a file goes to `$VISUAL`/`$EDITOR` (or the OS default), a
  * folder to the OS file manager. The child is detached and unref'd so the TUI is
- * never blocked (as the MCP OAuth browser open does). Returns the status line and
- * the editor hint to print, matching CC's "Opened <path>" + the $EDITOR nudge.
+ * never blocked (as the MCP OAuth browser open does). The caller words the
+ * result (`memoryDisplayPath`, `editorHint`), matching CC's `/memory`.
  *
  * Limitation: a terminal editor (vim/nano) needs the controlling tty, which the
  * pi TUI owns, so it cannot run detached — this suits GUI editors (code, subl)
@@ -14,7 +14,10 @@
  */
 
 import { spawn } from "node:child_process";
+import { relative } from "node:path";
+import { childProcessEnv } from "../lib/app-launch.mjs";
 import { commandLaunch } from "../lib/command-launch.ts";
+import { forwardSlashes, isRelativeInside, tildify } from "../lib/paths.ts";
 
 export interface OpenPlan {
 	command: string;
@@ -52,14 +55,28 @@ export function resolveOpen(
 	return { command: "xdg-open", args: [path] };
 }
 
-export interface OpenResult {
-	message: string;
-	hint?: string;
-	ok: boolean;
+export type OpenResult = { ok: true } | { ok: false; error: string };
+
+/**
+ * CC's display path for `/memory`'s result: `~/…` under the home directory,
+ * `./…` under the working directory, the shorter when both apply, else as is.
+ */
+export function memoryDisplayPath(path: string, cwd: string, home: string): string {
+	const tilde = tildify(path, home);
+	const underHome = tilde !== path;
+	const rel = relative(cwd, path);
+	const dot = isRelativeInside(rel) ? `./${forwardSlashes(rel)}` : undefined;
+	if (underHome && dot) return tilde.length <= dot.length ? tilde : dot;
+	return underHome ? tilde : (dot ?? path);
 }
 
-/** The editor hint CC prints under an opened file. */
-export const EDITOR_HINT = "To use a different editor, set the $EDITOR or $VISUAL environment variable.";
+/** CC's editor hint under an opened file, naming the variable it used. */
+export function editorHint(env: Record<string, string | undefined> = process.env): string {
+	const used = env.VISUAL ? `Using $VISUAL="${env.VISUAL}".` : env.EDITOR ? `Using $EDITOR="${env.EDITOR}".` : "";
+	return used
+		? `> ${used} To change editor, set $EDITOR or $VISUAL environment variable.`
+		: "> To use a different editor, set the $EDITOR or $VISUAL environment variable.";
+}
 
 /**
  * Spawn the opener/editor detached, resolving once the child either spawns
@@ -80,21 +97,19 @@ export function openPath(path: string, kind: "file" | "folder"): Promise<OpenRes
 		let child: ReturnType<typeof spawn>;
 		try {
 			// `$EDITOR=code` is VS Code's `code.cmd` shim on Windows, which a bare spawn cannot start.
-			const launch = commandLaunch(command, args, process.env);
-			child = spawn(launch.command, launch.args, { stdio: "ignore", detached: true, windowsVerbatimArguments: launch.windowsVerbatimArguments });
+			// The user's own environment under the bundled app (lib/app-launch.mjs): an
+			// editor with a terminal must not hand the app's pi state to a `pi` run there.
+			const env = childProcessEnv(process.env);
+			const launch = commandLaunch(command, args, env);
+			child = spawn(launch.command, launch.args, { env, stdio: "ignore", detached: true, windowsVerbatimArguments: launch.windowsVerbatimArguments });
 		} catch (error) {
-			finish({ message: `Could not open ${path}: ${error instanceof Error ? error.message : error}`, ok: false });
+			finish({ ok: false, error: error instanceof Error ? error.message : String(error) });
 			return;
 		}
-		child.on("error", (error) => finish({ message: `Could not open ${path}: ${error.message}`, ok: false }));
+		child.on("error", (error) => finish({ ok: false, error: error.message }));
 		child.on("spawn", () => {
 			child.unref();
-			finish({
-				message: `Opened ${path}`,
-				// CC shows the hint on file opens (even when $EDITOR handled it); folders don't.
-				hint: kind === "file" ? EDITOR_HINT : undefined,
-				ok: true,
-			});
+			finish({ ok: true });
 		});
 	});
 }

package/extensions/memory/panel.ts

@@ -3,66 +3,114 @@
  * Memory picker: a titled list of the CLAUDE.md-family / AGENTS.md / ONECODE.md
  * files plus "Open auto-memory folder", with an Auto-memory status line and a
  * learn-more link. Enter opens the selected entry (in `$EDITOR`); Esc closes.
+ * Above the list, where CC keeps its toggle rows (↑ from the first file
+ * reaches them): CC's "Auto-memory" toggle (lib/auto-memory.ts), then One
+ * Code's "Config sources" row, which switches between the Claude-compatible
+ * and independent modes (lib/config-mode.ts) after a confirmation, since it
+ * changes every place configuration is read from.
  *
  * Kept free of pi imports so the layout and navigation are unit-tested; the
  * extension owns repaint, the overlay, and the actual open.
  */
 
 import type { MemoryEntry } from "./entries.ts";
+import { type ConfigMode, MODE_LABELS } from "../lib/config-mode.ts";
+import { keyId } from "../lib/key-input.ts";
+import { wrapHints, wrapProse } from "../lib/tui-render.ts";
 
 export const MEMORY_DOCS_URL = "https://github.com/IsuruMaduranga/one-code";
 
+/** Cursor rows above the list. */
+export const AUTO_MEMORY_ROW = -2;
+export const CONFIG_SOURCES_ROW = -1;
+
 export interface MemoryPanelState {
+	/** The selected entry's index; the two toggle rows above the list are negative. */
 	cursor: number;
+	/** Set while the config-sources switch waits for a second Enter. */
+	confirmingMode?: boolean;
 }
 
 export function initialMemoryState(): MemoryPanelState {
 	return { cursor: 0 };
 }
 
+/** A setting's value in this process, the value saved for the next start, and whether an env variable sets it. */
+export interface SettingView<T> {
+	running: T;
+	saved: T;
+	fromEnv?: boolean;
+}
+
+/** Auto-memory; `CLAUDE_CODE_DISABLE_AUTO_MEMORY` can set it. */
+export type AutoMemoryView = SettingView<boolean>;
+
+/** The config-sources mode; `ONECODE_CONFIG_MODE` can set it. */
+export type ModeView = SettingView<ConfigMode>;
+
+/** "; applies from the next start" while the saved value differs from the running one. */
+const pendingSuffix = (view: SettingView<unknown>): string => (view.saved === view.running ? "" : "; applies from the next start");
+
+const MODE_DESCRIPTIONS: Record<ConfigMode, string> = {
+	"claude-compatible": "~/.claude, CLAUDE.md, .agents and pi's dirs",
+	independent: "~/.onecode, ONECODE.md, .agents and pi's dirs",
+};
+
 export type MemoryKey = { kind: "up" | "down" | "enter" | "close" };
 
 export function decodeMemoryKey(data: string): MemoryKey | undefined {
-	switch (data) {
-		case "\x1b[A":
-		case "\x1bOA":
-		case "\x10": // ctrl+p
+	switch (keyId(data)) {
+		case "up":
+		case "ctrl+p":
 			return { kind: "up" };
-		case "\x1b[B":
-		case "\x1bOB":
-		case "\x0e": // ctrl+n
+		case "down":
+		case "ctrl+n":
 			return { kind: "down" };
-		case "\r":
-		case "\n":
+		case "enter":
 			return { kind: "enter" };
-		case "\x1b":
-		case "\x03": // ctrl+c
+		case "escape":
+		case "ctrl+c":
 			return { kind: "close" };
 		default:
 			return undefined;
 	}
 }
 
-export type MemoryEffect = { kind: "open"; entry: MemoryEntry } | { kind: "close" };
+export type MemoryEffect =
+	| { kind: "open"; entry: MemoryEntry }
+	| { kind: "confirm-mode" }
+	| { kind: "toggle-mode" }
+	| { kind: "toggle-auto-memory" }
+	| { kind: "close" };
 
-export function applyMemoryKey(
-	state: MemoryPanelState,
-	key: MemoryKey,
-	entries: readonly MemoryEntry[],
-): MemoryEffect | undefined {
+/**
+ * Enter on "Config sources" asks first (`confirm-mode`); a second Enter
+ * switches (`toggle-mode`), and Esc or a move keeps the mode and the panel.
+ * "Auto-memory" toggles at once, as in Claude Code.
+ */
+export function applyMemoryKey(state: MemoryPanelState, key: MemoryKey, entries: readonly MemoryEntry[]): MemoryEffect | undefined {
+	const confirming = state.confirmingMode === true;
+	state.confirmingMode = false;
 	switch (key.kind) {
 		case "up":
-			state.cursor = Math.max(0, state.cursor - 1);
+			state.cursor = Math.max(AUTO_MEMORY_ROW, state.cursor - 1);
 			return undefined;
 		case "down":
 			state.cursor = Math.min(entries.length - 1, state.cursor + 1);
 			return undefined;
 		case "enter": {
+			if (state.cursor === AUTO_MEMORY_ROW) return { kind: "toggle-auto-memory" };
+			if (state.cursor === CONFIG_SOURCES_ROW) {
+				if (confirming) return { kind: "toggle-mode" };
+				state.confirmingMode = true;
+				return { kind: "confirm-mode" };
+			}
 			const entry = entries[state.cursor];
 			return entry ? { kind: "open", entry } : undefined;
 		}
 		case "close":
-			return { kind: "close" };
+			// Esc on the confirmation keeps the mode and the panel.
+			return confirming ? undefined : { kind: "close" };
 	}
 }
 
@@ -80,21 +128,36 @@ const DESC_COL = 34;
  * the cursor stays visible.
  */
 export function renderMemoryPanel(
-	input: { state: MemoryPanelState; entries: readonly MemoryEntry[]; width: number; height: number },
+	input: {
+		state: MemoryPanelState;
+		entries: readonly MemoryEntry[];
+		width: number;
+		height: number;
+		mode: ModeView;
+		autoMemory?: AutoMemoryView;
+	},
 	paint: PanelPaint,
 ): string[] {
-	const { state, entries, height } = input;
+	const { state, entries, height, mode, width } = input;
+	const autoMemory = input.autoMemory ?? { running: true, saved: true };
 
-	const header = [paint.bold("Memory"), "", `  ${paint.fg("muted", "Auto-memory: on")}`, ""];
-	const footer = [
+	const header = [
+		paint.bold("Memory"),
 		"",
-		paint.fg("muted", `Learn more: ${MEMORY_DOCS_URL}`),
+		renderAutoMemoryRow(autoMemory, state.cursor === AUTO_MEMORY_ROW, paint),
+		renderModeRow(mode, state.cursor === CONFIG_SOURCES_ROW, paint),
 		"",
-		paint.fg("muted", "Enter to open · Esc to close"),
 	];
+	const hints = state.confirmingMode
+		? [
+				...wrapProse(modeConfirmQuestion(mode), Math.max(20, width)).map((line) => paint.fg("warning", line)),
+				...wrapHints(`Enter to switch · Esc to keep ${MODE_LABELS[mode.saved]}`, width).map((line) => paint.fg("muted", line)),
+			]
+		: wrapHints("Enter to open or toggle · ↑ for auto-memory and config sources · Esc to close", width).map((line) => paint.fg("muted", line));
+	const footer = ["", paint.fg("muted", `Learn more: ${MEMORY_DOCS_URL}`), "", ...hints];
 
 	const listCapacity = Math.max(1, height - header.length - footer.length);
-	const start = scrollStart(state.cursor, entries.length, listCapacity);
+	const start = scrollStart(Math.max(0, state.cursor), entries.length, listCapacity);
 	const rows: string[] = [];
 	for (let i = start; i < Math.min(entries.length, start + listCapacity); i++) {
 		rows.push(renderRow(entries[i], i, i === state.cursor, paint));
@@ -103,6 +166,52 @@ export function renderMemoryPanel(
 	return [...header, ...rows, ...footer];
 }
 
+/**
+ * One line per toggle the panel changed (the result `/memory` reports), empty
+ * when nothing changed.
+ */
+export function settingChanges(before: { mode: ConfigMode; autoMemory: boolean }, mode: ModeView, autoMemory: AutoMemoryView): string {
+	const lines: string[] = [];
+	if (autoMemory.saved !== before.autoMemory) {
+		lines.push(`Turned auto-memory ${autoMemory.saved ? "on" : "off"}${pendingSuffix(autoMemory)}`);
+	}
+	if (mode.saved !== before.mode) {
+		lines.push(`Set config sources to ${MODE_LABELS[mode.saved]}${pendingSuffix(mode)}`);
+	}
+	return lines.join("\n");
+}
+
+/** The question the config-sources confirmation asks. */
+export function modeConfirmQuestion(mode: ModeView): string {
+	const next: ConfigMode = mode.saved === "independent" ? "claude-compatible" : "independent";
+	return `Switch config sources to ${MODE_LABELS[next]}? One Code will read ${MODE_DESCRIPTIONS[next]} instead, from the next start.`;
+}
+
+/**
+ * A toggle row's plain text, "<label>: <saved>", with "(from next start)" while
+ * the saved value differs from the running one; when `envName` sets it, the
+ * running value and that it is set there. Also returns the value shown.
+ */
+function settingRow<T>(label: string, view: SettingView<T>, valueText: (value: T) => string, envName: string, selected: boolean): { left: string; shown: T } {
+	const shown = view.fromEnv ? view.running : view.saved;
+	const note = view.fromEnv ? ` (set by ${envName})` : view.saved !== view.running ? " (from next start)" : "";
+	return { left: `${selected ? "❯ " : "  "}${label}: ${valueText(shown)}${note}`, shown };
+}
+
+/** "Auto-memory: on|off". */
+function renderAutoMemoryRow(view: AutoMemoryView, selected: boolean, paint: PanelPaint): string {
+	const { left } = settingRow("Auto-memory", view, (on) => (on ? "on" : "off"), "CLAUDE_CODE_DISABLE_AUTO_MEMORY", selected);
+	return selected ? paint.fg("accent", left) : left;
+}
+
+/** "Config sources: <mode>" and the mode's description. */
+function renderModeRow(mode: ModeView, selected: boolean, paint: PanelPaint): string {
+	const { left, shown } = settingRow("Config sources", mode, (value) => MODE_LABELS[value], "ONECODE_CONFIG_MODE", selected);
+	const pad = " ".repeat(Math.max(2, DESC_COL + 12 - left.length));
+	const description = MODE_DESCRIPTIONS[shown];
+	return selected ? `${paint.fg("accent", left)}${pad}${paint.fg("accent", description)}` : `${left}${pad}${paint.fg("muted", description)}`;
+}
+
 /** First index to show so `cursor` is within a `capacity`-tall window. */
 function scrollStart(cursor: number, total: number, capacity: number): number {
 	if (total <= capacity) return 0;

package/extensions/newer-model/index.ts

@@ -0,0 +1,31 @@
+/** User-only model-upgrade advice. No reminders, transcript entries, or request hooks. */
+import { homedir } from "node:os";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { modelSpec } from "../lib/model-policy.ts";
+import { MODEL_UNUSABLE_CHANNEL, type ModelUnusableEvent, withoutUnusable } from "../lib/model-unusable.ts";
+import { newerModelSuggestion } from "../lib/newer-model.ts";
+import { queueNotice } from "../lib/notices.ts";
+import { sessionOutlivesTurn } from "../lib/notifications.ts";
+import { readSuggestNewerModels } from "../lib/one-code-settings.ts";
+
+export default function newerModelExtension(pi: ExtensionAPI) {
+	const shown = new Set<string>();
+	const unusable = new Set<string>();
+	pi.events.on(MODEL_UNUSABLE_CHANNEL, (data) => unusable.add((data as ModelUnusableEvent).model));
+
+	const suggest = (ctx: ExtensionContext, model = ctx.model) => {
+		if (!sessionOutlivesTurn(ctx.mode) || !ctx.hasUI || !model || !readSuggestNewerModels(homedir())) return;
+		const key = JSON.stringify([ctx.sessionManager.getSessionId(), modelSpec(model)]);
+		if (shown.has(key)) return;
+		const suggestion = newerModelSuggestion(withoutUnusable(ctx.modelRegistry.getAvailable(), unusable), model);
+		if (!suggestion) return;
+		// Joined with the other extensions' startup and model-switch notices (lib/notices.ts).
+		queueNotice(pi.events, ctx, "info", `${suggestion.text} ${suggestion.fix}`);
+		shown.add(key);
+	};
+
+	// Local catalog/cache reads only. Never await a network refresh at startup.
+	// Session ids also handle RPC's duplicate session_start for a new session.
+	pi.on("session_start", (_event, ctx) => suggest(ctx));
+	pi.on("model_select", (event, ctx) => suggest(ctx, event.model));
+}

package/extensions/notebook/description.ts

@@ -0,0 +1,18 @@
+/**
+ * notebook_edit's model-facing description: Claude Code's NotebookEdit text
+ * with One Code's extras (pure).
+ *
+ * Claude Code addresses a cell by the id its Read tool prints; pi's read
+ * returns the notebook's JSON, so a cell is named by its own `id` or by its
+ * position (`cell-0`). The path may be relative and is `path` or
+ * `notebook_path`; `append` and the cleared outputs are One Code's.
+ */
+
+export const NOTEBOOK_EDIT_DESCRIPTION = `Replaces, inserts, or deletes a single cell in a Jupyter notebook (.ipynb file).
+
+Usage:
+- You must use the read tool on the notebook in this conversation before editing — this tool will fail otherwise.
+- \`path\` (or \`notebook_path\`) is the notebook, absolute or relative to the working directory.
+- \`cell_id\` is the cell's own \`id\` or, for a notebook whose cells have none, its position: \`cell-0\` is the first cell. It is required for \`replace\` and \`delete\`.
+- \`edit_mode\` defaults to \`replace\`. Use \`insert\` to add a new cell after the cell with the given \`cell_id\` (or at the beginning of the notebook if \`cell_id\` is omitted) — \`cell_type\` is required when inserting. Use \`delete\` to remove the cell. Use \`append\` to add a cell at the end without naming one.
+- Editing a code cell clears its outputs.`;