pi-goal-x 0.20.0 → 0.21.0

package/README.md

@@ -84,6 +84,7 @@ If the objective is already final and should start immediately, use:
 /goal-status            Show focused goal state
 /goal-list              List all open goals in .pi/goals/
 /goal-focus             Choose this session's focused goal
+/goal-unfocus           Stop this session's goal work without modifying the shared goal
 /goal-tweak <change>    Draft a revision to the focused active/paused goal
 /goal-pause             Pause the focused active goal
 /goal-resume            Resume a paused goal
@@ -104,7 +105,7 @@ Pressing `Esc` or aborting an active run pauses the goal so it does not remain f
 - **Branch-local focus**: because focus is reconstructed from the current session branch, `/tree` navigation can restore a different focus for a different branch.
 - **One continuation chain**: auto-continue only schedules work for the focused goal in the current session.
 
-Creating a goal with `/goals`, `/sisyphus`, `/goals-set`, or `/sisyphus-set` no longer clears other open goals. It creates a new active goal file and focuses it. Use `/goal-list` to inspect open goals and `/goal-focus` to switch the session focus. If the latest focus entry explicitly clears focus, or points at a missing/stale goal, a remaining single open goal is not auto-focused. By default (`autoSelectSingleGoal: false`) sessions start unfocused so goals stay session-scoped — useful when multiple sessions share the same `.pi/goals/` directory. Set `autoSelectSingleGoal: true` to restore the old behavior where a single open goal is auto-focused when no focus entry exists at all. If multiple open goals exist and the session has no valid focus, `/goal-resume`, `/goal-clear`, `/goal-abort`, `/goal-pause`, and `/goal-tweak` ask the user to choose a goal instead of acting on all of them.
+Creating a goal with `/goals`, `/sisyphus`, `/goals-set`, or `/sisyphus-set` no longer clears other open goals. It creates a new active goal file and focuses it. Use `/goal-list` to inspect open goals, `/goal-focus` to switch the session focus, and `/goal-unfocus` to detach the current session without pausing, modifying, archiving, or recording a project-ledger focus change for the shared goal. Unfocus also aborts in-flight work and audits owned by that session; asynchronous lifecycle results are discarded if focus changed while they were pending. If the latest focus entry explicitly clears focus, or points at a missing/stale goal, a remaining single open goal is not auto-focused and resume does not prompt to replace that explicit choice. By default (`autoSelectSingleGoal: false`) sessions start unfocused so focus stays session-scoped — useful when multiple sessions share the same `.pi/goals/` directory. Set `autoSelectSingleGoal: true` to restore the old behavior where a single open goal is auto-focused when no focus entry exists at all. If multiple open goals exist and the session has no valid focus, `/goal-resume`, `/goal-clear`, `/goal-abort`, `/goal-pause`, and `/goal-tweak` ask the user to choose a goal instead of acting on all of them.
 
 ## Agent tools
 

package/docs/agent-flow-design.md

@@ -77,6 +77,8 @@ let focusedGoalId: string | null = null;
 | `goalWorkToolCalledThisTurn` | empty-turn guard：只有本 turn 做了有意义工作才继续 auto-continue。 |
 | `turnStoppedFor` | pause/abort/complete/tweak 后阻止同一 turn 继续乱调用工具。 |
 | `postCompactReminderPending` | session compact 后给下一轮 agent 注入 deterministic resync prompt。 |
+| `focusRevision` | session focus 改变时递增；异步 completion/tweak/task proposal 在写入前必须验证 revision，避免 unfocus 后迟到结果修改共享 goal。 |
+| `hasExplicitSessionFocus` | 区分“从未选择 focus”和显式 null focus，保证 resume/tree 不覆盖 `/goal-unfocus`。 |
 | `activeGetGoalTurnsByGoalId` | 统计重复 `get_goal`，用于 soft nudge，不是 hard block。 |
 
 ## 4. 持久化：Goal 文件与 Ledger
@@ -140,6 +142,7 @@ ledger append 是 best-effort：写入失败不应该让用户的生命周期动
 | `/sisyphus-set <objective>` | 直接创建并启动 Sisyphus goal，不进入 draft discussion。 |
 | `/goal-list` | 列出 `.pi/goals/` 下所有 open goals。 |
 | `/goal-focus` | 让用户选择当前 session focus。 |
+| `/goal-unfocus` | 清除当前 session focus，终止该 session 的 continuation/in-flight work/audit，并用 revision gate 丢弃迟到异步结果；不暂停、修改、归档共享 goal，也不写 project-global focus event。 |
 | `/goal-status` / `/goal` | 显示 focused goal 状态和其他 open goals 提示。 |
 | `/goal-tweak <change>` | 修改 focused goal，但也要先走 tweak drafting。 |
 | `/goal-pause` | 用户暂停 focused active goal。 |

package/docs/architecture.md

@@ -68,6 +68,7 @@ Reusable logic is split into smaller modules:
   ├─ multiple open goals
   │    ├─ /goal-list shows the project goal pool
   │    ├─ /goal-focus chooses the session focus
+  │    ├─ /goal-unfocus clears only the session focus and leaves the shared goal open
   │    └─ unfocused sessions guide the user to choose instead of letting the agent decide
   │
   └─ /goal-clear or /goal-abort archives the focused goal or cancels drafting
