pi-goal-x 0.25.2 → 0.25.3

package/README.md

@@ -260,9 +260,13 @@ Always visible above the editor while a goal is focused:
 │ Current  t3 · Add the download button                              │
 │ Verify   Run npm test with zero failures.                          │
 │ File     .pi/goals/active_goal_...                                 │
-╰─ Ctrl+Shift+T: expand tasks ───────────────────────────────────────╯
+╰─ Ctrl+Shift+T: expand tasks · Ctrl+Shift+A ──────────────────── ● ─╯
 ```
 
+The green/gray `●` at the bottom-right of the border is the focused goal's
+independent-auditor status (green = on, gray = off); `Ctrl+Shift+A` toggles
+it per-goal (wide/medium footers advertise the chord).
+
 ### Expanded mode
 
 `Ctrl+Shift+T` expands the same component: full task tree (✓ complete, ▸ current, ~ skipped, · pending), the current-task block with its contract and evidence, goal-level verification, and recent activity.
@@ -351,7 +355,7 @@ Settings are stored in:
 .pi/pi-goal-x-settings.json
 ```
 
-Use `/goal-settings` to configure task lists, verification contracts, subtask depth, automatic goal selection, and completion auditing.
+Use `/goal-settings` to configure task lists, verification contracts, subtask depth, automatic goal selection, and completion auditing. Goal objectives have no hard length limit by default; set `objectiveMaxChars` (or `PI_GOAL_OBJECTIVE_MAX_CHARS`, `0` = no limit) to cap objective length across `create_goal`, `propose_goal_draft`, and `/goal-tweak`.
 
 ## License
 

package/docs/unified-dashboard.md

@@ -32,7 +32,7 @@ Always visible above the editor while a goal is focused:
 │ Current  t3 · Add the download button                                                  │
 │ Verify   Run npm test with zero failures.                                              │
 │ File     .pi/goals/active_goal_g1.md                                                   │
