pi-goal-x 0.25.3 → 0.26.0

package/README.md

@@ -260,12 +260,14 @@ 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+A ──────────────────── ● ─╯
+╰─ Ctrl+Shift+T: expand tasks─────── Ctrl+Shift+A: toggle auditor ● ─╯
 ```
 
 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).
+independent-auditor status (green = on, gray = off). Wide/medium footers
+right-align the `Ctrl+Shift+A: toggle auditor` note beside the dot — it
+shows the shortcut that turns the auditor on and off; narrow/minimal keep
+just the dot.
 
 ### Expanded mode
 

package/docs/architecture.md

@@ -19,7 +19,7 @@ handlers from their dedicated modules:
 | `goal-task-tools.ts` | `set_goal_tasks` / `update_goal_task` executors plus flat parent-linked conversion, id-stable merge, `countTasks` |
 | `goal-task-confirmation.ts` | Task-only result boundary (`{decision}`, no auditor toggle) with neutral Confirm task list / Keep current tasks labels |
 | `goal-commands.ts` | The curated fourteen-command palette and its handlers |
-| `goal-events.ts` | The 13 lifecycle event handlers (`context`, `turn_start`, `tool_call`, `tool_execution_end`, `turn_end`, `message_end`, `session_start`, `session_before_compact`, `session_compact`, `session_tree`, `before_agent_start`, `agent_end`, `session_shutdown`) |
+| `goal-events.ts` | The 14 lifecycle event handlers (`context`, `turn_start`, `tool_call`, `tool_execution_end`, `turn_end`, `message_end`, `session_start`, `session_before_compact`, `session_compact`, `session_tree`, `before_agent_start`, `agent_end`, `agent_settled`, `session_shutdown`) |
 | `goal-widget.ts` | Terminal input keybindings (Esc pause / abort-audit, Ctrl+Shift+T overlay) and the hidden debug helpers |
 | `goal-format.ts` | Pure formatting/message-introspection helpers and renderers |
 | `goal-service.ts` | `GoalService` — the sole mutation boundary: ordered reconcile → id/focus-revision validation → clone-mutate → write/archive → ledger → memory commit → returned effects |

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+A ──────────────────────────────────────── ● ─╯
+╰─ Ctrl+Shift+T: expand tasks─────────────────────────── Ctrl+Shift+A: toggle auditor ● ─╯
 ```
 
 Compact rows, in order:
@@ -74,13 +74,14 @@ Compact rows, in order:
     split; the header line is likewise one tone with only the `pi-goal-x`
     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.