@@ -89,7 +90,7 @@ Session focus is separate. Focus changes append a custom session entry:
 {
   version: 1,
   focusedGoalId: string | null,
-  reason: "created" | "selected" | "resumed" | "completed" | "cleared" | "aborted" | "migrated"
+  reason: "created" | "selected" | "unfocused" | "resumed" | "completed" | "cleared" | "aborted" | "migrated"
 }
 ```
 
@@ -98,8 +99,8 @@ Because this is stored with `pi.appendEntry("pi-goal-focus", ...)`, it is sessio
 1. Use a valid focused id from the latest focus entry.
 2. If the latest focus entry explicitly has `focusedGoalId: null`, or points at a missing/stale goal, remain unfocused.
 3. If no focus entry exists, merge a compatible legacy `pi-goal-state { version: 3, goal }` goal and focus it. If disk already has the same id, the disk record wins and the legacy session record only supplies focus.
-4. If no focus entry exists and exactly one open goal exists, auto-focus it for compatibility.
-5. If multiple open goals exist and no valid focus exists, remain unfocused until `/goal-focus`, `/goal-resume`, `/goal-clear`, `/goal-abort`, `/goal-pause`, or `/goal-tweak` asks the user to choose.
+4. If no focus entry exists and `autoSelectSingleGoal` is enabled, auto-focus the sole open goal for compatibility. The default is disabled.
+5. Otherwise remain unfocused until the user explicitly selects a goal. `/goal-unfocus` appends a null focus entry so the current session stays detached without modifying the shared goal or appending a project-global focus event. Resume and tree reconstruction preserve that explicit null focus.
 
 Focus is human-owned. No agent tool can switch focus. Lifecycle tools operate only on the focused goal.
 
@@ -137,6 +138,7 @@ A deprecated optional `draftId` parameter is accepted for compatibility but igno
 - `/goals-set` and `/sisyphus-set` directly create and focus a new open goal from the supplied objective.
 - `/goal-list` prints all open goals with id, status, mode, usage, objective title, path, and a focus marker.
 - `/goal-focus` uses `ctx.ui.select` when multiple goals are open and updates only session focus.
+- `/goal-unfocus` writes a null session focus entry, clears continuation/runtime state, aborts in-flight work and audits for that session, and leaves the shared active goal file and project-global focus ledger unchanged. Focus revision tokens prevent pending completion, tweak, and task-list confirmation results from mutating a goal after detachment.
 - `/goal-status` and `/goal` show the focused goal plus an `other open goals` hint.
 - `/goal-resume` resumes the focused paused goal; when unfocused with multiple open goals, it asks the user to choose. Choosing an already active goal only focuses it.
 - `/goal-clear` and `/goal-abort` archive only the focused/selected goal and never clear the whole pool at once.

package/extensions/goal-draft.ts

@@ -1,3 +1,5 @@
+import type { GoalTask } from "./goal-record.ts";
+
 export type GoalDraftingFocus = "goal" | "sisyphus";
 
 export interface GoalConfirmationIntentLike {
@@ -22,6 +24,45 @@ export type ToolGateDecision =
 	| { block: false }
 	| { block: true; reason: string };
 
+// ── Shared formatting helpers ──────────────────────────────────────────────
+
+function formatModeLabel(sisyphus: boolean): string {
+	return sisyphus ? "Sisyphus (prompt/criteria style)" : "Normal goal";
+}
+
+function formatPrefixedLines(content: string): string[] {
+	const lines: string[] = [];
+	for (const rawLine of content.split("\n")) {
+		const trimmed = rawLine.trim();
+		if (!trimmed) continue;
+		if (trimmed.startsWith("│")) {
+			lines.push(rawLine);
+		} else {
+			lines.push(`│   ${rawLine}`);
+		}
+	}
+	return lines;
+}
+
+function formatSection(title: string, content: string): string[] {
+	const body = formatPrefixedLines(content);
+	return ["", `─── ${title} ───`, "", ...body];
+}
+
+export function renderConfirmationTasks(tasks: GoalTask[], indent: number): string[] {
+	const prefix = "  ".repeat(indent);
+	const lines: string[] = [];
+	for (const t of tasks) {
+		const lw = t.lightweightSubtasks ? " (lightweight)" : "";
+		const contract = t.verificationContract ? ` contract: ${t.verificationContract}` : "";
+		lines.push(`${prefix}[ ] ${t.id}: ${t.title}${lw}${contract}`);
+		if (t.subtasks && t.subtasks.length > 0) {
+			lines.push(...renderConfirmationTasks(t.subtasks, indent + 1));
+		}
+	}
+	return lines;
+}
+
 export function promptSafeObjective(objective: string): string {
 	return objective.replace(/<\/?untrusted_objective>/gi, (tag) => tag.replace(/</g, "&lt;").replace(/>/g, "&gt;"));
 }
@@ -84,30 +125,13 @@ export function buildDraftConfirmationText(args: {
 	autoContinue: boolean;
 }): string {
 	const lines: string[] = [];
-	const modeLabel = args.focus === "sisyphus" ? "Sisyphus (prompt/criteria style)" : "Normal goal";
 	lines.push("● Goal draft ready for confirmation.");
 	lines.push("");
 	lines.push("─── Draft Details ───");
-	lines.push(`│   Mode: ${modeLabel}`);
+	lines.push(`│   Mode: ${formatModeLabel(args.focus === "sisyphus")}`);
 	lines.push(`│   Auto-continue: ${args.autoContinue ? "yes" : "no"}`);
-	lines.push("");
-	lines.push("─── Original Topic ───");
-	lines.push("");
-	for (const topicLine of args.originalTopic.trim().split("\n")) {
-		if (topicLine.trim()) lines.push(`│   ${topicLine}`);
-	}
-	lines.push("");
-	lines.push("─── Proposed Goal ───");
-	lines.push("");
-	for (const objLine of args.objective.split("\n")) {
-		const trimmed = objLine.trim();
-		if (!trimmed) continue;
-		if (trimmed.startsWith("│")) {
-			lines.push(objLine);
-		} else {
-			lines.push(`│   ${objLine}`);
-		}
-	}
+	lines.push(...formatSection("Original Topic", args.originalTopic.trim()));
+	lines.push(...formatSection("Proposed Goal", args.objective));
 	return lines.join("\n");
 }
 
@@ -116,42 +140,22 @@ export function buildTweakConfirmationText(args: {
 	newObjective: string;
 	changeSummary: string;
 	sisyphus: boolean;
+	tasks?: GoalTask[];
 }): string {
 	const lines: string[] = [];
-	const modeLabel = args.sisyphus ? "Sisyphus (prompt/criteria style)" : "Normal goal";
 	lines.push("● Goal tweak ready for confirmation.");
 	lines.push("");
 	lines.push("─── Draft Details ───");
-	lines.push(`│   Mode: ${modeLabel}`);
-	lines.push("");
-	lines.push("─── Change ───");
-	lines.push("");
-	for (const changeLine of args.changeSummary.split("\n")) {
-		if (changeLine.trim()) lines.push(`│   ${changeLine}`);
-	}
-	lines.push("");
-	lines.push("─── Current Objective ───");
-	lines.push("");
-	for (const curLine of args.currentObjective.split("\n")) {
-		const trimmed = curLine.trim();
-		if (!trimmed) continue;
-		if (trimmed.startsWith("│")) {
-			lines.push(curLine);
-		} else {
-			lines.push(`│   ${curLine}`);
-		}
-	}
-	lines.push("");
-	lines.push("─── Proposed New Objective ───");
-	lines.push("");
-	for (const newLine of args.newObjective.split("\n")) {
-		const trimmed = newLine.trim();
-		if (!trimmed) continue;
-		if (trimmed.startsWith("│")) {
-			lines.push(newLine);
-		} else {
-			lines.push(`│   ${newLine}`);
-		}
+	lines.push(`│   Mode: ${formatModeLabel(args.sisyphus)}`);
+	lines.push(...formatSection("Change", args.changeSummary));
+	lines.push(...formatSection("Current Objective", args.currentObjective));
+	lines.push(...formatSection("Proposed New Objective", args.newObjective));
+	if (args.tasks && args.tasks.length > 0) {
+		const taskLines = renderConfirmationTasks(args.tasks, 0);
+		lines.push("");
+		lines.push(`┌─ TASKS ─────────────────────────────────────┐`);
+		for (const tl of taskLines) lines.push(tl);
+		lines.push(`└──────────────────────────────────────────────┘`);
 	}
 	return lines.join("\n");
 }

package/extensions/goal-record.ts

@@ -2,7 +2,7 @@ export type GoalStatus = "active" | "paused" | "complete";
 export type StopReason = "user" | "agent";
 export type GoalEventKind = "checkpoint" | "stale" | "drafting";
 export type DraftingFocus = "goal" | "sisyphus";
-export type GoalFocusReason = "created" | "selected" | "resumed" | "completed" | "cleared" | "aborted" | "migrated";
+export type GoalFocusReason = "created" | "selected" | "unfocused" | "resumed" | "completed" | "cleared" | "aborted" | "migrated";
 
 export type TaskStatus = "pending" | "complete" | "skipped";
 
@@ -146,7 +146,7 @@ export function normalizeGoalFocusEntry(value: unknown): GoalFocusEntry | null {
 		? safeIdPart(raw.focusedGoalId)
 		: null;
 	const reason: GoalFocusReason =
-		raw.reason === "created" || raw.reason === "selected" || raw.reason === "resumed" || raw.reason === "completed" || raw.reason === "cleared" || raw.reason === "aborted" || raw.reason === "migrated"
+		raw.reason === "created" || raw.reason === "selected" || raw.reason === "unfocused" || raw.reason === "resumed" || raw.reason === "completed" || raw.reason === "cleared" || raw.reason === "aborted" || raw.reason === "migrated"
 			? raw.reason
 			: "selected";
 	return { version: 1, focusedGoalId, reason };

package/extensions/goal.ts

@@ -13,6 +13,7 @@ import {
 	buildTweakConfirmationText,
 	extractVerificationContract,
 	goalDraftingPrompt,
+	renderConfirmationTasks,
 	validateGoalDraftProposal,
 	type GoalDraftingFocus,
 } from "./goal-draft.ts";
@@ -387,9 +388,39 @@ function isMeaningfulProgressToolCall(toolName: string, args: unknown): boolean
 
 // ---------- extension entry point ----------
 
-export default function goalExtension(pi: ExtensionAPI): void {
+export default function goalExtension(
+	pi: ExtensionAPI,
+	dependencies: { runCompletionAuditor?: typeof runGoalCompletionAuditor } = {},
+): void {
 	let goalsById = new Map<string, GoalRecord>();
 	let focusedGoalId: string | null = null;
+	let focusRevision = 0;
+	let hasExplicitSessionFocus = false;
+
+	function assignFocusedGoalId(next: string | null): void {
+		if (focusedGoalId !== next) focusRevision += 1;
+		focusedGoalId = next;
+	}
+
+	function focusedOperationToken(goalId: string): { goalId: string; revision: number } {
+		return { goalId, revision: focusRevision };
+	}
+
+	function isFocusedOperationCurrent(token: { goalId: string; revision: number }): boolean {
+		return focusedGoalId === token.goalId && focusRevision === token.revision;
+	}
+
+	function focusedOperationCancelledResult(action: string, token: { goalId: string; revision: number }) {
+		return {
+			content: [{
+				type: "text" as const,
+				text: `${action} cancelled because goal ${token.goalId} is no longer focused in this session. The shared goal was not modified.`,
+			}],
+			details: goalDetails(state.goal),
+			terminate: true,
+		};
+	}
+
 	const state = {
 		get goal(): GoalRecord | null {
 			return focusedGoalFromPool(goalsById, focusedGoalId);
@@ -397,11 +428,11 @@ export default function goalExtension(pi: ExtensionAPI): void {
 		set goal(next: GoalRecord | null) {
 			if (next) {
 				goalsById.set(next.id, next);
-				focusedGoalId = next.id;
+				assignFocusedGoalId(next.id);
 				return;
 			}
 			if (focusedGoalId) goalsById.delete(focusedGoalId);
-			focusedGoalId = null;
+			assignFocusedGoalId(null);
 		},
 	};
 	let continuationQueuedFor: string | null = null;
@@ -426,8 +457,15 @@ export default function goalExtension(pi: ExtensionAPI): void {
 	//   after their successful execute. Once set, pi.on("tool_call") blocks all
 	//   subsequent in-turn tool calls except POST_STOP_ALLOWED_TOOLS. This is the
 	//   schema fix for "agent keeps writing files after pause_goal".
+	// turnSeq: lightweight generation counter, incremented at each turn start.
+	//   Used to scope turnStoppedFor so stale markers from prior turns or sessions
+	//   cannot poison a resumed active goal.
+	// checkpointGoalId: remembers the incoming goal id from queued continuations.
+	//   When set but the goal is no longer active/autoContinue, work tools are blocked.
 	let goalWorkToolCalledThisTurn = false;
-	let turnStoppedFor: string | null = null;
+	let turnSeq = 0;
+	let turnStoppedFor: { goalId: string; turnSeq: number } | null = null;
+	let checkpointGoalId: string | null = null;
 
 	// #5 post-compaction resync: when a compaction just happened, the next agent
 	// turn gets an extra reminder block. Set in session_compact, consumed
@@ -542,6 +580,28 @@ export default function goalExtension(pi: ExtensionAPI): void {
 		accounting.lastAccountedAt = null;
 	}
 
+	function advanceTurnSeq(): void {
+		turnSeq += 1;
+		if (turnStoppedFor?.turnSeq !== turnSeq) turnStoppedFor = null;
+	}
+
+	function currentTurnStoppedGoalId(): string | null {
+		if (!turnStoppedFor) return null;
+		if (turnStoppedFor.turnSeq !== turnSeq) {
+			turnStoppedFor = null;
+			return null;
+		}
+		return turnStoppedFor.goalId;
+	}
+
+	function isActionableContinuationGoal(goalId: string | null | undefined): goalId is string {
+		return !!goalId && state.goal?.id === goalId && state.goal.status === "active" && state.goal.autoContinue;
+	}
+
+	function isStaleCheckpointBlockedToolCall(toolName: string): boolean {
+		return !POST_STOP_ALLOWED_TOOL_SET.has(toolName);
+	}
+
 	function clearStoppedRuntimeState(): void {
 		clearContinuationState();
 		clearActiveAccounting();
@@ -572,11 +632,11 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			if (current && !current.activePath) {
 				goalsById = fresh;
 				goalsById.set(current.id, current);
-				focusedGoalId = current.id;
+				assignFocusedGoalId(current.id);
 				return true;
 			}
 			goalsById = fresh;
-			focusedGoalId = null;
+			assignFocusedGoalId(null);
 			clearStoppedRuntimeState();
 			if (current) resetGetGoalNudgeState(current.id);
 			if (tweakDraftingFor !== null) tweakDraftingFor = null;
@@ -589,19 +649,25 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			: diskGoal;
 		goalsById = fresh;
 		goalsById.set(reconciled.id, reconciled);
-		focusedGoalId = reconciled.id;
+		assignFocusedGoalId(reconciled.id);
 		if (reconciled.status !== "active" || !reconciled.autoContinue) clearContinuationState();
 		if (reconciled.status !== "active") clearActiveAccounting();
 		return true;
 	}
 
 	function appendFocusEntry(goalId: string | null, reason: GoalFocusReason): void {
+		hasExplicitSessionFocus = true;
 		pi.appendEntry(FOCUS_ENTRY, goalFocusDetails(goalId, reason));
 	}
 
-	function setFocusedGoalId(goalId: string | null, ctx: ExtensionContext, reason: GoalFocusReason): void {
+	function setFocusedGoalId(
+		goalId: string | null,
+		ctx: ExtensionContext,
+		reason: GoalFocusReason,
+		opts: { recordLedger?: boolean } = {},
+	): void {
 		const previousGoalId = focusedGoalId;
-		focusedGoalId = goalId && goalsById.has(goalId) ? goalId : null;
+		assignFocusedGoalId(goalId && goalsById.has(goalId) ? goalId : null);
 		if (previousGoalId !== focusedGoalId) {
 			clearContinuationState();
 			clearActiveAccounting();
@@ -612,9 +678,9 @@ export default function goalExtension(pi: ExtensionAPI): void {
 		appendFocusEntry(focusedGoalId, reason);
 		// Append ledger event for focus changes
 		try {
-			if (focusedGoalId) {
+			if (opts.recordLedger !== false && focusedGoalId) {
 				appendGoalEvent(ctx, { type: "goal_focused", goalId: focusedGoalId, reason, at: nowIso() });
-			} else if (previousGoalId) {
+			} else if (opts.recordLedger !== false && previousGoalId) {
 				appendGoalEvent(ctx, { type: "goal_unfocused", reason, at: nowIso() });
 			}
 		} catch {
@@ -627,7 +693,7 @@ export default function goalExtension(pi: ExtensionAPI): void {
 	function updateFocusedGoal(next: GoalRecord, ctx: ExtensionContext, shouldPersist = true): void {
 		const previousGoalId = focusedGoalId;
 		goalsById.set(next.id, next);
-		focusedGoalId = next.id;
+		assignFocusedGoalId(next.id);
 		if (previousGoalId !== focusedGoalId) {
 			resetGetGoalNudgeState(previousGoalId);
 			resetGetGoalNudgeState(focusedGoalId);
@@ -645,7 +711,7 @@ export default function goalExtension(pi: ExtensionAPI): void {
 	function removeFocusedGoal(ctx: ExtensionContext, reason: GoalFocusReason): void {
 		const previousGoalId = focusedGoalId;
 		if (focusedGoalId) goalsById.delete(focusedGoalId);
-		focusedGoalId = null;
+		assignFocusedGoalId(null);
 		clearStoppedRuntimeState();
 		resetGetGoalNudgeState(previousGoalId);
 		appendFocusEntry(null, reason);
@@ -829,7 +895,9 @@ export default function goalExtension(pi: ExtensionAPI): void {
 
 	function loadState(ctx: ExtensionContext): void {
 		goalsById = readActiveGoalPool(ctx);
-		focusedGoalId = null;
+		focusRevision += 1; // Session reload/tree navigation invalidates pending async focus operations.
+		assignFocusedGoalId(null);
+		hasExplicitSessionFocus = false;
 		let focusEntry: GoalFocusEntry | null = null;
 		let legacyGoal: GoalRecord | null = null;
 		let legacyStateSeen = false;
@@ -850,7 +918,8 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			legacyGoal = sanitizeGoalPaths(ctx, mergeGoalPromptFromDisk(ctx, legacyGoal));
 		}
 		const settings = loadGoalSettings(ctx.cwd);
-		focusedGoalId = resolveSessionFocus({ pool: goalsById, focusEntry, legacyGoal, autoSelectSingleGoal: settings.autoSelectSingleGoal });
+		hasExplicitSessionFocus = focusEntry !== null;
+		assignFocusedGoalId(resolveSessionFocus({ pool: goalsById, focusEntry, legacyGoal, autoSelectSingleGoal: settings.autoSelectSingleGoal }));
 		if (!focusEntry && focusedGoalId) {
 			try {
 				appendFocusEntry(focusedGoalId, legacyGoal?.id === focusedGoalId ? "migrated" : "selected");
@@ -1008,7 +1077,7 @@ export default function goalExtension(pi: ExtensionAPI): void {
 				state.goal = null;
 				if (focusedGoalId === prevId) {
 					goalsById.delete(prevId);
-					focusedGoalId = null;
+					assignFocusedGoalId(null);
 				}
 				clearStoppedRuntimeState();
 				syncGoalTools();
@@ -1245,7 +1314,7 @@ Verification contract:
 		continuationTimer = null;
 		continuationScheduledFor = null;
 		syncGoalTools();
-		if (!state.goal || state.goal.id !== goalId || state.goal.status !== "active" || !state.goal.autoContinue) {
+		if (!isActionableContinuationGoal(goalId)) {
 			if (continuationQueuedFor === goalId) continuationQueuedFor = null;
 			return;
 		}
@@ -1266,16 +1335,18 @@ Verification contract:
 		}
 		continuationQueuedFor = goalId;
 		const settings = loadGoalSettings(ctx.cwd);
+		const goal = state.goal;
+		if (!goal) return;
 		pi.sendMessage<GoalEventDetails>(
 			{
 				customType: GOAL_EVENT_ENTRY,
-				content: continuationPrompt(state.goal, settings),
+				content: continuationPrompt(goal, settings),
 				display: false,
 				details: {
 					kind: "checkpoint",
-					goalId: state.goal.id,
-					status: state.goal.status,
-					objective: state.goal.objective,
+					goalId: goal.id,
+					status: goal.status,
+					objective: goal.objective,
 					timestamp: Date.now(),
 				},
 			},
@@ -1471,6 +1542,34 @@ Verification contract:
 		ctx.ui.notify(`Focused goal: ${oneLineSummary(state.goal)}`, "info");
 	}
 
+	function unfocusGoalCommand(ctx: ExtensionContext): void {
+		const runtimeGoalId = state.goal?.id ?? runningGoalId ?? checkpointGoalId;
+		reconcileFocusedGoalFromDisk(ctx);
+		const current = state.goal;
+		const detachedGoalId = current?.id ?? runtimeGoalId;
+		let wasBusy = false;
+		try {
+			wasBusy = !ctx.isIdle();
+		} catch {}
+		if (detachedGoalId && wasBusy) turnStoppedFor = { goalId: detachedGoalId, turnSeq };
+		setFocusedGoalId(null, ctx, "unfocused", { recordLedger: false });
+		runningGoalId = null;
+		checkpointGoalId = null;
+		postCompactReminderPending = false;
+		if (auditAbortController) auditAbortController.abort();
+		if (detachedGoalId && wasBusy) {
+			try {
+				ctx.abort?.();
+			} catch {}
+		}
+		if (!current) {
+			const openCount = openGoals().length;
+			ctx.ui.notify(openCount > 0 ? buildUnfocusedOpenGoalsSummary(openCount) : detailedSummary(null), "info");
+			return;
+		}
+		ctx.ui.notify(`Goal unfocused for this session. It remains open in .pi/goals: ${current.id}`, "info");
+	}
+
 	async function handleGoalCommandTopic(rawTopic: string, ctx: ExtensionContext, focus: DraftingFocus, opts: { replace: boolean }): Promise<void> {
 		const topic = rawTopic.trim();
 		if (opts.replace) {
@@ -1729,7 +1828,7 @@ Verification contract:
 		},
 	};
 	pi.registerCommand("goal", {
-		description: "Show focused goal status. Discuss with /goals or /sisyphus; direct-start with /goals-set or /sisyphus-set; manage with /goal-list, /goal-focus, /goal-settings, /goal-tweak, /goal-clear, /goal-abort, /goal-pause, /goal-resume.",
+		description: "Show focused goal status. Discuss with /goals or /sisyphus; direct-start with /goals-set or /sisyphus-set; manage with /goal-list, /goal-focus, /goal-unfocus, /goal-settings, /goal-tweak, /goal-clear, /goal-abort, /goal-pause, /goal-resume.",
 		handler: statusCommand.handler,
 	});
 	pi.registerCommand("goal-status", statusCommand);
@@ -1747,6 +1846,12 @@ Verification contract:
 			await focusGoalCommand(ctx);
 		},
 	});
+	pi.registerCommand("goal-unfocus", {
+		description: "Stop focusing the current goal in this session without modifying or archiving the shared goal.",
+		handler: async (_rawArgs, ctx) => {
+			unfocusGoalCommand(ctx);
+		},
+	});
 	pi.registerCommand("goal-settings", {
 		description: "Open pi-goal settings, including auditor provider/model/thinking_level.",
 		handler: async (_rawArgs, ctx) => {
@@ -1964,20 +2069,6 @@ Verification contract:
 			const autoContinueFlag = params.autoContinue ?? true;
 			const sisyphusFlag = validation.expectedSisyphus;
 			// Build confirmation text: goal + optional task list
-			function renderConfirmationTasks(tasks: GoalTask[], indent: number): string[] {
-				const prefix = "  ".repeat(indent);
-				const lines: string[] = [];
-				for (const t of tasks) {
-					const lw = t.lightweightSubtasks ? " (lightweight)" : "";
-					const contract = t.verificationContract ? ` contract: ${t.verificationContract}` : "";
-					lines.push(`${prefix}[ ] ${t.id}: ${t.title}${lw}${contract}`);
-					if (t.subtasks && t.subtasks.length > 0) {
-						lines.push(...renderConfirmationTasks(t.subtasks, indent + 1));
-					}
-				}
-				return lines;
-			}
-
 			let taskSummarySection = "";
 			let tasksToCreate: GoalTask[] | undefined;
 			if (params.tasks && params.tasks.length > 0) {
@@ -2124,10 +2215,25 @@ ${objective}` : objective,
 			"The user will see a full plain-text report plus a [Confirm] / [Continue Chatting] choice. Confirm applies the tweak; Continue Chatting returns control to you to ask follow-up questions.",
 			"If the tool returns 'continue chatting', ask the user what they want changed. Do NOT re-propose the same content immediately; iterate based on their feedback first.",
 			"Do NOT use write/edit/bash to modify the active goal file directly. propose_goal_tweak is the only sanctioned channel.",
