@gavin-hu/my-pi-agent 0.13.1 → 0.14.0

package/extensions/bytefly/panel/settings.ts

@@ -6,44 +6,56 @@
  * views, cycling, validation, and grouping — so the screen and the runtime share
  * one definition and the tests need no host.
  *
- * The catalogue covers every scalar preference: booleans, enums, short strings,
- * and — with `doctor.timeoutMs` — a number. Each row states its own rule, so a
- * value the screen accepts is a value the loader keeps. Arrays (`doctor.skip`),
- * the `rates` table, and `price.peak` stay JSON edits: a list, a table, and a
- * nested object are not one row.
+ * The catalogue is curated rather than exhaustive: it holds the preferences a
+ * person changes, across every extension of the package, and each row states its
+ * own rule so a value the screen accepts is a value the loader keeps. The rest of
+ * the document stays JSON, reachable from the screen's JSON pane: a list
+ * (`doctor.skip`), a table (`price.rates`), and a schedule (`price.peak`) are not
+ * one row.
+ *
+ * Four sections have a normalizer here, so the screen shows what the footer, the
+ * notifier, and the doctor keep. The six owned by other extensions are read as the
+ * file states them, because importing their normalizer would be one extension
+ * importing another's module; each such row declares the loader's default, and
+ * `test/settings-coverage.test.ts` holds the pair together.
  */
 
 import { configSection, configValueAt } from "../../../lib/config.ts";
-import { GLYPHS } from "../../../lib/tui/glyphs.ts";
 import { DEFAULT_CHROME_CONFIG, isRailGlyph, normalizeChromeConfig } from "../chrome.ts";
-import { DEFAULT_CONFIG as DEFAULT_DOCTOR_CONFIG, normalizeConfig as normalizeDoctorConfig } from "../doctor/config.ts";
+import {
+	DEFAULT_CONFIG as DEFAULT_DOCTOR_CONFIG,
+	normalizeConfig as normalizeDoctorConfig,
+	TIMEOUT_MS_RANGE,
+} from "../doctor/config.ts";
 import {
 	CURRENCY_DEFAULTS,
 	DEFAULT_BYTEFLY_CONFIG,
 	DEFAULT_CURRENCY,
+	MAX_BUDGET,
+	MAX_DECIMALS,
 	normalizeByteflyConfig,
 } from "../footer/price/config.ts";
 import type { CurrencyCode } from "../footer/price/types.ts";
-import { DEFAULT_NOTIFY_CONFIG, normalizeNotifyConfig } from "../notify/config.ts";
+import { DEFAULT_NOTIFY_CONFIG, MAX_TITLE_LENGTH, normalizeNotifyConfig } from "../notify/config.ts";
 import type { Settings, WriteScope } from "../picker/types.ts";
 
 /** Where a preference is stored. */
-export type SettingSource = "app" | "bytefly";
+type SettingSource = "app" | "bytefly";
 
 /** The row control a preference uses. */
-export type SettingKind = "boolean" | "enum" | "text";
+type SettingKind = "boolean" | "enum" | "text";
 
 /** Where the effective value came from. */
-export type SettingOrigin = "default" | "global" | "project" | "inherited";
+type SettingOrigin = "default" | "global" | "project" | "inherited";
 
 /** One curated value a row can take. */
