pi-plan-task 3.0.1 → 4.0.0

package/README.md

@@ -26,13 +26,11 @@ Plan → Review → Approve → Execute → Verify → Continue / Stop
 - [Task file contract](#task-file-contract)
 - [Durable files](#durable-files)
 - [Lifecycle](#lifecycle)
-- [State v2](#state-v2)
+- [State](#state)
 - [Resume and recovery](#resume-and-recovery)
 - [Configuration](#configuration)
 - [Events](#events)
 - [Optional Plannotator integration](#optional-plannotator-integration)
-- [Upgrading to v3](#upgrading-to-v3)
-- [Legacy command migration](#legacy-command-migration)
 - [Troubleshooting](#troubleshooting)
 - [Development](#development)
 - [Safety notes](#safety-notes)
@@ -47,14 +45,13 @@ Plan → Review → Approve → Execute → Verify → Continue / Stop
 - One task can run here, in a new session, or in a clean session.
 - All remaining tasks can run here or one-per-session.
 - State updates are validated and serialized; multi-file changes use transactional replacement with rollback.
-- State v1 projects are backed up and migrated safely.
 - Optional Plannotator integration provides browser-based plan review.
 
 ## Requirements
 
 - Pi with extension/package support.
 - `ask_user_question` is required at runtime when planning or execution reaches a consequential user decision.
-- Plannotator is optional and only needed for `/plan review`.
+- Plannotator is optional. After a plan is submitted, choose `review` if the CLI is installed.
 
 ## Installation
 
@@ -82,11 +79,8 @@ Alternatively, add the package path to `packages` in `~/.pi/agent/settings.json`
 When the draft is valid, choose one of:
 
 ```text
-current  approve and execute in this session
-new      approve and execute in a normal new session
-fresh    approve and execute in a clean session
+approve  lock the submitted plan (then choose here/new/fresh, or run /build later)
 review   open optional Plannotator review
-revise   edit a new draft with feedback
 reject   reject and revise with feedback
 later    leave the submitted plan ready for later approval
 ```
@@ -109,7 +103,7 @@ Execution is approval-gated. A missing, changed, or unapproved plan cannot start
 The extension registers exactly three user-facing slash commands:
 
 ```text
-/plan   create, review, and approve plans
+/plan   create, approve, and reject plans
 /build  execute one or all tasks
 /tasks  inspect and manage tasks
 ```
@@ -122,29 +116,23 @@ The extension registers exactly three user-facing slash commands:
 | `/plan <request>` | Plan from a free-text request. |
 | `/plan <file> [notes]` | Use a repository spec file with optional guidance. |
 | `/plan request <text>` | Force text beginning with a reserved subcommand to be treated as a request. |
-| `/plan review` | Open the submitted `plan.md` in optional Plannotator. |
-| `/plan approve` | Interactively choose `current`, `new`, `fresh`, `revise`, or `cancel`. |
-| `/plan approve current` | Approve and execute the next task in this session. |
-| `/plan approve new` | Approve and execute the next task in a normal new session. |
-| `/plan approve fresh` | Approve and execute the next task in a clean session without parent conversation context. |
+| `/plan approve` | Approve the submitted plan. Does not start execution. |
 | `/plan reject [feedback]` | Reject the submitted plan and initialize a revision draft. |
-| `/plan revise` | Initialize a revision draft and ask for revision feedback. |
-| `/plan status` | Show lifecycle state, work identity, progress, hash, and current task. |
-| `/plan history` | List immutable submitted-plan snapshots. |
-| `/plan diff` | Compare current submitted files with the newest valid snapshot. |
 
 The first argument to `/plan` is reserved when it is one of:
 
 ```text
-review approve reject revise status history diff request
+approve reject request
 ```
 
-If the actual request starts with one of those words, use `/plan request ...`:
+If the actual request starts with a reserved word, use `/plan request ...`:
 
 ```text
 /plan request review the login page accessibility
 ```
 
+`/plan approve` only locks the submitted structure. In a UI session it then asks where the next task should run (`here`, `new`, or `fresh`). In non-UI mode it stops after approval; run `/build` or `/build all` to execute. `/plan reject` works from `ready`, `approved`, `blocked`, or `completed`.
+
 #### Draft behavior
 
 - New work receives a new `workId` and does not inherit old blocked/task runtime state.
@@ -158,42 +146,36 @@ If the actual request starts with one of those words, use `/plan request ...`:
 | Command | Description |
 | --- | --- |
 | `/build` | Execute one pending task in this session. |
-| `/build new` | Execute one task in a normal new session. |
-| `/build fresh` | Execute one task in a clean session. |
 | `/build all` | Execute all remaining tasks in this session. |
-| `/build all new` | Execute one task per new session and continue automatically. |
-| `/build all fresh` | Start in a clean session, then execute all remaining tasks in that clean session. |
-| `/build all --approval` | Execute here and pause for approval after every verified task. |
-| `/build all new --approval` | Use one new session per task and pause after every verified task. |
-| `/build all fresh --approval` | Start in a clean session and pause after every verified task. |
 
-Long-form aliases are accepted:
+`--all` is accepted as an alias for `all`. Unknown and duplicate options are rejected.
+
+After a single task is verified, a UI session asks:
 
 ```text
---all --new --fresh --approval
+Continue in this session
+Continue in a new session
+Stop
 ```
 
-Unknown, duplicate, and conflicting options are rejected. For example, `/build new fresh` is invalid.
-
-`--approval` applies only to all-task execution. In non-UI modes, per-task approval cannot prompt, so execution stops safely after the current task.
+Choosing a new session persists `continueMode: "all-new"` and opens a replacement session that runs `/build` for the next task. `/build all` continues remaining tasks here without prompting. In non-UI modes, `/build` stops after the current task.
 
 #### Session placement
 
+Placement is chosen in UI prompts, not as `/build` flags:
+
+- `here` continues in the current session.
 - `new` records the current session as parent and opens a replacement session.
-- `fresh` opens a clean session without the planning conversation as parent context.
-- `/build all new` persists its continuation policy, so reloads and subsequent session handoffs resume one task per session.
-- If initial session creation is cancelled, the plan remains approved and can be started again.
+- `fresh` is offered after `/plan approve` and opens a clean session without the planning conversation as parent context.
+- If session creation is cancelled, the plan remains approved and can be started again with `/build`.
 
 ### `/tasks` — inspection and rework
 
 | Command | Description |
 | --- | --- |
-| `/tasks` | Show the canonical checklist and progress. |
-| `/tasks review [id]` | Show a task, its criteria, unstaged/staged changes, and untracked files. |
+| `/tasks` | Show lifecycle status, work identity, approved hash, current task, and the canonical checklist. |
 | `/tasks rework <id>` | Reopen a verified task and every later task. |
 
-`/tasks review` truncates output at approximately 50 KB or 2000 lines. Use `git diff`, `git diff --cached`, and `git status --short` for complete output.
-
 Rework is intentionally strict:
 
 - The target must exist and already be verified.
@@ -203,7 +185,6 @@ Rework is intentionally strict:
 - Approval is revoked.
 - The plan returns to `ready` and must be approved again.
 
-Legacy standalone command names are not aliases. See [Legacy command migration](#legacy-command-migration).
 
 ## LLM tool: `plan_task`
 
@@ -316,11 +297,11 @@ Do not manually check top-level task items. Only a successful `plan_task verify`
 .plan_task/
 ├── plan.md       # submitted plan; immutable during execution
 ├── task.md       # canonical queue and completion truth
-├── state.json    # validated state v2 and task runtime metadata
+├── state.json    # validated workflow state and task runtime metadata
 ├── draft/        # exists only while planning or revising
 │   ├── plan.md
 │   └── task.md
-├── history/      # immutable snapshots and migration backups
+├── history/      # immutable submitted-plan snapshots
 └── .lock/        # short-lived cross-process workflow lock
 ```
 
@@ -378,7 +359,7 @@ pending → implementation-complete → verified
 
 `unblock` restores the task to whichever active state existed before blocking.
 
-## State v2
+## State
 
 `state.json` is validated before use. Unknown versions, malformed statuses, invalid IDs, invalid hashes, invalid dates, verified tasks without evidence, and blocked tasks without reasons fail closed.
 
@@ -392,7 +373,6 @@ Example:
   "planningRequest": "Add OAuth login",
   "currentTaskId": 2,
   "continueMode": "all-new",
-  "approvalEachTask": true,
   "executionMode": "automatic",
   "draftStructureHash": "0000000000000000000000000000000000000000000000000000000000000000",
   "approvedStructureHash": "1111111111111111111111111111111111111111111111111111111111111111",
@@ -428,7 +408,7 @@ The extension restores persisted behavior during startup, reload, resume, and fo
 | `planning` | Restores Plan mode, draft write boundary, and planning request framing. |
 | `ready` | Leaves the submitted plan ready for review/approval. |
 | `approved` | Leaves the plan approved and ready to build after hash verification. |
-| `executing` | Restores current task, build framing, continuation policy, and task approval mode. |
+| `executing` | Restores current task, build framing, and continuation policy. |
 | `blocked` | Restores blocked state and reasons without reporting completion. |
 | `completed` | Preserves completed history; verified work can be explicitly reopened. |
 
@@ -470,7 +450,7 @@ Shell tools, unknown tools, current submitted files, and implementation tools ar
 | `automatic` | The extension starts and coordinates local implementation sessions. |
 | `external` | Approval emits `pi-plan-task:plan-approved`; local `/build` does not execute. |
 
-New-session model and thinking behavior follow Pi defaults. The old unused `inheritSessionModel` and `inheritThinkingLevel` options were removed in v3.
+New-session model and thinking behavior follow Pi defaults.
 
 ## Events
 
@@ -487,7 +467,7 @@ pi-plan-task:task-blocked
 pi-plan-task:execution-finished
 ```
 
-Event payload version remains `1` and includes workflow metadata such as:
+Event payloads include workflow metadata such as:
 
 ```text
 cwd
@@ -526,99 +506,22 @@ Phase instructions are conversation messages rather than permanent system-prompt
 - Build framing includes `plan.md` as untrusted reference context.
 - Current task instructions and safety rules take precedence over plan content.
 - A clean session does not inherit the planning conversation as parent context.
-- A migrated `implementation-complete` task receives verification-only framing and must not call `complete` again.
+- An `implementation-complete` task that is resumed for verification receives verification-only framing and must not call `complete` again.
 
 ## Optional Plannotator integration
 
 Plannotator is not a core dependency.
 
-If the `plannotator` CLI is installed:
-
-```text
-/plan review
-```
-
-opens the submitted plan for browser review. Approved results are normalized to `/plan approve current`; annotated or rejected results are normalized to `/plan reject <feedback>`.
+If the `plannotator` CLI is installed, choose `review` after a plan is submitted. That opens the submitted plan for browser review. Approved results are normalized to `/plan approve`; annotated or rejected results are normalized to `/plan reject <feedback>`.
 
 If Plannotator is unavailable, use:
 
 ```text
+/tasks
 /plan approve
 /plan reject <feedback>
-/plan diff
-```
-
-## Upgrading to v3
-
-v3 is a breaking workflow release. The public three-command surface remains `/plan`, `/build`, and `/tasks`, but planning storage, task completion, verification, state validation, and retry behavior are stricter.
-
-### State v1 → state v2 migration
-
-The package version is v3; the persisted state schema moves from version 1 to version 2. On the first state load, the extension:
-
-1. backs up old `state.json` and `task.md` under `.plan_task/history/`;
-2. writes validated state v2;
-3. preserves a task as verified only when it was checked and had non-empty verification evidence;
-4. restores other previously checked tasks to unchecked `implementation-complete` state;
-5. clears approval and requires `/plan approve` before execution.
-
-Migrated `implementation-complete` tasks retain their implementation but must run verification again.
-
-### Changed planning storage
-
-Planning and revision now write only to:
-
-```text
-.plan_task/draft/plan.md
-.plan_task/draft/task.md
 ```
 
-Current submitted files remain unchanged until the draft validates and is transactionally submitted.
-
-### Changed completion semantics
-
-In v2, `complete` could check a task. In v3:
-
-```text
-complete  implementation finished, verification pending
-verify    verification passed, task checked and eligible to advance
-```
-
-### Changed rework semantics
-
-`/tasks rework <id>` now reopens the selected verified task and every later task, revokes approval, and requires a new approval before execution.
-
-### Removed configuration
-
-The unused options below are ignored and should be deleted:
-
-```json
-{
-  "inheritSessionModel": true,
-  "inheritThinkingLevel": true
-}
-```
-
-## Legacy command migration
-
-If upgrading from a release older than the three-command interface, use these replacements:
-
-| Removed | Replacement |
-| --- | --- |
-| `/plan-review` | `/plan review` |
-| `/plan-approve` | `/plan approve` |
-| `/plan-reject` | `/plan reject` |
-| `/plan-status` | `/plan status` |
-| `/plan-history` | `/plan history` |
-| `/plan-diff` | `/plan diff` |
-| `/goal` | `/build all` |
-| `/task-review` | `/tasks review` |
-| `/task-rework` | `/tasks rework` |
-| `/build-next-session` | internal public `/build` handoff |
-| `/goal-next-session` | internal public `/build` handoff |
-
-Legacy commands are not registered as compatibility aliases.
-
 ## Troubleshooting
 
 ### “Plan files changed after approval”
@@ -626,8 +529,7 @@ Legacy commands are not registered as compatibility aliases.
 The submitted structure no longer matches the approved hash. Inspect the files, then run:
 
 ```text
-/plan status
-/plan diff
+/tasks
 /plan approve
 ```
 
@@ -651,7 +553,7 @@ Run `/build` again when ready.
 
 ### Invalid `state.json`
 
-The extension fails closed and will not execute. Inspect `.plan_task/history/` for migration backups. Restore a known-good state or start an explicitly new plan rather than weakening state validation.
+The extension fails closed and will not execute. Inspect `.plan_task/history/` for snapshots. Restore a known-good state or start an explicitly new plan rather than weakening state validation.
 
 ### Stale `.plan_task/.lock`
 
@@ -662,9 +564,9 @@ Normal operations remove the lock automatically. A lock older than ten minutes i
 Use the built-in text workflow:
 
 ```text
-/plan status
-/plan diff
+/tasks
 /plan approve
+/plan reject <feedback>
 ```
 
 ## Development
@@ -680,7 +582,7 @@ The test suite includes:
 
 - parser and Markdown-boundary tests;
 - strict plan validation tests;
-- state schema and v1 migration tests;
+- state schema tests;
 - structure hash tests;
 - concurrent workflow mutation tests;
 - command-surface tests;

package/extensions/build-session.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { describe, it } from "node:test";
-import { buildHandoffCommand, parseBuildOptions } from "./build-session.ts";
+import { parseBuildOptions } from "./build-session.ts";
 
 function options(input: string) {
 	const result = parseBuildOptions(input);
@@ -11,23 +11,23 @@ function options(input: string) {
 
 describe("parseBuildOptions", () => {
 	it("executes one task here by default", () => {
-		assert.deepEqual(options(""), { scope: "one", placement: "here", approval: false, continuation: false });
+		assert.deepEqual(options(""), { scope: "one" });
 	});
-	it("parses placement and all-task execution", () => {
-		assert.equal(options("new").placement, "new");
-		assert.equal(options("--fresh").placement, "fresh");
-		assert.deepEqual(options("all new --approval"), { scope: "all", placement: "new", approval: true, continuation: false });
+	it("parses all-task execution", () => {
+		assert.deepEqual(options("all"), { scope: "all" });
+		assert.deepEqual(options("--all"), { scope: "all" });
 	});
-	it("rejects unknown, duplicate, and conflicting options", () => {
+	it("rejects removed placement and approval flags", () => {
+		for (const input of ["new", "fresh", "all new", "--approval"]) {
+			const result = parseBuildOptions(input);
+			assert.equal(result.ok, false);
+			if (result.ok) throw new Error("Expected removed build option to fail");
+			assert.match(result.error, /^Removed\./);
+		}
+	});
+	it("rejects unknown and duplicate options", () => {
 		assert.deepEqual(parseBuildOptions("banana"), { ok: false, error: "Unknown build option: banana" });
-		assert.equal(parseBuildOptions("new fresh").ok, false);
 		assert.equal(parseBuildOptions("all --all").ok, false);
 		assert.equal(parseBuildOptions("continue").ok, false);
-		assert.equal(parseBuildOptions("--approval").ok, false);
-	});
-	it("builds public handoff commands", () => {
-		assert.equal(buildHandoffCommand(options("new")), "/build");
-		assert.equal(buildHandoffCommand(options("all new --approval")), "/build");
-		assert.equal(buildHandoffCommand(options("all fresh --approval")), "/build all --approval");
 	});
 });

package/extensions/build-session.ts

@@ -1,42 +1,30 @@
-export type BuildPlacement = "here" | "new" | "fresh";
 export type BuildScope = "one" | "all";
 
 export interface BuildOptions {
 	scope: BuildScope;
-	placement: BuildPlacement;
-	approval: boolean;
-	continuation: boolean;
 }
 
 export type BuildParseResult = { ok: true; options: BuildOptions } | { ok: false; error: string };
 
-const ALLOWED = new Set(["all", "--all", "new", "--new", "fresh", "--fresh", "approval", "--approval"]);
+const REMOVED = new Map<string, string>([
+	["new", "Removed. After /plan approve or a finished task, choose a new session. /build runs the next task here."],
+	["--new", "Removed. After /plan approve or a finished task, choose a new session. /build runs the next task here."],
+	["fresh", "Removed. After /plan approve, choose fresh to start a clean session."],
+	["--fresh", "Removed. After /plan approve, choose fresh to start a clean session."],
+	["approval", "Removed. Use /build for one task or /build all for the rest."],
+	["--approval", "Removed. Use /build for one task or /build all for the rest."],
+]);
 
 export function parseBuildOptions(args: string): BuildParseResult {
 	const tokens = args.trim().split(/\s+/).map((token) => token.toLowerCase()).filter(Boolean);
-	const unknown = tokens.find((token) => !ALLOWED.has(token));
-	if (unknown) return { ok: false, error: `Unknown build option: ${unknown}` };
-	const hasNew = tokens.includes("new") || tokens.includes("--new");
-	const hasFresh = tokens.includes("fresh") || tokens.includes("--fresh");
-	if (hasNew && hasFresh) return { ok: false, error: "new and fresh cannot be combined." };
-	const unique = new Set(tokens.map((token) => token.replace(/^--/, "")));
-	if (unique.size !== tokens.length) return { ok: false, error: "Duplicate build options are not allowed." };
-	const scope: BuildScope = tokens.includes("all") || tokens.includes("--all") ? "all" : "one";
-	const approval = tokens.includes("approval") || tokens.includes("--approval");
-	if (approval && scope !== "all") return { ok: false, error: "approval requires all-task execution." };
-	return {
-		ok: true,
-		options: {
-			scope,
-			placement: hasFresh ? "fresh" : hasNew ? "new" : "here",
-			approval,
-			continuation: false,
-		},
-	};
-}
-
-export function buildHandoffCommand(options: Pick<BuildOptions, "scope" | "placement" | "approval">): string {
-	if (options.scope === "one" || options.placement === "new") return "/build";
-	const approvalFlag = options.approval ? " --approval" : "";
-	return `/build all${approvalFlag}`;
+	if (tokens.length === 0) return { ok: true, options: { scope: "one" } };
+	for (const token of tokens) {
+		const removed = REMOVED.get(token);
+		if (removed) return { ok: false, error: removed };
+	}
+	const normalized = tokens.map((token) => token.replace(/^--/, ""));
+	const unknown = normalized.find((token) => token !== "all");
+	if (unknown) return { ok: false, error: `Unknown build option: ${tokens[normalized.indexOf(unknown)]}` };
+	if (new Set(normalized).size !== tokens.length) return { ok: false, error: "Duplicate build options are not allowed." };
+	return { ok: true, options: { scope: "all" } };
 }

package/extensions/command-surface.test.ts

@@ -7,5 +7,9 @@ describe("public command surface", () => {
 		const source = await readFile(new URL("./index.ts", import.meta.url), "utf8");
 		const commands = [...source.matchAll(/registerCommand\("([^"]+)"/g)].map((match) => match[1]);
 		assert.deepEqual(commands, ["plan", "build", "tasks"]);
+		assert.match(source, /planSubcommands = \["approve", "reject", "request"\]/);
+		assert.match(source, /value: "all"/);
+		assert.match(source, /value: "rework"/);
+		assert.doesNotMatch(source, /planSubcommands = \[[^\]]*review/);
 	});
 });

package/extensions/index.ts

@@ -7,7 +7,7 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
-import { buildHandoffCommand, parseBuildOptions, type BuildPlacement } from "./build-session.ts";
+import { parseBuildOptions } from "./build-session.ts";
 import { ensureDefaultGlobalConfig, isAllowedPlanTool, loadConfig } from "./config.ts";
 import {
 	ensurePlanDir,
@@ -31,10 +31,9 @@ import { markTaskPendingInMarkdown, parseTaskMarkdown } from "./parse.ts";
 import { draftPlanFilePath, draftTaskFilePath, isPlanArtifactPath, planFilePath, taskFilePath } from "./paths.ts";
 import { buildPrompt, buildRequest, buildStatus, buildStatusKey, planPrompt, planRequest } from "./prompts.ts";
 import type { PlanState, TaskItem } from "./types.ts";
-import { formatTaskList, TaskListComponent } from "./task-ui.ts";
+import { formatTaskList, formatWorkflowStatus, TaskListComponent } from "./task-ui.ts";
 import { initialState, structureHash, transition, updateTaskState } from "./state.ts";
-import { normalizeReviewResult, validatePlan, textDiff } from "./review.ts";
-import { listPlanSnapshots } from "./history.ts";
+import { normalizeReviewResult, validatePlan } from "./review.ts";
 import { addTools, removeAddedTools, type ToolDelta } from "./tools.ts";
 import { assertApprovedStructure, blockCurrentTask, completeCurrentTask, reworkFromTask, unblockTask, verifyCurrentTask, classifyQueue } from "./workflow-policy.ts";
 import { commitDraft, initializeDraftWithState, loadStateLocked, mutateWorkflow, readCurrentArtifacts, readDraftArtifacts, saveStateLocked } from "./workflow-store.ts";
@@ -43,8 +42,15 @@ type Mode = "idle" | "plan" | "build";
 
 const CONTINUE_THIS = "Continue in this session";
 const CONTINUE_NEW = "Continue in a new session";
+const CONTINUE_STOP = "Stop";
 const BUILD_ONE_HERE_COMMAND = "/build";
-
+const REMOVED_PLAN_COMMANDS: Record<string, string> = {
+	review: "Removed. After a plan is submitted, choose review if Plannotator is available, or run /plan approve or /plan reject.",
+	revise: "Removed. Use /plan reject [feedback] to revise a submitted plan.",
+	status: "Removed. Run /tasks to see status, progress, and the approved hash.",
+	history: "Removed. Submitted snapshots are in .plan_task/history/.",
+	diff: "Removed. Compare the current files with the newest snapshot in .plan_task/history/.",
+} as const;
 function contentKey(content: string): string {
 	return createHash("sha256").update(content).digest("hex");
 }
@@ -93,8 +99,8 @@ export default async function planTaskExtension(pi: ExtensionAPI): Promise<void>
 
 	let mode: Mode = "idle";
 	let continueAll = false;
-	let approvalEachTask = false;
 	let continueNew = false;
+	let pendingHandoff: "new" | "fresh" | undefined;
 	let currentTaskId: number | undefined;
 	let planToolsDelta: ToolDelta | undefined;
 	let awaitingChoice = false;
@@ -173,6 +179,7 @@ export default async function planTaskExtension(pi: ExtensionAPI): Promise<void>
 		mode = "idle";
 		continueAll = false;
 		continueNew = false;
+		pendingHandoff = undefined;
 		currentTaskId = undefined;
 		resetFraming();
 		restoreTools();
@@ -235,6 +242,18 @@ export default async function planTaskExtension(pi: ExtensionAPI): Promise<void>
 		return true;
 	}
 
+	async function queueBuildHandoff(ctx: ExtensionContext, message?: string): Promise<void> {
+		mode = "idle";
+		currentTaskId = undefined;
+		resetFraming();
+		updateStatus(ctx);
+		pendingHandoff = "new";
+		planState = { ...planState, continueMode: "all-new", currentTaskId: undefined };
+		if (stateRestorable) await saveStateLocked(ctx.cwd, planState);
+		if (message) ctx.ui.notify(message, "info");
+		pi.sendUserMessage(BUILD_ONE_HERE_COMMAND, { expandPromptTemplates: true });
+	}
+
 	async function afterBuildSettled(ctx: ExtensionContext): Promise<void> {
 		if (mode !== "build" || awaitingChoice || currentTaskId === undefined) return;
 		const file = await loadTaskFile(ctx.cwd);
@@ -251,8 +270,7 @@ export default async function planTaskExtension(pi: ExtensionAPI): Promise<void>
 			if (continueNew) {
 				const decision = classifyQueue(file, planState);
 				if (decision.kind === "runnable") {
-					mode = "idle"; currentTaskId = undefined; resetFraming(); updateStatus(ctx);
-					pi.sendUserMessage("/build new", { expandPromptTemplates: true });
+					await queueBuildHandoff(ctx);
 					return;
 				}
 				await startNextTask(ctx);
@@ -285,28 +303,12 @@ export default async function planTaskExtension(pi: ExtensionAPI): Promise<void>
 			leaveModes(ctx);
 			return;
 		}
-		if (approvalEachTask) {
-			if (!ctx.hasUI) {
-				ctx.ui.notify("Task complete. Per-task approval requires UI; run /build to continue.", "info");
-				leaveModes(ctx);
-				return;
-			}
-			awaitingChoice = true;
-			const review = await ctx.ui.select(`Task ${currentTaskId} verified. What next?`, ["Continue to next task", "Stop execution"]);
-			awaitingChoice = false;
-			if (review !== "Continue to next task") { leaveModes(ctx); return; }
-		}
 		if (continueAll) {
 			await startNextTask(ctx);
 			return;
 		}
 		if (continueNew) {
-			mode = "idle";
-			currentTaskId = undefined;
-			resetFraming();
-			updateStatus(ctx);
-			ctx.ui.notify("Task complete. Opening a new session for the next task.", "info");
-			pi.sendUserMessage("/build new", { expandPromptTemplates: true });
+			await queueBuildHandoff(ctx, "Task complete. Opening a new session for the next task.");
 			return;
 		}
 		if (!ctx.hasUI) {
@@ -315,24 +317,17 @@ export default async function planTaskExtension(pi: ExtensionAPI): Promise<void>
 			return;
 		}
 		awaitingChoice = true;
-		const choice = await ctx.ui.select("Task complete. What next?", [CONTINUE_THIS, CONTINUE_NEW]);
+		const choice = await ctx.ui.select("Task complete. What next?", [CONTINUE_THIS, CONTINUE_NEW, CONTINUE_STOP]);
 		awaitingChoice = false;
 		if (choice === CONTINUE_THIS) {
 			await startNextTask(ctx);
 			return;
 		}
 		if (choice === CONTINUE_NEW) {
-			mode = "idle";
-			currentTaskId = undefined;
-			resetFraming();
-			updateStatus(ctx);
-			pi.sendUserMessage("/build new", { expandPromptTemplates: true });
+			await queueBuildHandoff(ctx, "Task complete. Opening a new session for the next task.");
 			return;
 		}
-		mode = "idle";
-		currentTaskId = undefined;
-		resetFraming();
-		updateStatus(ctx);
+		leaveModes(ctx);
 	}
 
 	pi.registerTool({
@@ -451,37 +446,12 @@ export default async function planTaskExtension(pi: ExtensionAPI): Promise<void>
 	async function approvePlan(args: string, ctx: ExtensionCommandContext): Promise<void> {
 		const persisted = await loadStateLocked(ctx.cwd);
 		if (persisted) planState = persisted;
-		const selected = args.trim() || (ctx.hasUI ? ((await ctx.ui.select("Approve plan: choose next action", ["current", "new", "fresh", "revise", "cancel"])) ?? "cancel") : "current");
-		const choice = selected.toLowerCase();
-		const revisionAllowed = choice === "revise" && ["ready", "approved", "blocked", "completed"].includes(planState.status);
-		if (planState.status !== "ready" && !revisionAllowed) { ctx.ui.notify(`Plan is not awaiting approval (status: ${planState.status}).`, "warning"); return; }
-		if (!["current", "new", "fresh", "revise", "cancel"].includes(choice)) {
-			ctx.ui.notify("Usage: /plan approve [current|new|fresh]", "error");
+		if (args.trim()) {
+			ctx.ui.notify("Usage: /plan approve\nPlacement flags were removed. Approve first, then run /build or choose here/new/fresh when prompted.", "error");
 			return;
 		}
+		if (planState.status !== "ready") { ctx.ui.notify(`Plan is not awaiting approval (status: ${planState.status}).`, "warning"); return; }
 		const approvalConfig = await loadConfig(ctx.cwd);
-		if (approvalConfig.executionMode === "external" && (choice === "new" || choice === "fresh")) {
-			ctx.ui.notify("External execution mode does not start local sessions.", "warning");
-			return;
-		}
-		if (choice === "cancel") {
-			planState = transition(planState, "idle");
-			await saveStateLocked(ctx.cwd, planState);
-			leaveModes(ctx);
-			ctx.ui.notify("Plan approval cancelled.", "info");
-			return;
-		}
-		if (choice === "revise") {
-			const feedback = ctx.hasUI ? await ctx.ui.input("Revision feedback", "Explain what should change") : "";
-			if (!feedback?.trim()) { ctx.ui.notify("Revision cancelled; current plan is unchanged.", "info"); return; }
-			const current = await readCurrentArtifacts(ctx.cwd);
-			planState = transition(planState, "planning");
-			planState = { ...planState, planningRequest: `Revise the current plan: ${feedback.trim()}`, planningBaselineHash: structureHash(current.plan, current.task), approvedStructureHash: undefined, failureReason: feedback.trim() };
-			planState = await initializeDraftWithState(ctx.cwd, planState, current);
-			await enterPlanMode(ctx);
-			pi.sendUserMessage(`Revise the current draft with this feedback:\n${feedback.trim()}`);
-			return;
-		}
 		const current = await readCurrentArtifacts(ctx.cwd);
 		const parsed = parseTaskMarkdown(current.task);
 		const validation = validatePlan(current.plan, current.task, parsed);
@@ -490,24 +460,37 @@ export default async function planTaskExtension(pi: ExtensionAPI): Promise<void>
 		planState = transition(planState, "approved");
 		planState = { ...planState, approvedStructureHash, draftStructureHash: approvedStructureHash, executionMode: approvalConfig.executionMode, failureReason: undefined };
 		await saveStateLocked(ctx.cwd, planState);
-		const payload = { version: 1, cwd: ctx.cwd, planPath: planFilePath(ctx.cwd), taskPath: taskFilePath(ctx.cwd), planHash: approvedStructureHash, sessionFile: ctx.sessionManager.getSessionFile() };
-		pi.events.emit("pi-plan-task:plan-approved", payload);
+		pi.events.emit("pi-plan-task:plan-approved", { version: 1, cwd: ctx.cwd, planPath: planFilePath(ctx.cwd), taskPath: taskFilePath(ctx.cwd), planHash: approvedStructureHash, sessionFile: ctx.sessionManager.getSessionFile() });
+		leaveModes(ctx);
 		if (approvalConfig.executionMode === "external") {
-			leaveModes(ctx);
 			ctx.ui.notify("Plan approved. External execution event emitted.", "info");
 			return;
 		}
+		if (!ctx.hasUI) {
+			ctx.ui.notify("Plan approved. Run /build or /build all.", "info");
+			return;
+		}
+		awaitingChoice = true;
+		const choice = await ctx.ui.select("Plan approved. Where should the next task run?", ["here", "new", "fresh"]);
+		awaitingChoice = false;
 		if (choice === "new" || choice === "fresh") {
 			await startBuildInNewSession(ctx, BUILD_ONE_HERE_COMMAND, choice === "fresh");
 			return;
 		}
-		await beginBuild(ctx, false, "here");
+		if (choice === "here") {
+			await beginBuild(ctx, false);
+			return;
+		}
+		ctx.ui.notify("Plan approved. Run /build when you want to execute.", "info");
 	}
 
 	async function rejectPlan(args: string, ctx: ExtensionCommandContext): Promise<void> {
 		const persisted = await loadStateLocked(ctx.cwd);
 		if (persisted) planState = persisted;
-		if (planState.status !== "ready") { ctx.ui.notify(`Plan is not awaiting review (status: ${planState.status}).`, "warning"); return; }
+		if (!["ready", "approved", "blocked", "completed"].includes(planState.status)) {
+			ctx.ui.notify(`Plan cannot be rejected from ${planState.status}.`, "warning");
+			return;
+		}
 		const feedback = args.trim() || (ctx.hasUI ? await ctx.ui.input("Plan feedback", "Explain what should change") : "");
 		const current = await readCurrentArtifacts(ctx.cwd);
 		planState = transition(planState, "planning");
@@ -519,30 +502,11 @@ export default async function planTaskExtension(pi: ExtensionAPI): Promise<void>
 		if (feedback) pi.sendUserMessage(`Revise the current draft with this review feedback:\n${feedback}`);
 	}
 
-	async function showPlanStatus(ctx: ExtensionCommandContext): Promise<void> {
-		const persisted = await loadStateLocked(ctx.cwd);
-		const file = await loadTaskFile(ctx.cwd);
-		ctx.ui.notify(`Plan status: ${persisted?.status ?? "idle"}\nApproved hash: ${persisted?.approvedStructureHash ?? "none"}\nWork id: ${persisted?.workId ?? "none"}\nProgress: ${file ? formatProgress(file.tasks) : "0/0"}\nCurrent task: ${persisted?.currentTaskId ?? "none"}`, "info");
-	}
-
-	async function showPlanHistory(ctx: ExtensionCommandContext): Promise<void> {
-		const items = await listPlanSnapshots(ctx.cwd);
-		ctx.ui.notify(items.length ? items.map((item) => `v${item.version} ${item.createdAt}`).join("\n") : "No plan history.", "info");
-	}
-
-	async function showPlanDiff(ctx: ExtensionCommandContext): Promise<void> {
-		const items = await listPlanSnapshots(ctx.cwd);
-		if (!items.length) { ctx.ui.notify("No plan history.", "info"); return; }
-		const currentPlan = (await readOptionalFile(planFilePath(ctx.cwd))) ?? "";
-		const currentTask = (await readOptionalFile(taskFilePath(ctx.cwd))) ?? "";
-		ctx.ui.notify(textDiff(`${items.at(-1)!.plan}\n${items.at(-1)!.task}`, `${currentPlan}\n${currentTask}`) || "No changes.", "info");
-	}
-
-	async function reviewPlan(ctx: ExtensionCommandContext): Promise<void> {
+	async function reviewPlan(ctx: ExtensionContext): Promise<void> {
 		try {
 			const result = await pi.exec("plannotator", ["annotate", planFilePath(ctx.cwd), "--markdown", "--json"]);
 			const review = normalizeReviewResult(result.stdout.trim());
-			if (review?.decision === "approved") { pi.sendUserMessage("/plan approve current", { expandPromptTemplates: true }); return; }
+			if (review?.decision === "approved") { pi.sendUserMessage("/plan approve", { expandPromptTemplates: true }); return; }
 			if (review?.decision === "rejected" && review.feedback) { pi.sendUserMessage(`/plan reject ${review.feedback}`, { expandPromptTemplates: true }); return; }
 			if (result.code !== 0) ctx.ui.notify("Plannotator is unavailable or review failed; use /plan approve or /plan reject.", "warning");
 		} catch {
@@ -550,9 +514,9 @@ export default async function planTaskExtension(pi: ExtensionAPI): Promise<void>
 		}
 	}
 
-	const planSubcommands = ["review", "approve", "reject", "revise", "status", "history", "diff", "request"];
+	const planSubcommands = ["approve", "reject", "request"];
 	pi.registerCommand("plan", {
-		description: "Create, review, approve, reject, or inspect a plan",
+		description: "Create, approve, or reject a plan",
 		getArgumentCompletions: (prefix) => {
 			const items = planSubcommands.map((name) => ({ value: name, label: name }));
 			const filtered = items.filter((item) => item.value.startsWith(prefix.trim().toLowerCase()));
@@ -563,31 +527,37 @@ export default async function planTaskExtension(pi: ExtensionAPI): Promise<void>
 			const [rawAction = "", ...rest] = trimmed.split(/\s+/);
 			const action = rawAction.toLowerCase();
 			const actionArgs = rest.join(" ");
+			if (action in REMOVED_PLAN_COMMANDS) {
+				ctx.ui.notify(REMOVED_PLAN_COMMANDS[action]!, "error");
+				return;
+			}
 			switch (action) {
-				case "review": await reviewPlan(ctx); return;
 				case "approve": await approvePlan(actionArgs, ctx); return;
 				case "reject": await rejectPlan(actionArgs, ctx); return;
-				case "revise": await approvePlan("revise", ctx); return;
-				case "status": await showPlanStatus(ctx); return;
-				case "history": await showPlanHistory(ctx); return;
-				case "diff": await showPlanDiff(ctx); return;
 				case "request": await startPlanRequest(actionArgs, ctx); return;
 				default: await startPlanRequest(args, ctx);
 			}
 		},
 	});
 
-	async function beginBuild(
-		ctx: ExtensionCommandContext,
-		runAll: boolean,
-		placement: BuildPlacement = "here",
-		options: { chainNew?: boolean; approvalEachTask?: boolean } = {},
-	): Promise<void> {
+	async function beginBuild(ctx: ExtensionCommandContext, runAll: boolean): Promise<void> {
 		const persisted = await loadStateLocked(ctx.cwd);
 		if (!persisted) { ctx.ui.notify("No plan state found. Run /plan first.", "error"); return; }
 		planState = persisted;
 		const executionConfig = await loadConfig(ctx.cwd);
 		if (executionConfig.executionMode === "external") { ctx.ui.notify("External execution mode is enabled; waiting for an external executor.", "info"); return; }
+		if (pendingHandoff) {
+			const clean = pendingHandoff === "fresh";
+			pendingHandoff = undefined;
+			if (!runAll) {
+				const started = await startBuildInNewSession(ctx, BUILD_ONE_HERE_COMMAND, clean);
+				if (!started) {
+					planState = { ...planState, continueMode: undefined };
+					await saveStateLocked(ctx.cwd, planState);
+				}
+				return;
+			}
+		}
 		if (planState.status !== "approved" && planState.status !== "executing") {
 			ctx.ui.notify(`Plan must be approved before execution (status: ${planState.status}). Use /plan approve.`, "error");
 			return;
@@ -609,87 +579,33 @@ export default async function planTaskExtension(pi: ExtensionAPI): Promise<void>
 		if (queue.kind === "all-complete") { await enterBuildMode(ctx); await startNextTask(ctx); return; }
 		if (queue.kind === "all-remaining-blocked") { await enterBuildMode(ctx); await startNextTask(ctx); return; }
 
-		const continuingAllNew = planState.continueMode === "all-new";
-		const persistedAllNew = continuingAllNew && placement === "here" && !runAll;
-		const chainNew = options.chainNew === true || persistedAllNew;
-		const approval = options.approvalEachTask === true || (continuingAllNew && planState.approvalEachTask === true);
+		const chainNew = planState.continueMode === "all-new" && !runAll;
 		const continueMode: PlanState["continueMode"] = chainNew ? "all-new" : runAll ? "all-here" : "single";
-
-		if (placement === "new" || placement === "fresh") {
-			const command = buildHandoffCommand({ scope: runAll ? "all" : "one", placement, approval });
-			const pendingState: PlanState = { ...planState, continueMode: continuingAllNew || (runAll && placement === "new") ? "all-new" : runAll ? "all-here" : "single", approvalEachTask: approval, currentTaskId: undefined };
-			planState = pendingState;
-			currentTaskId = undefined;
-			await saveStateLocked(ctx.cwd, pendingState);
-			const started = await startBuildInNewSession(ctx, command, placement === "fresh");
-			if (!started) { planState = { ...pendingState, continueMode: undefined, approvalEachTask: false }; await saveStateLocked(ctx.cwd, planState); }
-			return;
-		}
 		if (planState.status === "approved") planState = transition(planState, "executing");
-		planState = { ...planState, currentTaskId: undefined, approvalEachTask: approval, continueMode };
+		planState = { ...planState, currentTaskId: undefined, approvalEachTask: false, continueMode };
 		await saveStateLocked(ctx.cwd, planState);
 		continueAll = runAll && !chainNew;
-		approvalEachTask = approval;
 		continueNew = chainNew;
 		await enterBuildMode(ctx);
 		ctx.ui.notify(chainNew ? "Building the next task; remaining tasks will use new sessions." : runAll ? "Building remaining tasks." : "Building the next task.", "info");
 		await startNextTask(ctx);
 	}
 
-	const buildSubcommands = ["all", "new", "fresh", "--approval"];
 	pi.registerCommand("build", {
-		description: "Execute one task or all remaining tasks, here or in a new session",
+		description: "Execute one task or all remaining tasks in this session",
 		getArgumentCompletions: (prefix) => {
 			const token = prefix.trim().split(/\s+/).at(-1)?.toLowerCase() ?? "";
-			const items = buildSubcommands.map((name) => ({ value: name, label: name }));
+			const items = [{ value: "all", label: "all" }];
 			const filtered = items.filter((item) => item.value.startsWith(token));
 			return filtered.length ? filtered : null;
 		},
 		handler: async (args, ctx) => {
 			const parsed = parseBuildOptions(args);
 			if (!parsed.ok) { ctx.ui.notify(parsed.error, "error"); return; }
-			const options = parsed.options;
-			await beginBuild(
-				ctx,
-				options.scope === "all",
-				options.placement,
-				{
-					chainNew: options.scope === "all" && options.placement === "new",
-					approvalEachTask: options.scope === "all" && options.approval,
-				},
-			);
+			await beginBuild(ctx, parsed.options.scope === "all");
 		},
 	});
 
-	async function reviewTask(args: string, ctx: ExtensionCommandContext): Promise<void> {
-		const file = await loadTaskFile(ctx.cwd);
-		const requestedId = Number(args.trim());
-		const task = Number.isFinite(requestedId) && requestedId > 0
-			? file?.tasks.find((item) => item.id === requestedId)
-			: currentTaskId === undefined
-				? file?.tasks.find((item) => !item.done)
-				: file?.tasks.find((item) => item.id === currentTaskId);
-		if (!task) { ctx.ui.notify("No matching task to review.", "info"); return; }
-		const sections: string[] = [];
-		try {
-			const [unstaged, staged, status] = await Promise.all([
-				pi.exec("git", ["diff", "--", "."]),
-				pi.exec("git", ["diff", "--cached", "--", "."]),
-				pi.exec("git", ["status", "--short"]),
-			]);
-			if (unstaged.stdout.trim()) sections.push(`Unstaged:\n${unstaged.stdout}`);
-			if (staged.stdout.trim()) sections.push(`Staged:\n${staged.stdout}`);
-			const untracked = status.stdout.split(/\r?\n/).filter((line) => line.startsWith("??")).join("\n");
-			if (untracked) sections.push(`Untracked:\n${untracked}`);
-		} catch { sections.push("(no git diff available)"); }
-		const full = `Task ${task.id}: ${task.title}\n\n${task.body}\n\nWorking tree:\n${sections.join("\n\n") || "(clean)"}`;
-		const lines = full.split(/\r?\n/);
-		let output = lines.slice(0, 2000).join("\n");
-		if (Buffer.byteLength(output, "utf8") > 50_000) output = Buffer.from(output, "utf8").subarray(0, 50_000).toString("utf8");
-		if (output.length < full.length) output += "\n\n[Output truncated. Use git diff, git diff --cached, and git status --short for full details.]";
-		ctx.ui.notify(output, "info");
-	}
-
 	async function reworkTask(args: string, ctx: ExtensionCommandContext): Promise<void> {
 		const id = Number(args.trim());
 		if (!Number.isInteger(id) || id <= 0) { ctx.ui.notify("Provide a positive task id.", "error"); return; }
@@ -709,9 +625,9 @@ export default async function planTaskExtension(pi: ExtensionAPI): Promise<void>
 	}
 
 	pi.registerCommand("tasks", {
-		description: "Show tasks, review a task, or reopen a task for rework",
+		description: "Show plan status and tasks, or reopen a task for rework",
 		getArgumentCompletions: (prefix) => {
-			const items = ["review", "rework"].map((name) => ({ value: name, label: name }));
+			const items = [{ value: "rework", label: "rework" }];
 			const filtered = items.filter((item) => item.value.startsWith(prefix.trim().toLowerCase()));
 			return filtered.length ? filtered : null;
 		},
@@ -719,16 +635,18 @@ export default async function planTaskExtension(pi: ExtensionAPI): Promise<void>
 			const [rawAction = "", ...rest] = args.trim().split(/\s+/);
 			const action = rawAction.toLowerCase();
 			const actionArgs = rest.join(" ");
-			if (action === "review") { await reviewTask(actionArgs, ctx); return; }
+			if (action === "review") { ctx.ui.notify("Removed. Run /tasks for status and the checklist, or use git diff for working-tree details.", "error"); return; }
 			if (action === "rework") { await reworkTask(actionArgs, ctx); return; }
-			if (action) { ctx.ui.notify("Usage: /tasks [review [id]|rework <id>]", "error"); return; }
+			if (action) { ctx.ui.notify("Usage: /tasks [rework <id>]", "error"); return; }
+			const persisted = await loadStateLocked(ctx.cwd);
+			if (persisted) planState = persisted;
 			const file = await loadTaskFile(ctx.cwd);
 			const tasks = file?.tasks ?? [];
 			if (ctx.mode !== "tui") {
-				ctx.ui.notify(formatTaskList(tasks), "info");
+				ctx.ui.notify(formatWorkflowStatus(planState, tasks), "info");
 				return;
 			}
-			await ctx.ui.custom<void>((_tui, theme, _kb, done) => new TaskListComponent(tasks, theme, () => done()));
+			await ctx.ui.custom<void>((_tui, theme, _kb, done) => new TaskListComponent(tasks, theme, () => done(), planState.status));
 		},
 	});
 
@@ -736,6 +654,7 @@ export default async function planTaskExtension(pi: ExtensionAPI): Promise<void>
 		mode = "idle";
 		continueAll = false;
 		continueNew = false;
+		pendingHandoff = undefined;
 		currentTaskId = undefined;
 		planToolsDelta = undefined;
 		awaitingChoice = false;
@@ -748,7 +667,6 @@ export default async function planTaskExtension(pi: ExtensionAPI): Promise<void>
 			if (persisted) {
 				planState = persisted;
 				currentTaskId = persisted.currentTaskId;
-				approvalEachTask = persisted.approvalEachTask === true;
 				continueAll = persisted.continueMode === "all-here";
 				continueNew = persisted.continueMode === "all-new";
 				if (["approved", "executing", "blocked"].includes(persisted.status) && persisted.approvedStructureHash) {
@@ -913,11 +831,12 @@ export default async function planTaskExtension(pi: ExtensionAPI): Promise<void>
 			}
 			awaitingChoice = true;
 			const choice = await ctx.ui.select(`Plan ready (${formatProgress(tasks)}). What next?`, [
-				"current", "new", "fresh", "review", "revise", "reject", "later",
+				"approve", "review", "reject", "later",
 			]);
 			awaitingChoice = false;
-			if (choice === "current" || choice === "new" || choice === "fresh") pi.sendUserMessage(`/plan approve ${choice}`, { expandPromptTemplates: true });
-			else if (choice === "review" || choice === "revise" || choice === "reject") pi.sendUserMessage(`/plan ${choice}`, { expandPromptTemplates: true });
+			if (choice === "approve") pi.sendUserMessage("/plan approve", { expandPromptTemplates: true });
+			else if (choice === "review") await reviewPlan(ctx);
+			else if (choice === "reject") pi.sendUserMessage("/plan reject", { expandPromptTemplates: true });
 			else ctx.ui.notify("Plan is ready. Run /plan approve when you want to execute it.", "info");
 			return;
 		}

package/extensions/integration.test.ts

@@ -114,35 +114,34 @@ describe("extension command integration", () => {
 		} finally { await h.close(); }
 	});
 
-	it("keeps initial new-session cancellation approved", async () => {
+	it("rejects removed build placement flags and keeps the plan approved", async () => {
 		const h = await harness();
 		try {
 			await writeWorkflow(h.cwd, "approved");
 			await h.commands.get("build").handler("new", h.ctx);
 			const state = await loadState(h.cwd);
 			assert.equal(state?.status, "approved");
-			assert.equal(state?.continueMode, undefined);
+			assert.equal(h.notifications.some((message) => message.startsWith("Removed.")), true);
 		} finally { await h.close(); }
 	});
 
-	it("hands off all-new approval and all-fresh through public build commands", async () => {
-		const allNew = await harness();
-		try {
-			await writeWorkflow(allNew.cwd, "approved");
-			allNew.setNewSessionCancelled(false);
-			await allNew.commands.get("build").handler("all new --approval", allNew.ctx);
-			const state = await loadState(allNew.cwd);
-			assert.equal(state?.continueMode, "all-new");
-			assert.equal(state?.approvalEachTask, true);
-			assert.equal(allNew.sent.includes("/build"), true);
-		} finally { await allNew.close(); }
-		const fresh = await harness();
+	it("hands off the next task through a queued /build after Continue in a new session", async () => {
+		const h = await harness();
 		try {
-			await writeWorkflow(fresh.cwd, "approved");
-			fresh.setNewSessionCancelled(false);
-			await fresh.commands.get("build").handler("all fresh", fresh.ctx);
-			assert.equal(fresh.sent.includes("/build all"), true);
-		} finally { await fresh.close(); }
+			const checked = TASK.replace("- [ ] 1. A", "- [x] 1. A");
+			let state = await writeWorkflow(h.cwd, "executing", checked);
+			state = updateTaskState(state, 1, "verified", { verification: "passed" });
+			await saveState(h.cwd, state);
+			h.ctx.hasUI = true;
+			h.ctx.ui.select = async () => "Continue in a new session";
+			h.setNewSessionCancelled(false);
+			await h.handlers.get("session_start")({}, h.ctx);
+			await h.handlers.get("agent_settled")({}, h.ctx);
+			assert.equal(h.sent.includes("/build"), true);
+			assert.equal((await loadState(h.cwd))?.continueMode, "all-new");
+			await h.commands.get("build").handler("", h.ctx);
+			assert.equal(h.sent.filter((message) => message === "/build").length >= 2, true);
+		} finally { await h.close(); }
 	});
 
 	it("external mode refuses local build", async () => {
@@ -167,7 +166,9 @@ describe("extension command integration", () => {
 			await h.handlers.get("agent_settled")({}, h.ctx);
 			assert.equal((await loadState(h.cwd))?.status, "ready");
 			assert.equal(await readFile(planFilePath(h.cwd), "utf8"), "# Plan");
-			await h.commands.get("plan").handler("approve current", h.ctx);
+			await h.commands.get("plan").handler("approve", h.ctx);
+			assert.equal((await loadState(h.cwd))?.status, "approved");
+			await h.commands.get("build").handler("", h.ctx);
 			assert.equal((await loadState(h.cwd))?.status, "executing");
 			assert.equal(h.sent.some((message) => message.includes("Execute planned task 1")), true);
 		} finally { await h.close(); }
@@ -196,23 +197,21 @@ describe("extension command integration", () => {
 		} finally { await h.close(); }
 	});
 
-	it("supports revision, rejection, task review, and successful cascading rework", async () => {
+	it("supports rejection from approved, removed task review, status on /tasks, and cascading rework", async () => {
 		const h = await harness();
 		try {
 			h.ctx.hasUI = true;
 			await writeWorkflow(h.cwd, "approved");
 			await h.commands.get("plan").handler("revise", h.ctx);
-			assert.equal((await loadState(h.cwd))?.status, "planning");
-			assert.equal(h.sent.some((message) => message.includes("Revise the current draft")), true);
-			await writeFile(draftPlanFilePath(h.cwd), "# Revised", "utf8");
-			await writeFile(draftTaskFilePath(h.cwd), TASK, "utf8");
-			await h.handlers.get("agent_settled")({}, h.ctx);
-			assert.equal((await loadState(h.cwd))?.status, "ready");
+			assert.equal((await loadState(h.cwd))?.status, "approved");
+			assert.equal(h.notifications.some((message) => message.startsWith("Removed.")), true);
 			await h.commands.get("plan").handler("reject more detail", h.ctx);
 			assert.equal((await loadState(h.cwd))?.status, "planning");
 			assert.equal(h.sent.some((message) => message.includes("review feedback")), true);
 			await h.commands.get("tasks").handler("review 1", h.ctx);
-			assert.equal(h.notifications.some((message) => message.includes("Task 1: A")), true);
+			assert.equal(h.notifications.some((message) => message.includes("Removed.") && message.includes("/tasks")), true);
+			await h.commands.get("tasks").handler("", h.ctx);
+			assert.equal(h.notifications.some((message) => message.includes("Status:")), true);
 		} finally { await h.close(); }
 		const rework = await harness();
 		try {

package/extensions/task-ui.ts

@@ -1,6 +1,6 @@
 import { matchesKey, truncateToWidth } from "@earendil-works/pi-tui";
 import { formatProgress } from "./files.ts";
-import type { TaskItem } from "./types.ts";
+import type { PlanState, TaskItem } from "./types.ts";
 
 export function formatTaskList(tasks: TaskItem[]): string {
 	if (tasks.length === 0) return "No tasks found in .plan_task/task.md.";
@@ -8,15 +8,26 @@ export function formatTaskList(tasks: TaskItem[]): string {
 	return `Progress ${formatProgress(tasks)}\n${lines.join("\n")}`;
 }
 
+export function formatWorkflowStatus(state: PlanState | undefined, tasks: TaskItem[]): string {
+	return [
+		`Status: ${state?.status ?? "idle"}`,
+		`Approved hash: ${state?.approvedStructureHash ?? "none"}`,
+		`Work id: ${state?.workId ?? "none"}`,
+		`Current task: ${state?.currentTaskId ?? "none"}`,
+		formatTaskList(tasks),
+	].join("\n");
+}
 export class TaskListComponent {
 	private readonly tasks: TaskItem[];
+	private readonly status: string;
 	private readonly theme: { fg: (name: "accent" | "muted" | "dim" | "success" | "text", text: string) => string };
 	private readonly onClose: () => void;
 	private cachedWidth?: number;
 	private cachedLines?: string[];
 
-	constructor(tasks: TaskItem[], theme: TaskListComponent["theme"], onClose: () => void) {
+	constructor(tasks: TaskItem[], theme: TaskListComponent["theme"], onClose: () => void, status = "idle") {
 		this.tasks = tasks;
+		this.status = status;
 		this.theme = theme;
 		this.onClose = onClose;
 	}
@@ -28,7 +39,7 @@ export class TaskListComponent {
 	render(width: number): string[] {
 		if (this.cachedLines && this.cachedWidth === width) return this.cachedLines;
 		const th = this.theme;
-		const lines = ["", truncateToWidth(`  ${th.fg("accent", "Plan tasks")}  ${th.fg("muted", formatProgress(this.tasks))}`, width), ""];
+		const lines = ["", truncateToWidth(`  ${th.fg("accent", "Plan tasks")}  ${th.fg("muted", `${formatProgress(this.tasks)}  ${this.status}`)}`, width), ""];
 		if (this.tasks.length === 0) lines.push(truncateToWidth(`  ${th.fg("dim", "No tasks found. Run /plan first.")}`, width));
 		else for (const task of this.tasks) {
 			const check = task.done ? th.fg("success", "x") : th.fg("dim", " ");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-plan-task",
-  "version": "3.0.1",
+  "version": "4.0.0",
   "license": "MIT",
   "description": "Pi package: /plan, /build, and /tasks with approved, resumable plan execution.",
   "keywords": [