@zhushanwen/pi-goal 0.1.6 → 0.3.0

package/src/agent-end-handler.ts

@@ -31,8 +31,8 @@ import {
 } from "./templates";
 import {
 	type GoalSession,
-	persistGoalState,
-	updateWidget,
+	persistAndUpdate,
+	sendGoalContextMessage,
 	writeGoalHistoryEntry,
 } from "./tool-handler";
 
@@ -56,9 +56,17 @@ export async function handleAgentEnd(pi: ExtensionAPI, session: GoalSession, ctx
 			await handleTerminalStateAgentEnd(pi, session, ctx, checkStale); return;
 		}
 		if (!isActiveStatus(session.state.status)) return;
+
+		// ESC / user abort during text generation also pauses the goal
+		if (ctx.signal?.aborted) {
+			session.pendingPause = true;
+			const progress = checkProgress(session.state, session.tasksCompletedAtAgentStart);
+			await handleStallAndContinuation(pi, session, ctx, progress, checkStale);
+			return;
+		}
+
 		const budgetAction = await handleBudgetChecks(pi, session, ctx, checkBudgetOnTurnEnd(session.state), checkStale);
 		if (budgetAction !== "continue") return;
-		session.state.turnCount++;
 		const progress = checkProgress(session.state, session.tasksCompletedAtAgentStart);
 		const progressAction = handleProgressAndTasks(pi, session, ctx, progress, checkStale);
 		if (progressAction !== "continue") return;