-export interface SettingOption {
+interface SettingOption {
 	value: string;
 	label: string;
 }
 
 /** What a text row accepts, checked before a write so the file cannot hold less. */
-export interface TextRule {
+interface TextRule {
 	/** Longest accepted value, in the units the loader slices with. */
 	maxLength: number;
 	/** Why `raw` cannot be stored, or `undefined` when it can. */
@@ -51,22 +63,32 @@ export interface TextRule {
 }
 
 /** One heading in the Settings list. */
-export interface SettingGroup {
+interface SettingGroup {
 	key: string;
 	label: string;
 }
 
 /** The `bytefly.json` sections the Settings section can read and write. */
-export type ConfigSectionName = "notify" | "chrome" | "doctor" | "price";
+export type ConfigSectionName =
+	| "notify"
+	| "chrome"
+	| "doctor"
+	| "price"
+	| "worktree"
+	| "rewind"
+	| "job"
+	| "watch"
+	| "memory"
+	| "goal";
 
 /** Where a `bytefly.json` row lives: a section, and the path to its leaf. */
-export interface SettingConfig {
+interface SettingConfig {
 	section: ConfigSectionName;
 	path: readonly string[];
 }
 
 /** One `bytefly.json` leaf a row writes alongside its own. */
-export interface SettingLeaf {
+interface SettingLeaf {
 	section: ConfigSectionName;
 	path: readonly string[];
 	value: unknown;
@@ -116,7 +138,7 @@ export interface SettingsSnapshot {
 }
 
 /** One rendered group: its heading and the rows under it. */
-export interface GroupedSettings {
+interface GroupedSettings {
 	key: string;
 	label: string;
 	views: SettingView[];
@@ -130,6 +152,10 @@ export const SETTING_GROUPS: readonly SettingGroup[] = [
 	{ key: "pricing", label: "Pricing" },
 	{ key: "transcript", label: "Transcript" },
 	{ key: "terminal", label: "Terminal" },
+	{ key: "worktree", label: "Worktree" },
+	{ key: "snapshots", label: "Snapshots" },
+	{ key: "jobs", label: "Jobs and watchers" },
+	{ key: "memory", label: "Memory" },
 ];
 
 const ON_OFF: readonly SettingOption[] = [
@@ -147,8 +173,8 @@ const METHOD_OPTIONS: readonly SettingOption[] = [
 	{ value: "notify-send", label: "Linux" },
 ];
 
-/** Cost precision 0-4, the range the `price` section clamps `decimals` to. */
-const DECIMALS_OPTIONS: readonly SettingOption[] = [0, 1, 2, 3, 4].map((value) => ({
+/** Cost precision 0 through the loader's ceiling, the range `price` clamps `decimals` to. */
+const DECIMALS_OPTIONS: readonly SettingOption[] = Array.from({ length: MAX_DECIMALS + 1 }, (_, value) => ({
 	value: String(value),
 	label: String(value),
 }));
@@ -292,7 +318,7 @@ export const SETTING_ROWS: readonly SettingDescriptor[] = [
 		fallback: "Pi",
 		options: [],
 		text: {
-			maxLength: 40,
+			maxLength: MAX_TITLE_LENGTH,
 			validate: (raw) => (raw.trim() === "" ? "A title is required." : undefined),
 		},
 		config: { section: "notify", path: ["title"] },
@@ -313,13 +339,13 @@ export const SETTING_ROWS: readonly SettingDescriptor[] = [
 		id: "doctor.timeoutMs",
 		group: "diagnostics",
 		label: "Probe timeout",
-		description: "How long one doctor probe may take, in milliseconds; 100 to 30000.",
+		description: `How long one doctor probe may take, in milliseconds; ${TIMEOUT_MS_RANGE.min} to ${TIMEOUT_MS_RANGE.max}.`,
 		source: "bytefly",
 		kind: "text",
 		fallback: String(DEFAULT_DOCTOR_CONFIG.timeoutMs),
 		json: "number",
 		options: [],
-		text: integerRule(100, 30_000),
+		text: integerRule(TIMEOUT_MS_RANGE.min, TIMEOUT_MS_RANGE.max),
 		config: { section: "doctor", path: ["timeoutMs"] },
 	},
 	{
@@ -367,7 +393,7 @@ export const SETTING_ROWS: readonly SettingDescriptor[] = [
 		fallback: "0",
 		json: "number",
 		options: [],
-		text: amountRule(0, 10_000_000),
+		text: amountRule(0, MAX_BUDGET),
 		config: { section: "price", path: ["budget"] },
 	},
 	{
@@ -377,11 +403,25 @@ export const SETTING_ROWS: readonly SettingDescriptor[] = [
 		description: "The single-column glyph that leads a tool result or notice body, e.g. ╎ │ ┃ ▏.",
 		source: "bytefly",
 		kind: "text",
-		fallback: GLYPHS.divider,
+		fallback: DEFAULT_CHROME_CONFIG.rail,
 		options: [],
 		text: RAIL_RULE,
 		config: { section: "chrome", path: ["rail"] },
 	},
+	{
+		id: "goal.achieved",
+		group: "transcript",
+		label: "Achieved goal",
+		description: "How a completed goal renders: the dimmed rail line, or nothing.",
+		source: "bytefly",
+		kind: "enum",
+		fallback: "hide",
+		options: [
+			{ value: "show", label: "Show" },
+			{ value: "hide", label: "Hide" },
+		],
+		config: { section: "goal", path: ["achieved"] },
+	},
 	{
 		id: "outputPad",
 		group: "transcript",
@@ -407,6 +447,147 @@ export const SETTING_ROWS: readonly SettingDescriptor[] = [
 		json: "boolean",
 		options: ON_OFF,
 	},
+	{
+		id: "worktree.baseRef",
+		group: "worktree",
+		label: "Base ref",
+		description: "Where a new worktree branches from: the remote default branch, or the current local HEAD.",
+		source: "bytefly",
+		kind: "enum",
+		fallback: "fresh",
+		options: [
+			{ value: "fresh", label: "Fresh" },
+			{ value: "head", label: "Head" },
+		],
+		config: { section: "worktree", path: ["baseRef"] },
+	},
+	{
+		id: "worktree.branchPrefix",
+		group: "worktree",
+		label: "Branch prefix",
+		description: "Prepended to every branch a managed worktree creates.",
+		source: "bytefly",
+		kind: "text",
+		fallback: "worktree-",
+		options: [],
+		text: {
+			// The loader trims and rejects an empty prefix but sets no ceiling; this
+			// only stops a runaway buffer.
+			maxLength: 80,
+			validate: (raw) => (raw.trim() === "" ? "A prefix is required." : undefined),
+		},
+		config: { section: "worktree", path: ["branchPrefix"] },
+	},
+	{
+		id: "worktree.fetchRemote",
+		group: "worktree",
+		label: "Fetch remote",
+		description: "Fetch the remote before branching, so a new worktree starts from its latest commit.",
+		source: "bytefly",
+		kind: "boolean",
+		fallback: "true",
+		json: "boolean",
+		options: ON_OFF,
+		config: { section: "worktree", path: ["fetchRemote"] },
+	},
+	{
+		id: "worktree.pruneAfterDays",
+		group: "worktree",
+		label: "Prune after (days)",
+		description: "Age at which `/worktree prune` removes a clean worktree nobody is using.",
+		source: "bytefly",
+		kind: "text",
+		fallback: "7",
+		json: "number",
+		options: [],
+		text: integerRule(0, 3650),
+		config: { section: "worktree", path: ["pruneAfterDays"] },
+	},
+	{
+		id: "rewind.autoSnapshots",
+		group: "snapshots",
+		label: "Automatic snapshots",
+		description: "Take one rewind snapshot per prompt, before the first mutating tool call.",
+		source: "bytefly",
+		kind: "boolean",
+		fallback: "true",
+		json: "boolean",
+		options: ON_OFF,
+		config: { section: "rewind", path: ["autoSnapshots"] },
+	},
+	{
+		id: "rewind.max",
+		group: "snapshots",
+		label: "Snapshots kept",
+		description: "Snapshots kept per repository before the oldest are pruned; 0 keeps none.",
+		source: "bytefly",
+		kind: "text",
+		fallback: "20",
+		json: "number",
+		options: [],
+		text: integerRule(0, 1000),
+		config: { section: "rewind", path: ["max"] },
+	},
+	{
+		id: "rewind.safetySnapshot",
+		group: "snapshots",
+		label: "Safety snapshot",
+		description: "Snapshot the current state before a restore, so a rewind can itself be undone.",
+		source: "bytefly",
+		kind: "boolean",
+		fallback: "true",
+		json: "boolean",
+		options: ON_OFF,
+		config: { section: "rewind", path: ["safetySnapshot"] },
+	},
+	{
+		id: "job.wakeOnFinish",
+		group: "jobs",
+		label: "Wake when a job finishes",
+		description: "Start one agent turn when any background job finishes.",
+		source: "bytefly",
+		kind: "boolean",
+		fallback: "false",
+		json: "boolean",
+		options: ON_OFF,
+		config: { section: "job", path: ["wakeOnFinish"] },
+	},
+	{
+		id: "job.detachedByDefault",
+		group: "jobs",
+		label: "Keep jobs after exit",
+		description: "Leave jobs running when the session ends, unless the job opts out.",
+		source: "bytefly",
+		kind: "boolean",
+		fallback: "false",
+		json: "boolean",
+		options: ON_OFF,
+		config: { section: "job", path: ["detachedByDefault"] },
+	},
+	{
+		id: "watch.wakeOnMatch",
+		group: "jobs",
+		label: "Wake on a match",
+		description: "Start one agent turn when a watcher matches while the agent is idle.",
+		source: "bytefly",
+		kind: "boolean",
+		fallback: "false",
+		json: "boolean",
+		options: ON_OFF,
+		config: { section: "watch", path: ["wakeOnMatch"] },
+	},
+	{
+		id: "memory.inject",
+		group: "memory",
+		label: "Inject notes",
+		description: "Put stored memory notes in context before each run.",
+		source: "bytefly",
+		kind: "boolean",
+		fallback: "true",
+		json: "boolean",
+		options: ON_OFF,
+		config: { section: "memory", path: ["inject"] },
+	},
 ];
 
 /** The rows a scope can write: app rows are personal-file only. */
@@ -414,21 +595,13 @@ export function rowsForScope(scope: WriteScope): readonly SettingDescriptor[] {
 	return scope === "global" ? SETTING_ROWS : SETTING_ROWS.filter((row) => row.source === "bytefly");
 }
 
-/** The number of rows the section shows for `scope`. */
-export function countSettings(scope: WriteScope): number {
-	return rowsForScope(scope).length;
-}
-
-/** Whether `raw` is one of a row's curated options. */
-export function validValue(row: SettingDescriptor, raw: string): boolean {
-	return row.options.some((option) => option.value === raw);
-}
-
 /**
  * Why a text row cannot store `raw`, or `undefined` when it can.
  *
- * The limits mirror the loaders (`notify.title` is sliced to 40, the currency
- * symbol to 4) so the editor cannot save a value the next read shortens.
+ * The limits are the loaders' own (`notify.title` is sliced to `MAX_TITLE_LENGTH`,
+ * the rail to one column) so the editor cannot save a value the next read shortens.
+ * A row that is not text is refused here rather than in the caller, so a programmatic
+ * `setValue` gets the same reason the screen would show.
  */
 export function textError(row: SettingDescriptor, raw: string): string | undefined {
 	const rule = row.text;
@@ -449,16 +622,16 @@ function appValue(snapshot: SettingsSnapshot, row: SettingDescriptor): { value:
 	switch (row.id) {
 		case "byteflyUi": {
 			const quiet = snapshot.app.quietStartup;
-			return { value: quiet === true ? "true" : "false", origin: quiet === undefined ? "default" : "global" };
+			return { value: quiet === true ? "true" : row.fallback, origin: quiet === undefined ? "default" : "global" };
 		}
 		case "outputPad":
 			return {
-				value: snapshot.app.outputPad === 0 ? "0" : "1",
+				value: snapshot.app.outputPad === 0 ? "0" : row.fallback,
 				origin: snapshot.app.outputPad === undefined ? "default" : "global",
 			};
 		case "showHardwareCursor":
 			return {
-				value: snapshot.app.showHardwareCursor === true ? "true" : "false",
+				value: snapshot.app.showHardwareCursor === true ? "true" : row.fallback,
 				origin: snapshot.app.showHardwareCursor === undefined ? "default" : "global",
 			};
 		default:
@@ -484,7 +657,11 @@ type SectionReader = (
 	path: readonly string[],
 ) => unknown;
 
-const SECTION_READERS: Record<ConfigSectionName, SectionReader> = {
+/**
+ * The four sections bytefly owns, each read through its own normalizer so the
+ * screen shows the value the loader keeps.
+ */
+const SECTION_READERS: Partial<Record<ConfigSectionName, SectionReader>> = {
 	notify: (globalRaw, projectRaw, path) =>
 		configValueAt(normalizeNotifyConfig(projectRaw, normalizeNotifyConfig(globalRaw, DEFAULT_NOTIFY_CONFIG)), path),
 	chrome: (globalRaw, projectRaw, path) =>
@@ -495,7 +672,22 @@ const SECTION_READERS: Record<ConfigSectionName, SectionReader> = {
 		configValueAt(normalizeByteflyConfig(projectRaw, normalizeByteflyConfig(globalRaw, DEFAULT_BYTEFLY_CONFIG)), path),
 };
 
-/** Read a `bytefly.json` preference, normalized over the global section. */
+/**
+ * Read a leaf whose owning extension owns the normalizer.
+ *
+ * A section without a reader here belongs to another extension, and importing its
+ * normalizer would be one extension importing another's module. So the row states
+ * the loader's default in `fallback`, `test/settings-coverage.test.ts` holds the
+ * two together, and the visible cost is that a hand-edited value outside the
+ * loader's clamp shows as written until it is reset.
+ */
+function rawLeaf(snapshot: SettingsSnapshot, config: SettingConfig, scope: WriteScope): unknown {
+	const projectLeaf =
+		scope === "project" ? configValueAt(configSection(snapshot.project, config.section), config.path) : undefined;
+	return projectLeaf ?? configValueAt(configSection(snapshot.global, config.section), config.path);
+}
+
+/** Read a `bytefly.json` preference: normalized where bytefly owns the section. */
 function byteflyValue(
 	snapshot: SettingsSnapshot,
 	row: SettingDescriptor,
@@ -505,8 +697,12 @@ function byteflyValue(
 	if (!config) throw new Error(`Setting ${row.id} has no config section`);
 	const globalRaw = configSection(snapshot.global, config.section);
 	const projectRaw = scope === "project" ? configSection(snapshot.project, config.section) : undefined;
-	const leaf = SECTION_READERS[config.section](globalRaw, projectRaw, config.path);
+	const reader = SECTION_READERS[config.section];
+	const leaf = reader ? reader(globalRaw, projectRaw, config.path) : rawLeaf(snapshot, config, scope);
 	return {
+		// A normalizer is total, so its fallback only covers a future row whose
+		// normalizer has no default yet; a raw read needs it when neither document
+		// states the key.
 		value: leaf === undefined ? row.fallback : String(leaf),
 		origin: originFor(config, snapshot, scope),
 	};

package/extensions/bytefly/panel/tui/settings-view.ts

@@ -57,7 +57,7 @@ export function projectNote(theme: Theme, width: number): string {
 }
 
 /** Where the focused row's value is written, and which scope supplied it. */
-export function originLine(view: SettingView, paths: { scope: WriteScope; cwd: string; agentDir: string }): string {
+function originLine(view: SettingView, paths: { scope: WriteScope; cwd: string; agentDir: string }): string {
 	const path =
 		view.source === "app" ? join(paths.agentDir, PI_SETTINGS_FILE) : configPath(paths.scope, paths.cwd, paths.agentDir);
 	const file = sanitizeLine(path);
@@ -105,8 +105,54 @@ export function settingDetail(options: {
 }
 
 /** The section's key hints, in the order they drop as the width runs out. */
-export function settingsHints(): string[] {
-	return ["Esc close", "←/→", "Space change", "Tab scope", "↑/↓ select"];
+export function settingsHints(json = false): string[] {
+	return [
+		"Esc close",
+		"←/→",
+		"Space change",
+		"Tab scope",
+		"u reset",
+		json ? "J hide" : "J JSON",
+		"[ ] group",
+		"↑/↓ select",
+	];
+}
+
+/**
+ * The focused row's section as the active scope stores it.
+ *
+ * This is the only view of the keys the catalogue leaves to JSON, so it names the
+ * section and its file rather than pretending to be complete: the pane is clipped
+ * to the detail budget and says how many lines it left out. `section` is the row's
+ * `bytefly.json` section, which the caller has already established.
+ */
+export function sectionJsonPane(options: {
+	theme: Theme;
+	width: number;
+	section: string;
+	view: SettingView;
+	document: unknown;
+	budget: number;
+	paths: { scope: WriteScope; cwd: string; agentDir: string };
+}): string[] {
+	const { theme, width, section, view, document, budget, paths } = options;
+	const source = paint(theme, "faint", originLine(view, paths));
+	const head = `${paint(theme, "meta", sanitizeLine(section))} ${paint(theme, "faint", "—")} ${source}`;
+	const lines = [clip(`${INDENT}${head}`, width)];
+	const room = Math.max(0, budget - lines.length);
+	const body = document === undefined ? [] : JSON.stringify(document, null, 2).split("\n");
+
+	if (body.length === 0) {
+		if (room > 0) lines.push(clip(`${INDENT}${paint(theme, "faint", "Not set in this scope.")}`, width));
+		return lines;
+	}
+
+	const shown = body.slice(0, room);
+	if (body.length > room && shown.length > 0) {
+		shown[shown.length - 1] = `… ${body.length - room} more lines`;
+	}
+	for (const line of shown) lines.push(clip(`${INDENT}${paint(theme, "faint", sanitizeLine(line))}`, width));
+	return lines;
 }
 
 /** The editor's key hints: `Esc` cancels the edit, it does not close the screen. */

package/extensions/bytefly/panel/tui.ts

@@ -43,6 +43,7 @@ import {
 import {
 	editHints,
 	projectNote,
+	sectionJsonPane,
 	settingDetail,
 	settingRow,
 	settingsHints,
@@ -103,6 +104,8 @@ export class PanelComponent implements Component {
 	private notice: string | undefined;
 	/** The text row being edited: its id, the buffer, and the caret offset. */
 	private editing: { id: string; buffer: string; caret: number } | undefined;
+	/** True while the Settings detail pane shows the focused row's section as JSON. */
+	private json = false;
 	/** The visible section. */
 	private section: PanelSection;
 
@@ -182,6 +185,8 @@ export class PanelComponent implements Component {
 			);
 			return;
 		}
+		// The JSON pane names a file, so a scope switch has to close it.
+		this.json = false;
 		this.options.runtime.setScope(next);
 		this.options.requestRender();
 	}
@@ -234,6 +239,29 @@ export class PanelComponent implements Component {
 			.then(() => this.options.requestRender());
 	}
 
+	/** Delete the focused setting's leaf, so its default applies again. */
+	private resetSetting(): void {
+		const entry = this.activeEntries()[this.cursor.selected];
+		if (entry?.kind !== "setting") return;
+		const scope = this.options.runtime.scope();
+		this.chain = this.chain
+			.then(() => this.options.settings.reset(scope, entry.setting.id))
+			.catch((error: unknown) => this.notify(error instanceof Error ? error.message : String(error)))
+			.then(() => this.options.requestRender());
+	}
+
+	/** Toggle the detail pane between the row and its whole section as stored. */
+	private toggleJson(): void {
+		const entry = this.activeEntries()[this.cursor.selected];
+		if (entry?.kind !== "setting") return;
+		if (!entry.setting.config) {
+			this.notify(`${entry.setting.label} is a Pi setting; bytefly.json has no section for it.`);
+			return;
+		}
+		this.json = !this.json;
+		this.options.requestRender();
+	}
+
 	/** Store the editor's buffer; a refusal keeps it open with the reason shown. */
 	private commitEdit(): void {
 		const editing = this.editing;
@@ -348,6 +376,7 @@ export class PanelComponent implements Component {
 	private switchSection(next: PanelSection): void {
 		if (next === this.section) return;
 		this.section = next;
+		this.json = false;
 		this.prime();
 		this.options.requestRender();
 	}
@@ -362,6 +391,14 @@ export class PanelComponent implements Component {
 			this.select(lastRow(this.activeEntries()));
 			return;
 		}
+		if (data === "[") {
+			this.jumpGroup(-1);
+			return;
+		}
+		if (data === "]") {
+			this.jumpGroup(1);
+			return;
+		}
 		switch (navIntent(data)) {
 			case "up":
 				this.move(-1);
@@ -384,6 +421,26 @@ export class PanelComponent implements Component {
 		}
 	}
 
+	/** Move to the first row of the next (or previous) group. */
+	private jumpGroup(direction: -1 | 1): void {
+		const entries = this.activeEntries();
+		const headers = entries.flatMap((entry, index) => (entry.kind === "group" ? [index] : []));
+		const selected = this.cursor.selected;
+		// Step past the focused row's own header: landing on it would not move.
+		const own = headers.filter((index) => index < selected).at(-1);
+		const target =
+			direction === 1
+				? headers.find((index) => index > selected)
+				: headers.filter((index) => index < (own ?? 0)).at(-1);
+		if (target === undefined) return;
+		for (let index = target + 1; index < entries.length; index += 1) {
+			if (isSelectable(entries[index])) {
+				this.select(index);
+				return;
+			}
+		}
+	}
+
 	/** Settings keys: change, scope, navigation. `←`/`→` stay on sections. */
 	private handleSettingsInput(data: string): void {
 		this.clampSelection(this.activeEntries());
@@ -395,6 +452,14 @@ export class PanelComponent implements Component {
 			this.switchScope();
 			return;
 		}
+		if (data === "u") {
+			this.resetSetting();
+			return;
+		}
+		if (data === "J") {
+			this.toggleJson();
+			return;
+		}
 		this.navigate(data);
 	}
 
@@ -483,7 +548,7 @@ export class PanelComponent implements Component {
 		if (this.editing) return hintLine(this.theme, width, editHints());
 		const hints =
 			this.section === "settings"
-				? settingsHints()
+				? settingsHints(this.json)
 				: extensionHints({
 						expanded,
 						refreshing: this.refreshing,
@@ -527,33 +592,36 @@ export class PanelComponent implements Component {
 			this.theme,
 			width,
 			this.section,
-			settingsSummary(this.theme, width, scope, this.options.settings.count(scope)),
+			settingsSummary(this.theme, width, scope, views.length),
 		);
 		const entries = settingEntries(views);
 		const note = scope === "project" ? projectNote(this.theme, width) : undefined;
 
-		if (entries.length === 0) {
-			return dockListFrame({
-				header,
-				summary,
-				body: emptyState(this.theme, width, { label: "No settings found." }),
-				hint: this.hintRow(width),
-			});
-		}
-
 		this.retainFocus(entries);
 		this.clampSelection(entries);
 
 		const focusedEntry = entries[this.cursor.selected];
 		const focused = focusedEntry?.kind === "setting" ? focusedEntry.setting : undefined;
-		const detail = settingDetail({
-			theme: this.theme,
-			width,
-			view: focused,
-			budget: this.detailRows(false),
-			dirty: this.dirty,
-			paths: { scope, cwd: this.options.cwd, agentDir: this.options.agentDir },
-		});
+		const jsonConfig = this.json ? focused?.config : undefined;
+		const detail =
+			jsonConfig && focused
+				? sectionJsonPane({
+						theme: this.theme,
+						width,
+						section: jsonConfig.section,
+						view: focused,
+						document: this.options.settings.sectionDocument(scope, jsonConfig.section),
+						budget: this.detailRows(true),
+						paths: { scope, cwd: this.options.cwd, agentDir: this.options.agentDir },
+					})
+				: settingDetail({
+						theme: this.theme,
+						width,
+						view: focused,
+						budget: this.detailRows(false),
+						dirty: this.dirty,
+						paths: { scope, cwd: this.options.cwd, agentDir: this.options.agentDir },
+					});
 
 		this.cursor.visible = fitRows(
 			this.options.viewportRows,