+			"tasks (optional): an array of task objects to REPLACE the current goal's task list. When omitted,",
+			"  the existing task list is inherited as-is. When provided, the full task list is replaced with",
+			"  the new tasks — add/remove/change tasks by passing the complete updated list.",
+			"  Each task has: {id, title, verificationContract?, lightweightSubtasks?, subtasks?}.",
+			"  Subtasks use the same shape recursively. The task list is displayed in the confirmation",
+			"  dialog alongside the objective diff, matching propose_goal_draft's rendering format.",
+			"Start from the current goal's objective text and task list (the inheritance defaults), then",
+			"  edit/rewrite them directly rather than composing a goal from scratch.",
 		],
 		parameters: Type.Object({
 			newObjective: Type.String({ description: "The complete revised objective text. For Sisyphus goals, preserve the Sisyphus style unless the user explicitly changes it." }),
-			changeSummary: Type.String({ description: "One-sentence description of what was changed (used in confirmation dialog and tweak log)." }),
+			changeSummary: Type.String({ description: "One-sentence description of what was changed (used in confirmation dialog, activity log, and tweak log)." }),
+			tasks: Type.Optional(Type.Array(Type.Object({
+				id: Type.String({ description: "Short stable slug e.g. 'task-1'" }),
+				title: Type.String({ description: "Human-readable task title" }),
+				verificationContract: Type.Optional(Type.String({ description: "Optional verification contract for this task." })),
+				lightweightSubtasks: Type.Optional(Type.Boolean({ description: "If true, subtasks are lightweight (no completion enforcement). Default false." })),
+				subtasks: Type.Optional(Type.Any({ description: "Optional recursive array of sub-tasks (same shape as parent)." })),
+			}), { description: "Optional task list to replace the current goal's tasks. When omitted the existing task list is inherited. Each task supports recursive subtasks." })),
 		}),
 		executionMode: "sequential",
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
@@ -2149,6 +2255,41 @@ ${objective}` : objective,
 			const changeSummary = params.changeSummary.trim();
 			if (!changeSummary) throw new Error("propose_goal_tweak requires a non-empty changeSummary.");
 
+			// Resolve tasks: inherit from current goal if not provided, or normalize/validate the passed tasks.
+			let tweakTasks: GoalTask[] | undefined;
+			if (params.tasks && Array.isArray(params.tasks) && params.tasks.length > 0) {
+				tweakTasks = params.tasks.map((t: Record<string, unknown>) => {
+					const task: GoalTask = {
+						id: t.id as string,
+						title: t.title as string,
+						status: "pending",
+						verificationContract: t.verificationContract as string | undefined,
+						lightweightSubtasks: t.lightweightSubtasks === true ? true : undefined,
+					};
+					const rawSubtasks = t.subtasks;
+					if (Array.isArray(rawSubtasks) && rawSubtasks.length > 0) {
+						task.subtasks = rawSubtasks
+							.map((s: Record<string, unknown>) => normalizeTaskItem(s))
+							.filter((s: GoalTask | undefined): s is GoalTask => !!s);
+					}
+					return task;
+				});
+				// Validate task list
+				if (tweakTasks.length > 50) {
+					return { content: [{ type: "text", text: "Task list cannot exceed 50 tasks." }], details: goalDetails(state.goal) };
+				}
+				const settings = loadGoalSettings(ctx.cwd);
+				const depthViolation = findSubtaskDepthViolation(tweakTasks, settings.subtaskDepth ?? 1);
+				if (depthViolation) {
+					return { content: [{ type: "text", text: depthViolation }], details: goalDetails(state.goal) };
+				}
+			} else {
+				// Inherit current task list when no tasks parameter provided
+				if (state.goal.taskList && state.goal.taskList.tasks.length > 0) {
+					tweakTasks = state.goal.taskList.tasks;
+				}
+			}
+
 			// Auto-start the tweak drafting flow if not already active.
 			if (tweakDraftingFor !== state.goal.id) {
 				await startGoalTweakDrafting(changeSummary, ctx);
@@ -2168,9 +2309,11 @@ ${objective}` : objective,
 				newObjective,
 				changeSummary,
 				sisyphus: !!state.goal.sisyphus,