+    is on, gray when off — drawn right before the `╯` corner. In wide/medium
+    layouts the footer also right-aligns a `Ctrl+Shift+A: toggle auditor`
+    note beside the dot, making explicit that the shortcut turns the auditor
+    on and off; narrow and minimal keep just the dot. `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

package/extensions/goal-draft.ts

@@ -150,6 +150,7 @@ export function goalDraftingPrompt(topic: string, focus: GoalDraftingFocus): str
 		"- For simple single-step goals, no task list is required. The `tasks` parameter can be omitted.",
 		"- After goal creation, `propose_task_list` is still available for user-requested task additions or structural changes.",
 		"- propose_goal_draft opens the user's Confirm / Continue Chatting dialog. Confirm creates and focuses the goal; Continue Chatting means keep refining through normal proposal cycles.",
+		"- Before proposing, write the COMPLETE goal into your own message — every section (objective, success criteria, boundaries, constraints, verification contract) and the full task list — so the user can scroll up and re-read the whole goal while the confirmation dialog is open. Nothing may be omitted from the presented goal.",
 		"- create_goal is not a shortcut. Direct create_goal calls are rejected so the user keeps explicit say in goal creation.",
 	];
 

package/extensions/goal-drafting.ts

@@ -454,7 +454,30 @@ export function registerDraftingTools(core: GoalCore): void {
 			clearGoalDrafting(core, ctx);
 			return { content: [{ type: "text", text: `${summary}\n\nGoal tweak confirmed and applied.` }], details: goalDetails(result.goal), terminate: true };
 		},
-		renderCall(args, theme) { return new Text(theme.fg("toolTitle", "propose_goal_draft ") + theme.fg("muted", args?.objective ?? ""), 0, 0); },
+		renderCall(args, theme) {
+			// §proposal-presentation: the tool-call display lands in the terminal
+			// buffer the moment the tool call starts — BEFORE the confirmation
+			// dialog opens — so it is the scrollable "complete presentation" of
+			// the goal. It must show the full objective contract AND every task
+			// line; the dialog frame alone cannot (its churn-guard bound keeps
+			// it within the terminal height). The user can scroll up and read
+			// everything while the dialog is open ("the user can just scroll").
+			const objective = String(args?.objective ?? "");
+			let text = theme.fg("toolTitle", "propose_goal_draft ") + theme.fg("muted", objective);
+			const flatTasks = Array.isArray(args?.tasks) ? (args.tasks as FlatTaskInput[]) : [];
+			const derived = flatTasks.length === 0 ? (deriveTasksFromObjective(objective) ?? []) : [];
+			const taskBlock = flatTasks.length > 0
+				? { header: "Tasks proposed for confirmation:", lines: flatTasks.map((t) => `[ ] ${t.id}: ${t.title}`) }
+				: derived.length > 0
+					? { header: "Tasks derived from the objective (confirm or ask the agent to adjust):", lines: renderConfirmationTasks(derived, 0) }
+					: null;
+			if (taskBlock) {
+				text += "\n\n" + theme.fg("toolTitle", theme.bold(taskBlock.header)) + "\n" + theme.fg("toolOutput", taskBlock.lines.join("\n"));
+			}
+			if (args?.auto_continue === false) text += "\n\n" + theme.fg("muted", "Automatic continuation: disabled");
+			if (args?.block_completion === true) text += "\n\n" + theme.fg("muted", "Block completion on pending tasks: enabled");
+			return new Text(text, 0, 0);
+		},
 		renderResult(result, _opts, theme) { return renderGoalResult(result, _opts, theme); },
 	}));
 }

package/extensions/goal-events.ts

@@ -34,10 +34,12 @@ import type { GoalMutationOutcome } from "./goal-service.ts";
  * The goal extension's lifecycle event handlers (context, turn_start,
  * tool_call, tool_execution_end, turn_end, message_end, session_start,
  * session_before_compact, session_compact, session_tree, before_agent_start,
- * agent_end, session_shutdown). All state flows through the GoalCore.
+ * agent_end, agent_settled, session_shutdown). All state flows through the
+ * GoalCore.
  */
 export function registerGoalEvents(core: GoalCore): void {
 	const { pi } = core;
+	let continuationAfterSettleFor: string | null = null;
 
 	pi.on("context", async (event): Promise<{ messages: typeof event.messages } | undefined> => {
 		let changed = false;
@@ -418,6 +420,7 @@ export function registerGoalEvents(core: GoalCore): void {
 	pi.on("agent_end", async (event, ctx) => {
 		const endedGoalId = core.runningGoalId;
 		core.runningGoalId = null;
+		continuationAfterSettleFor = null;
 
 		// Account for any tokens from aborted in-flight assistant messages so
 		// they are not silently lost (but charge them to the original goal).
@@ -446,10 +449,23 @@ export function registerGoalEvents(core: GoalCore): void {
 		}
 		core.persist(ctx);
 		core.updateUI(ctx);
-		core.queueContinuation(ctx);
+		// agent_end runs before pi finishes retries, compaction, terminating-tool
+		// settlement, and queued messages. Starting the continuation timer here
+		// can poll a stale busy context for minutes on pi 0.84. agent_settled is
+		// available in both supported SDK lines (0.83 and 0.84) and is the first
+		// point where pi guarantees no automatic work remains.
+		continuationAfterSettleFor = core.state.goal.id;
+	});
+
+	pi.on("agent_settled", async (_event, ctx) => {
+		const goalId = continuationAfterSettleFor;
+		continuationAfterSettleFor = null;
+		if (!goalId || !core.isActionableContinuationGoal(goalId)) return;
+		core.queueContinuation(ctx, true);
 	});
 
 	pi.on("session_shutdown", async (_event, ctx) => {
+		continuationAfterSettleFor = null;
 		core.accountProgress(ctx);
 		core.clearContinuationTimer();
 		core.terminalInputUnsubscribe?.();

package/extensions/goal-questionnaire.ts

@@ -29,6 +29,139 @@ export interface GoalQuestionnaireResult {
 
 export type ProposalDecision = "confirm" | "continue" | "cancel";
 
+/**
+ * Bound a custom dialog using the regular renderer's frame cache when
+ * available. The pi 0.84 fullscreen renderer does not expose that cache, so
+ * reserve four rows for host chrome and use the remaining terminal height.
+ */
+export function computeDialogLineLimit(args: { terminalRows?: number; baseFrameLines?: number }): number | undefined {
+	const rows = args.terminalRows;
+	if (!rows || rows <= 0) return undefined;
+	if (args.baseFrameLines && args.baseFrameLines > 0) {
+		return Math.min(rows, Math.max(10, rows - args.baseFrameLines + 1));
+	}
+	return Math.min(rows, Math.max(4, rows - 4));
+}
+
+/**
+ * Proposal-confirmation segment descriptor: absolute line indices of the
+ * tasks section (header + every task line) and the start of the options tail
+ * inside a rendered questionnaire dialog.
+ */
+export interface ProposalPresentationSegments {
+	tasksStart: number;
+	tasksEnd: number;
+	tailStart: number;
+}
+
+/**
+ * Locate the proposal tasks segment and the options tail in a rendered dialog.
+ * Returns null when the dialog is not a proposal-style confirmation (no
+ * "Tasks proposed for confirmation:" header / "┌─ TASKS ─" box).
+ */
+export function findProposalPresentationSegments(lines: string[], tailStart: number): ProposalPresentationSegments | null {
+	if (tailStart < 0) return null;
+	const tasksStart = lines.findIndex((l) => l.includes("Tasks proposed for confirmation:") || l.includes("┌─ TASKS ─"));
+	if (tasksStart < 0 || tasksStart >= tailStart) return null;
+	let tasksEnd = tasksStart;
+	for (let i = tasksStart + 1; i < tailStart; i++) {
+		if (/^\s*\[[ x~]\]/.test(lines[i])) tasksEnd = i;
+		else break;
+	}
+	return { tasksStart, tasksEnd, tailStart };
+}
+
+/**
+ * Fit a rendered dialog to the terminal-height bound without ever hiding the
+ * question. The protected head (top border + tabs + question line) is always
+ * kept; the remaining budget is spent on the tail — options/footer/bottom
+ * border — so long context blocks (proposal confirmations) are sliced from
+ * their head exactly as the pre-fix tail-slice did (383ae52 surface). When the
+ * options block starts immediately after the head (plain agent questions with
+ * no context block), the TOP options are kept instead of the tail so the
+ * recommended/first option stays visible; the footer hint and bottom border
+ * are always the last rendered lines. Never returns more than maxDialogLines.
+ *
+ * Proposal confirmations (proposal segments given) keep the head, the tasks
+ * section (header + every task line), and the options/footer/bottom border in
+ * frame; only the objective-box middle is sacrificed in-frame — the full
+ * objective is always present in the scrollable transcript presentation
+ * (propose_goal_draft renderCall), so nothing of the goal is ever omitted.
+ */
+export function fitDialogLines(
+	lines: string[],
+	maxDialogLines: number,
+	protectedHead: number,
+	optionsImmediatelyAfterHead = false,
+	proposal: ProposalPresentationSegments | null = null,
+): string[] {
+	if (maxDialogLines <= 0 || lines.length <= maxDialogLines) return lines;
+	const keepHead = Math.min(protectedHead, maxDialogLines);
+	const budget = maxDialogLines - keepHead;
+	if (budget <= 0) return lines.slice(0, keepHead);
+	const rest = lines.slice(protectedHead);
+	if (rest.length <= budget) return [...lines.slice(0, keepHead), ...rest];
+	if (proposal) {
+		return fitProposalPresentation(lines, maxDialogLines, keepHead, proposal);
+	}
+	if (optionsImmediatelyAfterHead) {
+		// Plain select-mode question: keep the footer hint + bottom border (as
+		// many as fit), then spend the remaining room on the TOP options so the
+		// recommended/first option stays visible; leading blank separators are
+		// dropped first when room is short. Never exceeds maxDialogLines.
+		const headLines = lines.slice(0, keepHead);
+		const firstContent = rest.findIndex((l) => l.trim().length > 0);
+		const lead = firstContent > 0 ? rest.slice(0, firstContent) : [];
+		const contentStart = firstContent > 0 ? firstContent : 0;
+		const tailBudget = Math.min(2, budget); // footer hint + bottom border
+		const tail = rest.slice(-tailBudget);
+		const room = budget - tailBudget;
+		const keepContent = Math.max(0, Math.min(rest.length - contentStart, room));
+		const keepLead = Math.max(0, Math.min(lead.length, room - keepContent));
+		const content = rest.slice(contentStart, contentStart + keepContent);
+		return [...headLines, ...lead.slice(0, keepLead), ...content, ...tail];
+	}
+	// Context-heavy / input / submit dialogs: keep the head and the tail
+	// (options, footer, bottom border) exactly as the pre-fix tail-slice did.
+	return [...lines.slice(0, keepHead), ...rest.slice(rest.length - budget)];
+}
+
+/**
+ * Proposal confirmation fit: keep the protected head, the tasks section, and
+ * the options/footer/bottom border; the objective-box middle is sacrificed
+ * in-frame (it stays fully readable in the scrollback presentation). Interior
+ * blank spacing lines are dropped first when room is short; task lines are
+ * only dropped after that, from the end, when the bound is exhausted (those
+ * lines remain in the scrollback presentation). Never exceeds maxDialogLines.
+ */
+function fitProposalPresentation(
+	lines: string[],
+	maxDialogLines: number,
+	keepHead: number,
+	proposal: ProposalPresentationSegments,
+): string[] {
+	const { tasksStart, tasksEnd, tailStart } = proposal;
+	const head = lines.slice(0, keepHead);
+	const tasks = lines.slice(Math.max(tasksStart, keepHead), Math.min(tasksEnd, tailStart) + 1);
+	const tail = lines.slice(Math.max(tailStart, keepHead));
+	const candidate = [...head, ...tasks, ...tail];
+	if (candidate.length <= maxDialogLines) return candidate;
+	// Tight: drop blank spacing lines below the head (e.g. the blank between
+	// the options and the footer hint) before touching any content line.
+	const stripped = candidate.filter((l, i) => i < keepHead || l.trim() !== "");
+	if (stripped.length <= maxDialogLines) return stripped;
+	// Bound still exhausted: keep the head, then spend the room on the tail
+	// first (options/footer/bottom border — the actionable decision surface —
+	// kept from its end so the border and footer never drop), then on the
+	// tasks from the start. The dropped task lines remain fully readable in
+	// the scrollback presentation. Never exceeds maxDialogLines.
+	const tailNoBlanks = tail.filter((l) => l.trim() !== "");
+	const keepTail = Math.min(tailNoBlanks.length, Math.max(0, maxDialogLines - keepHead));
+	const tailKept = tailNoBlanks.slice(tailNoBlanks.length - keepTail);
+	const keepTasks = Math.min(tasks.length, Math.max(0, maxDialogLines - keepHead - keepTail));
+	return [...head, ...tasks.slice(0, keepTasks), ...tailKept];
+}
+
 export function normalizeQuestionnaireQuestions(rawQuestions: GoalQuestionnaireQuestion[]): GoalQuestionnaireQuestion[] {
 	const seenIds = new Set<string>();
 	return rawQuestions.map((q, i) => {
@@ -108,18 +241,20 @@ export async function runGoalQuestionnaire(ctx: ExtensionContext, rawQuestions:
 		// the frame never exceeds the terminal height — without this, closing a dialog
 		// taller than the terminal triggers pi-tui's generic shrink full-render
 		// (\x1b[2J\x1b[H\x1b[3J), erasing terminal scrollback and yanking the viewport
-		// so the window takes ~10s to scroll back to the bottom. The tail slice keeps
-		// the actionable options/footer in view; content that fits renders exactly as
-		// the pre-regression (383ae52) UI. Only applies with real TUI dimensions.
+		// so the window takes ~10s to scroll back to the bottom. The slice keeps
+		// the question and the actionable options/footer in view (see
+		// fitDialogLines); content that fits renders exactly as the
+		// pre-regression (383ae52) UI. Only applies with real TUI dimensions.
 		const tuiInfo = tui as unknown as { terminal?: { rows?: number }; previousLines?: string[] };
 		const terminalRows = tuiInfo.terminal?.rows;
 		const baseFrame = tuiInfo.previousLines?.length;
-		const maxDialogLines = terminalRows && baseFrame ? Math.max(10, terminalRows - baseFrame + 1) : undefined;
+		const maxDialogLines = computeDialogLineLimit({ terminalRows, baseFrameLines: baseFrame });
 		let currentTab = 0;
 		let optionIndex = 0;
 		let inputMode = false;
 		let inputQuestionId: string | null = null;
 		let cachedLines: string[] | undefined;
+		let optionsStartIndex = -1;
 		let auditorEnabled = auditorToggleInit?.defaultEnabled ?? true;
 		const answers = new Map<string, GoalQuestionnaireAnswer>();
 		const drafts = new Map<string, string>();
@@ -439,6 +574,9 @@ export async function runGoalQuestionnaire(ctx: ExtensionContext, rawQuestions:
 			};
 
 			add(theme.fg("accent", "─".repeat(safeWidth)));
+			// Lines up to the question line (top border, tabs, question incl.
+			// wraps) are the protected head — the slice below must never hide them.
+			let protectedCount = lines.length;
 			if (isMulti) {
 				const tabs: string[] = ["← "];
 				for (let i = 0; i < questions.length; i++) {
@@ -453,9 +591,11 @@ export async function runGoalQuestionnaire(ctx: ExtensionContext, rawQuestions:
 				tabs.push(" →");
 				add(` ${tabs.join("")}`);
 				lines.push("");
+				protectedCount = lines.length;
 			}
 
 			function renderOptions() {
+				optionsStartIndex = lines.length;
 				for (let i = 0; i < opts.length; i++) {
 					const opt = opts[i];
 					const selected = i === optionIndex;
@@ -467,6 +607,7 @@ export async function runGoalQuestionnaire(ctx: ExtensionContext, rawQuestions:
 
 			if (inputMode && q) {
 				addWrapped(theme.fg("text", ` ${q.question}`));
+				protectedCount = lines.length;
 				if (q.context) renderContextLines(q.context);
 				lines.push("");
 				if (q.options.length > 0) {
@@ -479,6 +620,7 @@ export async function runGoalQuestionnaire(ctx: ExtensionContext, rawQuestions:
 				add(theme.fg("dim", " Enter to submit • Esc to cancel"));
 			} else if (currentTab === questions.length) {
 				add(theme.fg("accent", theme.bold(" Ready to submit")));
+				protectedCount = lines.length;
 				lines.push("");
 				for (const question of questions) {
 					const answer = answers.get(question.id);
@@ -488,6 +630,7 @@ export async function runGoalQuestionnaire(ctx: ExtensionContext, rawQuestions:
 				add(allAnswered() ? theme.fg("success", " Press Enter to submit") : theme.fg("warning", ` Unanswered: ${questions.filter((qq) => !answers.has(qq.id)).map((qq) => qq.id).join(", ")}`));
 			} else if (q) {
 				addWrapped(theme.fg("text", ` ${q.question}`));
+				protectedCount = lines.length;
 				if (q.context) renderContextLines(q.context);
 				// Auditor toggle line between context and options
 				if (auditorToggleInit) {
@@ -516,9 +659,21 @@ export async function runGoalQuestionnaire(ctx: ExtensionContext, rawQuestions:
 					lines[i] = truncateToWidth(lines[i], safeWidth);
 				}
 			}
-			// Churn guard: tail-slice to the terminal-height bound (see factory top).
+			// Churn guard: bound to the terminal height (see factory top) so the
+			// opened frame never exceeds the screen. Never slice the question:
+			// keep the protected head, then spend the rest of the budget on the
+			// tail (options/footer/bottom border) — or, for plain select-mode
+			// questions where the options start right after the head, keep the
+			// top options so the recommended one stays visible. Proposal
+			// confirmations additionally keep the tasks section in frame; the
+			// objective-box middle is sacrificed there because the full objective
+			// is always in the scrollable transcript presentation (renderCall).
 			if (maxDialogLines !== undefined && lines.length > maxDialogLines) {
-				lines = lines.slice(lines.length - maxDialogLines);
+				const optionsImmediatelyAfterHead = !inputMode && currentTab !== questions.length && !!q && !q.context && opts.length > 0;
+				const proposalSegments = !inputMode && currentTab !== questions.length && !!q && q.context
+					? findProposalPresentationSegments(lines, optionsStartIndex)
+					: null;
+				lines = fitDialogLines(lines, maxDialogLines, protectedCount, optionsImmediatelyAfterHead, proposalSegments);
 			}
 			cachedLines = lines;
 			return lines;

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

@@ -317,7 +317,8 @@ export function renderCompactDashboard(
 
 	// §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.
+	// below); wide/medium footers right-align a note next to it explaining
+	// that Ctrl+Shift+A turns the auditor on and off.
 
 	// §9.1 compact task counts + progress bars live in the Tasks header row
 	// (below); the standalone progress lines were removed in favor of it.
@@ -396,21 +397,26 @@ 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))
-		// §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.
+			: spec.footerHint);
+	// The auditor dot sits at the bottom-right of the border: green when the
+	// focused goal's independent auditor is on, muted gray when off. In
+	// wide/medium a right-aligned note (same frame tone as the hint) explains
+	// that Ctrl+Shift+A turns the auditor on and off; narrow/minimal keep
+	// just the dot. The boxFooter right slot pushes both to the right edge,
+	// so the chord and its note are right-aligned by construction.
 	const auditorDot = model.auditorEnabled ? success(theme, "●") : muted(theme, "●");
-	lines.push(boxFooter(theme, safeWidth, footerHint, auditorDot));
+	const right =
+		mode === "wide" || mode === "medium"
+			? `${frame(theme, "Ctrl+Shift+A: toggle auditor")} ${auditorDot}`
+			: auditorDot;
+	lines.push(boxFooter(theme, safeWidth, footerHint, right));
 	return lines;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-x",
-  "version": "0.25.3",
+  "version": "0.26.0",
   "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",
@@ -62,9 +62,9 @@
     "typebox": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "^0.83.0",
-    "@earendil-works/pi-coding-agent": "^0.83.0",
-    "@earendil-works/pi-tui": "^0.83.0",
+    "@earendil-works/pi-ai": "^0.84.1",
+    "@earendil-works/pi-coding-agent": "^0.84.1",
+    "@earendil-works/pi-tui": "^0.84.1",
     "typebox": "^1.0.58",
     "typescript": "^5.9.3"
   },