pi-goal-x 0.7.2 → 0.8.2

package/README.md

@@ -1,20 +1,34 @@
 # pi-goal-x
 
-> **Fork of [@capyup/pi-goal](https://github.com/capyup/pi-goal).** Upstream changes can be merged from the original repository.
+> **Fork of [@capyup/pi-goal](https://github.com/capyup/pi-goal)** — this repository extends the upstream with quality-of-life features for the completion auditor, lifecycle reliability improvements, and drafting UX refinements. Upstream changes can be merged from the original repository.
 
 `pi-goal-x` is a long-running goal extension for [pi](https://github.com/earendil-works/pi-coding-agent). It gives the agent a durable objective, a visible lifecycle, and schema-gated tools for drafting, executing, pausing, resuming, and completing work.
 
 The extension is designed around one rule: **the user owns intent; the agent executes only after the goal is explicit and confirmed**.
 
-## What's new in pi-goal-x
+## What's different from upstream
 
-pi-goal-x adds a handful of quality-of-life features on top of the original:
+All core features of [@capyup/pi-goal](https://github.com/capyup/pi-goal) are preserved. The following changes are specific to pi-goal-x:
 
-- **See what the auditor is doing.** When a goal completes and the auditor kicks in, you get a live view — a spinner, the tool it's running, and recent output lines. No more wondering if anything is happening.
-- **Skip the audit with Escape.** If you're in a hurry or just don't need an audit right now, press Escape. The goal completes immediately without waiting.
-- **Turn off the auditor entirely.** If you never want audits, set it once in `/goal-settings` and you're done. The agent can bypass it by asking you to confirm.
-- **Know why an audit was skipped.** Whether you pressed Escape or had it disabled, the ledger records the reason.
-- **Faster, safer audit lifecycle.** The audit starts and stops cleanly — no more stuck goals, ghost states, or having to kill the session.
+### Completion auditor
+
+- **Live progress widget** — when the auditor runs, the TUI shows a spinner, the current tool being executed, and recent output lines. No more wondering if anything is happening.
+- **Escape to skip** — press Escape during an audit to abort it and complete the goal immediately. The skip is recorded in the ledger as `audit_skipped` with reason `user_aborted` and auditor model metadata.
+- **Disable the auditor entirely** — set `disabled: true` in `.pi/goal-auditor.json` (or toggle it via `/goal-settings` → `disabled`). The agent can still bypass with user confirmation by passing `confirmBypassAuditor: true` to `update_goal`.
+- **Skipped audits are recorded** — every skip (whether disabled or Escape-aborted) is logged to the ledger with the reason, provider, model, and thinking level for full traceability.
+- **Robust abort detection** — the auditor detects aborts both from exceptions *and* from `session.prompt()` returning after an abort signal, preventing stuck goals or ghost states.
+- **Cleaner lifecycle** — `AbortSignal` is properly wired to `session.abort()`, animation timers are cleaned up, and the unsubscribe path is always executed. No more having to kill the session.
+- **Completion report includes full auditor output** — the auditor's full report is included in the goal completion conversation message upon approval, not just a verdict.
+- **Session factory injection** — `runGoalCompletionAuditor` accepts an optional `createSession` parameter for testability, enabling mock auditor sessions in tests.
+
+### Drafting & UX
+
+- **Normalized proposal-refinement language** — consistent terminology ("keep refining through normal proposal cycles") across all drafting prompts and tools.
+- **`PI_GOAL_AUTO_CONFIRM=0` opt-out** — explicitly set the env var to `0` to disable auto-confirm even in headless contexts (useful for benchmarking).
+
+### Testing
+
+- **Comprehensive abort/skip coverage** — unit tests for `audit_skipped` ledger events, disabled auditor config, Esc-to-skip widget behaviour, post-prompt abort detection, and the `confirmBypassAuditor` parameter.
 
 ## What it provides
 

package/extensions/goal-draft.ts

@@ -104,7 +104,7 @@ export function goalDraftingPrompt(topic: string, focus: GoalDraftingFocus): str
 		"- If the topic is already concrete, you may proceed directly to propose_goal_draft.",
 		"- The goal contract should make the objective, success criteria, boundaries, constraints, and blocker rule explicit.",
 		"- Keep grilling assumptions until the objective, success criteria, boundaries, constraints, and blocker rule are clear enough to confirm.",
-		"- propose_goal_draft opens the user's Confirm / Continue Chatting dialog. Confirm creates and focuses the goal; Continue Chatting means keep clarifying.",
+		"- 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.",
 		"- create_goal is not a shortcut. Direct create_goal calls are rejected so the user keeps explicit say in goal creation.",
 	];
 

package/extensions/goal-policy.ts

@@ -116,11 +116,14 @@ export function abortGoalCommandMessage(args: { archived: boolean; wasDrafting:
 	return args.archived ? "Goal aborted and archived." : args.wasDrafting ? "Drafting cancelled." : "No goal is set.";
 }
 
-export function buildCompletionReport(args: { detailedSummary: string; completionSummary?: string | null; auditorReport?: string | null }): string {
+export function buildCompletionReport(args: { detailedSummary: string; completionSummary?: string | null; auditorReport?: string | null; auditSkippedReason?: string | null }): string {
+	const auditSkipped = args.auditSkippedReason?.trim();
 	const auditorReport = args.auditorReport?.trim();
-	const lines = auditorReport
-		? ["Goal audit approved.", "", "Auditor approval:", auditorReport, "", "Goal complete."]
-		: ["Goal complete."];
+	const lines = auditSkipped
+		? ["Goal audit skipped.", "", "Reason: " + auditSkipped, "", "Goal complete."]
+		: auditorReport
+			? ["Goal audit approved.", "", "Auditor approval:", auditorReport, "", "Goal complete."]
+			: ["Goal complete."];
 	const summary = args.completionSummary?.trim();
 	if (summary) {
 		lines.push("", "Completion summary:", summary);

package/extensions/goal-questionnaire.ts

@@ -56,6 +56,7 @@ export function formatQuestionnaireAnswers(result: GoalQuestionnaireResult): str
 }
 
 export function shouldAutoConfirmProposal(args: { hasUI: boolean; autoConfirmEnv?: string }): boolean {
+	if (args.autoConfirmEnv === "0") return false; // explicit opt-out (benchmarking)
 	return !args.hasUI || args.autoConfirmEnv === "1";
 }
 

package/extensions/goal.ts

@@ -667,7 +667,8 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			clearActiveAccounting();
 			return;
 		}
-		if (state.goal?.activePath && !reconcileFocusedGoalFromDisk(ctx, { preserveMemoryUsage: true })) return;
+		// Skip disk reconciliation for complete goals — they are pending archival at turn_end.
+		if (state.goal?.activePath && state.goal?.status !== "complete" && !reconcileFocusedGoalFromDisk(ctx, { preserveMemoryUsage: true })) return;
 		if (!state.goal || state.goal.status !== "active" || accounting.activeGoalId !== state.goal.id) {
 			beginAccounting();
 			return;
@@ -1677,7 +1678,7 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			return {
 				content: [{
 					type: "text",
-					text: "User clicked 'Continue Chatting'. The goal was NOT created. Ask the user what they want to change about the draft (objective, scope, criteria, steps), then revise and call propose_goal_draft again. Do not call propose_goal_draft again with the same content — wait for the user's input first.",
+					text: "Goal draft refinement requested (Continue Chatting). The goal was not created — drafting remains active. Ask the user what they want changed about the draft (objective, scope, criteria, steps), then revise and call propose_goal_draft again. Do not re-propose the same content — wait for the user's input first.",
 				}],
 				details: goalDetails(state.goal),
 			};
@@ -1751,13 +1752,16 @@ export default function goalExtension(pi: ExtensionAPI): void {
 						details: goalDetails(state.goal),
 					};
 				}
-				// Auditor disabled and confirmed — skip audit, complete immediately
-				await pi.sendMessage<GoalAuditEventDetails>({
+				// Auditor disabled and confirmed — skip audit.
+				// Defer archival: set goal complete in-memory + write active file WITHOUT
+				// archiving. Archival happens at turn_end so the agent has a chance to
+				// recognise the skipped audit before the goal is archived.
+				pi.sendMessage<GoalAuditEventDetails>({
 					customType: GOAL_AUDIT_ENTRY,
-					content: `Auditor disabled — completion bypassed for goal ${auditTarget.id}.`,
+					content: `Goal completed — auditor disabled in settings.`,
 					display: true,
 					details: { phase: "skipped", goalId: auditTarget.id, auditor: auditorLabel },
-				}, { triggerTurn: true });
+				});
 				try {
 					appendGoalEvent(ctx, {
 						type: "audit_skipped",
@@ -1771,41 +1775,32 @@ export default function goalExtension(pi: ExtensionAPI): void {
 				} catch {
 					// Ledger append failure should not block completion
 				}
-				// Mark goal complete directly (skip audit entirely)
+				// Set goal complete in memory (defer archival to turn_end)
 				accountProgress(ctx);
-				state.goal = auditTarget;
-				stopActiveGoal("complete", "agent", ctx);
-				const completedGoal = state.goal;
-				turnStoppedFor = completedGoal?.id ?? null;
 				auditProgress = null;
 				goalWidgetComponent?.invalidate();
-				if (completedGoal) {
-					resetGetGoalNudgeState(completedGoal.id);
-					goalsById.delete(completedGoal.id);
-					focusedGoalId = null;
-					appendFocusEntry(null, "completed");
-					syncGoalTools();
-					updateUI(ctx);
-					try {
-						appendGoalEvent(ctx, {
-							type: "goal_completed",
-							goalId: completedGoal.id,
-							archivePath: completedGoal.archivedPath,
-							at: nowIso(),
-						});
-					} catch {
-						// Ledger append failure should not crash completion
-					}
-				}
+				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: buildCompletionReport({
-							detailedSummary: detailedSummary(completedGoal),
+							detailedSummary: detailedSummary(state.goal),
 							completionSummary: params.completionSummary,
+							auditSkippedReason: "auditor disabled in settings",
 						}),
 					}],
-					details: goalDetails(completedGoal),
+					details: goalDetails(state.goal),
 					terminate: true,
 				};
 			}
@@ -1884,47 +1879,39 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			// skip notification is exposed exactly once to the agent as part of the
 			// update_goal tool execution, matching the disabled-flow pattern exactly.
 			if (auditor.error === "Auditor aborted.") {
-				await pi.sendMessage<GoalAuditEventDetails>({
+				// Esc-skip: same deferred archival pattern as disabled bypass.
+				pi.sendMessage<GoalAuditEventDetails>({
 					customType: GOAL_AUDIT_ENTRY,
-					content: `Auditor aborted — completion bypassed for goal ${auditTarget.id}.`,
+					content: `Goal completed — auditor bypassed (user pressed Escape during audit).`,
 					display: true,
 					details: { phase: "skipped", goalId: auditTarget.id, auditor: auditorLabel },
-				}, { triggerTurn: true });
-				// Mark goal complete directly (skip audit entirely)
+				});
+				// Set goal complete in memory (defer archival to turn_end)
 				accountProgress(ctx);
-				state.goal = auditTarget;
-				stopActiveGoal("complete", "agent", ctx);
-				const completedGoal = state.goal;
-				turnStoppedFor = completedGoal?.id ?? null;
 				auditProgress = null;
 				goalWidgetComponent?.invalidate();
-				if (completedGoal) {
-					resetGetGoalNudgeState(completedGoal.id);
-					goalsById.delete(completedGoal.id);
-					focusedGoalId = null;
-					appendFocusEntry(null, "completed");
-					syncGoalTools();
-					updateUI(ctx);
-					try {
-						appendGoalEvent(ctx, {
-							type: "goal_completed",
-							goalId: completedGoal.id,
-							archivePath: completedGoal.archivedPath,
-							at: nowIso(),
-						});
-					} catch {
-						// Ledger append failure should not crash completion
-					}
-				}
+				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: buildCompletionReport({
-							detailedSummary: detailedSummary(completedGoal),
+							detailedSummary: detailedSummary(state.goal),
 							completionSummary: params.completionSummary,
+							auditSkippedReason: "auditor bypassed (user pressed Escape during audit)",
 						}),
 					}],
-					details: goalDetails(completedGoal),
+					details: goalDetails(state.goal),
 					terminate: true,
 				};
 			}
@@ -1989,45 +1976,35 @@ export default function goalExtension(pi: ExtensionAPI): void {
 				display: true,
 				details: { phase: "approved", goalId: auditTarget.id, auditor: auditor.model },
 			});
