pi-goal-x 0.8.1 → 0.9.0

package/README.md

@@ -1,20 +1,49 @@
 # 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, mid-flight objective updates, deferred archival, 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.
+### Mid-flight objective updates
+
+- **`update_goal({updatedObjective})`** — the agent can now sync the goal objective mid-flight when user requirements change, *without* completing the goal. This ensures the completion auditor evaluates against the latest requirements. The combined path (`updatedObjective` + `status: "complete"`) applies the update first, then runs the normal completion+audit flow.
+- **`apply_goal_tweak`** remains available for `/goal-tweak` drafting revisions; the new parameter is the lightest possible touch on the existing `update_goal` tool.
+
+### Deferred archival
+
+- **No more premature archiving**: previously, `update_goal` archived the goal file inline within the tool handler before the agent could see the audit result (or skip notification). Archival is now deferred until `turn_end` — after the agent has received the audit/skip result in the conversation. The goal remains visible in the active pool through the entire completion flow.
+- **Cleaner lifecycle**: completed goals are archived by the `turn_end` lifecycle hook, not by the tool handler. The `accountProgress` guard skips disk reconciliation for completed goals.
+
+### E2e test infrastructure
+
+- **Deterministic fork tests using `--mode json`**: the e2e suite spawns a real `pi --fork --mode json` session, parses structured `tool_execution_start`/`tool_execution_end` JSON events for field-level assertions — no free-text AI output parsing. Uses `--append-system-prompt` + `--tools` to force deterministic tool calls.
+- **Full coverage**: 131 tests total — function-level integration tests (12), mock-pi handler tests (4), file-validity checks (6), and real `pi --fork --mode json` tests (3 scenarios: quick-sync, combined sync+complete, deferred archival).
+
+### 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-policy.ts