-╰─ Ctrl+Shift+T: expand tasks ───────────────────────────────────────────────────────────╯
+╰─ Ctrl+Shift+T: expand tasks · Ctrl+Shift+A ──────────────────────────────────────── ● ─╯
 ```
 
 Compact rows, in order:
@@ -52,7 +52,7 @@ Compact rows, in order:
    tasks. The subtask segment appears only when the current task has direct
    children. The whole header row is neutral gray (label, counts, bar fill,
    and empty cells) so nothing in the progress info is colourful.
-5. Task list section: the top-level tasks shown by default in **pastel
+6. Task list section: the top-level tasks shown by default in **pastel
    amber** (`mdHeading`) with colour-coded markers and ids (✓ complete muted
    green, ▸ current teal, ~ skipped gray, · pending amber), an aligned id
    column, truncated amber titles, and a `… +N more` overflow line when the
@@ -72,7 +72,15 @@ Compact rows, in order:
     shortcut hint and trailing fill — is drawn in one frame tone (the
     neutral-gray `muted`), so the color spans the full width with no two-tone
     split; the header line is likewise one tone with only the `pi-goal-x`
-    brand in accent.
+    brand in accent. The auditor status lives in the bottom-right of this
+    border: a single `●` — green when the focused goal's independent auditor
+    is on, gray when off — drawn right before the `╯` corner, and the
+    wide/medium footers also append ` · Ctrl+Shift+A` to the hint (narrow and
+    minimal keep the dot alone). `Ctrl+Shift+A` toggles the auditor per-goal
+    (persisted, `auditor_toggled` ledger event, dashboard refresh,
+    notification; inert with no focused goal, a goal modal open, or a
+    complete goal). The expanded dashboard does not render the auditor
+    indicator.
 
 When every top-level task is done, the current line reads
 `Current  All tasks complete`. With `disableTasks` enabled the task rows are
@@ -212,6 +220,7 @@ auditor's findings, and returns to the normal dashboard so work can continue.
 | Key | Action |
 | --- | --- |
 | `Ctrl+Shift+T` | Toggle the dashboard between compact and expanded |
+| `Ctrl+Shift+A` | Toggle the focused goal's independent auditor on/off (persisted per-goal; inert with no goal, a goal modal open, or a complete goal) |
 | `↑` / `↓`, `PgUp` / `PgDn`, `Home` / `End` | Scroll the expanded task tree (see [Scrolling the task list](#scrolling-the-task-list)) |
 | `Ctrl+Shift+↑` / `Ctrl+Shift+↓`, `Ctrl+Shift+PgUp` / `Ctrl+Shift+PgDn`, `Ctrl+Shift+Home` / `Ctrl+Shift+End` | Scroll the compact task list |
 | `Esc` | Collapse the expanded dashboard; otherwise pause the goal |

package/extensions/goal-activity.ts

@@ -61,6 +61,8 @@ function mapEvent(event: GoalLedgerEvent, taskTitles: ReadonlyMap<string, string
 			return { at: event.at, kind: "goal", text: "Created and focused the goal." };
 		case "goal_tweaked":
 			return { at: event.at, kind: "goal", text: "Updated the goal objective and task plan." };
+		case "auditor_toggled":
+			return { at: event.at, kind: "goal", text: event.enabled ? "Turned the independent auditor on." : "Turned the independent auditor off." };
 		case "goal_paused":
 			return {
 				at: event.at,

package/extensions/goal-commands.ts

@@ -262,6 +262,7 @@ export function registerGoalCommands(core: GoalCore): void {
 		{ key: "autoSelectSingleGoal", label: "autoSelectSingleGoal", section: "Goal behavior", kind: "boolean" },
 		{ key: "disableContracts", label: "disableContracts", section: "Goal behavior", kind: "boolean" },
 		{ key: "stallTimeoutMinutes", label: "stall timeout (minutes)", section: "Goal behavior", kind: "positiveInteger" },
+		{ key: "objectiveMaxChars", label: "max objective length (0 = none)", section: "Goal behavior", kind: "positiveInteger" },
 		{ key: "disableTasks", label: "disableTasks", section: "Task tracking", kind: "boolean" },
 		{ key: "subtaskDepth", label: "subtaskDepth", section: "Task tracking", kind: "positiveInteger" },
 		{ key: "disabled", label: "auditor disabled", section: "Completion auditor", kind: "boolean" },
@@ -276,6 +277,7 @@ export function registerGoalCommands(core: GoalCore): void {
 		}
 		if (key === "subtaskDepth") return config.subtaskDepth !== undefined ? String(config.subtaskDepth) : "1";
 		if (key === "stallTimeoutMinutes") return config.stallTimeoutMinutes !== undefined ? String(config.stallTimeoutMinutes) : "0";
+		if (key === "objectiveMaxChars") return config.objectiveMaxChars !== undefined ? String(config.objectiveMaxChars) : "0";
 		return config[key] ?? "(default)";
 	}
 
@@ -343,8 +345,9 @@ export function registerGoalCommands(core: GoalCore): void {
 				const input = await ctx.ui.input(`Set ${row.label}`, settingsValue(config, key));
 				if (input === undefined) continue;
 				// Row-driven lower bound: subtaskDepth is a nesting depth (min 1);
-				// stallTimeoutMinutes defaults to 0 meaning "no stall timeout".
-				const min = row.key === "stallTimeoutMinutes" ? 0 : 1;
+				// stallTimeoutMinutes and objectiveMaxChars default to 0 meaning
+				// "off / no limit".
+				const min = (row.key === "stallTimeoutMinutes" || row.key === "objectiveMaxChars") ? 0 : 1;
 				// Full-string decimal validation: no partial parseInt. Rejects
 				// 1.5, 1x, negatives, infinity, and unsafe integers alike.
 				const trimmed = input.trim();
@@ -478,9 +481,12 @@ export function registerGoalCommands(core: GoalCore): void {
 			ctx.ui.notify("Provide the replacement objective: /goal-tweak <new objective>", "info");
 			return;
 		}
-		if (trimmed.length > 4000) {
-			ctx.ui.notify(`Replacement objective exceeds 4000 characters (${trimmed.length}).`, "warning");
-			return;
+		if (trimmed.length > (loadGoalSettings(ctx.cwd).objectiveMaxChars ?? 0)) {
+			const max = loadGoalSettings(ctx.cwd).objectiveMaxChars;
+			if (max !== undefined && max > 0) {
+				ctx.ui.notify(`Replacement objective exceeds ${max} characters (${trimmed.length}).`, "warning");
+				return;
+			}
 		}
 		await startGoalDrafting(core, ctx, "tweak", trimmed, currentGoal);
 	}

package/extensions/goal-compaction.ts

@@ -37,6 +37,9 @@ export function buildGoalCompactSummary(goal: GoalRecord, events: GoalLedgerEven
         case "goal_tweaked":
           lines.push(`    - tweaked: ${event.changeSummary}`);
           break;
+        case "auditor_toggled":
+          lines.push(`    - auditor toggled ${event.enabled ? "on" : "off"}`);
+          break;
         case "completion_requested":
           lines.push(`    - completion requested${event.summary ? `: ${truncateText(event.summary, 80)}` : ""}`);
           break;

package/extensions/goal-core-tools.ts

@@ -8,6 +8,7 @@ import { budgetLine } from "./goal-accounting.ts";
 import { buildGoalCreatedReport, buildTaskSummary, validateGoalAgentPause, validateGoalBlock } from "./goal-policy.ts";
 import { buildUnfocusedOpenGoalsSummary, otherOpenGoalCount } from "./goal-pool.ts";
 import { readGoalLedger } from "./goal-ledger.ts";
+import { loadGoalSettings } from "./goal-settings.ts";
 import { buildGoalHistoryBlock, buildGoalTaskDetailBlock } from "./goal-format.ts";
 import { sisyphusStepProgress } from "./goal-policy.ts";
 import { deriveTasksFromObjective } from "./goal-task-derive.ts";
@@ -105,7 +106,7 @@ pi.registerTool(defineTool({
 		"Pass mode=\"sisyphus\" only when the user explicitly invoked Sisyphus mode.",
 	],
 	parameters: Type.Object({
-		objective: Type.String({ description: "Full goal text. For Sisyphus goals this MUST include the user's numbered steps + per-step done criteria, taken faithfully from the user's input. 1-4000 characters." }),
+		objective: Type.String({ description: "Full goal text. For Sisyphus goals this MUST include the user's numbered steps + per-step done criteria, taken faithfully from the user's input. Length is capped by the `max objective length` goal setting (0/unset = no limit)." }),
 		mode: Type.Optional(StringEnum(["regular", "sisyphus"] as const, { description: "Goal mode. Defaults to regular. Use sisyphus only when the user explicitly invoked Sisyphus mode." })),
 		token_budget: Type.Optional(Type.Integer({ minimum: 1, description: "Optional token budget in whole tokens. Accept it only when the user explicitly supplied a budget; never invent one." })),
 	}, { additionalProperties: false }),
@@ -114,9 +115,10 @@ pi.registerTool(defineTool({
 		core.reconcileFocusedGoalFromDisk(ctx);
 		const objective = params.objective.trim();
 		if (!objective) throw new Error("create_goal requires a non-empty objective.");
-		if (objective.length > 4000) {
+		const objectiveMaxChars = loadGoalSettings(ctx.cwd).objectiveMaxChars ?? 0;
+		if (objectiveMaxChars > 0 && objective.length > objectiveMaxChars) {
 			return {
-				content: [{ type: "text", text: `create_goal objective exceeds 4000 characters (${objective.length}). Shorten the objective and retry.` }],
+				content: [{ type: "text", text: `create_goal objective exceeds ${objectiveMaxChars} characters (${objective.length}). Shorten the objective or raise the max objective length setting.` }],
 				details: goalDetails(core.state.goal),
 			};
 		}

package/extensions/goal-drafting.ts

@@ -153,7 +153,14 @@ export async function startGoalDrafting(core: GoalCore, ctx: ExtensionContext, m
 		clearGoalDrafting(core, ctx);
 	}
 	const startedAt = nowIso();
-	const auditorEnabled = !loadGoalSettings(ctx.cwd).disabled;
+	// §tweak-persist: a tweak confirmation defaults to the target goal's
+	// persisted per-goal auditor setting (skipAuditor); the global `auditor
+	// disabled` setting is only the fallback when the goal has no per-goal
+	// value. Confirming a tweak must never silently re-enable or disable the
+	// auditor the user chose when the goal was created.
+	const auditorEnabled = mode === "tweak"
+		? !(targetGoal?.skipAuditor ?? loadGoalSettings(ctx.cwd).disabled)
+		: !loadGoalSettings(ctx.cwd).disabled;
 	activeDrafts.set(core, { mode, originalTopic: trimmed, targetGoalId: targetGoal?.id, startedAt, auditorEnabled });
 	draftSessionEntry(core, { version: 1, mode, seed: trimmed, targetGoalId: targetGoal?.id, startedAt, auditorEnabled });
 	core.clearContinuationState();
