pi-goal-x 0.25.1 → 0.25.3

package/README.md

@@ -249,22 +249,24 @@ Verify that the generated report contains every required section.
 Always visible above the editor while a goal is focused:
 
 ```text
-╭─ pi-goal-x ─ Add CSV export to reports ─────── 12m47s · 18.2K tok ─╮
-│ ● In progress · Focused: yes · Other goals: 2                      │
-│ Tasks  [██████░░░░] 3/5 · 60%                                      │
-├─ Tasks ────────────────────────────────────────────────────────────┤
+╭─ pi-goal-x ─ Add CSV export to reports ────────────────────────────╮
+│ goal: running [12m47s 18.2K] (+2 open)                             │
+├─ Tasks · ✓3 done · 2 open ──────────── [█████░░░] · Sub 2/3 [██░░] ┤
 │ ✓ t1  Review reports page and data source                          │
 │ ✓ t2  Implement filtered CSV export                                │
-│ ▸ t3  Add the download button                                      │
+│ ▸ t3  Add the download button ☑ ▸ 2/3                              │
 │ · t4  Add documentation                                            │
 │ … +1 more task                                                     │
 │ Current  t3 · Add the download button                              │
-│ Subtasks [███████░░░] 2/3 · 67%                                    │
 │ 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.
@@ -353,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

@@ -21,53 +21,66 @@ activity are never fabricated for display.
 Always visible above the editor while a goal is focused:
 
 ```text
-╭─ pi-goal-x ─ Add CSV export to reports────────────── 12m47s · 18.2K tok ─╮
-│ ● In progress · Focused: yes · Other goals: 2                            │
-│ Tasks  [███████████░░░░░░░] 3/5 · 60%                                    │
-├─ Tasks ─────────────────────────────────────────────────────────────────┤
-│ ✓ t1  Review reports page and data source                                │
-│ ✓ t2  Implement filtered CSV export                                      │
-│ ▸ t3  Add the download button                                            │
-│ · t4  Add documentation                                                  │
-│ … +1 more task                                                           │
-│ Current  t3 · Add the download button                                    │
-│ Subtasks [████████████░░░░░░] 2/3 · 67%                                  │
-│ Verify   Run npm test with zero failures.                                │
-│ File     .pi/goals/active_goal_g1.md                                     │
-╰─ Ctrl+Shift+T: expand tasks─────────────────────────────────────────────╯
+╭─ pi-goal-x ─ Add CSV export to reports ────────────────────────────────────────────────╮
+│ goal: running [12m47s 18.2K] (+2 open)                                                 │
+├─ Tasks · ✓3 done · 2 open ─────────────────────────────────── [████░░] · Sub 2/3 [██░] ┤
+│ ✓ t1  Review reports page and data source                                              │
+│ ✓ t2  Implement filtered CSV export                                                    │
+│ ▸ t3  Add the download button ☑ ▸ 2/3                                                  │
+│ · t4  Add documentation                                                                │
+│ … +1 more task                                                                         │
+│ 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+A ──────────────────────────────────────── ● ─╯
 ```
 
 Compact rows, in order:
 
-1. Header (rounded corners): title plus elapsed time and token usage.
-2. Status: colored symbol + explicit label, focus state, other open goals
-   (`·`-separated). Colors come from the theme with a monochrome fallback.
+1. Header (rounded corners): title. (Usage lives in the status line below,
+   not in the header.)
+2. Status: `goal: <status> [<elapsed> <tokens>] (+N open)` — the same
+   terminology as the pi footer status line.
 3. Token budget (when configured): `⛽ Budget 18.2K / 50K · 36%`.
-4. Top-level task progress (`3/5 · 60%`); a skipped top-level task counts as
-   done (§9.1). The whole progress element is neutral gray — bar fill and
-   empty cells included — so nothing in the progress info is colourful.
-5. Task list section: the top-level tasks shown by default in **pastel
+4. Tasks header row: `Tasks · ✓N done · M open` with the compact task
+   progress bar, then the current task's subtask bar beside it
+   (` · Sub done/total ` + bar — the word `Sub` is dropped in narrow mode so
+   the full counts still fit at 50 columns, and the segment is omitted
+   entirely in minimal mode, where the counts and task bar alone use all
+   available space). `N` counts top-level tasks complete **or skipped** — a
+   skipped top-level task counts as done (§9.1) — and `M` counts pending
+   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.
+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
    list is longer than the row budget (5 rows at wide, 4 medium, 3 narrow, 2
-   minimal). The current task is fully highlighted in the theme's accent
-   color (marker, id, title). The whole box chrome — top/bottom frame,
-   left/right edges, corners and interior rules — is drawn in one tone: the
-   theme's neutral gray (`muted`). No blue tinge.
+   minimal). Tasks that have direct subtasks show a muted `▸ done/total`
+   marker at the end of their row (leaf tasks show none). The current task
+   is fully highlighted in the theme's accent color (marker, id, title). The
+   whole box chrome — top/bottom frame, left/right edges, corners and
+   interior rules — is drawn in one tone: the theme's neutral gray
+   (`muted`). No blue tinge.
 6. Current task: `Current  t3 · Add the download button` (id and title in the
    accent color).
-7. Current-task subtask progress (`2/3 · 67%`) when the current task has
-   direct children (the current task's subtasks stay inline). The subtask
-   bar and its fraction are neutral gray like the top-level progress.
-8. Goal-level verification contract (first line, truncated).
-9. Blocked or paused detail (reason, suggested action).
-10. Active (or archived) goal file path.
-11. Footer with the expansion shortcut. The whole footer line — leading dash,
+7. Goal-level verification contract (first line, truncated).
+8. Blocked or paused detail (reason, suggested action).
+9. Active (or archived) goal file path.
+10. Footer with the expansion shortcut. The whole footer line — leading dash,
     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
@@ -207,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

@@ -1,5 +1,4 @@
 import { type AgentToolResult, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { footerStatus } from "./goal-core.ts";
 import { FOCUS_ENTRY, STATE_ENTRY, GOAL_EVENT_ENTRY, goalDetails } from "./goal-format.ts";
 import { loadGoalSettings, loadGoalSettingsFileConfig } from "./goal-settings.ts";
 import {
@@ -122,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;
@@ -669,9 +670,12 @@ export function createGoalCore(
 			return;
 		}
 
-		const displayGoal = goalForDisplay() ?? state.goal;
-		const otherCount = otherOpenGoalCount(goalsById, focusedGoalId);
-		ctx.ui.setStatus("goal", `${footerStatus(displayGoal)}${otherCount > 0 ? ` (+${otherCount} open)` : ""}`);
+		// The goal widget is the single home for goal status: the status line
+		// lives in the compact/expanded dashboard (goal: <label> [<usage>]
+		// (+N open)), so the focused-goal footer segment is cleared — a stale
+		// unfocused hint or earlier status must not linger once a goal is
+		// focused. The unfocused branch above still sets its own hint.
+		ctx.ui.setStatus("goal", undefined);
 
 		if (!widgetRegistered) {
 			ctx.ui.setWidget(
@@ -808,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);
 	}
@@ -992,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