-			// Account for any remaining elapsed time before stopping.
+			// Account for any remaining elapsed time.
+			// Defer archival: set goal complete in-memory + write active file WITHOUT
+			// archiving. Archival happens at turn_end so the agent can see the auditor
+			// approval before the goal is archived.
 			accountProgress(ctx);
-			state.goal = auditTarget;
-			stopActiveGoal("complete", "agent", ctx);
-			const completedGoal = state.goal;
-			// C9 fix: mark turn-stopped so subsequent in-turn tool calls are blocked.
-			turnStoppedFor = completedGoal?.id ?? null;
-			// Clear auditor progress to restore normal widget state
 			auditProgress = null;
 			goalWidgetComponent?.invalidate();
-			if (completedGoal) {
-				resetGetGoalNudgeState(completedGoal.id);
-				goalsById.delete(completedGoal.id);
-				focusedGoalId = null;
-				appendFocusEntry(null, "completed");
-				syncGoalTools();
-				updateUI(ctx);
-				// Append ledger: goal completed
-				try {
-					appendGoalEvent(ctx, {
-						type: "goal_completed",
-						goalId: completedGoal.id,
-						archivePath: completedGoal.archivedPath,
-						at: nowIso(),
-					});
-				} catch {
-					// Ledger append failure should not crash completion
-				}
-			}
+			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: buildCompletionReport({
-						detailedSummary: detailedSummary(completedGoal),
+						detailedSummary: detailedSummary(state.goal),
 						completionSummary: params.completionSummary,
 						auditorReport: auditor.output,
 					}),
 				}],