+				tasks: tweakTasks,
 			});
 
 			const headless = shouldAutoConfirmProposal({ hasUI: ctx.hasUI, autoConfirmEnv: process.env.PI_GOAL_AUTO_CONFIRM });
+			const tweakFocus = focusedOperationToken(state.goal.id);
 
 			let decision: { decision: "confirm" | "continue"; auditorEnabled: boolean };
 			if (headless) {
@@ -2187,6 +2330,9 @@ ${objective}` : objective,
 					};
 				}
 			}
+			if (!isFocusedOperationCurrent(tweakFocus)) {
+				return focusedOperationCancelledResult("Goal tweak", tweakFocus);
+			}
 
 			if (decision.decision === "confirm") {
 				// Persist any auditor toggle change
@@ -2204,6 +2350,9 @@ ${objective}` : objective,
 					// Clear any prior agent pause reason — the user has redefined the work.
 					pauseReason: undefined,
 					pauseSuggestedAction: undefined,
+					taskList: tweakTasks && tweakTasks.length > 0
+						? { tasks: tweakTasks, blockCompletion: false, proposedAt: nowIso() }
+						: undefined,
 				};
 				// IMPORTANT: bypass setGoal() / persist() here. persist() calls
 				// syncGoalPromptFromDisk() which would RE-READ the stale objective
