pi-goal-x 0.14.0 → 0.15.0

package/README.md

@@ -54,7 +54,7 @@ All core features of [@capyup/pi-goal](https://github.com/capyup/pi-goal) are pr
 
 - **Live progress widget** — when the auditor runs, the TUI shows a spinner, a progress bar (`[████░░░░] 40%`), step labels (`Inspecting files...`, `Verifying success criteria...`), the current tool being executed, and recent output lines. No more wondering if anything is happening.
 - **Escape to skip** — press Escape during an audit to abort it and complete the goal immediately. The skip is recorded in the ledger as `audit_skipped` with reason `user_aborted` and auditor model metadata.
-- **Disable the auditor entirely** — set `disabled: true` in `.pi/goal-auditor.json` (or toggle it via `/goal-settings` → `disabled`). The agent can still bypass with user confirmation by passing `confirmBypassAuditor: true` to `update_goal`.
+- **Disable the auditor entirely** — set `disabled: true` in `.pi/pi-goal-x-settings.json` (or toggle it via `/goal-settings`). The agent can still bypass with user confirmation by passing `confirmBypassAuditor: true` to `update_goal`.
 - **Skipped audits are recorded** — every skip (whether disabled or Escape-aborted) is logged to the ledger with the reason, provider, model, and thinking level for full traceability.
 - **Robust abort detection** — the auditor detects aborts both from exceptions *and* from `session.prompt()` returning after an abort signal, preventing stuck goals or ghost states.
 - **Cleaner lifecycle** — `AbortSignal` is properly wired to `session.abort()`, animation timers are cleaned up, and the unsubscribe path is always executed. No more having to kill the session.
@@ -223,7 +223,7 @@ Before archiving the goal, `update_goal` starts a separate pi agent in an isolat
 
 The auditor is semantic, not a paperwork checklist: it should reject scaffold-only, alpha, generated-template, proxy-metric, build-only, or weakly verified completions when the real user outcome is not satisfied.
 
-By default the auditor uses the current/default pi model. Configure it via `.pi/goal-auditor.json`, interactively with `/goal-settings` → `auditor`, or environment variables (see [Settings files](#settings-files)).
+By default the auditor uses the current/default pi model. Configure it via `.pi/pi-goal-x-settings.json`, or interactively with `/goal-settings` (see [Configuration](#configuration)).
 
 The completion result prints a full report into the conversation:
 
@@ -271,11 +271,9 @@ Before commands, tools, and lifecycle hooks act on a focused goal, the runtime r
 
 Goal paths are constrained to `.pi/goals/` and `.pi/goals/archived/`; absolute paths, traversal, NUL bytes, symlinks, and unsafe metadata paths are rejected.
 
-## Settings files
+## Configuration
 
-Configuration is split across two files under `.pi/`.
-
-### `.pi/goal-settings.json`
+All settings live in a single file: **`.pi/pi-goal-x-settings.json`**
 
 Configured interactively via `/goal-settings`, or edited directly:
 
@@ -283,24 +281,7 @@ Configured interactively via `/goal-settings`, or edited directly:
 {
   "disableTasks": false,
   "disableContracts": false,
-  "subtaskDepth": 1
-}
-```
-
-| Field | Default | Purpose |
-|---|---:|---|
-| `disableTasks` | `false` | Suppress task list features entirely when `true` |
-| `disableContracts` | `false` | Suppress verification contract enforcement when `true` |
-| `subtaskDepth` | `1` | Maximum nesting depth for subtasks (`1` = tasks → subtasks, `2` = tasks → subtasks → sub-subtasks) |
-
-**Env var overrides:** `PI_GOAL_DISABLE_TASKS=1` and `PI_GOAL_DISABLE_CONTRACTS=1` take precedence over the file. Set to any truthy string to disable.
-
-### `.pi/goal-auditor.json`
-
-Configured interactively via `/goal-settings` → `auditor`, or edited directly:
-
-```json
-{
+  "subtaskDepth": 1,
   "provider": "fireworks",
   "model": "accounts/fireworks/models/deepseek-v4-flash",
   "thinkingLevel": "high",
@@ -310,18 +291,27 @@ Configured interactively via `/goal-settings` → `auditor`, or edited directly:
 
 | Field | Default | Purpose |
 |---|---:|---|
-| `provider` | system default | Provider name for the auditor agent (`anthropic`, `fireworks`, `google`, `groq`, etc.) |
+| `disableTasks` | `false` | Suppress task list features entirely when `true` |
+| `disableContracts` | `false` | Suppress verification contract enforcement when `true` |
+| `subtaskDepth` | `1` | Maximum nesting depth for subtasks |
+| `provider` | system default | Provider name for the auditor agent |
 | `model` | system default | Model name for the auditor agent |
-| `thinkingLevel` | system default | Thinking level: `none`, `low`, `medium`, `high` |
+| `thinkingLevel` | system default | Thinking level: `off`, `minimal`, `low`, `medium`, `high`, `xhigh` |
 | `disabled` | `false` | When `true`, skip the completion audit entirely |
 
-**Env var overrides:** `PI_GOAL_AUDITOR_PROVIDER`, `PI_GOAL_AUDITOR_MODEL`, and `PI_GOAL_AUDITOR_THINKING_LEVEL` take precedence over file config. `PI_GOAL_AUDITOR_THINKING` is also accepted as an alias for the thinking level.
+**Env var overrides:**
+- `PI_GOAL_DISABLE_TASKS=1` — disable task features (takes precedence over file)
+- `PI_GOAL_DISABLE_CONTRACTS=1` — disable contract enforcement (takes precedence over file)
+- `PI_GOAL_SETTINGS_FILE=custom-path.json` — alternative settings file path (relative to cwd or absolute)
 
 ## Environment variables
 
 | Variable | Default | Purpose |
 |---|---:|---|
 | `PI_GOAL_AUTO_CONFIRM` | unset | When `1`, auto-confirms drafts in headless/test contexts |
+| `PI_GOAL_DISABLE_TASKS` | — | When `1`, disable task features (overrides settings file) |
+| `PI_GOAL_DISABLE_CONTRACTS` | — | When `1`, disable contract enforcement (overrides settings file) |
+| `PI_GOAL_SETTINGS_FILE` | `.pi/pi-goal-x-settings.json` | Alternative settings file path (relative to cwd or absolute) |
 
 ## Development
 

package/docs/architecture.md

@@ -200,7 +200,7 @@ Before archiving, the tool starts a separate in-memory pi session with a focused
 - `<approved/>` allows archiving;
 - `<disapproved/>`, no marker, an error, or abort rejects completion and leaves the goal open.
 
-The auditor uses the current/default model unless `.pi/goal-auditor.json` or `PI_GOAL_AUDITOR_PROVIDER`, `PI_GOAL_AUDITOR_MODEL`, and `PI_GOAL_AUDITOR_THINKING_LEVEL` override provider/model/thinking. `/goal-settings` opens a small UI menu with an `auditor` item; inside it, `provider`, `model`, and `thinking_level` each open a free-text input and save back to `.pi/goal-auditor.json`.
+The auditor uses the current/default model unless `.pi/pi-goal-x-settings.json` overrides `provider`, `model`, or `thinkingLevel`. `/goal-settings` opens a TUI showing all settings (disabled, provider, model, thinking_level, subtaskDepth, disableTasks, disableContracts); each editable field opens a free-text input and saves back to `.pi/pi-goal-x-settings.json`.
 
 The user sees:
 

package/extensions/goal-auditor.ts

@@ -14,14 +14,7 @@ import {
 	type ResourceLoader,
 } from "@earendil-works/pi-coding-agent";
 import type { GoalRecord, GoalTask, GoalTaskList } from "./goal-record.ts";
-import type { GoalSettings } from "./goal-settings.ts";
-
-export interface GoalAuditorConfig {
-	provider?: string;
-	model?: string;
-	thinkingLevel?: ThinkingLevel;
-	disabled?: boolean;
-}
+import { loadGoalSettings, type GoalSettings } from "./goal-settings.ts";
 
 export interface AuditorProgress {
 	/** Current tool being executed by the auditor, if any */
@@ -55,10 +48,6 @@ export interface GoalAuditorResult {
 
 const THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh"]);
 
-export function goalAuditorConfigPath(cwd: string): string {
-	return path.join(cwd, ".pi", "goal-auditor.json");
-}
-
 function asNonEmptyString(value: unknown): string | undefined {
 	return typeof value === "string" && value.trim() ? value.trim() : undefined;
 }
@@ -68,59 +57,7 @@ function asThinkingLevel(value: unknown): ThinkingLevel | undefined {
 	return text && THINKING_LEVELS.has(text) ? text as ThinkingLevel : undefined;
 }
 
-export function parseGoalAuditorConfig(raw: unknown): GoalAuditorConfig {
-	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
-	const record = raw as Record<string, unknown>;
-	const config: GoalAuditorConfig = {};
-	const provider = asNonEmptyString(record.provider);
-	const model = asNonEmptyString(record.model);
-	const thinkingLevel = asThinkingLevel(record.thinkingLevel ?? record.thinking_level);
-	if (provider) config.provider = provider;
-	if (model) config.model = model;
-	if (thinkingLevel) config.thinkingLevel = thinkingLevel;
-	if (record.disabled === true || record.disabled === "true") config.disabled = true;
-	return config;
-}
-
-export function loadGoalAuditorFileConfig(cwd: string): GoalAuditorConfig {
-	try {
-		const configPath = goalAuditorConfigPath(cwd);
-		if (fs.existsSync(configPath)) return parseGoalAuditorConfig(JSON.parse(fs.readFileSync(configPath, "utf8")));
-	} catch {
-		return {};
-	}
-	return {};
-}
-
-export function loadGoalAuditorConfig(cwd: string, env: NodeJS.ProcessEnv = process.env): GoalAuditorConfig {
-	const fileConfig = loadGoalAuditorFileConfig(cwd);
-	return {
-		...fileConfig,
-		provider: asNonEmptyString(env.PI_GOAL_AUDITOR_PROVIDER) ?? fileConfig.provider,
-		model: asNonEmptyString(env.PI_GOAL_AUDITOR_MODEL) ?? fileConfig.model,
-		thinkingLevel: asThinkingLevel(env.PI_GOAL_AUDITOR_THINKING_LEVEL ?? env.PI_GOAL_AUDITOR_THINKING) ?? fileConfig.thinkingLevel,
-	};
-}
 
-export function saveGoalAuditorFileConfig(cwd: string, config: GoalAuditorConfig): GoalAuditorConfig {
-	const clean: GoalAuditorConfig = {};
-	const provider = asNonEmptyString(config.provider);
-	const model = asNonEmptyString(config.model);
-	const thinkingLevel = asThinkingLevel(config.thinkingLevel);
-	if (provider) clean.provider = provider;
-	if (model) clean.model = model;
-	if (thinkingLevel) clean.thinkingLevel = thinkingLevel;
-	if (config.disabled === true) clean.disabled = true;
-	const configPath = goalAuditorConfigPath(cwd);
-	fs.mkdirSync(path.dirname(configPath), { recursive: true });
-	const persisted: Record<string, unknown> = {};
-	if (clean.provider) persisted.provider = clean.provider;
-	if (clean.model) persisted.model = clean.model;
-	if (clean.thinkingLevel) persisted.thinking_level = clean.thinkingLevel;
-	if (clean.disabled) persisted.disabled = true;
-	fs.writeFileSync(configPath, `${JSON.stringify(persisted, null, 2)}\n`, "utf8");
-	return clean;
-}
 
 export function parseAuditorDecision(output: string): { approved: boolean; disapproved: boolean } {
 	const approved = /<approved\s*\/>/.test(output);
@@ -282,7 +219,7 @@ function makeAuditorResourceLoader(): ResourceLoader {
 	};
 }
 
-function resolveAuditorModel(ctx: ExtensionContext, config: GoalAuditorConfig): { model: Model<any> | undefined; error?: string } {
+function resolveAuditorModel(ctx: ExtensionContext, config: GoalSettings): { model: Model<any> | undefined; error?: string } {
 	if (!config.model && !config.provider) return { model: ctx.model };
 	if (config.provider && config.model) {
 		const model = ctx.modelRegistry.find(config.provider, config.model);
@@ -325,7 +262,7 @@ export async function runGoalCompletionAuditor(args: {
 	 */
 	createSession?: typeof createAgentSession;
 }): Promise<GoalAuditorResult> {
-	const config = loadGoalAuditorConfig(args.ctx.cwd);
+	const config = loadGoalSettings(args.ctx.cwd);
 	const resolved = resolveAuditorModel(args.ctx, config);
 	const model = resolved.model;
 	const thinkingLevel = config.thinkingLevel;

package/extensions/goal-settings.ts

@@ -1,28 +1,59 @@
 /**
- * Global goal settings: config file + env var overrides for disabling
- * task lists and/or verification contracts.
+ * Unified global goal settings.
  *
- * Reads `.pi/goal-settings.json` with env var overrides:
+ * Reads `.pi/pi-goal-x-settings.json` with env var overrides:
  *   PI_GOAL_DISABLE_TASKS     — "true" to disable, any other value = use file config
  *   PI_GOAL_DISABLE_CONTRACTS — "true" to disable, any other value = use file config
+ *   PI_GOAL_SETTINGS_FILE     — alternative settings file path (relative to cwd or absolute)
  *
- * Pattern mirrors `goalAuditorConfig` in goal-auditor.ts.
+ * The file may contain:
+ *   disableTasks, disableContracts, subtaskDepth,
+ *   provider, model, thinkingLevel, disabled
+ *
+ * additionalProperties: false — unknown keys are rejected.
  */
 
 import * as fs from "node:fs";
 import * as path from "node:path";
 
+export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
+
 export interface GoalSettings {
 	disableTasks?: boolean;
 	disableContracts?: boolean;
 	subtaskDepth?: number;
+	provider?: string;
+	model?: string;
+	thinkingLevel?: ThinkingLevel;
+	disabled?: boolean;
 }
 
+export const PI_GOAL_SETTINGS_FILE_ENV = "PI_GOAL_SETTINGS_FILE";
+
+const THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh"]);
+
+const ALLOWED_SETTINGS_KEYS = new Set([
+	"disableTasks",
+	"disableContracts",
+	"subtaskDepth",
+	"provider",
+	"model",
+	"thinkingLevel",
+	"thinking_level",
+	"disabled",
+]);
+
 /**
- * Resolve the path to the global goal-settings.json file.
+ * Resolve the path to the unified settings file.
+ * Uses `PI_GOAL_SETTINGS_FILE` env var if set (relative to cwd or absolute).
+ * Otherwise defaults to `.pi/pi-goal-x-settings.json`.
  */
-export function goalSettingsPath(cwd: string): string {
-	return path.join(cwd, ".pi", "goal-settings.json");
+export function goalSettingsPath(cwd: string, env: NodeJS.ProcessEnv = process.env): string {
+	const override = asNonEmptyString(env[PI_GOAL_SETTINGS_FILE_ENV]);
+	if (override) {
+		return path.isAbsolute(override) ? override : path.join(cwd, override);
+	}
+	return path.join(cwd, ".pi", "pi-goal-x-settings.json");
 }
 
 function asNonEmptyString(value: unknown): string | undefined {
@@ -44,7 +75,10 @@ function asPositiveInt(value: unknown): number | undefined {
 	return undefined;
 }
 
-const ALLOWED_SETTINGS_KEYS = new Set(["disableTasks", "disableContracts", "subtaskDepth"]);
+function asThinkingLevel(value: unknown): ThinkingLevel | undefined {
+	const text = asNonEmptyString(value);
+	return text && THINKING_LEVELS.has(text) ? text as ThinkingLevel : undefined;
+}
 
 /**
  * Parse raw (deserialized JSON) into a GoalSettings object.
@@ -55,24 +89,31 @@ export function parseGoalSettings(raw: unknown): GoalSettings {
 	const record = raw as Record<string, unknown>;
 	const unknownKeys = Object.keys(record).filter((k) => !ALLOWED_SETTINGS_KEYS.has(k));
 	if (unknownKeys.length > 0) {
-		throw new Error(`Unknown goal-settings.json key(s): ${unknownKeys.join(", ")}`);
+		throw new Error(`Unknown pi-goal-x-settings.json key(s): ${unknownKeys.join(", ")}`);
 	}
 	const settings: GoalSettings = {};
 	const disableTasks = asBool(record.disableTasks);
 	const disableContracts = asBool(record.disableContracts);
 	const subtaskDepth = asPositiveInt(record.subtaskDepth);
+	const provider = asNonEmptyString(record.provider);
+	const model = asNonEmptyString(record.model);
+	const thinkingLevel = asThinkingLevel(record.thinkingLevel ?? record.thinking_level);
 	if (disableTasks !== undefined) settings.disableTasks = disableTasks;
 	if (disableContracts !== undefined) settings.disableContracts = disableContracts;
 	if (subtaskDepth !== undefined) settings.subtaskDepth = subtaskDepth;
+	if (provider !== undefined) settings.provider = provider;
+	if (model !== undefined) settings.model = model;
+	if (thinkingLevel !== undefined) settings.thinkingLevel = thinkingLevel;
+	if (record.disabled === true || record.disabled === "true") settings.disabled = true;
 	return settings;
 }
 
 /**
  * Load settings from the file on disk. Returns {} if file missing or invalid.
  */
-export function loadGoalSettingsFileConfig(cwd: string): GoalSettings {
+export function loadGoalSettingsFileConfig(cwd: string, env?: NodeJS.ProcessEnv): GoalSettings {
 	try {
-		const configPath = goalSettingsPath(cwd);
+		const configPath = goalSettingsPath(cwd, env);
 		if (fs.existsSync(configPath)) return parseGoalSettings(JSON.parse(fs.readFileSync(configPath, "utf8")));
 	} catch {
 		// file missing, malformed JSON, etc. — use defaults
@@ -83,13 +124,50 @@ export function loadGoalSettingsFileConfig(cwd: string): GoalSettings {
 /**
  * Load settings with env var overrides.
  * Env vars take precedence over file config.
- * Default: both flags false (features enabled).
+ * Default: all flags false/undefined (features enabled, default model).
  */
 export function loadGoalSettings(cwd: string, env: NodeJS.ProcessEnv = process.env): GoalSettings {
-	const fileConfig = loadGoalSettingsFileConfig(cwd);
+	const fileConfig = loadGoalSettingsFileConfig(cwd, env);
 	return {
 		disableTasks: asBool(env.PI_GOAL_DISABLE_TASKS) ?? fileConfig.disableTasks ?? false,
 		disableContracts: asBool(env.PI_GOAL_DISABLE_CONTRACTS) ?? fileConfig.disableContracts ?? false,
 		subtaskDepth: fileConfig.subtaskDepth ?? 1,
+		provider: fileConfig.provider,
+		model: fileConfig.model,
+		thinkingLevel: fileConfig.thinkingLevel,
+		disabled: fileConfig.disabled,
 	};
 }
+
+/**
+ * Save settings to the unified settings file on disk.
+ * Persists only non-default values using the canonical key names.
+ */
+export function saveGoalSettingsFileConfig(cwd: string, settings: GoalSettings): GoalSettings {
+	const clean: GoalSettings = {};
+	const provider = asNonEmptyString(settings.provider);
+	const model = asNonEmptyString(settings.model);
+	const thinkingLevel = asThinkingLevel(settings.thinkingLevel);
+	const disableTasks = asBool(settings.disableTasks);
+	const disableContracts = asBool(settings.disableContracts);
+	const subtaskDepth = asPositiveInt(settings.subtaskDepth);
+	if (provider) clean.provider = provider;
+	if (model) clean.model = model;
+	if (thinkingLevel) clean.thinkingLevel = thinkingLevel;
+	if (settings.disabled === true) clean.disabled = true;
+	if (disableTasks === true) clean.disableTasks = true;
+	if (disableContracts === true) clean.disableContracts = true;
+	if (subtaskDepth !== undefined) clean.subtaskDepth = subtaskDepth;
+	const configPath = goalSettingsPath(cwd);
+	fs.mkdirSync(path.dirname(configPath), { recursive: true });
+	const persisted: Record<string, unknown> = {};
+	if (clean.provider) persisted.provider = clean.provider;
+	if (clean.model) persisted.model = clean.model;
+	if (clean.thinkingLevel) persisted.thinking_level = clean.thinkingLevel;
+	if (clean.disabled) persisted.disabled = true;
+	if (clean.disableTasks) persisted.disableTasks = true;
+	if (clean.disableContracts) persisted.disableContracts = true;
+	if (clean.subtaskDepth !== undefined) persisted.subtaskDepth = clean.subtaskDepth;
+	fs.writeFileSync(configPath, `${JSON.stringify(persisted, null, 2)}\n`, "utf8");
+	return clean;
+}

package/extensions/goal.ts

@@ -17,13 +17,15 @@ import {
 	type GoalDraftingFocus,
 } from "./goal-draft.ts";
 import {
-	goalAuditorConfigPath,
-	loadGoalAuditorFileConfig,
 	runGoalCompletionAuditor,
-	saveGoalAuditorFileConfig,
-	type GoalAuditorConfig,
 } from "./goal-auditor.ts";
-import { loadGoalSettings, type GoalSettings } from "./goal-settings.ts";
+import {
+	goalSettingsPath,
+	loadGoalSettings,
+	loadGoalSettingsFileConfig,
+	saveGoalSettingsFileConfig,
+	type GoalSettings,
+} from "./goal-settings.ts";
 import {
 	proposalDialogFailureMessage,
 	registerQuestionnaireTools,
@@ -482,7 +484,7 @@ export default function goalExtension(pi: ExtensionAPI): void {
 
 	function abortAudit(ctx: ExtensionContext): void {
 		if (!auditAbortController || !auditProgress) return;
-		const auditorConfig = loadGoalAuditorFileConfig(ctx.cwd);
+		const settings = loadGoalSettingsFileConfig(ctx.cwd);
 		auditAbortController.abort();
 		auditAbortController = null;
 		stopAuditAnimation();
@@ -495,9 +497,9 @@ export default function goalExtension(pi: ExtensionAPI): void {
 					type: "audit_skipped",
 					goalId: state.goal.id,
 					reason: "user_aborted",
-					provider: auditorConfig.provider,
-					model: auditorConfig.model,
-					thinkingLevel: auditorConfig.thinkingLevel,
+					provider: settings.provider,
+					model: settings.model,
+					thinkingLevel: settings.thinkingLevel,
 					at: nowIso(),
 				});
 			} catch {
@@ -1306,75 +1308,85 @@ export default function goalExtension(pi: ExtensionAPI): void {
 		}
 	}
 
-	function auditorConfigValue(config: GoalAuditorConfig, key: keyof GoalAuditorConfig): string {
+	function settingsValue(config: GoalSettings, key: keyof GoalSettings): string {
 		if (key === "disabled") return config.disabled === true ? "true" : "false";
+		if (key === "disableTasks") return config.disableTasks === true ? "true" : "false";
+		if (key === "disableContracts") return config.disableContracts === true ? "true" : "false";
+		if (key === "subtaskDepth") return config.subtaskDepth !== undefined ? String(config.subtaskDepth) : "1";
 		return config[key] ?? "(default)";
 	}
 
-	function auditorSettingsLines(config: GoalAuditorConfig): string[] {
+	function settingsLines(config: GoalSettings): string[] {
 		return [
-			`disabled: ${auditorConfigValue(config, "disabled")}`,
-			`provider: ${auditorConfigValue(config, "provider")}`,
-			`model: ${auditorConfigValue(config, "model")}`,
-			`thinking_level: ${auditorConfigValue(config, "thinkingLevel")}`,
+			`disabled: ${settingsValue(config, "disabled")}`,
+			`provider: ${settingsValue(config, "provider")}`,
+			`model: ${settingsValue(config, "model")}`,
+			`thinking_level: ${settingsValue(config, "thinkingLevel")}`,
+			`disableTasks: ${settingsValue(config, "disableTasks")}`,
+			`disableContracts: ${settingsValue(config, "disableContracts")}`,
+			`subtaskDepth: ${settingsValue(config, "subtaskDepth")}`,
 		];
 	}
 
-	async function handleGoalAuditorSettings(ctx: ExtensionContext): Promise<void> {
+	async function handleSettingsMenu(ctx: ExtensionContext): Promise<void> {
 		if (!ctx.hasUI) {
-			ctx.ui.notify(`Goal auditor settings file: ${goalAuditorConfigPath(ctx.cwd)}`, "info");
+			ctx.ui.notify(`Settings file: ${goalSettingsPath(ctx.cwd)}`, "info");
 			return;
 		}
-		const fieldLabels = ["disabled", "provider", "model", "thinking_level"] as const;
+		const editorKeys = ["disabled", "provider", "model", "thinking_level", "subtaskDepth"] as const;
 		while (true) {
-			const config = loadGoalAuditorFileConfig(ctx.cwd);
-			const options = [
-				`disabled: ${auditorConfigValue(config, "disabled")}`,
-				`provider: ${auditorConfigValue(config, "provider")}`,
-				`model: ${auditorConfigValue(config, "model")}`,
-				`thinking_level: ${auditorConfigValue(config, "thinkingLevel")}`,
-			];
-			const selected = await ctx.ui.select("Goal auditor settings", options);
-			if (!selected) return;
-			const index = options.indexOf(selected);
-			const field = fieldLabels[index];
-			if (!field) return;
-			const key = field === "thinking_level" ? "thinkingLevel" : field;
+			const config = loadGoalSettingsFileConfig(ctx.cwd);
+			const options = settingsLines(config).map((line) => `  ${line}`);
+			options.unshift("─── Settings ───");
+			options.push("Done");
+			const selected = await ctx.ui.select("Goal settings", options);
+			if (!selected || selected === "Done" || selected === "─── Settings ───") return;
+			// Strip leading spaces from selection
+			const selectedTrimmed = selected.trim();
+			const colon = selectedTrimmed.indexOf(":");
+			if (colon === -1) continue;
+			const field = selectedTrimmed.slice(0, colon).trim();
+			const editorKey = field === "thinking_level" ? "thinkingLevel" : field;
+			if (!(editorKeys as readonly string[]).includes(editorKey)) continue;
+			const key = editorKey as keyof GoalSettings;
 			if (key === "disabled") {
-				// Toggle the disabled flag
-				const next: GoalAuditorConfig = { ...config, disabled: !config.disabled };
-				saveGoalAuditorFileConfig(ctx.cwd, next);
-				ctx.ui.notify(`Goal auditor settings saved:\n${auditorSettingsLines(loadGoalAuditorFileConfig(ctx.cwd)).join("\n")}`, "info");
+				const next = { ...config, disabled: !config.disabled };
+				saveGoalSettingsFileConfig(ctx.cwd, next);
+				ctx.ui.notify(`Settings saved:\n${settingsLines(loadGoalSettingsFileConfig(ctx.cwd)).join("\n")}`, "info");
+				continue;
+			}
+			if (key === "subtaskDepth") {
+				const input = await ctx.ui.input("Set subtaskDepth", String(config.subtaskDepth ?? 1));
+				if (input === undefined) continue;
+				const n = parseInt(input.trim(), 10);
+				if (isNaN(n) || n < 1) {
+					ctx.ui.notify("subtaskDepth must be a positive integer", "warning");
+					continue;
+				}
+				const next = { ...config, subtaskDepth: n };
+				saveGoalSettingsFileConfig(ctx.cwd, next);
+				ctx.ui.notify(`Settings saved:\n${settingsLines(loadGoalSettingsFileConfig(ctx.cwd)).join("\n")}`, "info");
 				continue;
 			}
-			const currentValue = auditorConfigValue(config, key as keyof GoalAuditorConfig);
-			const input = await ctx.ui.input(`Set auditor ${field}`, currentValue === "(default)" ? "Leave empty for default" : currentValue);
+			const currentValue = settingsValue(config, key);
+			const input = await ctx.ui.input(`Set ${field}`, currentValue === "(default)" ? "Leave empty for default" : currentValue);
 			if (input === undefined) continue;
-			const next: GoalAuditorConfig = { ...config };
-			const trimmed = input.trim();
-			if (!trimmed) {
-				delete next[key as keyof GoalAuditorConfig];
+			const next: GoalSettings = { ...config };
+			const inputTrimmed = input.trim();
+			if (!inputTrimmed) {
+				delete next[key];
 			} else if (key === "thinkingLevel") {
-				if (!["off", "minimal", "low", "medium", "high", "xhigh"].includes(trimmed)) {
+				if (!["off", "minimal", "low", "medium", "high", "xhigh"].includes(inputTrimmed)) {
 					ctx.ui.notify("thinking_level must be one of: off, minimal, low, medium, high, xhigh", "warning");
 					continue;
 				}
-				next.thinkingLevel = trimmed as GoalAuditorConfig["thinkingLevel"];
+				next.thinkingLevel = inputTrimmed as GoalSettings["thinkingLevel"];
 			} else if (key === "provider" || key === "model") {
-				next[key] = trimmed;
+				next[key] = inputTrimmed;
 			}
-			saveGoalAuditorFileConfig(ctx.cwd, next);
-			ctx.ui.notify(`Goal auditor settings saved:\n${auditorSettingsLines(loadGoalAuditorFileConfig(ctx.cwd)).join("\n")}`, "info");
-		}
-	}
-
-	async function handleGoalSettings(ctx: ExtensionContext): Promise<void> {
-		if (!ctx.hasUI) {
-			ctx.ui.notify(`Goal settings require UI. Auditor config file: ${goalAuditorConfigPath(ctx.cwd)}`, "warning");
-			return;
+			saveGoalSettingsFileConfig(ctx.cwd, next);
+			ctx.ui.notify(`Settings saved:\n${settingsLines(loadGoalSettingsFileConfig(ctx.cwd)).join("\n")}`, "info");
 		}
-		const selected = await ctx.ui.select("Goal settings", ["auditor"]);
-		if (selected === "auditor") await handleGoalAuditorSettings(ctx);
 	}
 
 	async function handleGoalClear(ctx: ExtensionContext): Promise<void> {
@@ -1461,7 +1473,7 @@ export default function goalExtension(pi: ExtensionAPI): void {
 	pi.registerCommand("goal-settings", {
 		description: "Open pi-goal settings, including auditor provider/model/thinking_level.",
 		handler: async (_rawArgs, ctx) => {
-			await handleGoalSettings(ctx);
+			await handleSettingsMenu(ctx);
 		},
 	});
 
@@ -2039,13 +2051,13 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			} catch {
 				// Ledger append failure should not block completion
 			}
-			const auditorConfig = loadGoalAuditorFileConfig(ctx.cwd);
-			const auditorLabel = auditorConfig.provider || auditorConfig.model || auditorConfig.thinkingLevel
-				? `${auditorConfig.provider ?? "default"}/${auditorConfig.model ?? "default"}${auditorConfig.thinkingLevel ? `:${auditorConfig.thinkingLevel}` : ""}`
+			const settings = loadGoalSettingsFileConfig(ctx.cwd);
+			const auditorLabel = settings.provider || settings.model || settings.thinkingLevel
+				? `${settings.provider ?? "default"}/${settings.model ?? "default"}${settings.thinkingLevel ? `:${settings.thinkingLevel}` : ""}`
 				: "default";
 
 			// Check if auditor is disabled
-			if (auditorConfig.disabled === true) {
+			if (settings.disabled === true) {
 				if (params.confirmBypassAuditor !== true) {
 					return {
 						content: [{ type: "text", text: [
@@ -2072,9 +2084,9 @@ export default function goalExtension(pi: ExtensionAPI): void {
 						type: "audit_skipped",
 						goalId: auditTarget.id,
 						reason: "disabled",
-						provider: auditorConfig.provider,
-						model: auditorConfig.model,
-						thinkingLevel: auditorConfig.thinkingLevel,
+						provider: settings.provider,
+						model: settings.model,
+						thinkingLevel: settings.thinkingLevel,
 						at: nowIso(),
 					});
 				} catch {
@@ -2128,9 +2140,9 @@ export default function goalExtension(pi: ExtensionAPI): void {
 				appendGoalEvent(ctx, {
 					type: "audit_started",
 					goalId: auditTarget.id,
-					provider: auditorConfig.provider,
-					model: auditorConfig.model,
-					thinkingLevel: auditorConfig.thinkingLevel,
+					provider: settings.provider,
+					model: settings.model,
+					thinkingLevel: settings.thinkingLevel,
 					at: nowIso(),
 				});
 			} catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-x",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Goal mode extension for pi: persistent long-running objectives, /goal-set drafting, Sisyphus prompt style, autoContinue, and an above-editor status overlay. Fork of @capyup/pi-goal.",
   "license": "MIT",
   "author": "pi-goal-x contributors",