@@ -43,6 +43,14 @@ export function validateGoalCompletion(args: {
 	return { ok: true };
 }
 
+export function validateGoalUpdate(args: {
+	goal: GoalPolicyRecordLike | null;
+}): PolicyValidation {
+	if (!args.goal) return { ok: false, message: "No goal is set; cannot update objective." };
+	if (args.goal.status === "complete") return { ok: false, message: "Goal is already complete; cannot update objective." };
+	return { ok: true };
+}
+
 export function validateGoalAbort(args: {
 	goal: GoalPolicyRecordLike | null;
 	runningGoalId?: string | null;
@@ -116,11 +124,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.ts

@@ -106,6 +106,7 @@ import {
 	shouldInjectPostCompactReminder,
 	validateGoalAbort,
 	validateGoalCompletion,
+	validateGoalUpdate,
 	validatePauseGoal,
 	validateResumeGoal,
 } from "./goal-policy.ts";
@@ -667,7 +668,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;
@@ -1703,16 +1705,70 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			"Do not call update_goal merely because work is stopping, substantial progress was made, or tests passed without covering every requirement.",
 			"Do not use update_goal=complete as an escape hatch when you are blocked. If you are blocked, call pause_goal({reason, suggestedAction?}) instead so the user can intervene.",
 			"For sisyphus goals, do not mark complete until every numbered step has been executed and individually verified against its done criterion.",
+			"If the user gives requirements, feedback, or corrections that differ from the goal objective, the goal is stale. Use update_goal with updatedObjective to sync the objective before continuing work or before marking the goal complete. This ensures the auditor evaluates against the latest requirements.",
 		],
 		parameters: Type.Object({
-			status: StringEnum([COMPLETE_STATUS] as const, { description: "Set to complete only when the objective is achieved." }),
+			status: Type.Optional(StringEnum([COMPLETE_STATUS] as const, { description: "Set to complete only when the objective is achieved." })),
 			completionSummary: Type.Optional(Type.String({ description: "Concise completion claim and evidence summary passed to the independent auditor agent." })),
 			confirmBypassAuditor: Type.Optional(Type.Boolean({ description: "Set to true to confirm bypassing the independent auditor when it is disabled in settings." })),
+			updatedObjective: Type.Optional(Type.String({ description: "Revised goal objective. Use when the user's requirements have changed mid-flight. The goal remains active so the agent can continue working toward the new objective. Can be combined with status=complete to update the objective before the completion audit." })),
 		}),
 		executionMode: "sequential",
 		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
 			reconcileFocusedGoalFromDisk(ctx);
-			if (params.status !== COMPLETE_STATUS) throw new Error("update_goal only supports status=complete.");
+
+			// -- Phase 1: Objective update (quick sync) --
+			// Apply updatedObjective before any completion logic so the completion
+			// flow (if status=complete is also set) reads the latest objective.
+			if (params.updatedObjective !== undefined) {
+				const newObjective = params.updatedObjective.trim();
+				if (!newObjective) throw new Error("update_goal requires a non-empty updatedObjective.");
+				const updateGate = validateGoalUpdate({ goal: state.goal });
+				if (!updateGate.ok) {
+					return {
+						content: [{ type: "text", text: updateGate.message }],
+						details: goalDetails(state.goal),
+					};
+				}
+				if (!state.goal) throw new Error("Goal disappeared during objective update.");
+				const next: GoalRecord = {
+					...state.goal,
+					objective: newObjective,
+					updatedAt: nowIso(),
+				};
+				state.goal = writeActiveGoalFile(ctx, next);
+				pi.appendEntry(STATE_ENTRY, goalDetails(state.goal));
+				try {
+					appendGoalEvent(ctx, {
+						type: "goal_tweaked",
+						goalId: state.goal.id,
+						changeSummary: "Objective updated via update_goal",
+						at: state.goal.updatedAt,
+					});
+				} catch {
+					// Ledger append failure should not block update
+				}
+				updateUI(ctx);
+
+				// Quick sync only (no status=complete) — return without terminating
+				if (params.status !== COMPLETE_STATUS) {
+					return {
+						content: [{ type: "text", text: `Goal objective updated.` }],
+						details: goalDetails(state.goal),
+					};
+				}
+				// Fall through: status=complete also set, proceed with completion below
+			}
+
+			// -- Phase 2: Status validation --
+			if (params.status !== COMPLETE_STATUS) {
+				if (params.updatedObjective === undefined) {
+					throw new Error("update_goal requires either status=complete or updatedObjective.");
+				}
+				throw new Error("update_goal requires status=complete when marking a goal complete.");
+			}
+
+			// -- Phase 3: Completion --
 			const completionGate = validateGoalCompletion({ goal: state.goal, runningGoalId });
 			if (!completionGate.ok) {
 				return {
@@ -1751,13 +1807,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: `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 +1830,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 +1934,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: `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,50 +2031,41 @@ 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,
 			};
 		},
 		renderCall(args, theme) {
-			return new Text(theme.fg("toolTitle", "update_goal ") + theme.fg("success", args.status), 0, 0);
+			const label = args?.status ?? args?.updatedObjective ? "sync" : "";
+			return new Text(theme.fg("toolTitle", "update_goal ") + theme.fg("success", label), 0, 0);
 		},
 		renderResult(result, _options, theme) {
 			return renderGoalResult(result, theme);
@@ -2403,6 +2436,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/prompts/goal-prompts.ts

@@ -44,7 +44,9 @@ If you hit a real blocker that you cannot resolve with one more reasonable next
 
 If the user explicitly asks to abandon/cancel this goal, or the objective is obsolete, impossible, or unsafe to continue and should not be marked complete, call abort_goal({reason}) with a non-empty reason and stop.
 
-Do NOT silently invent workarounds, fake completion, or quietly redefine the objective. Do NOT call update_goal=complete to escape a blocker.${sisyphusDisciplineBlock(goal) ? `\n${sisyphusDisciplineBlock(goal)}` : ""}`;
+Do NOT silently invent workarounds, fake completion, or quietly redefine the objective. Do NOT call update_goal=complete to escape a blocker.
+
+Goal evolution: if the user gives requirements, feedback, or corrections that differ from the goal objective, the goal is stale. Propose the updated objective concisely and wait for the user to confirm before continuing. Use update_goal with updatedObjective for narrow focus-area changes, or suggest /goal-tweak for broader revisions (boundaries, constraints, multiple sections). Do NOT mark the goal complete with a stale objective.${sisyphusDisciplineBlock(goal) ? `\n${sisyphusDisciplineBlock(goal)}` : ""}`;
 }
 
 export function continuationPrompt(goal: GoalRecord): string {
@@ -77,6 +79,8 @@ export function continuationPrompt(goal: GoalRecord): string {
 		"Do not call update_goal unless the goal is complete enough to survive independent semantic auditing. Do not mark a goal complete merely because work is stopping.",
 		"Do not ask the user for confirmation unless there is a real blocker.",
 		"",
+		"Goal evolution: if the user gives requirements, feedback, or corrections that differ from the goal objective, the goal is stale. Propose the updated objective concisely and wait for the user to confirm before continuing. Use update_goal with updatedObjective for narrow focus-area changes, or suggest /goal-tweak for broader revisions (boundaries, constraints, multiple sections). Do NOT mark the goal complete with a stale objective.",
+		"",
 		"If you hit a real blocker (missing credentials, contradictory spec, file/permission you cannot access, dangerous operation pending user approval, or an unclear Sisyphus-style ordered plan), call pause_goal({reason, suggestedAction?}) and stop. If the user explicitly asks to abandon/cancel, or the objective is obsolete, impossible, or unsafe to continue, call abort_goal({reason}) and stop. Do not silently invent workarounds. Do not fake completion. pause_goal and abort_goal are structured lifecycle exits; update_goal=complete is not an escape hatch for blockers.",
 		...(goal.sisyphus ? ["", sisyphusDisciplineBlock(goal)] : []),
 	].join("\n");

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.8.1",
+  "version": "0.9.0",
   "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",