@@ -2220,7 +2369,7 @@ ${objective}` : objective,
 				// Reset autoContinue counter — plan changed, agent gets a fresh chain.
 				resetGetGoalNudgeState(state.goal.id);
 				// Mark turn-stopped so subsequent in-turn tool calls are blocked.
-				turnStoppedFor = state.goal.id;
+				turnStoppedFor = { goalId: state.goal.id, turnSeq };
 				syncGoalTools();
 				updateUI(ctx);
 				ctx.ui.notify(`Goal tweaked: ${truncateText(changeSummary, 160)}`, "info");
@@ -2235,6 +2384,20 @@ ${objective}` : objective,
 				} catch {
 					// Ledger append failure should not crash tweak
 				}
+				// Append ledger event for task list change if tasks were provided
+				if (params.tasks && Array.isArray(params.tasks) && params.tasks.length > 0) {
+					try {
+						appendGoalEvent(ctx, {
+							type: "task_list_set",
+							goalId: state.goal.id,
+							taskCount: params.tasks.length,
+							blockCompletion: false,
+							at: state.goal.updatedAt,
+						});
+					} catch {
+						// Ledger append failure should not crash tweak
+					}
+				}
 				return {
 					content: [{
 						type: "text",
@@ -2332,6 +2495,7 @@ ${objective}` : objective,
 			}
 
 			const auditTarget = mergeGoalPromptFromDisk(ctx, state.goal);
+			const completionFocus = focusedOperationToken(auditTarget.id);
 			// Append ledger: completion requested
 			try {
 				appendGoalEvent(ctx, {
@@ -2379,7 +2543,7 @@ ${objective}` : objective,
 					updatedAt: nowIso(),
 				};
 				state.goal = writeActiveGoalFile(ctx, state.goal);
-				turnStoppedFor = state.goal?.id ?? null;
+				turnStoppedFor = state.goal ? { goalId: state.goal.id, turnSeq } : null;
 				resetGetGoalNudgeState(state.goal?.id);
 				syncGoalTools();
 				updateUI(ctx);
@@ -2445,7 +2609,7 @@ ${objective}` : objective,
 					updatedAt: nowIso(),
 				};
 				state.goal = writeActiveGoalFile(ctx, state.goal);
-				turnStoppedFor = state.goal?.id ?? null;
+				turnStoppedFor = state.goal ? { goalId: state.goal.id, turnSeq } : null;
 				resetGetGoalNudgeState(state.goal?.id);
 				syncGoalTools();
 				updateUI(ctx);
@@ -2476,6 +2640,9 @@ ${objective}` : objective,
 				display: true,
 				details: { phase: "started", goalId: auditTarget.id, auditor: auditorLabel },
 			}, { triggerTurn: true });