@@ -81,9 +89,7 @@ async function handleTerminalStateAgentEnd(
 	checkStale: () => boolean,
 ): Promise<void> {
 	const state = session.state!;
-	persistGoalState(pi, session, ctx);
-	if (checkStale()) return;
-	updateWidget(session, ctx);
+	if (persistAndUpdate(pi, session, ctx, checkStale)) return;
 	if (state.status === "complete") {
 		ctx.ui.notify(
 			`Objective completed ✓ (${getCompletedCount(state.tasks)}/${state.tasks.length} tasks, ${state.currentTurnIndex} turns)`,
@@ -118,9 +124,7 @@ async function handleBudgetChecks(
 		session.state!.status = transitionStatus(session.state!.status, dim === "token" ? "budget_limited" : "time_limited");
 		session.state!.completedAtTurnIndex = session.state!.currentTurnIndex;
 		writeGoalHistoryEntry(pi, session);
-		persistGoalState(pi, session, ctx);
-		if (checkStale()) return "stop";
-		updateWidget(session, ctx);
+		if (persistAndUpdate(pi, session, ctx, checkStale)) return "stop";
 		ctx.ui.notify(
 			dim === "token"
 				? "Token budget exhausted, Goal terminated."
@@ -132,10 +136,8 @@ async function handleBudgetChecks(
 	// 90% steering → 收尾
 	if (budgetResult.shouldSendSteering) {
 		session.state!.budgetLimitSteeringSent = true;
-		persistGoalState(pi, session, ctx);
-		if (checkStale()) return "stop";
-		updateWidget(session, ctx);
-		pi.sendUserMessage(budgetLimitPrompt(session.state!, "token"), { deliverAs: "steer" });
+		if (persistAndUpdate(pi, session, ctx, checkStale)) return "stop";
+		sendGoalContextMessage(pi, budgetLimitPrompt(session.state!, "token"), "steer");
 		return "stop";
 	}
 	if (checkStale()) return "stop";
@@ -174,9 +176,7 @@ function handleAllTasksDone(
 		state.status = transitionStatus(state.status, "complete");
 		state.completedAtTurnIndex = state.currentTurnIndex;
 		writeGoalHistoryEntry(pi, session);
-		persistGoalState(pi, session, ctx);
-		if (checkStale()) return "stop";
-		updateWidget(session, ctx);
+		if (persistAndUpdate(pi, session, ctx, checkStale)) return "stop";
 		ctx.ui.notify(
 			`All tasks completed, Goal auto-closed. (${progress.completedCount}/${progress.totalCount} tasks, ${state.currentTurnIndex} turns)`,
 			"info",
@@ -184,21 +184,22 @@ function handleAllTasksDone(
 		return "stop";
 	}
 	if (progress.budgetTight) {
-		pi.sendUserMessage(
+		sendGoalContextMessage(
+			pi,
 			`All tasks completed, token budget ${Math.round(state.tokensUsed / state.budget.tokenBudget! * PERCENT_FACTOR)}% used.` +
 			`Call goal_manager's complete_goal now with overall evidence.` +
 			`\n\nObjective: ${state.objective}`,
-			{ deliverAs: "steer" },
+			"steer",
 		);
 	} else {
-		pi.sendUserMessage(
+		sendGoalContextMessage(
+			pi,
 			`All ${progress.totalCount} tasks completed. Call goal_manager's complete_goal with overall evidence.` +
 				`\n\nObjective: ${state.objective}`,
-			{ deliverAs: "followUp" },
+			"followUp",
 		);
 	}
-	persistGoalState(pi, session, ctx);
-	updateWidget(session, ctx);
+	persistAndUpdate(pi, session, ctx);
 	return "stop";
 }
 
@@ -211,22 +212,20 @@ function handleNoTasksOrMaxTurns(
 		state.status = transitionStatus(state.status, "cancelled");
 		state.completedAtTurnIndex = state.currentTurnIndex;
 		writeGoalHistoryEntry(pi, session);
-		persistGoalState(pi, session, ctx);
-		if (checkStale()) return "stop";
-		updateWidget(session, ctx);
+		if (persistAndUpdate(pi, session, ctx, checkStale)) return "stop";
 		ctx.ui.notify(
 			`Max turns reached (${state.budget.maxTurns}), LLM did not create task list.`,
 			"warning",
 		);
 		return "stop";
 	}
-	pi.sendUserMessage(
-		`No task list created yet. Call goal_manager's create_tasks immediately to decompose the work into verifiable task steps.` +
+	sendGoalContextMessage(
+		pi,
+		`No task list created yet. First check if the objective is already satisfied — if yes, call goal_manager's cancel_goal with cancelReason. Otherwise call create_tasks immediately to decompose the work into verifiable task steps.` +
 			`\n\nObjective: ${state.objective}`,
-		{ deliverAs: "followUp" },
+		"followUp",
 	);
-	persistGoalState(pi, session, ctx);
-	updateWidget(session, ctx);
+	persistAndUpdate(pi, session, ctx);
 	return "stop";
 }
 
@@ -239,9 +238,7 @@ function handleMaxTurnsReached(
 	state.status = transitionStatus(state.status, "cancelled");
 	state.completedAtTurnIndex = state.currentTurnIndex;
 	writeGoalHistoryEntry(pi, session);
-	persistGoalState(pi, session, ctx);
-	if (checkStale()) return "stop";
-	updateWidget(session, ctx);
+	if (persistAndUpdate(pi, session, ctx, checkStale)) return "stop";
 	ctx.ui.notify(
 		`Max turns reached (${state.budget.maxTurns}), ${incomplete.length} tasks still incomplete.`,
 		"warning",
@@ -258,6 +255,15 @@ async function handleStallAndContinuation(
 	const state = session.state!;
 	if (checkStale()) return;
 
+	// ESC pause: if tool call was aborted, pause instead of continuing
+	if (session.pendingPause) {
+		session.pendingPause = false;
+		state.status = transitionStatus(state.status, "paused");
+		if (persistAndUpdate(pi, session, ctx, checkStale)) return;
+		ctx.ui.notify("Goal paused (user interrupt). Use /goal resume to continue.", "info");
+		return;
+	}
+
 	// Stall 检测
 	updateStallCounter(state, progress.isStalled);
 	if (state.stallCount >= state.budget.maxStallTurns) {
@@ -268,13 +274,11 @@ async function handleStallAndContinuation(
 
 	// 去抖 + Continuation
 	if (!consumeTokensForDebounce(state)) {
-		persistGoalState(pi, session, ctx);
-		updateWidget(session, ctx);
+		persistAndUpdate(pi, session, ctx);
 		return;
 	}
-	persistGoalState(pi, session, ctx);
-	updateWidget(session, ctx);
-	pi.sendUserMessage(continuationPrompt(state), { deliverAs: "followUp" });
+	persistAndUpdate(pi, session, ctx);
+	sendGoalContextMessage(pi, continuationPrompt(state), "followUp");
 }
 
 /** 更新 stall 计数。stall 时递增，否则重置。 */
@@ -287,9 +291,7 @@ function updateStallCounter(state: { stallCount: number; lastProgressTurn: numbe
 function markGoalBlocked(pi: ExtensionAPI, session: GoalSession, ctx: ExtensionContext, checkStale: () => boolean): void {
 	const state = session.state!;
 	state.status = transitionStatus(state.status, "blocked");
-	persistGoalState(pi, session, ctx);
-	if (checkStale()) return;
-	updateWidget(session, ctx);
+	if (persistAndUpdate(pi, session, ctx, checkStale)) return;
 	ctx.ui.notify(
 		`${state.stallCount} consecutive turns without progress, Goal auto-blocked. Use /goal resume to continue or /goal clear to reset.`,
 		"warning",

package/src/before-agent-start-handler.ts

@@ -18,7 +18,7 @@ import {
 	type GoalTask,
 	isActiveStatus,
 	isTerminalStatus,
-	isTerminalTaskStatus,
+	isTaskDone,
 	transitionStatus,
 } from "./state";
 import {
@@ -28,8 +28,7 @@ import {
 import {
 	clearGoalSession,
 	type GoalSession,
-	persistGoalState,
-	updateWidget,
+	persistAndUpdate,
 } from "./tool-handler";
 import { renderTerminalStatusLine } from "./widget";
 
@@ -100,7 +99,7 @@ function checkStaleness(session: GoalSession) {
 	let allTerminal = true;
 
 	for (const task of state.tasks) {
-		if (!isTerminalTaskStatus(task.status)) {
+		if (!isTaskDone(task)) {
 			allTerminal = false;
 			const staleTurns = state.currentTurnIndex - task.lastUpdatedTurn;
 			if (staleTurns >= TASK_STALL_TURN_THRESHOLD) {
@@ -163,8 +162,7 @@ function checkContextUsage(
 	if (usage && usage.contextWindow > 0 && (usage.tokens ?? 0) / usage.contextWindow > CONTEXT_USAGE_RATIO_LIMIT) {
 		const state = session.state!;
 		state.status = transitionStatus(state.status, "paused");
-		persistGoalState(pi, session, ctx);
-		updateWidget(session, ctx);
+		persistAndUpdate(pi, session, ctx);
 		return {
 			message: {
 				customType: "goal-context-exceeded",

package/src/budget.ts

@@ -16,7 +16,7 @@ import {
 	SECONDS_PER_MINUTE,
 } from "./constants";
 import type { GoalRuntimeState } from "./state";
-import { getElapsedTimeSeconds } from "./state";
+import { getCompletedCount, getElapsedTimeSeconds, getIncompleteTasks } from "./state";
 
 // ── 决策类型 ────────────────────────────────────────
 
@@ -139,8 +139,8 @@ export interface ProgressCheck {
 }
 
 export function checkProgress(state: GoalRuntimeState, tasksCompletedAtStart: number): ProgressCheck {
-	const incomplete = state.tasks.filter((t) => t.status === "pending" || t.status === "in_progress");
-	const completedCount = state.tasks.filter((t) => t.status === "completed").length;
+	const incomplete = getIncompleteTasks(state.tasks);
+	const completedCount = getCompletedCount(state.tasks);
 	const totalCount = state.tasks.length;
 	const progressThisRound = completedCount - tasksCompletedAtStart;
 

package/src/command-handler.ts

@@ -31,8 +31,9 @@ import { objectiveUpdatedPrompt } from "./templates";
 import {
 	clearGoalSession,
 	type GoalSession,
+	persistAndUpdate,
 	persistGoalState,
-	updateWidget,
+	sendGoalContextMessage,
 	writeGoalHistoryEntry,
 } from "./tool-handler";
 
@@ -51,6 +52,7 @@ export async function handleGoalCommand(
 		case "resume": return handleResume(pi, session, ctx);
 		case "history": return handleHistory(ctx);
 		case "clear": return handleClear(pi, session, ctx);
+		case "abort": return handleAbort(pi, session, ctx);
 		case "update": return handleUpdate(pi, session, parsed.objective, ctx);
 		case "set": return handleSet(pi, session, parsed.objective ?? "", parsed.budget, ctx);
 	}
@@ -89,8 +91,7 @@ function handlePause(pi: ExtensionAPI, session: GoalSession, ctx: ExtensionConte
 		return;
 	}
 	session.state.status = transitionStatus(session.state.status, "paused");
-	persistGoalState(pi, session, ctx);
-	updateWidget(session, ctx);
+	persistAndUpdate(pi, session, ctx);
 	ctx.ui.notify("Goal paused. Use /goal resume to continue.", "info");
 }
 
@@ -116,13 +117,11 @@ function handleResume(pi: ExtensionAPI, session: GoalSession, ctx: ExtensionCont
 	if (resumeBudgetCheck) {
 		const dim = resumeBudgetCheck.dimension;
 		state.status = transitionStatus(state.status, dim === "token" ? "budget_limited" : "time_limited");
-		persistGoalState(pi, session, ctx);
-		updateWidget(session, ctx);
+		persistAndUpdate(pi, session, ctx);
 		ctx.ui.notify(`${dim === "token" ? "Token" : "Time"} budget exhausted, cannot resume. Use /goal clear to reset.`, "warning");
 		return;
 	}
-	persistGoalState(pi, session, ctx);
-	updateWidget(session, ctx);
+	persistAndUpdate(pi, session, ctx);
 
 	const incomplete = getIncompleteTasks(state.tasks);
 	if (incomplete.length > 0) {
@@ -191,6 +190,29 @@ function handleClear(pi: ExtensionAPI, session: GoalSession, ctx: ExtensionConte
 	ctx.ui.notify("Goal cleared.", "info");
 }
 
+// ── /goal abort ──────────────────────────────────────
+
+function handleAbort(pi: ExtensionAPI, session: GoalSession, ctx: ExtensionContext): void {
+	if (!session.state) { ctx.ui.notify("Goal mode not active.", "info"); return; }
+	if (isTerminalStatus(session.state.status)) {
+		ctx.ui.notify(`Goal is already in terminal state (${session.state.status}).`, "warning");
+		return;
+	}
+	if (session.state.tasks.length > 0) {
+		const nonCancelled = session.state.tasks.filter(t => t.status !== "cancelled");
+		if (nonCancelled.length > 0) {
+			ctx.ui.notify(`Cannot abort: ${nonCancelled.length} non-cancelled tasks exist. Use /goal clear to force cancel.`, "warning");
+			return;
+		}
+	}
+	session.state.status = "cancelled";
+	session.state.completedAtTurnIndex = session.state.currentTurnIndex;
+	writeGoalHistoryEntry(pi, session);
+	persistGoalState(pi, session, ctx);
+	clearGoalSession(session, ctx);
+	ctx.ui.notify("Goal aborted: no work needed.", "info");
+}
+
 // ── /goal update ──────────────────────────────────────
 
 function handleUpdate(
@@ -208,19 +230,17 @@ function handleUpdate(
 	state.objectiveUpdatedAt = Date.now();
 	state.tasks = [];
 	state.stallCount = 0;
-	state.turnCount = 0;
 	state.currentTurnIndex = 0;
 	state.lastProgressTurn = 0;
 	state.budgetLimitSteeringSent = false;
 	state.budgetWarning70Sent = false;
 	state.budgetWarning90Sent = false;
 	session.tasksCompletedAtAgentStart = 0;
-	persistGoalState(pi, session, ctx);
-	updateWidget(session, ctx);
+	persistAndUpdate(pi, session, ctx);
 	ctx.ui.notify(`Objective updated:\nPrevious: ${oldObjective}\nNew: ${newObjective}`, "info");
 
 	if (isActiveStatus(state.status)) {
-		pi.sendUserMessage(objectiveUpdatedPrompt(state, oldObjective), { deliverAs: "steer" });
+		sendGoalContextMessage(pi, objectiveUpdatedPrompt(state, oldObjective), "steer");
 	}
 }
 
@@ -263,8 +283,7 @@ function handleSet(
 	session.tasksCompletedAtAgentStart = 0;
 	session.hasPendingInjection = false;
 
-	persistGoalState(pi, session, ctx);
-	updateWidget(session, ctx);
+	persistAndUpdate(pi, session, ctx);
 
 	const budgetNotice: string[] = [];
 	if (budget.tokenBudget) budgetNotice.push(`Token budget: ${budget.tokenBudget}`);

package/src/commands.ts

@@ -6,7 +6,7 @@ import { MAX_STALL_CAP, MAX_TURNS_CAP, UPDATE_PREFIX_LENGTH } from "./constants"
 import type { BudgetConfig } from "./state";
 
 export interface GoalCommandArgs {
-	action: "set" | "status" | "pause" | "resume" | "clear" | "update" | "history";
+	action: "set" | "status" | "pause" | "resume" | "clear" | "abort" | "update" | "history";
 	objective?: string;
 	budget?: Partial<BudgetConfig>;
 }
@@ -28,6 +28,9 @@ export function parseGoalArgs(raw: string): GoalCommandArgs {
 	if (trimmed === "clear") {
 		return { action: "clear" };
 	}
+	if (trimmed === "abort") {
+		return { action: "abort" };
+	}
 	if (trimmed === "history") {
 		return { action: "history" };
 	}

package/src/constants.ts

@@ -42,3 +42,8 @@ export const OBJECTIVE_TRUNCATE_KEEP = 77; // DISPLAY_LIMIT - 3 for "..."
 export const TASK_STALL_TURN_THRESHOLD = 10;	// task/subtask 停滞提醒阈值（turn 数）
 export const AUTO_CLEAR_TURNS = 2;				// 终态后自动清理轮数
 export const MAX_HISTORY_ENTRIES = 20;			// goal-history entry GC 上限
+
+export const VERIFY_METHOD_WIDGET_LEN = 30;	// widget 中验证方法显示的截断长度
+export const EXT_INIT_TASK_DESC_MAX = 60;	// external init 中 task description 截断上限
+export const TASK_DESC_MAX_LENGTH = 80;		// task description 截断上限（normalizeDescription）
+export const ELLIPSIS_LENGTH = 3;

package/src/index.ts

@@ -25,11 +25,15 @@ import { handleAgentEnd } from "./agent-end-handler";
 import { handleBeforeAgentStart } from "./before-agent-start-handler";
 import { handleGoalCommand } from "./command-handler";
 import {
+	ELLIPSIS_LENGTH,
+	EXT_INIT_TASK_DESC_MAX,
 	MAX_HISTORY_ENTRIES,
 } from "./constants";
 import {
+	createInitialState,
 	deserializeState,
 	getCompletedCount,
+	type GoalExternalInit,
 	isActiveStatus,
 	isTerminalStatus,
 } from "./state";
@@ -41,6 +45,7 @@ import {
 	HISTORY_ENTRY_TYPE,
 	isGoalEntry,
 	isStaleContextError,
+	persistGoalState,
 	updateWidget,
 } from "./tool-handler";
 import { toSingleLine } from "./widget";
@@ -178,45 +183,60 @@ export default function goalExtension(pi: ExtensionAPI) {
 		tasksCompletedAtAgentStart: 0,
 		hasPendingInjection: false,
 		isProcessing: false, // P1-3: 防重入
+		pendingPause: false, // ESC 中断标记
 	};
 
-	// ── Tool: goal_manager ─────────────────────────────
+	// Capture latest ctx for external API (initializeGoalFromExternal needs it for persistGoalState)
+	let lastCtx: ExtensionContext | undefined;
 
 	pi.registerTool({
 		name: "goal_manager",
 		label: "Goal Manager",
-		description:
-			"Goal mode task manager. This tool is only available after starting a goal via the /goal command. AI cannot trigger it proactively. If Goal mode is not active, calling this tool will error." +
-			"\n\nAvailable actions:" +
-			"\n- create_tasks: Decompose the objective into a task list (call once at goal start). Each task description must be a one-line summary (max 60 chars), no newlines or markdown" +
-			"\n- add_tasks: Append new tasks to the existing list (when omissions are discovered). Each task description must be a one-line summary (max 60 chars), no newlines or markdown" +
-			"\n- update_tasks: Batch update task statuses (completed requires evidence, cancelled does not block goal completion)" +
-			"\n- list_tasks: View progress and remaining budget" +
-			"\n- complete_goal: Mark the objective as achieved (all tasks must be completed + evidence)" +
-			"\n- cancel_goal: Cancel the current goal (use when user wants to exit/stop)" +
-			"\n- report_blocked: Report being blocked (use when encountering unsolvable issues)" +
-			"\n- add_subtasks: Add subtasks to a specified task (params: taskId, texts[]). Use this instead of todo tool in Goal mode" +
-			"\n- update_subtasks: Batch update subtask statuses (params: taskId, subUpdates[])" +
-			"\n- delete_subtasks: Delete subtasks from a specified task (params: taskId, subIds[])",
+			description:
+				"Goal mode task manager. This tool is only available after starting a goal via the /goal command. AI cannot trigger it proactively. If Goal mode is not active, calling this tool will error." +
+				"\n\nAvailable actions:" +
+				"\n- create_tasks: Decompose the objective into a task list (call once at goal start). Each task description must be a one-line summary (max 60 chars), no newlines or markdown. Accept verifications array for task verification." +
+				"\n- add_tasks: Append new tasks to the existing list (when omissions are discovered). Fails if no tasks exist yet — use create_tasks first. Each task description must be a one-line summary (max 60 chars), no newlines or markdown. Accept verifications array." +
+				"\n- update_tasks: Batch update task statuses. Must follow state machine: pending→in_progress→completed→verified. Cannot skip states (pending→completed is forbidden). Exactly one task should be in_progress at a time. Completed requires evidence. Cancelled does not block goal completion. Completing a task with verification triggers a verification prompt — then call update_tasks with status=verified and actual=<result>." +
+				"\n- list_tasks: View progress and remaining budget" +
+				"\n- complete_goal: Mark the objective as achieved. Only call when ALL tasks are completed or verified with concrete evidence. Do not mark complete merely because the budget is nearly exhausted or because you are stopping work. Before calling, use list_tasks to verify all tasks are done." +
+				"\n- cancel_goal: Cancel the current goal (use when user wants to exit/stop)" +
+				"\n- report_blocked: Report being blocked. Only use after trying at least 3 alternative approaches to the same blocking condition. Do not use merely because the work is hard, slow, uncertain, incomplete, or would benefit from clarification. Requires a specific reason describing what is blocking and what you have already tried." +
+				"\n- add_subtasks: Add subtasks to a specified task (params: taskId, texts[]). Use this instead of todo tool in Goal mode" +
+				"\n- update_subtasks: Batch update subtask statuses (params: taskId, subUpdates[])" +
+				"\n- delete_subtasks: Delete subtasks from a specified task (params: taskId, subIds[])",
 		promptSnippet: "Manage task list, completion status, and exit for /goal mode",
 		promptGuidelines: [
 			"[Workflow] After receiving the objective, the first step must be create_tasks to decompose. Do not re-call if task list already exists",
+			"[Status flow] Tasks must follow this order: pending → in_progress → completed → verified. You CANNOT skip in_progress. Before marking completed, always set status=in_progress first. Transitions: pending→in_progress | pending→cancelled, in_progress→completed | in_progress→cancelled, completed→verified (only if task has verification)",
 			"[Format] Each task description must be a one-line summary, max 60 chars. No newlines, markdown, or detailed parameter lists — those go in execution phase. Example: 'Fix hook-registry dedup logic' not 'Fix hook-registry dedup + transport-execute enhancementConfig guard + failover-loop ...'",
 			"[Append] When discovering omissions during execution, use add_tasks to append — do not re-call create_tasks",
 			"[Completion] After completing a task, call update_tasks with status=completed and provide evidence (e.g. 'test X passed', 'file F created')",
-			"[Goal completion] Only call complete_goal when all tasks are completed with overall evidence",
+			"[Goal completion] Only call complete_goal when all tasks are completed or verified with overall evidence",
 			"[Exit] When user says 'stop', 'exit', 'cancel', '不用了', '结束', etc. indicating they don't want to continue, immediately call cancel_goal — do not guide them through complete_goal",
-			"[Blocked] When encountering unsolvable technical issues, call report_blocked with the reason",
+			"[Blocked] Do not call report_blocked the first time a blocker appears. Try at least 3 alternative approaches first. Only report blocked when genuinely at an impasse without user input — not because work is hard, slow, uncertain, or incomplete. Once you call report_blocked, include what you have already tried in the reason.",
 			"[Progress] Use list_tasks anytime to check remaining tasks and budget",
 			"[Cancel] To cancel a task, use update_tasks with status=cancelled. Cancelled tasks do not block goal completion",
-			"[Forbidden] Do not mark tasks as completed without evidence, and do not call complete_goal without evidence",
+			"[Audit] Before marking a task completed, verify against actual current state (files, command output, test results). Intent, partial progress, or 'it should work' are NOT evidence. Do not redefine success around work already done — preserve original scope. Uncertain or indirect evidence means not completed, keep working.",
+			"[Fidelity] Optimize for movement toward the requested end state, not the easiest passing change. Do not substitute a narrower or safer solution because it is easier to verify. An edit is aligned only if it makes the requested final state more true.",
+			"[Forbidden] Do not mark tasks as completed without evidence, and do not call complete_goal without evidence. Do not mark completed due to budget exhaustion or because you are stopping work.",
 			"[Forbidden] Do not force task completion when the user explicitly wants to exit — call cancel_goal directly",
+			"[Quick exit] When no tasks have been created and you determine the objective is already met, call cancel_goal with cancelReason instead of creating tasks",
 			"[Forbidden] Do not re-call create_tasks to overwrite existing incomplete tasks — use add_tasks to append",
 			"[Subtask] For fine-grained step tracking in Goal mode, use add_subtasks — do not use the todo tool",
+			"[Verification] Each task should have a concrete verification method. Use verifications param in create_tasks/add_tasks. Templates:",
+			"[Verification] - Command: method='pnpm --filter <pkg> typecheck', expected='zero type errors'",
+			"[Verification] - Test: method='pnpm --filter <pkg> test', expected='all tests pass'",
+			"[Verification] - File: method='check <path> exists and contains <content>', expected='file exists with matching content'",
+			"[Verification] - Manual: method='manual check <specific items>', expected='<expected result'",
+			"[Verification] Multiple related tasks can share one verification — set verification on the LAST related task only",
+			"[Verification] Do NOT create a separate 'run tests' task for verification — use verification field instead",
+			"[Verification] When a task with verification is completed, run the verification command with bash. Then call update_tasks with status=verified and actual=<result>",
 		],
 		parameters: GoalManagerParams,
 
 		async execute(_toolCallId: string, params: Static<typeof GoalManagerParams>, signal: AbortSignal | undefined, _onUpdate: unknown, ctx: ExtensionContext) {
+			lastCtx = ctx;
 			try {
 				// P1-4: 透传 signal
 				return await executeGoalAction(pi, session, params, ctx, signal);
@@ -255,35 +275,40 @@ export default function goalExtension(pi: ExtensionAPI) {
 				return new Text(text?.type === "text" ? (text.text ?? "") : "", 0, 0);
 			}
 			const tasks = details.tasks;
-			const completed = tasks.filter((t) => t.status === "completed").length;
+			const completed = getCompletedCount(tasks);
 			const summary = theme.fg("success", `✓ ${completed}/${tasks.length} completed`);
 			if (!expanded || tasks.length === 0) {
 				return new Text(summary, 0, 0);
 			}
 			const lines = [summary];
 			for (const t of tasks) {
-				const icon = t.status === "completed"
-					? theme.fg("success", "✓")
-					: t.status === "in_progress"
-						? theme.fg("warning", "●")
-						: t.status === "cancelled"
-							? theme.fg("dim", "✗")
-							: theme.fg("dim", "☐");
+				const icon = t.status === "verified"
+					? theme.fg("success", "◉")
+					: t.status === "completed"
+						? theme.fg("success", "✓")
+						: t.status === "in_progress"
+							? theme.fg("warning", "●")
+							: t.status === "cancelled"
+								? theme.fg("dim", "✗")
+								: theme.fg("dim", "☐");
 				const descText = toSingleLine(t.description);
-				const desc = (t.status === "completed" || t.status === "cancelled")
+				const desc = (t.status === "verified" || t.status === "completed" || t.status === "cancelled")
 					? theme.fg("dim", descText)
 					: theme.fg("text", descText);
 				lines.push(`  ${icon} ${theme.fg("accent", `#${t.id}`)} ${desc}`);
-			// Subtask items in expanded view
+			// Subtask items in expanded view — collapse when all completed
 			if (t.subtasks && t.subtasks.length > 0) {
-				for (const s of t.subtasks) {
-					const subIcon = s.status === "completed"
-						? theme.fg("success", "\u2713")
-						: s.status === "in_progress"
-							? theme.fg("warning", "\u25cf")
-							: theme.fg("dim", "\u25cb");
-					const subText = s.status === "completed" ? theme.fg("dim", s.text) : theme.fg("muted", s.text);
-					lines.push(`    ${subIcon} ${theme.fg("dim", `${t.id}.${s.id}`)} ${subText}`);
+				const allSubCompleted = t.subtasks.every((s: { status: string }) => s.status === "completed");
+				if (!allSubCompleted) {
+					for (const s of t.subtasks) {
+						const subIcon = s.status === "completed"
+							? theme.fg("success", "\u2713")
+							: s.status === "in_progress"
+								? theme.fg("warning", "\u25cf")
+								: theme.fg("dim", "\u25cb");
+						const subText = s.status === "completed" ? theme.fg("dim", s.text) : theme.fg("muted", s.text);
+						lines.push(`    ${subIcon} ${theme.fg("dim", `${t.id}.${s.id}`)} ${subText}`);
+					}
 				}
 			}
 		}
@@ -295,7 +320,7 @@ export default function goalExtension(pi: ExtensionAPI) {
 
 	pi.registerCommand("goal", {
 		description:
-			"Goal-driven mode: /goal <objective> [--tokens N] [--timeout N] [--max-turns N] | /goal pause | /goal resume | /goal clear | /goal update <new-objective> | /goal status | /goal history",
+			"Goal-driven mode: /goal <objective> [--tokens N] [--timeout N] [--max-turns N] | /goal pause | /goal resume | /goal abort | /goal clear | /goal update <new-objective> | /goal status | /goal history",
 		handler: async (args: string | undefined, ctx: ExtensionCommandContext) => {
 			await handleGoalCommand(pi, session, args, ctx);
 		},
@@ -303,6 +328,7 @@ export default function goalExtension(pi: ExtensionAPI) {
 
 	// ── Event: before_agent_start ──────────────────────
 	pi.on("before_agent_start", async (_event: BeforeAgentStartLikeEvent, ctx: ExtensionContext) => {
+		lastCtx = ctx;
 		return handleBeforeAgentStart(pi, session, ctx);
 	});
 
@@ -345,6 +371,7 @@ export default function goalExtension(pi: ExtensionAPI) {
 
 	// ── Event: session_start (state reconstruction) ───
 	pi.on("session_start", async (_event: SessionStartLikeEvent, ctx: ExtensionContext) => {
+		lastCtx = ctx;
 		reconstructGoalState(pi, session, ctx);
 		if (session.state) {
 			session.tasksCompletedAtAgentStart = getCompletedCount(session.state.tasks);
@@ -372,4 +399,47 @@ export default function goalExtension(pi: ExtensionAPI) {
 			return new Text(prefix + theme.fg("dim", content), 0, 0);
 		});
 	}
+
+	// ── External API: initializeGoalFromExternal ──────────
+
+	/**
+	 * Allow other extensions (e.g. coding-workflow) to programmatically initialize a goal.
+	 * Skips the /goal command flow — directly creates state + tasks.
+	 * Returns true if initialized, false if goal already active.
+	 */
+	function initializeGoalFromExternal(
+		objective: string,
+		tasks: string[],
+		budget?: { tokenBudget?: number; timeBudgetMinutes?: number; maxTurns?: number },
+		ctx?: ExtensionContext,
+	): boolean {
+		if (session.state && isActiveStatus(session.state.status)) {
+			return false;
+		}
+
+		session.state = createInitialState(objective, budget);
+		session.tasksCompletedAtAgentStart = 0;
+
+		// Create tasks (same logic as handleCreateTasks)
+		session.state.tasks = tasks.map((desc, i) => ({
+			id: i + 1,
+			description: desc.length > EXT_INIT_TASK_DESC_MAX ? desc.slice(0, EXT_INIT_TASK_DESC_MAX - ELLIPSIS_LENGTH) + "..." : desc,
+			status: "pending" as const,
+			lastUpdatedTurn: session.state!.currentTurnIndex,
+		}));
+
+		// Persist state so it survives session reconstruction.
+		// Prefer explicitly passed ctx (from the calling extension's tool execute),
+		// fallback to lastCtx captured from this extension's own event handlers.
+		const persistCtx = ctx ?? lastCtx;
+		if (persistCtx) {
+			persistGoalState(pi, session, persistCtx);
+		}
+
+		return true;
+	}
+
+	// Expose on pi for cross-extension access
+	const api = pi as unknown as Record<string, unknown>;
+	api.__goalInit = initializeGoalFromExternal satisfies GoalExternalInit;
 }