-				details: goalDetails(completedGoal),
+				details: goalDetails(state.goal),
 				terminate: true,
 			};
 		},
@@ -2403,6 +2380,31 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			return;
 		}
 		refreshGoalDisplayFromDisk(ctx);
+
+		// Archive a goal that was marked complete by update_goal but whose archival
+		// was deferred so the agent could see/recognize the audit result first.
+		// This runs after the agent's turn ends — the agent has now seen the result.
+		if (state.goal?.status === "complete" && !state.goal?.archivedPath) {
+			const completedGoal = state.goal;
+			const archived = archiveGoalFile(ctx, completedGoal);
+			resetGetGoalNudgeState(completedGoal.id);
+			goalsById.delete(completedGoal.id);
+			focusedGoalId = null;
+			appendFocusEntry(null, "completed");
+			syncGoalTools();
+			updateUI(ctx);
+			try {
+				appendGoalEvent(ctx, {
+					type: "goal_completed",
+					goalId: completedGoal.id,
+					archivePath: archived.archivedPath,
+					at: nowIso(),
+				});
+			} catch {
+				// Ledger append failure should not crash completion
+			}
+		}
+
 		// If the assistant ended a turn without queuing more tool calls, push a continuation right away.
 		// #4: only queue if some real work was done this turn — otherwise the model is
 		// just chatting and we should not keep firing turns on noise.

package/extensions/storage/goal-files.ts

@@ -205,7 +205,6 @@ export function parseGoalFile(filePath: string): GoalRecord | null {
 }
 
 export function writeActiveGoalFile(ctx: GoalFileContext, current: GoalRecord): GoalRecord {
-	if (current.status === "complete") return archiveGoalFile(ctx, current);
 	const activePath = activePathForGoal(ctx, current);
 	const next = sanitizeGoalPaths(ctx, { ...current, activePath, updatedAt: nowIso() });
 	atomicWriteGoalFile(ctx, GOALS_DIR, activePath, serializeGoalFile(next));

package/package.json

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