+			if (!isFocusedOperationCurrent(completionFocus)) {
+				return focusedOperationCancelledResult("Goal completion", completionFocus);
+			}
 			// Append ledger: audit started
 			try {
 				appendGoalEvent(ctx, {
@@ -2510,16 +2677,17 @@ ${objective}` : objective,
 
 			// Create a dedicated AbortController for the audit so it can be interrupted via Escape
 			auditAbortController?.abort(); // Clean up any stale controller
-			auditAbortController = new AbortController();
+			const completionAuditController = new AbortController();
+			auditAbortController = completionAuditController;
 
-			const auditor = await runGoalCompletionAuditor({
+			const auditor = await (dependencies.runCompletionAuditor ?? runGoalCompletionAuditor)({
 				ctx,
 				goal: auditTarget,
 				completionSummary: params.completionSummary,
 				detailedSummary: detailedSummary(auditTarget),
 				verificationSummary: params.verificationSummary,
 				settings: loadGoalSettings(ctx.cwd),
-				signal: auditAbortController.signal,
+				signal: completionAuditController.signal,
 				onProgress: (progress) => {
 					auditProgress = {
 						...progress,
@@ -2529,9 +2697,14 @@ ${objective}` : objective,
 				},
 			});
 			// Clear abort controller — audit finished on its own
