pi-goal-x 0.15.1 → 0.16.1

package/extensions/goal-policy.ts

@@ -202,7 +202,8 @@ export function validateTaskSkip(args: {
 	const task = args.goal.taskList.tasks.find((t) => t.id === args.taskId);
 	if (!task) return { ok: false, message: `Task "${args.taskId}" not found.` };
 	if (task.status === "complete") return { ok: false, message: `Task "${args.taskId}" is already complete.` };
-	if (task.status === "skipped") return { ok: false, message: `Task "${args.taskId}" was already skipped.` };
+	// Skipped tasks toggle via the executor; reason is only required for first-time skips.
+	if (task.status === "skipped") return { ok: true };
 	if (!args.reason.trim()) return { ok: false, message: "skip_task requires a non-empty reason." };
 	return { ok: true };
 }

package/extensions/goal.ts

@@ -105,6 +105,7 @@ import {
 } from "./prompts/goal-prompts.ts";
 import { buildGoalRunningNotification } from "./widgets/goal-notifications.ts";
 import { GoalWidgetComponent, type AuditorWidgetProgress } from "./widgets/goal-widget.ts";
+import { showEscapeDialog, type EscapeDialogResult } from "./widgets/goal-escape-dialog.ts";
 
 import {
 	abortGoalCommandMessage,
@@ -407,6 +408,7 @@ export default function goalExtension(pi: ExtensionAPI): void {
 	let auditProgress: AuditorWidgetProgress | null = null;
 	let auditAnimationTimer: ReturnType<typeof setInterval> | null = null;
 	let auditAbortController: AbortController | null = null;
+	let showingEscapeDialog = false;
 
 
 	// Per-turn flags reset in turn_start (#4, C9 fix).
@@ -959,6 +961,7 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			// Must return { consume: true } so the TUI doesn't also process the key
 			// and abort the running tool execution, which would cascade into pausing
 			// the entire goal (agent_end sees ctx.signal?.aborted and calls pauseActiveGoal).
+			if (showingEscapeDialog) return undefined;
 			if (matchesKey(data, "escape") && auditProgress) {
 				abortAudit(ctx);
 				return { consume: true };
@@ -2192,41 +2195,88 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			// Clear auditor progress display
 			stopAuditAnimation();
 
-			// If the audit was aborted by the user (Esc), skip the audit and leave the
-			// goal active/paused so the agent can ask the user what to do next.
+			// If the audit was aborted by the user (Esc), show a TUI dialog letting
+			// the user choose: mark complete without audit, or continue working.
 			if (auditor.error === "Auditor aborted.") {
-				pi.sendMessage<GoalAuditEventDetails>({
-					customType: GOAL_AUDIT_ENTRY,
-					content: [
-						`Goal audit skipped — auditor bypassed (user pressed Escape during audit).`, 
-						`Goal remains ${statusLabel(auditTarget)}.`, 
-						"", 
-						"Use goal_question to ask the user whether to:", 
-						"  - Mark the goal complete anyway (call complete_goal again)", 
-						"  - Give feedback on the work so far", 
-						"  - Continue working toward the goal",
-					].join("\n"),
-					display: true,
-					details: { phase: "skipped", goalId: auditTarget.id, auditor: auditorLabel },
-				});
 				auditProgress = null;
 				goalWidgetComponent?.invalidate();
-				syncGoalTools();
 				updateUI(ctx);
-				return {
-					content: [{
-						type: "text",
-						text: [
-							"Goal audit skipped (Escape pressed). The goal remains active.",
-							"",
-							"Use goal_question to ask the user whether to:",
-							"  - Mark the goal complete anyway (call complete_goal again)",
-							"  - Give feedback on the work so far",
-							"  - Continue working toward the goal",
+
+				showingEscapeDialog = true;
+				const userChoice: EscapeDialogResult = await showEscapeDialog(ctx, auditTarget.objective);
+				showingEscapeDialog = false;
+
+				if (userChoice === "complete_without_audit") {
+					// ── Mark complete without audit ────────────────────────────
+					pi.sendMessage<GoalAuditEventDetails>({
+						customType: GOAL_AUDIT_ENTRY,
+						content: `Goal completed — user bypassed audit via Escape.`,
+						display: true,
+						details: { phase: "skipped", goalId: auditTarget.id, auditor: auditorLabel },
+					});
+					try {
+						appendGoalEvent(ctx, {
+							type: "audit_skipped",
+							goalId: auditTarget.id,
+							reason: "user_aborted",
+							provider: settings.provider,
+							model: settings.model,
+							thinkingLevel: settings.thinkingLevel,
+							at: nowIso(),
+						});
+					} catch {
+						// Ledger append failure should not block completion
+					}
+					// Set goal complete in memory (defer archival to turn_end)
+					accountProgress(ctx);
+					state.goal = {
+						...auditTarget,
+						status: "complete",
+						stopReason: "agent",
+						updatedAt: nowIso(),
+					};
+					state.goal = writeActiveGoalFile(ctx, state.goal);
+					pi.appendEntry(STATE_ENTRY, goalDetails(state.goal));
+					turnStoppedFor = state.goal?.id ?? null;
+					resetGetGoalNudgeState(state.goal?.id);
+					syncGoalTools();
+					updateUI(ctx);
+					return {
+						content: [{
+							type: "text",
+							text: [
+								"User chose to mark the goal complete (bypassed audit via Escape).",
+								"",
+								"The goal is complete. Provide a final summary of what was accomplished.",
+							].join("\n"),
+						}],
+						details: goalDetails(state.goal),
+					};
+				} else {
+					// ── Continue working ────────────────────────────────────
+					pi.sendMessage<GoalAuditEventDetails>({
+						customType: GOAL_AUDIT_ENTRY,
+						content: [
+							`Goal audit skipped — user chose to continue working.`,
+							`Goal remains ${statusLabel(auditTarget)}.`,
 						].join("\n"),
-					}],
-					details: goalDetails(state.goal),
-				};
+						display: true,
+						details: { phase: "skipped", goalId: auditTarget.id, auditor: auditorLabel },
+					});
+					syncGoalTools();
+					updateUI(ctx);
+					return {
+						content: [{
+							type: "text",
+							text: [
+								"User chose to continue working (bypassed audit via Escape).",
+								"",
+								"Resume working toward the goal.",
+							].join("\n"),
+						}],
+						details: goalDetails(state.goal),
+					};
+				}
 			}
 
 			// Show final audit output briefly before clearing
@@ -2505,6 +2555,7 @@ export default function goalExtension(pi: ExtensionAPI): void {
 		promptGuidelines: [
 			"Use propose_task_list after a goal is confirmed, on the first continuation turn, if the objective naturally decomposes into trackable milestones.",
 			"Do not add a task list for simple, single-step goals.",
+			"If a task list already exists on the goal, only call propose_task_list to restructure it when (a) the user explicitly asks for a change, or (b) the goal objective or requirements have structurally changed. Do not restructure the task list autonomously.",
 			"Existing tasks with matching IDs preserve their status/evidence/timestamps; new IDs start as pending; removed IDs are gone.",
 			"After confirmation the turn stops; the next continuation will arrive automatically.",
 			"You may optionally specify a verificationContract per task to define what verification evidence is required before completing that task.",
@@ -2761,9 +2812,12 @@ export default function goalExtension(pi: ExtensionAPI): void {
 		label: "Skip Task",
 		description: "Skip a pending task in the current goal's task list. Does NOT stop the turn — the agent can continue working.",
 		promptSnippet: "Skip a task with a reason. Does not stop the turn.",
-		promptGuidelines: [
+promptGuidelines: [
 			"Use skip_task to mark a task as skipped with a required reason.",
 			"The turn does NOT stop after skip_task — you may continue with other work.",
+			"Only skip a task when the user explicitly asks you to, or when the task directly contradicts a hard constraint (e.g. an impossible requirement).",
+			"Do NOT autonomously skip tasks to avoid work, or because they look optional, inconvenient, or out of scope. When in doubt, ask the user first.",
+			"If skip_task is called on an already-skipped task, it toggles back to pending (unskip).",
 		],
 		parameters: Type.Object({
 			taskId: Type.String({ description: "Task id to skip" }),
@@ -2787,8 +2841,15 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			}
 			if (!state.goal?.taskList) throw new Error("Task list disappeared during task skip.");
 			const now = nowIso();
+			const wasAlreadySkipped = findTaskInTree(state.goal.taskList.tasks, params.taskId)?.status === "skipped";
+
 			const updatedTasks = updateTaskInTree(state.goal.taskList.tasks, params.taskId, (t) => {
-				// Cascade skip to all subtasks (full subtasks only)
+				if (t.status === "skipped") {
+					// Toggle back to pending — clear skip state, do NOT cascade to subtasks
+					const { skippedAt, skipReason, ...rest } = t;
+					return { ...rest, status: "pending" as const };
+				}
+				// First-time skip: cascade to all subtasks (full subtasks only)
 				const base = { ...t, status: "skipped" as const, skippedAt: now, skipReason: params.reason.trim() };
 				if (t.subtasks && t.subtasks.length > 0 && !t.lightweightSubtasks) {
 					return skipAllSubtasks(base, now, params.reason.trim());
@@ -2806,22 +2867,33 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			syncGoalTools();
 			updateUI(ctx);
 
-			// Append ledger event
+// Append ledger event
 			try {
-				appendGoalEvent(ctx, {
-					type: "task_skipped",
-					goalId: state.goal.id,
-					taskId: params.taskId,
-					reason: params.reason.trim(),
-					at: now,
-				});
+				if (wasAlreadySkipped) {
+					appendGoalEvent(ctx, {
+						type: "task_skipped",
+						goalId: state.goal.id,
+						taskId: params.taskId,
+	reason: "unskipped (toggle via skip_task)",
+						at: now,
+					});
+				} else {
+					appendGoalEvent(ctx, {
+						type: "task_skipped",
+						goalId: state.goal.id,
+						taskId: params.taskId,
+						reason: params.reason.trim(),
+						at: now,
+					});
+				}
 			} catch {
 				// Ledger failure should not block task skip
 			}
 
 			const taskSummary = buildTaskSummary(state.goal.taskList!);
+			const action = wasAlreadySkipped ? "unsikpped" : "skipped";
 			return {
-				content: [{ type: "text", text: `${params.taskId} skipped. ${taskSummary}.` }],
+				content: [{ type: "text", text: `${params.taskId} ${action}. ${taskSummary}.` }],
 				details: goalDetails(state.goal),
 			};
 		},

package/extensions/prompts/goal-prompts.ts

@@ -130,17 +130,19 @@ ${untrustedObjectiveBlock(goal)}
 
 Available work tools for pursuing the active goal include write, read, bash, and edit. Use those tools directly for file and shell work; do not call get_goal repeatedly to discover tools.
 
-If the objective naturally decomposes into trackable milestones, you may call propose_task_list to set up structured tasks. Do not add a task list for simple, single-step goals.
+After goal confirmation, you may call propose_task_list once to set up an initial task list if the objective decomposes into trackable milestones. If a task list already exists, only restructure it when the user asks or the goal structurally changes — do not restructure autonomously. Do not add a task list for simple, single-step goals.
 
 To ask the user a structured question (e.g. when the user's spec changes and you need to clarify before updating the goal), use goal_question. It opens a question dialog and returns the user's answer as tool output. Use plain conversation for simple clarifications.
 
+Task skipping restrictions: Only skip a task when the user explicitly asks you to, or when the task directly contradicts a hard constraint (e.g. an impossible requirement). Do NOT autonomously skip tasks to avoid work, or because they look optional, inconvenient, or out of scope. When in doubt, ask the user first. Calling skip_task on an already-skipped task toggles it back to pending (unskip).
+
 Keep this goal in force until it is actually achieved. Do not pause for confirmation just because a phase, chapter, file, or checklist item is finished. At each natural stopping point, compare every explicit requirement with concrete evidence from the workspace/session. If the objective is complete, call complete_goal with status=complete and provide a verificationSummary; complete_goal will launch an independent pi auditor agent and only archive if that auditor returns <approved/>. If it is not complete, choose the next concrete action and do it.
 
 The completion auditor is independent and semantic, not a paperwork checklist. It may inspect files and command output, and it will reject scaffold-only, alpha, template, proxy-metric, or weakly verified completions with <disapproved/>.
 
 Before marking any sub-item as complete (including ✅ checkmarks in your output), verify thoroughly against the goal's success criteria and any verification contract. Only mark items as done when you have concrete evidence — not intent or partial progress.
 
-If the user presses Escape while the audit is running, the audit is skipped and the goal remains active. Use goal_question to ask the user whether to mark the goal complete anyway, give feedback, or continue working toward the goal.
+If the user presses Escape during a completion audit, a TUI dialog appears with "Mark complete without audit" or "Continue working". You will receive a structured message with the user's choice.
 
 If you hit a real blocker that you cannot resolve with one more reasonable next step (missing credentials, contradictory spec, file/permission you cannot access, dangerous operation pending user approval, or an unclear Sisyphus-style ordered plan), the CORRECT action is to call pause_goal({reason, suggestedAction?}) with a structured, non-empty reason. pause_goal IS the channel for handing control back to the user — do not substitute a conversational "blocked, please help" summary in your final message and skip the tool call. Without pause_goal, the goal stays "active" and the UI cannot show the blocker. After pause_goal returns, you may add one short user-facing summary, but the tool call comes first.
 
@@ -168,7 +170,9 @@ export function continuationPrompt(goal: GoalRecord, settings?: GoalSettings): s
 		"",
 		"Available work tools for pursuing the active goal include write, read, bash, and edit. Use those tools directly for file and shell work; do not call get_goal repeatedly to discover tools.",
 		"",
-		"To ask the user a structured question (e.g. when the user's spec changes and you need to clarify before updating the goal), use goal_question. It opens a question dialog and returns the user's answer as tool output. Use plain conversation for simple clarifications.",
+"To ask the user a structured question (e.g. when the user's spec changes and you need to clarify before updating the goal), use goal_question. It opens a question dialog and returns the user's answer as tool output. Use plain conversation for simple clarifications.",
+		"",
+		"Task skipping restrictions: Only skip a task when the user explicitly asks you to, or when the task directly contradicts a hard constraint (e.g. an impossible requirement). Do NOT autonomously skip tasks to avoid work, or because they look optional, inconvenient, or out of scope. When in doubt, ask the user first. Calling skip_task on an already-skipped task toggles it back to pending (unskip).",
 		"",
 		"Avoid repeating work that is already done. Choose the next concrete action toward the objective.",
 		"",

package/extensions/widgets/goal-escape-dialog.ts

@@ -0,0 +1,145 @@
+import { matchesKey, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import type { Component, TUI } from "@earendil-works/pi-tui";
+import type { ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+
+/**
+ * Result of the Escape dialog during audit.
+ */
+export type EscapeDialogResult = "complete_without_audit" | "continue_working";
+
+/**
+ * Show a TUI confirmation dialog when the user presses Escape during a completion audit.
+ *
+ * Presents two choices:
+ *   - Mark complete without audit (skips auditor, marks goal complete immediately)
+ *   - Continue working (returns to agent, goal stays active)
+ *
+ * Returns the user's choice. Escape or Enter on a focused option submits the selection.
+ */
+export async function showEscapeDialog(
+	ctx: ExtensionContext,
+	goalObjective: string,
+): Promise<EscapeDialogResult> {
+	if (!ctx.hasUI) {
+		// Fallback for headless/RPC mode — return "continue" as the safe default
+		return "continue_working";
+	}
+
+	return await ctx.ui.custom<EscapeDialogResult>(
+		(tui: TUI, theme: Theme, _keybindings: unknown, done: (result: EscapeDialogResult) => void): Component => {
+			const wasHardwareCursorShown = tui.getShowHardwareCursor();
+			tui.setShowHardwareCursor(false);
+
+			let selectedIndex = 1; // Default: "Continue working" (index 1)
+			let cancelled = false;
+
+			const OPTIONS: Array<{ label: string; value: EscapeDialogResult; description: string }> = [
+				{
+					label: "Mark complete without audit",
+					value: "complete_without_audit",
+					description: "Bypass the auditor and mark the goal complete now.",
+				},
+				{
+					label: "Continue working",
+					value: "continue_working",
+					description: "Resume work on the goal. The audit will not run this turn.",
+				},
+			];
+
+			const accent = (s: string) => theme.fg("accent", s);
+			const dim = (s: string) => theme.fg("dim", s);
+			const warning = (s: string) => theme.fg("warning", s);
+
+			// ── Component ────────────────────────────────────────────────────
+			const component: Component & { dispose?(): void } = {
+				dispose() {
+					tui.setShowHardwareCursor(wasHardwareCursorShown);
+				},
+
+				invalidate(): void {
+					// No cached state to invalidate
+				},
+
+				render(width: number): string[] {
+					const termWidth = Math.min(width, 80);
+					const innerWidth = Math.min(termWidth, 64) - 2; // inner content width between ││
+
+					/** Build a bordered line: fits exactly `innerWidth` visible chars between ││ */
+					function line(leftContent: string): string {
+						const vis = visibleWidth(leftContent);
+						const fill = innerWidth - vis;
+						return accent("│") + leftContent + (fill > 0 ? " ".repeat(fill) : "") + accent("│");
+					}
+
+					const horizLine = "─".repeat(innerWidth);
+					const lines: string[] = [];
+					const p = "  "; // left padding inside the border
+
+					// ── Header ────────────────────────────────────────────────
+					lines.push(accent(`┌${horizLine}┐`));
+					lines.push(line(p + theme.bold("Audit interrupted by Escape") + dim("  (continue = default)")));
+					const truncatedObjective = truncateToWidth(goalObjective, innerWidth - 14, "…");
+					lines.push(line(p + dim("Goal: ") + dim(truncatedObjective)));
+					lines.push(accent(`├${horizLine}┤`));
+
+					// ── Options ─────────────────────────────────────────────
+					OPTIONS.forEach((opt, i) => {
+						const isSelected = i === selectedIndex && !cancelled;
+						const marker = isSelected ? "▸ " : "  ";
+						const label = isSelected ? warning(opt.label) : opt.label;
+						const truncLabel = truncateToWidth(label, innerWidth - 6, "…");
+						lines.push(line(p + marker + truncLabel));
+						if (isSelected && opt.description) {
+							const desc = dim(opt.description);
+							const truncDesc = truncateToWidth(desc, innerWidth - 10, "…");
+							lines.push(line(p + " ".repeat(4) + truncDesc));
+						}
+					});
+
+					// ── Footer ───────────────────────────────────────────────
+					lines.push(accent(`├${horizLine}┤`));
+					const footerText = dim("Enter to select  ·  ↑↓ to navigate  ·  Esc = continue working");
+						const truncFooter = truncateToWidth(footerText, innerWidth - 2, "…");
+					lines.push(line(p + truncFooter));
+					lines.push(accent(`└${horizLine}┘`));
+
+					return lines;
+				},
+
+				handleInput(data: string): void {
+					if (matchesKey(data, "up")) {
+						selectedIndex = (selectedIndex - 1 + OPTIONS.length) % OPTIONS.length;
+						tui.requestRender();
+						return;
+					}
+					if (matchesKey(data, "down")) {
+						selectedIndex = (selectedIndex + 1) % OPTIONS.length;
+						tui.requestRender();
+						return;
+					}
+					if (matchesKey(data, "enter")) {
+						cancelled = false;
+						done(OPTIONS[selectedIndex].value);
+						return;
+					}
+					if (matchesKey(data, "escape")) {
+						cancelled = true;
+						done("continue_working");
+						return;
+					}
+				},
+			};
+
+			return component;
+		},
+		{
+			overlay: true,
+			overlayOptions: {
+				anchor: "center",
+				width: "70%",
+				minWidth: 50,
+				maxHeight: "50%",
+			},
+		},
+	);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-x",
-  "version": "0.15.1",
+  "version": "0.16.1",
   "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",