@@ -305,7 +312,9 @@ export function registerDraftingTools(core: GoalCore): void {
 			const draft = activeDraft(core);
 			if (!draft) return { content: [{ type: "text", text: "No guided goal draft is active. Do not create a goal without the user starting /goal or /sisyphus." }], details: goalDetails(core.state.goal) };
 			const objective = params.objective.trim();
-			if (!objective || objective.length > 4000) return { content: [{ type: "text", text: "The proposed objective must be between 1 and 4000 characters." }], details: goalDetails(core.state.goal) };
+			if (!objective) return { content: [{ type: "text", text: "The proposed objective must be at least 1 character." }], details: goalDetails(core.state.goal) };
+			const objectiveMaxChars = loadGoalSettings(ctx.cwd).objectiveMaxChars ?? 0;
+			if (objectiveMaxChars > 0 && objective.length > objectiveMaxChars) return { content: [{ type: "text", text: `The proposed objective must be at most ${objectiveMaxChars} characters (${objective.length} given).` }], details: goalDetails(core.state.goal) };
 			const expectedSisyphus = draft.mode === "sisyphus";
 			if (draft.mode !== "tweak" && ((params.sisyphus === true) !== expectedSisyphus)) return { content: [{ type: "text", text: "Proposal mode does not match the command that began this draft." }], details: goalDetails(core.state.goal) };
 			const taskResult = proposedTaskList(core, ctx, params.tasks as FlatTaskInput[] | undefined, params.block_completion);
@@ -389,6 +398,11 @@ export function registerDraftingTools(core: GoalCore): void {
 			// keep status/evidence/completedAt/skippedAt/skipReason, new ids start
 			// pending, removed ids drop. currentTaskId survives only while its task
 			// is still pending in the merged tree.
+			// §tweak-resume: a confirmed tweak is a deliberate revision of a
+			// stalled goal — set when the goal actually transitions out of
+			// paused/blocked so the post-apply glue can resume accounting,
+			// continuation, and the ledger event.
+			let resumed = false;
 			const result = core.goalService.apply(ctx, {
 				reconcile: false, focusToken: token, refreshFromDisk: true,
 				mutate: (goal) => {
@@ -400,13 +414,43 @@ export function registerDraftingTools(core: GoalCore): void {
 					const currentTaskId = mergedTaskList && goal.currentTaskId && !currentTaskIdIsPending(mergedTaskList.tasks, goal.currentTaskId)
 						? undefined
 						: goal.currentTaskId;
-					return { ...goal, objective: extracted.objective, verificationContract: extracted.verificationContract ?? goal.verificationContract, taskList, currentTaskId, skipAuditor, updatedAt: now };
+					// §tweak-resume: resume a paused/blocked goal (mirror the
+					// /goal-resume transition: status active + pause metadata
+					// cleared); budget_limited stays behind its hard resource
+					// gate and an active goal stays active.
+					const stalled = goal.status === "paused" || goal.status === "blocked";
+					if (stalled) resumed = true;
+					return {
+						...goal,
+						objective: extracted.objective,
+						verificationContract: extracted.verificationContract ?? goal.verificationContract,
+						taskList, currentTaskId, skipAuditor,
+						status: stalled ? "active" : goal.status,
+						autoContinue: stalled ? true : goal.autoContinue,
+						stopReason: stalled ? undefined : goal.stopReason,
+						pauseReason: stalled ? undefined : goal.pauseReason,
+						pauseSuggestedAction: stalled ? undefined : goal.pauseSuggestedAction,
+						updatedAt: now,
+					};
 				},
 				ledger: (written) => [{ type: "goal_tweaked", goalId: written.id, changeSummary: "Goal revised through /goal-tweak drafting.", at: written.updatedAt }, ...(taskResult.value ? [{ type: "task_list_set" as const, goalId: written.id, taskCount: countTasks(written.taskList?.tasks), blockCompletion: taskResult.value.blockCompletion, at: written.updatedAt }] : [])],
 			});
 			if (!result.ok) return { content: [{ type: "text", text: "Goal tweak was not applied: " + result.message }], details: goalDetails(core.state.goal) };
+			if (resumed) {
+				try {
+					core.goalService.appendEvents(ctx, [{ type: "goal_resumed", goalId: result.goal.id, reason: "tweak", at: nowIso() }]);
+				} catch {
+					// Ledger append failure should not crash the tweak.
+				}
+			}
 			core.clearContinuationState();
 			core.updateUI(ctx);
+			if (resumed) {
+				// Resume glue mirrors replaceGoal: restart accounting and queue
+				// the auto-continuation so the revived goal keeps going.
+				core.beginAccounting();
+				core.queueContinuation(ctx, true);
+			}
 			clearGoalDrafting(core, ctx);
 			return { content: [{ type: "text", text: `${summary}\n\nGoal tweak confirmed and applied.` }], details: goalDetails(result.goal), terminate: true };
 		},

package/extensions/goal-ledger.ts

@@ -11,6 +11,7 @@ export type GoalLedgerEvent =
   | { type: "goal_paused"; goalId: string; reason: string; suggestedAction?: string; status?: "paused"; source?: "user" | "agent"; at: string }
   | { type: "goal_resumed"; goalId: string; reason: string; at: string }
   | { type: "goal_tweaked"; goalId: string; changeSummary: string; at: string }
+  | { type: "auditor_toggled"; goalId: string; enabled: boolean; at: string }
   | { type: "completion_requested"; goalId: string; summary?: string; at: string }
   | { type: "audit_started"; goalId: string; provider?: string; model?: string; thinkingLevel?: string; at: string }
   | { type: "audit_result"; goalId: string; verdict: "approved" | "disapproved" | "error"; report: string; at: string }
@@ -224,6 +225,8 @@ function isValidLedgerEvent(value: unknown): value is GoalLedgerEvent {
       return typeof obj.goalId === "string" && typeof obj.reason === "string";
     case "goal_tweaked":
       return typeof obj.goalId === "string" && typeof obj.changeSummary === "string";
+    case "auditor_toggled":
+      return typeof obj.goalId === "string" && typeof obj.enabled === "boolean";
     case "completion_requested":
       return typeof obj.goalId === "string" && (obj.summary === undefined || typeof obj.summary === "string");
     case "audit_started":
@@ -275,6 +278,8 @@ function sanitizeEvent(event: GoalLedgerEvent): GoalLedgerEvent {
       return { ...event, goalId: safeGoalId(event.goalId) };
     case "goal_tweaked":
       return { ...event, goalId: safeGoalId(event.goalId) };
+    case "auditor_toggled":
+      return { ...event, goalId: safeGoalId(event.goalId) };
     case "completion_requested":
       return { ...event, goalId: safeGoalId(event.goalId) };
     case "audit_started":

package/extensions/goal-settings.ts

@@ -4,11 +4,12 @@
  * 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_OBJECTIVE_MAX_CHARS — objective length cap (0 = no limit), overrides file
  *   PI_GOAL_SETTINGS_FILE     — alternative settings file path (relative to cwd or absolute)
  *
  * The file may contain:
  *   disableTasks, disableContracts, subtaskDepth,
- *   provider, model, thinkingLevel, disabled
+ *   provider, model, thinkingLevel, disabled, objectiveMaxChars
  *
  * additionalProperties: false — unknown keys are rejected.
  */
@@ -31,6 +32,12 @@ export interface GoalSettings {
 	auditorProjectResources?: boolean;
 	/** F5: stall detector timeout in minutes (0 = off). */
 	stallTimeoutMinutes?: number;
+	/**
+	 * Maximum objective length in characters (0/unset = no limit, the
+	 * default; >0 caps objectives in create_goal, propose_goal_draft, and
+	 * /goal-tweak).
+	 */
+	objectiveMaxChars?: number;
 }
 
 export const PI_GOAL_SETTINGS_FILE_ENV = "PI_GOAL_SETTINGS_FILE";
@@ -76,6 +83,7 @@ const ALLOWED_SETTINGS_KEYS = new Set([
 	"autoSelectSingleGoal",
 	"auditorProjectResources",
 	"stallTimeoutMinutes",
+	"objectiveMaxChars",
 ]);
 
 /**
@@ -110,6 +118,16 @@ function asPositiveInt(value: unknown): number | undefined {
 	return undefined;
 }
 
+/** Positive-integer-or-zero parser (for settings where 0 = off / no limit). */
+function asNonNegativeInt(value: unknown): number | undefined {
+	if (typeof value === "number" && Number.isInteger(value) && value >= 0) return value;
+	if (typeof value === "string") {
+		const n = parseInt(value, 10);
+		if (!isNaN(n) && n >= 0) return n;
+	}
+	return undefined;
+}
+
 function asThinkingLevel(value: unknown): ThinkingLevel | undefined {
 	const text = asNonEmptyString(value);
 	return text && THINKING_LEVELS.has(text) ? text as ThinkingLevel : undefined;
@@ -144,6 +162,8 @@ export function parseGoalSettings(raw: unknown): GoalSettings {
 	if (record.auditorProjectResources === true || record.auditorProjectResources === "true") settings.auditorProjectResources = true;
 	const stallTimeoutMinutes = asPositiveInt(record.stallTimeoutMinutes);
 	if (stallTimeoutMinutes !== undefined) settings.stallTimeoutMinutes = stallTimeoutMinutes;
+	const objectiveMaxChars = asNonNegativeInt(record.objectiveMaxChars);
+	if (objectiveMaxChars !== undefined) settings.objectiveMaxChars = objectiveMaxChars;
 	return settings;
 }
 
@@ -186,6 +206,7 @@ export function loadGoalSettings(cwd: string, env: NodeJS.ProcessEnv = process.e
 		autoSelectSingleGoal: fileConfig.autoSelectSingleGoal ?? false,
 		auditorProjectResources: fileConfig.auditorProjectResources ?? false,
 		stallTimeoutMinutes: fileConfig.stallTimeoutMinutes,
+		objectiveMaxChars: asNonNegativeInt(env.PI_GOAL_OBJECTIVE_MAX_CHARS) ?? fileConfig.objectiveMaxChars,
 	};
 }
 
@@ -204,6 +225,7 @@ export function loadGoalSettings(cwd: string, env: NodeJS.ProcessEnv = process.e
 export function envOverrideFor(key: keyof GoalSettings | "settingsFile", env: NodeJS.ProcessEnv = process.env): string | null {
 	if (key === "disableTasks" && env.PI_GOAL_DISABLE_TASKS !== undefined) return "PI_GOAL_DISABLE_TASKS";
 	if (key === "disableContracts" && env.PI_GOAL_DISABLE_CONTRACTS !== undefined) return "PI_GOAL_DISABLE_CONTRACTS";
+	if (key === "objectiveMaxChars" && env.PI_GOAL_OBJECTIVE_MAX_CHARS !== undefined) return "PI_GOAL_OBJECTIVE_MAX_CHARS";
 	if (key === "settingsFile" && env[PI_GOAL_SETTINGS_FILE_ENV] !== undefined) return PI_GOAL_SETTINGS_FILE_ENV;
 	return null;
 }
@@ -227,6 +249,7 @@ export function effectiveSettingsReport(cwd: string, env: NodeJS.ProcessEnv = pr
 		{ key: "thinkingLevel", label: "thinking_level", format: (v) => v.thinkingLevel ?? "(default)" },
 		{ key: "auditorProjectResources", label: "auditor project resources", format: (v) => (v.auditorProjectResources === true ? "true" : "false") },
 		{ key: "stallTimeoutMinutes", label: "stall timeout (minutes)", format: (v) => String(v.stallTimeoutMinutes ?? 0) },
+		{ key: "objectiveMaxChars", label: "max objective length (0 = none)", format: (v) => String(v.objectiveMaxChars ?? 0) },
 	];
 	for (const row of rows) {
 		const envVar = envOverrideFor(row.key, env);
@@ -262,6 +285,7 @@ export function saveGoalSettingsFileConfig(cwd: string, settings: GoalSettings):
 	if (settings.autoSelectSingleGoal === true) clean.autoSelectSingleGoal = true;
 	if (settings.auditorProjectResources === true) clean.auditorProjectResources = true;
 	if (settings.stallTimeoutMinutes !== undefined) clean.stallTimeoutMinutes = settings.stallTimeoutMinutes;
+	if (settings.objectiveMaxChars !== undefined) clean.objectiveMaxChars = settings.objectiveMaxChars;
 	const configPath = goalSettingsPath(cwd);
 	fs.mkdirSync(path.dirname(configPath), { recursive: true });
 	settingsFileCache.delete(configPath);
@@ -276,6 +300,7 @@ export function saveGoalSettingsFileConfig(cwd: string, settings: GoalSettings):
 	if (settings.autoSelectSingleGoal === true) persisted.autoSelectSingleGoal = true;
 	if (settings.auditorProjectResources === true) persisted.auditorProjectResources = true;
 	if (clean.stallTimeoutMinutes !== undefined) persisted.stallTimeoutMinutes = clean.stallTimeoutMinutes;
+	if (clean.objectiveMaxChars !== undefined) persisted.objectiveMaxChars = clean.objectiveMaxChars;
 	fs.writeFileSync(configPath, `${JSON.stringify(persisted, null, 2)}\n`, "utf8");
 	return clean;
 }

package/extensions/goal-state.ts

@@ -121,6 +121,8 @@ export interface GoalCore {
 	archiveCurrentGoal(ctx: ExtensionContext, reason: StopReason | undefined): GoalRecord | null;
 	stopActiveGoal(status: Exclude<GoalStatus, "active">, reason: StopReason | undefined, ctx: ExtensionContext): void;
 	pauseActiveGoal(ctx: ExtensionContext): void;
+	/** §auditor-toggle: flip the focused goal's persisted per-goal skipAuditor and record the ledger event. */
+	toggleGoalAuditor(ctx: ExtensionContext): void;
 	queueContinuation(ctx: ExtensionContext, force?: boolean): void;
 	flushGoalTransaction(ctx: ExtensionContext): void;
 	replaceGoal(config: GoalCreationConfig, ctx: ExtensionContext, startNow?: boolean, verificationContract?: string, tokenBudget?: number): void;
@@ -810,6 +812,38 @@ export function createGoalCore(
 		ctx.ui.notify("Goal paused.", "info");
 	}
 
+	/**
+	 * §auditor-toggle: flip the focused goal's independent-auditor setting.
+	 * Persisted per-goal (revision-safe via goalService.apply), recorded as an
+	 * auditor_toggled ledger event, reflected in the dashboard, and announced.
+	 * Inert when no goal is focused or the goal is complete; the widget's
+	 * modal-depth guard keeps it inert while a goal modal is open.
+	 */
+	function toggleGoalAuditor(ctx: ExtensionContext): void {
+		if (!state.goal) {
+			ctx.ui.notify("No focused goal to toggle the auditor for.", "info");
+			return;
+		}
+		if (state.goal.status === "complete") {
+			ctx.ui.notify("This goal is complete; the auditor no longer applies.", "info");
+			return;
+		}
+		const nextEnabled = state.goal.skipAuditor === true;
+		const result = goalService.apply(ctx, {
+			reconcile: false,
+			refreshFromDisk: true,
+			mutate: (g) => ({ ...g, skipAuditor: g.skipAuditor === true ? undefined : true, updatedAt: nowIso() }),
+			ledger: (written) => [{ type: "auditor_toggled" as const, goalId: written.id, enabled: nextEnabled, at: written.updatedAt }],
+		});
+		if (!result.ok) {
+			ctx.ui.notify("Could not toggle the auditor: " + result.message, "error");
+			return;
+		}
+		goalService.flushTurn(ctx); // P1-3: user-visible setting change persists now, not at turn end
+		updateUI(ctx);
+		ctx.ui.notify(nextEnabled ? "Auditor enabled for this goal." : "Auditor disabled for this goal.", "info");
+	}
+
 	function flushGoalTransaction(ctx: ExtensionContext): void {
 		goalService.flushTurn(ctx);
 	}
@@ -994,6 +1028,7 @@ export function createGoalCore(
 		archiveCurrentGoal,
 		stopActiveGoal,
 		pauseActiveGoal,
+		toggleGoalAuditor,
 		queueContinuation,
 		flushGoalTransaction,
 		touchGoalActivity,

package/extensions/goal-widget.ts

@@ -162,6 +162,16 @@ export function syncTerminalInputPause(core: GoalCore, ctx: ExtensionContext): v
 				return { consume: true };
 			}
 
+			// Ctrl+Shift+A — toggle the focused goal's independent auditor.
+			// Persisted per-goal (revision-safe), ledger event, dashboard
+			// refresh, notification; inert with no focused goal or a complete
+			// goal (the modal-depth guard above covers goal modals).
+			if (matchesKey(data, "ctrl+shift+a")) {
+				core.toggleGoalAuditor(ctx);
+				core.goalWidgetComponentRef.current?.invalidate();
+				return { consume: true };
+			}
+
 			// Navigation keys: plain arrows scroll the expanded dashboard (it is
 			// modal while open); Ctrl+Shift+↑/↓/PgUp/PgDn/Home/End scroll the
 			// compact task list — free chords, consumed only when the compact

package/extensions/widgets/goal-dashboard-model.ts

@@ -34,6 +34,8 @@ export interface GoalDashboardModel {
 	};
 
 	focused: boolean;
+	/** §auditor-toggle: whether the independent completion auditor is enabled for this goal (derived from the goal's persisted skipAuditor; undefined = on). */
+	auditorEnabled: boolean;
 	filePath?: string;
 
 	usage: {
@@ -498,6 +500,7 @@ export function deriveGoalDashboardModel(
 		title: displayObjectiveTitle(goal.objective),
 		status,
 		focused,
+		auditorEnabled: goal.skipAuditor !== true,
 		filePath: goal.activePath ?? goal.archivedPath,
 		usage: {
 			activeSeconds: goal.usage.activeSeconds,

package/extensions/widgets/goal-dashboard-renderer.ts

@@ -96,16 +96,20 @@ function boxSectionRule(theme: Theme, width: number, label: string, right = ""):
 	return `${frame(theme, "├")}${l}${frame(theme, H.repeat(fill))}${r}${frame(theme, "┤")}`;
 }
 
-function boxFooter(theme: Theme, width: number, content: string): string {
+function boxFooter(theme: Theme, width: number, content: string, right = ""): string {
 	const inner = Math.max(4, width - 2);
-	if (!content) {
+	// Optional right slot mirrors boxHeader's right-meta treatment (` ● ─`
+	// before the corner), so the auditor dot sits at the bottom-right of the
+	// border. The dot survives; the hint (left content) truncates when tight.
+	const r = right ? ` ${right} ${frame(theme, H)}` : "";
+	if (!content && !r) {
 		return frame(theme, `╰${H.repeat(inner)}╯`);
 	}
 	// The footer is one frame tone: leading dash, hint text and trailing fill
 	// all carry the frame color, so the blue-gray spans the whole line.
-	const l = frame(theme, `${H} ${fit(content, inner - 4)}`);
-	const fill = Math.max(1, inner - visibleWidth(l));
-	return `${frame(theme, "╰")}${l}${frame(theme, H.repeat(fill))}${frame(theme, "╯")}`;
+	const l = content ? frame(theme, `${H} ${fit(content, Math.max(0, inner - 4 - visibleWidth(r)))}`) : "";
+	const fill = Math.max(1, inner - visibleWidth(l) - visibleWidth(r));
+	return `${frame(theme, "╰")}${l}${frame(theme, H.repeat(fill))}${r}${frame(theme, "╯")}`;
 }
 
 // ── §5.2 status colors ──────────────────────────────────────────────────────
@@ -311,6 +315,10 @@ export function renderCompactDashboard(
 		lines.push(boxLine(theme, safeWidth, `${theme.fg(fuel as RenderColor, "⛽")} ${muted(theme, "Budget")} ${theme.fg(fuel as RenderColor, formatBudget(model.budget.used, model.budget.total))}`));
 	}
 
+	// §auditor-toggle: the focused goal's independent-auditor status is the
+	// bottom-right border dot (green on / muted gray off, see the footer
+	// below); the Ctrl+Shift+A chord is advertised in wide/medium footers.
+
 	// §9.1 compact task counts + progress bars live in the Tasks header row
 	// (below); the standalone progress lines were removed in favor of it.
 
@@ -388,15 +396,21 @@ export function renderCompactDashboard(
 		lines.push(boxLine(theme, safeWidth, `${dim(theme, `File     ${model.filePath}`)}`));
 	}
 
-	const footerHint = opts.footerHint
+	const footerHint = (opts.footerHint
 		?? (listOverflows
 			? mode === "minimal"
 				? "↑↓: scroll"
 				: mode === "narrow"
 					? "Ctrl+Shift+↑↓: scroll"
 					: "Ctrl+Shift+T: expand · Ctrl+Shift+↑↓: scroll"
-			: spec.footerHint);
-	lines.push(boxFooter(theme, safeWidth, footerHint));
+			: spec.footerHint))
+		// §auditor-toggle: wide/medium footers also advertise the Ctrl+Shift+A
+		// toggle; narrow/minimal keep only the border dot.
+		+ (mode === "wide" || mode === "medium" ? " · Ctrl+Shift+A" : "");
+	// The auditor dot lives in the bottom-right of the border: green when the
+	// focused goal's independent auditor is on, muted gray when off.
+	const auditorDot = model.auditorEnabled ? success(theme, "●") : muted(theme, "●");
+	lines.push(boxFooter(theme, safeWidth, footerHint, auditorDot));
 	return lines;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-x",
-  "version": "0.25.2",
+  "version": "0.25.3",
   "description": "Goal mode extension for pi: durable long-running objectives, five model tools, structured tasks, independent completion audit, Sisyphus mode, auto-continue, and a status overlay.",
   "license": "MIT",
   "author": "pi-goal-x contributors",
@@ -26,8 +26,14 @@
   "files": [
     "extensions",
     "README.md",
-    "docs",
-    "LICENSE"
+    "LICENSE",
+    "docs/agent-flow-design.md",
+    "docs/agentic-runtime-prd.md",
+    "docs/architecture.md",
+    "docs/goal-ts-refactor-test-strategy.md",
+    "docs/pi-autoresearch-survey.md",
+    "docs/pi-goal-x-unified-dashboard-plan.md",
+    "docs/unified-dashboard.md"
   ],
   "pi": {
     "extensions": [

package/docs/.pi/goals/.goals-pool-snapshot.json

@@ -1 +0,0 @@
-{"version":1,"dirMtimeMs":1786087947377.8738,"goals":[]}