-			auditAbortController = null;
+			if (auditAbortController === completionAuditController) auditAbortController = null;
 			// Clear auditor progress display
 			stopAuditAnimation();
+			if (!isFocusedOperationCurrent(completionFocus)) {
+				auditProgress = null;
+				goalWidgetComponent?.invalidate();
+				return focusedOperationCancelledResult("Goal completion", completionFocus);
+			}
 
 			// If the audit was aborted by the user (Esc), show a TUI dialog letting
 			// the user choose: mark complete without audit, or continue working.
@@ -2543,6 +2716,9 @@ ${objective}` : objective,
 				showingEscapeDialog = true;
 				const userChoice: EscapeDialogResult = await showEscapeDialog(ctx, auditTarget.objective);
 				showingEscapeDialog = false;
+				if (!isFocusedOperationCurrent(completionFocus)) {
+					return focusedOperationCancelledResult("Goal completion", completionFocus);
+				}
 
 				if (userChoice === "complete_without_audit") {
 					// ── Mark complete without audit ────────────────────────────
@@ -2574,7 +2750,7 @@ ${objective}` : objective,
 						updatedAt: nowIso(),
 					};
 					state.goal = writeActiveGoalFile(ctx, state.goal);
-					turnStoppedFor = state.goal?.id ?? null;
+					turnStoppedFor = state.goal ? { goalId: state.goal.id, turnSeq } : null;
 					resetGetGoalNudgeState(state.goal?.id);
 					syncGoalTools();
 					updateUI(ctx);
@@ -2592,7 +2768,7 @@ ${objective}` : objective,
 				} else {
 					// ── Continue working → pause the goal ──────────────
 					pauseActiveGoal(ctx);
-					turnStoppedFor = state.goal?.id ?? null;
+					turnStoppedFor = state.goal ? { goalId: state.goal.id, turnSeq } : null;
 					return {
 						content: [{ type: "text", text: "Goal paused — user chose to continue working after skipping audit." }],
 						details: state.goal ? goalDetails(state.goal) : undefined,
@@ -2674,7 +2850,7 @@ ${objective}` : objective,
 				updatedAt: nowIso(),
 			};
 			state.goal = writeActiveGoalFile(ctx, state.goal);
-			turnStoppedFor = state.goal?.id ?? null;
+			turnStoppedFor = state.goal ? { goalId: state.goal.id, turnSeq } : null;
 			resetGetGoalNudgeState(state.goal?.id);
 			syncGoalTools();
 			updateUI(ctx);
@@ -2741,7 +2917,7 @@ ${objective}` : objective,
 			resetGetGoalNudgeState(next.id);
 			// C9 fix: mark turn-stopped so subsequent in-turn tool calls are blocked.
 			// This is the schema-level closure of "agent kept writing files after pause_goal".
-			turnStoppedFor = state.goal.id;
+			turnStoppedFor = { goalId: state.goal.id, turnSeq };
 
 			const suggestionLine = suggested ? `\nSuggested: ${truncateText(suggested, 160)}` : "";
 			ctx.ui.notify(
@@ -2801,7 +2977,7 @@ ${objective}` : objective,
 			const archived = archiveCurrentGoal(ctx, "agent");
 			resetGetGoalNudgeState(abortedGoalId);
 			setGoal(null, ctx, true, "aborted");
-			turnStoppedFor = abortedGoalId;
+			turnStoppedFor = { goalId: abortedGoalId, turnSeq };
 
 			const archiveLine = archived?.archivedPath ? `\nArchive: ${archived.archivedPath}` : "";
 			ctx.ui.notify(
@@ -2967,8 +3143,12 @@ ${objective}` : objective,
 			const taskLines = renderTaskLines(taskList.tasks);
 			const gateLabel = blockCompletion ? " (blockCompletion enabled)" : "";
 			const proposalText = [`Proposed task list${gateLabel}:`, "", ...taskLines].join("\n");
+			const taskListFocus = focusedOperationToken(state.goal.id);
 
 			const dialogResult = await showProposalDialog(ctx, proposalText, "goal", !state.goal?.skipAuditor);
+			if (!isFocusedOperationCurrent(taskListFocus)) {
+				return focusedOperationCancelledResult("Task list proposal", taskListFocus);
+			}
 			if (dialogResult.decision !== "confirm") {
 				return {
 					content: [{ type: "text", text: "Task list proposal declined." }],
@@ -2990,7 +3170,7 @@ ${objective}` : objective,
 			}
 			state.goal = { ...state.goal, taskList, updatedAt: now };
 			setGoal(state.goal, ctx);
-			turnStoppedFor = state.goal.id;
+			turnStoppedFor = { goalId: state.goal.id, turnSeq };
 			resetGetGoalNudgeState(state.goal.id);
 			syncGoalTools();
 			updateUI(ctx);
