@narumitw/pi-goal 0.1.17 → 0.1.19

package/README.md

@@ -2,21 +2,21 @@
 
 [![npm](https://img.shields.io/npm/v/@narumitw/pi-goal)](https://www.npmjs.com/package/@narumitw/pi-goal) [![Pi extension](https://img.shields.io/badge/Pi-extension-blue)](https://pi.dev) [![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](./LICENSE)
 
-`@narumitw/pi-goal` is a native [Pi coding agent](https://pi.dev) extension that adds durable `/goal` commands and a `goal_complete` tool for autonomous, verifiable task completion.
+`@narumitw/pi-goal` is a native [Pi coding agent](https://pi.dev) extension that adds session-scoped `/goal` commands and a `goal_complete` tool for autonomous, verifiable task completion.
 
-Goal mode keeps sending guarded automatic follow-up messages until the agent calls `goal_complete`, the user pauses or clears the goal, or an optional token budget is reached.
+Goal mode uses Codex-like persistence instructions and keeps sending guarded continuation messages until the agent calls `goal_complete`, the user pauses or clears the goal, or an optional token budget is reached.
 
 ## ✨ Features
 
-- Adds `/goal <goal_to_complete>` to start goal mode.
+- Adds `/goal <goal_to_complete>` to start goal mode, with confirmation before replacing an existing goal.
 - Bare `/goal` shows the current goal summary.
-- Adds `/goal pause`, `/goal resume`, `/goal clear`, and `/goal edit <goal_to_complete>`.
-- Keeps `/goal-status` and `/goal-stop` as compatibility aliases.
+- Keeps advanced goal management inside `/goal` subcommands: `pause`, `resume`, `clear`, and `edit`.
+- Exposes only one top-level command: `/goal`.
 - Supports optional token budgets such as `/goal --tokens 100k <goal>`.
 - Tracks `active`, `paused`, `budget_limited`, and `complete` states.
-- Persists in-progress goal state per working directory under the Pi agent config directory.
+- Stores goal state in the current Pi session, following Codex's thread-owned goal model instead of using a global per-directory goal.
 - Registers a `goal_complete` tool for explicit completion.
-- Automatically prompts the agent to continue if an active turn ends early.
+- Automatically prompts the agent to continue if an active turn ends early, directly triggering the next turn when Pi is idle.
 - Guards auto-follow-ups so replaced, paused, cleared, completed, or budget-limited goals are not continued.
 - Encourages verification before the goal is marked complete.
 
@@ -44,41 +44,43 @@ pi -e ./extensions/pi-goal
 /goal
 /goal implement snake game
 /goal --tokens 100k fix the failing test and verify it
+/goal edit ship the smaller fix first
 /goal pause
 /goal resume
 /goal clear
-/goal edit ship the smaller fix first
-/goal-status
-/goal-stop
 ```
 
-- `/goal` shows the current goal, status, iteration count, elapsed time, and token usage.
-- `/goal <goal_to_complete>` starts goal mode when no other goal is active.
-- `/goal --tokens 100k <goal_to_complete>` starts goal mode with a token budget. `k` and `m` suffixes are accepted, for example `100k` or `1.5m`.
+- `/goal` shows the current goal, status, iteration count, elapsed time, token usage, and available `/goal` subcommands.
+- `/goal <goal_to_complete>` starts goal mode. If another unfinished goal exists, Pi asks for confirmation before replacing it with a new active goal and resetting its usage counters.
+- `/goal --tokens 100k <goal_to_complete>` starts or replaces goal mode with a token budget. `k` and `m` suffixes are accepted, for example `100k` or `1.5m`.
+- `/goal edit <goal_to_complete>` updates the existing goal objective without resetting usage counters. Active goals stay active, paused goals stay paused, and budget-limited goals remain budget-limited if their budget is still exhausted.
 - `/goal pause` stops prompt injection and auto-continuation without forgetting the goal.
-- `/goal resume` resumes a paused or budget-limited goal.
-- `/goal clear` cancels the current goal and clears persisted state.
-- `/goal edit <goal_to_complete>` replaces the current goal with a new active goal.
-- `/goal-status` is a compatibility alias for `/goal`.
-- `/goal-stop` is a compatibility alias for `/goal clear`.
+- `/goal resume` resumes a paused or budget-limited goal when the token budget allows it.
+- `/goal clear` cancels the current goal and also removes any legacy persisted state for the current working directory.
 
 Goal objectives are limited to 4,000 characters. Put longer instructions in a file and reference the file path from `/goal`.
 
+## 🔁 Session and reload behavior
+
+Goal state is stored as Pi session state, similar to Codex's thread-owned goals. `/reload` and reopening the same Pi session can restore that session's unfinished goal. Starting a new Pi session in the same working directory does not inherit the old goal.
+
+Older versions wrote unfinished goals to `~/.pi/agent/pi-goal-state.json` keyed by working directory. This version no longer reads that global file, and `/goal clear` removes any legacy entry for the current working directory.
+
 ## 📊 Statusline states
 
 `pi-goal` writes compact status strings for statusline extensions:
 
-- `goal: active 3m` — an active goal without a token budget.
-- `goal: active 18k/100k` — an active goal with token usage and budget.
-- `goal: paused` — auto-continuation is paused.
-- `goal: budget 100k/100k` — the token budget was reached; auto-continuation stops.
-- `goal: complete` — shown briefly after `goal_complete` succeeds.
+- `🎯 active 3m` — an active goal without a token budget.
+- `🎯 active 18k/100k` — an active goal with token usage and budget.
+- `🎯 paused` — auto-continuation is paused.
+- `🎯 budget 100k/100k` — the token budget was reached; auto-continuation stops.
+- `🎯 complete` — shown briefly after `goal_complete` succeeds.
 
 ## ✅ How completion works
 
-The extension registers a `goal_complete` tool. While a goal is active, the system prompt tells the agent to keep working, verify the result, and call `goal_complete` only when the goal is fully done.
+The extension registers a `goal_complete` tool. While a goal is active, the system prompt uses Codex-like persistence rules: keep going until the goal is resolved end-to-end, do not stop at analysis, a plan, partial fixes, or suggested next steps, use available tools for implementation and verification, and call `goal_complete` only when the goal is fully done.
 
-If an agent turn ends before `goal_complete` is called, the extension records elapsed time and token usage, checks the budget, verifies that the same goal id is still active, then sends a follow-up prompt to continue the same goal.
+If an agent turn ends before `goal_complete` is called, the extension records elapsed time and token usage, checks the budget, verifies that the same goal id is still active, then sends a continuation prompt for the same goal. When Pi is already idle, this directly triggers the next turn; otherwise it is queued as a follow-up until the agent finishes current work.
 
 ## 🧠 Use cases
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@narumitw/pi-goal",
-	"version": "0.1.17",
+	"version": "0.1.19",
 	"description": "Pi extension that keeps working on a /goal until the agent marks it complete.",
 	"type": "module",
 	"license": "MIT",

package/src/goal.ts

@@ -25,6 +25,10 @@ interface GoalCompleteDetails {
 	summary: string;
 }
 
+interface GoalStateEntryData {
+	goal?: ActiveGoal | null;
+}
+
 interface CommandResult {
 	kind: "show" | "start" | "pause" | "resume" | "clear" | "edit";
 	objective?: string;
@@ -34,6 +38,7 @@ interface CommandResult {
 interface StatusContext {
 	cwd: string;
 	ui: {
+		confirm: (title: string, message: string) => Promise<boolean>;
 		notify: (message: string, level?: "info" | "warning" | "error") => void;
 		setStatus: (key: string, value: string | undefined) => void;
 	};
@@ -42,6 +47,7 @@ interface StatusContext {
 }
 
 const STATUS_KEY = "goal";
+const GOAL_STATE_ENTRY_TYPE = "goal-state";
 const MAX_OBJECTIVE_LENGTH = 4_000;
 const STATE_FILE = join(
 	process.env.PI_CODING_AGENT_DIR ?? join(process.env.HOME ?? ".", ".pi", "agent"),
@@ -50,6 +56,7 @@ const STATE_FILE = join(
 
 let activeGoal: ActiveGoal | undefined;
 let completionStatusTimer: NodeJS.Timeout | undefined;
+let extensionApi: ExtensionAPI | undefined;
 
 const goalCompleteTool = defineTool({
 	name: "goal_complete",
@@ -71,7 +78,7 @@ const goalCompleteTool = defineTool({
 		if (completedGoal) {
 			activeGoal = transitionGoal(completedGoal, "complete");
 			updateGoalUsage(activeGoal, ctx);
-			persistGoal(ctx.cwd, activeGoal);
+			persistGoal(activeGoal);
 		}
 
 		const goal = completedGoal?.text ?? "unknown goal";
@@ -91,6 +98,7 @@ const goalCompleteTool = defineTool({
 });
 
 export default function goal(pi: ExtensionAPI) {
+	extensionApi = pi;
 	pi.registerTool(goalCompleteTool);
 
 	pi.registerCommand("goal", {
@@ -116,33 +124,23 @@ export default function goal(pi: ExtensionAPI) {
 					clearGoal(ctx);
 					return;
 				case "edit":
-					editGoal(result.objective ?? "", result.tokenBudget, ctx);
+					editGoal(result.objective ?? "", result.tokenBudget, pi, ctx);
 					return;
 				case "start":
-					startGoal(result.objective ?? "", result.tokenBudget, pi, ctx);
+					await startGoal(result.objective ?? "", result.tokenBudget, pi, ctx);
 					return;
 			}
 		},
 	});
 
-	pi.registerCommand("goal-stop", {
-		description: "Compatibility alias for /goal clear",
-		handler: async (_args, ctx) => clearGoal(ctx),
-	});
-
-	pi.registerCommand("goal-status", {
-		description: "Compatibility alias for bare /goal",
-		handler: async (_args, ctx) => showGoal(ctx),
-	});
-
 	pi.on("session_start", (_event, ctx) => {
-		activeGoal = loadGoal(ctx.cwd);
+		activeGoal = loadGoalFromSession(ctx);
 		if (activeGoal) updateStatus(ctx, activeGoal);
 		else ctx.ui.setStatus(STATUS_KEY, undefined);
 	});
 
 	pi.on("session_shutdown", (_event, ctx) => {
-		if (activeGoal) persistGoal(ctx.cwd, activeGoal);
+		if (activeGoal) persistGoal(activeGoal);
 		ctx.ui.setStatus(STATUS_KEY, undefined);
 		if (completionStatusTimer) clearTimeout(completionStatusTimer);
 	});
@@ -164,40 +162,49 @@ export default function goal(pi: ExtensionAPI) {
 
 		if (activeGoal.tokenBudget !== undefined && activeGoal.tokensUsed >= activeGoal.tokenBudget) {
 			activeGoal = transitionGoal(activeGoal, "budget_limited");
-			persistGoal(ctx.cwd, activeGoal);
+			persistGoal(activeGoal);
 			updateStatus(ctx, activeGoal);
 			ctx.ui.notify(`Goal token budget reached: ${formatBudget(activeGoal)}`, "warning");
 			return;
 		}
 
-		persistGoal(ctx.cwd, activeGoal);
+		persistGoal(activeGoal);
 		updateStatus(ctx, activeGoal);
 
 		const currentGoal = activeGoal;
 		if (!currentGoal || currentGoal.id !== goalId || currentGoal.status !== "active") return;
-		pi.sendUserMessage(buildContinuePrompt(currentGoal), { deliverAs: "followUp" });
+		sendContinuationPrompt(pi, ctx, currentGoal);
 	});
 }
 
-function startGoal(objective: string, tokenBudget: number | undefined, pi: ExtensionAPI, ctx: StatusContext) {
+async function startGoal(
+	objective: string,
+	tokenBudget: number | undefined,
+	pi: ExtensionAPI,
+	ctx: StatusContext,
+) {
 	const validationError = validateObjective(objective);
 	if (validationError) {
 		ctx.ui.notify(validationError, "warning");
 		return;
 	}
 
-	if (activeGoal && activeGoal.status !== "complete") {
-		ctx.ui.notify(
-			`A goal is already ${activeGoal.status}. Use /goal edit <objective> to replace it, /goal clear to stop it, or /goal to inspect it.`,
-			"warning",
+	const existingGoal = activeGoal?.status !== "complete" ? activeGoal : undefined;
+	if (existingGoal) {
+		const shouldReplace = await ctx.ui.confirm(
+			"Replace goal?",
+			`Current goal: ${existingGoal.text}\n\nNew goal: ${objective}`,
 		);
-		return;
+		if (!shouldReplace) {
+			ctx.ui.notify(`Goal kept: ${existingGoal.text}`, "info");
+			return;
+		}
 	}
 
 	activeGoal = createGoal(objective, tokenBudget, currentTokenTotal(ctx));
-	persistGoal(ctx.cwd, activeGoal);
+	persistGoal(activeGoal);
 	updateStatus(ctx, activeGoal);
-	ctx.ui.notify(`Goal started: ${objective}`, "info");
+	ctx.ui.notify(existingGoal ? `Goal replaced: ${objective}` : `Goal started: ${objective}`, "info");
 	sendGoalPrompt(pi, ctx, activeGoal);
 }
 
@@ -211,7 +218,7 @@ function pauseGoal(ctx: StatusContext) {
 		return;
 	}
 	activeGoal = transitionGoal(activeGoal, "paused");
-	persistGoal(ctx.cwd, activeGoal);
+	persistGoal(activeGoal);
 	updateStatus(ctx, activeGoal);
 	ctx.ui.notify(`Goal paused: ${activeGoal.text}`, "info");
 }
@@ -226,7 +233,7 @@ function resumeGoal(ctx: StatusContext) {
 		return;
 	}
 	activeGoal = transitionGoal(activeGoal, "active");
-	persistGoal(ctx.cwd, activeGoal);
+	persistGoal(activeGoal);
 	updateStatus(ctx, activeGoal);
 	ctx.ui.notify(`Goal resumed: ${activeGoal.text}`, "info");
 }
@@ -244,27 +251,44 @@ function clearGoal(ctx: StatusContext) {
 	ctx.ui.notify(`Goal cleared: ${stoppedGoal}`, "warning");
 }
 
-function editGoal(objective: string, tokenBudget: number | undefined, ctx: StatusContext) {
+function editGoal(
+	objective: string,
+	tokenBudget: number | undefined,
+	pi: ExtensionAPI,
+	ctx: StatusContext,
+) {
 	const validationError = validateObjective(objective);
 	if (validationError) {
 		ctx.ui.notify(validationError, "warning");
 		return;
 	}
+	if (!activeGoal) {
+		ctx.ui.notify("No active goal. Use /goal <objective> to start one.", "warning");
+		return;
+	}
 
-	activeGoal = createGoal(objective, tokenBudget, currentTokenTotal(ctx));
-	persistGoal(ctx.cwd, activeGoal);
+	updateGoalUsage(activeGoal, ctx);
+	activeGoal = normalizeGoalForBudget({
+		...activeGoal,
+		text: objective,
+		status: editedGoalStatus(activeGoal.status),
+		tokenBudget: tokenBudget ?? activeGoal.tokenBudget,
+		updatedAt: Date.now(),
+	});
+	persistGoal(activeGoal);
 	updateStatus(ctx, activeGoal);
 	ctx.ui.notify(`Goal updated: ${objective}`, "info");
+	if (activeGoal.status === "active") sendObjectiveUpdatedPrompt(pi, ctx, activeGoal);
 }
 
 function showGoal(ctx: StatusContext) {
 	if (!activeGoal) {
-		ctx.ui.notify("No active goal.", "info");
+		ctx.ui.notify("Usage: /goal <objective>\nNo goal is currently set.", "info");
 		ctx.ui.setStatus(STATUS_KEY, undefined);
 		return;
 	}
 	updateGoalUsage(activeGoal, ctx);
-	persistGoal(ctx.cwd, activeGoal);
+	persistGoal(activeGoal);
 	updateStatus(ctx, activeGoal);
 	ctx.ui.notify(goalSummary(activeGoal), "info");
 }
@@ -286,7 +310,22 @@ function createGoal(text: string, tokenBudget: number | undefined, baselineToken
 }
 
 function transitionGoal(goal: ActiveGoal, status: GoalStatus): ActiveGoal {
-	return { ...goal, status, updatedAt: Date.now() };
+	return normalizeGoalForBudget({ ...goal, status, updatedAt: Date.now() });
+}
+
+function editedGoalStatus(status: GoalStatus): GoalStatus {
+	return status === "paused" ? "paused" : "active";
+}
+
+function normalizeGoalForBudget(goal: ActiveGoal): ActiveGoal {
+	if (
+		goal.status === "active" &&
+		goal.tokenBudget !== undefined &&
+		goal.tokensUsed >= goal.tokenBudget
+	) {
+		return { ...goal, status: "budget_limited" };
+	}
+	return goal;
 }
 
 function incrementGoal(goal: ActiveGoal): ActiveGoal {
@@ -377,7 +416,18 @@ function validateObjective(objective: string): string | undefined {
 }
 
 function sendGoalPrompt(pi: ExtensionAPI, ctx: StatusContext, goal: ActiveGoal) {
-	const prompt = buildGoalPrompt(goal);
+	sendPrompt(pi, ctx, buildGoalPrompt(goal));
+}
+
+function sendObjectiveUpdatedPrompt(pi: ExtensionAPI, ctx: StatusContext, goal: ActiveGoal) {
+	sendPrompt(pi, ctx, buildObjectiveUpdatedPrompt(goal));
+}
+
+function sendContinuationPrompt(pi: ExtensionAPI, ctx: StatusContext, goal: ActiveGoal) {
+	sendPrompt(pi, ctx, buildContinuePrompt(goal));
+}
+
+function sendPrompt(pi: ExtensionAPI, ctx: StatusContext, prompt: string) {
 	if (ctx.isIdle?.()) pi.sendUserMessage(prompt);
 	else pi.sendUserMessage(prompt, { deliverAs: "followUp" });
 }
@@ -388,11 +438,11 @@ function updateStatus(ctx: StatusContext, goal: ActiveGoal) {
 
 function formatStatus(goal: ActiveGoal | undefined) {
 	if (!goal) return undefined;
-	if (goal.status === "complete") return "goal: complete";
-	if (goal.status === "paused") return "goal: paused";
-	if (goal.status === "budget_limited") return `goal: budget ${formatBudget(goal)}`;
-	if (goal.tokenBudget !== undefined) return `goal: active ${formatBudget(goal)}`;
-	return `goal: active ${formatDuration(goal.timeUsedSeconds)}`;
+	if (goal.status === "complete") return "🎯 complete";
+	if (goal.status === "paused") return "🎯 paused";
+	if (goal.status === "budget_limited") return `🎯 budget ${formatBudget(goal)}`;
+	if (goal.tokenBudget !== undefined) return `🎯 active ${formatBudget(goal)}`;
+	return `🎯 active ${formatDuration(goal.timeUsedSeconds)}`;
 }
 
 function formatBudget(goal: ActiveGoal) {
@@ -406,9 +456,16 @@ function goalSummary(goal: ActiveGoal) {
 		`Iteration: ${goal.iteration}`,
 		`Elapsed: ${formatDuration(goal.timeUsedSeconds)}`,
 		`Tokens: ${goal.tokenBudget === undefined ? formatTokenCount(goal.tokensUsed) : formatBudget(goal)}`,
+		`Commands: ${goalCommandHint(goal.status)}`,
 	].join("\n");
 }
 
+function goalCommandHint(status: GoalStatus) {
+	if (status === "active") return "/goal edit <objective>, /goal pause, /goal clear";
+	if (status === "paused") return "/goal edit <objective>, /goal resume, /goal clear";
+	return "/goal edit <objective>, /goal clear";
+}
+
 function formatDuration(seconds: number) {
 	if (seconds < 60) return `${seconds}s`;
 	const minutes = Math.floor(seconds / 60);
@@ -425,16 +482,25 @@ function formatTokenCount(value: number) {
 
 function buildGoalPrompt(goal: ActiveGoal) {
 	const budgetLine = goal.tokenBudget === undefined ? "" : `\nToken budget: ${formatTokenCount(goal.tokenBudget)}.`;
-	return `Goal mode is active. Complete this goal fully:\n\n${goal.text}${budgetLine}\n\nKeep working until the goal is done. Do not stop after planning or partial progress. When the goal is fully complete and verified, call the goal_complete tool with a concise completion summary.`;
+	return `Goal mode is active. Complete this goal fully:\n\n${goal.text}${budgetLine}\n\n${goalPersistenceRules("this goal")}`;
+}
+
+function buildObjectiveUpdatedPrompt(goal: ActiveGoal) {
+	const budgetLine = goal.tokenBudget === undefined ? "" : `\nToken budget: ${formatBudget(goal)} used.`;
+	return `The active /goal objective was updated. Continue working toward this goal:\n\n${goal.text}${budgetLine}\n\n${goalPersistenceRules("the updated goal")}`;
 }
 
 function buildGoalSystemPrompt(goal: ActiveGoal) {
 	const budgetLine = goal.tokenBudget === undefined ? "" : `\n- Respect the goal token budget (${formatBudget(goal)} used).`;
-	return `Active /goal: ${goal.text}\n\nGoal-mode rules:\n- Continue making concrete progress until the active goal is fully complete.\n- Do not end your response with only a plan, TODO list, or partial progress.\n- Verify the result when possible using appropriate checks.\n- If the goal is not complete at the end of a turn, expect an automatic follow-up and continue from where you left off.\n- Only call the goal_complete tool after the goal is fully complete and verified.${budgetLine}`;
+	return `Active /goal: ${goal.text}\n\nGoal-mode rules:\n- Keep going until the active goal is completely resolved end-to-end.\n- Do not stop at analysis, a plan, TODO list, partial fixes, or suggested next steps.\n- Autonomously perform implementation and verification with the available tools when they are needed to complete the goal.\n- Persevere through recoverable tool failures by trying reasonable alternatives instead of yielding early.\n- If the goal is not complete at the end of a turn, expect an automatic continuation and keep working from where you left off.\n- Only call the goal_complete tool after the goal is fully complete and verified.${budgetLine}`;
 }
 
 function buildContinuePrompt(goal: ActiveGoal) {
-	return `Continue the active /goal until it is complete:\n\n${goal.text}\n\nThis is automatic continuation #${goal.iteration}. If the goal is not complete yet, keep working and verify progress. If it is fully complete and verified, call the goal_complete tool.`;
+	return `Continue the active /goal until it is complete:\n\n${goal.text}\n\nThis is automatic continuation #${goal.iteration}. ${goalPersistenceRules("this goal")}`;
+}
+
+function goalPersistenceRules(goalLabel: string) {
+	return `Keep going until ${goalLabel} is completely resolved end-to-end. Do not stop at analysis, a plan, TODO list, partial fixes, or suggested next steps. Autonomously perform implementation and verification with the available tools when they are needed. If a tool call fails, try reasonable alternatives instead of yielding early. Only call the goal_complete tool after ${goalLabel} is fully complete and verified.`;
 }
 
 function currentTokenTotal(ctx: StatusContext): number {
@@ -452,18 +518,28 @@ function currentTokenTotal(ctx: StatusContext): number {
 	return total;
 }
 
-function persistGoal(cwd: string, goal: ActiveGoal) {
-	writeState(cwd, goal);
+function persistGoal(goal: ActiveGoal) {
+	extensionApi?.appendEntry<GoalStateEntryData>(GOAL_STATE_ENTRY_TYPE, { goal });
 }
 
 function clearPersistedGoal(cwd: string) {
-	writeState(cwd, undefined);
+	extensionApi?.appendEntry<GoalStateEntryData>(GOAL_STATE_ENTRY_TYPE, { goal: null });
+	clearLegacyPersistedGoal(cwd);
 }
 
-function loadGoal(cwd: string): ActiveGoal | undefined {
-	const goals = readState();
-	const stored = goals[cwd];
-	return isGoal(stored) && stored.status !== "complete" ? stored : undefined;
+function loadGoalFromSession(ctx: StatusContext): ActiveGoal | undefined {
+	const sessionManager = ctx.sessionManager as
+		| {
+				getBranch?: () => Array<{ type?: string; customType?: string; data?: unknown }>;
+				getEntries?: () => Array<{ type?: string; customType?: string; data?: unknown }>;
+			}
+		| undefined;
+	const entries = sessionManager?.getBranch?.() ?? sessionManager?.getEntries?.() ?? [];
+	const entry = entries
+		.filter((entry) => entry.type === "custom" && entry.customType === GOAL_STATE_ENTRY_TYPE)
+		.pop();
+	const data = entry?.data as GoalStateEntryData | undefined;
+	return isGoal(data?.goal) && data.goal.status !== "complete" ? data.goal : undefined;
 }
 
 function clearActiveGoal(ctx: StatusContext) {
@@ -474,7 +550,7 @@ function clearActiveGoal(ctx: StatusContext) {
 
 function showCompletionStatus(ctx: StatusContext) {
 	if (completionStatusTimer) clearTimeout(completionStatusTimer);
-	ctx.ui.setStatus(STATUS_KEY, "goal: complete");
+	ctx.ui.setStatus(STATUS_KEY, "🎯 complete");
 	completionStatusTimer = setTimeout(() => ctx.ui.setStatus(STATUS_KEY, undefined), 8_000);
 }
 
@@ -490,14 +566,15 @@ function readState(): Record<string, unknown> {
 	}
 }
 
-function writeState(cwd: string, goal: ActiveGoal | undefined) {
+function clearLegacyPersistedGoal(cwd: string) {
+	if (!existsSync(STATE_FILE)) return;
 	const goals = readState();
-	if (goal) goals[cwd] = goal;
-	else delete goals[cwd];
+	delete goals[cwd];
 	mkdirSync(dirname(STATE_FILE), { recursive: true });
 	writeFileSync(STATE_FILE, `${JSON.stringify(goals, null, 2)}\n`);
 }
 
+
 function isGoal(value: unknown): value is ActiveGoal {
 	if (!value || typeof value !== "object") return false;
 	const goal = value as Partial<ActiveGoal>;