@@ -3267,8 +3447,8 @@ promptGuidelines: [
 
 	pi.on("turn_start", async (_event, ctx) => {
 		// Per-turn flag resets (#4 + C9 fix).
+		advanceTurnSeq();
 		goalWorkToolCalledThisTurn = false;
-		turnStoppedFor = null;
 		syncGoalTools();
 		beginAccounting();
 		updateUI(ctx);
@@ -3276,17 +3456,29 @@ promptGuidelines: [
 
 	// #4 + C9 fix + Phase 5 C3: gate in-turn tool calls based on lifecycle state.
 	pi.on("tool_call", async (event, ctx) => {
+		const stoppedGoalId = currentTurnStoppedGoalId();
 		// Post-stop in-turn block (C9 0ad8 fix): after pause_goal / abort_goal /
 		// complete_goal / propose_goal_tweak fires in this turn, block all subsequent tool calls except
 		// read-only inspection. Forces the agent to yield the turn instead of "fixing"
 		// the situation by creating extra files etc.
-		if (turnStoppedFor !== null && !POST_STOP_ALLOWED_TOOL_SET.has(event.toolName)) {
+		if (stoppedGoalId !== null && !POST_STOP_ALLOWED_TOOL_SET.has(event.toolName)) {
 			return {
 				block: true,
-				reason: `The goal was already stopped earlier in this turn (goalId=${turnStoppedFor}). ` +
+				reason: `The goal was already stopped earlier in this turn (goalId=${stoppedGoalId}). ` +
 					`Do not call more tools; end the turn with a brief summary and yield to the user.`,
 			};
 		}
+		// Stale checkpoint guard: if the turn was triggered by a queued continuation
+		// for a goal that is no longer active/autoContinue, block work tools.
+		if (checkpointGoalId !== null && !isActionableContinuationGoal(checkpointGoalId) && isStaleCheckpointBlockedToolCall(event.toolName)) {
+			// Block the tool call with a stale-checkpoint message.
+			return {
+				block: true,
+				reason: `Cannot call ${event.toolName}: the goal checkpoint that triggered this turn is no longer active. ` +
+					`Goal ${checkpointGoalId} has been paused, cleared, or replaced. ` +
+					`End the turn with a brief summary and yield to the user.`,
+			};
+		}
 		// Phase 5 soft gate relaxation: active-goal question block and repeated get_goal
 		// block are removed. The agent is trusted to prefer work tools; prompts nudge
 		// toward concrete work without hard-stopping the turn.
@@ -3329,7 +3521,7 @@ promptGuidelines: [
 			const archived = archiveGoalFile(ctx, completedGoal);
 			resetGetGoalNudgeState(completedGoal.id);
 			goalsById.delete(completedGoal.id);
-			focusedGoalId = null;
+			assignFocusedGoalId(null);
 			appendFocusEntry(null, "completed");
 			syncGoalTools();
 			updateUI(ctx);
@@ -3369,8 +3561,9 @@ promptGuidelines: [
 	pi.on("session_start", async (event, ctx) => {
 		syncGoalTools();
 		loadState(ctx);
+		syncGoalTools();
 		syncTerminalInputPause(ctx);
-		if (event.reason === "resume" && !state.goal && openGoals().length > 1 && ctx.hasUI) {
+		if (event.reason === "resume" && !state.goal && !hasExplicitSessionFocus && openGoals().length > 1 && ctx.hasUI) {
 			await focusGoalCommand(ctx);
 		}
 		// Codex behavior: prompt before reactivating a paused goal on resume.
@@ -3409,11 +3602,13 @@ promptGuidelines: [
 	});
 
 	pi.on("before_agent_start", async (event, ctx) => {
+		advanceTurnSeq();
 		syncGoalTools();
 		const currentSystemPrompt = () => ctx.getSystemPrompt?.() || event.systemPrompt;
 		const incomingGoalId = extractGoalIdFromInjectedMessage(event.prompt ?? "");
 
 		if (confirmationIntent !== null) {
+			checkpointGoalId = null;
 			clearContinuationState();
 			clearActiveAccounting();
 			runningGoalId = null;
@@ -3421,6 +3616,7 @@ promptGuidelines: [
 		}
 
 		if (tweakDraftingFor !== null) {
+			checkpointGoalId = null;
 			clearContinuationState();
 			clearActiveAccounting();
 			runningGoalId = null;
@@ -3431,8 +3627,12 @@ promptGuidelines: [
 		// matches the active goal, abort the whole turn instead of letting the
 		// model act on a stale instruction.
 		if (incomingGoalId !== null) {
+			// Reconcile from disk to pick up any external state changes before
+			// evaluating whether the checkpoint is actionable.
+			reconcileFocusedGoalFromDisk(ctx);
+			checkpointGoalId = incomingGoalId;
 			clearContinuationState();
-			if (!state.goal || state.goal.id !== incomingGoalId || (state.goal.status !== "active") || !state.goal.autoContinue) {
+			if (!isActionableContinuationGoal(incomingGoalId)) {
 				try {
 					ctx.abort?.();
 				} catch {}
@@ -3441,10 +3641,12 @@ promptGuidelines: [
 					systemPrompt: `${currentSystemPrompt()}\n\n${staleContinuationPrompt(incomingGoalId, state.goal)}`,
 				};
 			}
+			checkpointGoalId = null;
 		} else {
 			// A user-driven turn — clear any queued continuation so we don't
 			// double-fire after the user's own message returns. Also reset the
 			// autoContinue nudge state so the user always gets a fresh chain.
+			checkpointGoalId = null;
 			clearContinuationState();
 			resetGetGoalNudgeState(state.goal?.id);
 		}

package/extensions/prompts/goal-prompts.ts

@@ -238,14 +238,21 @@ export function goalTweakDraftingPrompt(current: GoalRecord, hint: string): stri
 		"<current_objective>",
 		promptSafeObjective(current.objective),
 		"</current_objective>",
+		...(current.taskList && current.taskList.tasks.length > 0
+			? ["", taskListBlock(current), ""]
+			: []),
 		`Sisyphus mode: ${sisyphusOn ? "on (prompt/criteria style)" : "off"}`,
 		"",
 		"User's tweak hint (may be empty):",
+		"User's tweak hint (may be empty):",
 		"<tweak_hint>",
 		safeHint,
 		"</tweak_hint>",
 		"",
 		"Drafting protocol:",
+		"- Start from the EXISTING goal — you are editing the current goal, not writing from scratch.",
+		"  The current objective (above) and task list (if any) are your starting point. Edit/rewrite",
+		"  them directly, preserving what works and changing what needs to change.",
 		"- Apply common sense: if the hint is fully self-explanatory, acknowledge in one sentence and apply the tweak immediately. Do not invent unnecessary questions.",
 		"- Otherwise ask focused questions (1-3 rounds) to clarify exactly what to change. Prefer numbered options or yes/no.",
 		"- Do NOT call create_goal (a goal already exists).",
@@ -264,6 +271,10 @@ export function goalTweakDraftingPrompt(current: GoalRecord, hint: string): stri
 			? " === Sisyphus Goal === block (Objective / Success criteria / Boundaries / Constraints / If blocked / Sisyphus reminder)."
 			: " === Goal === block (Objective / Success criteria / Boundaries / Constraints / If blocked)."),
 		"   - changeSummary: one sentence describing what changed.",
+		"   - tasks (optional): an array of task objects to REPLACE the current goal's task list. If omitted,",
+		"     the existing task list is inherited as-is. If you need to add/remove/change tasks, pass the",
+		"     full updated task list here. Each task has {id, title, verificationContract?, lightweightSubtasks?, subtasks?}.",
+		"     Subtasks use the same shape recursively.",
 		"2. propose_goal_tweak opens the user's Confirm / Continue Chatting dialog.",
 		"   - Confirm applies the tweak. Stop; the next continuation will arrive automatically if the goal is active.",
 		"   - Continue Chatting means the drafting stays active — ask the user what they want changed, then revise and call propose_goal_tweak again.",

package/package.json

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