pi-goal-x 0.13.0 → 0.14.0

package/README.md

@@ -19,10 +19,19 @@ All core features of [@capyup/pi-goal](https://github.com/capyup/pi-goal) are pr
 - **Auditor integration** — the independent completion auditor receives both the `verificationContract` and `verificationSummary` and cross-checks claims against real artifacts.
 - **`complete_goal` `testResults` removed** — replaced with `verificationSummary`. The old structured test results interface is gone.
 
-### Task list system
+### Unified goal + task acceptance
 
-- **Structured task breakdown** — the agent can propose a task list via `propose_task_list`, which shows the user a Confirm / Continue Chatting dialog (mirrors the `propose_goal_draft` pattern). Once confirmed, tasks are displayed in prompts, the widget, serialized to disk, and included in auditor review.
-- **Per-task completion** — `complete_task` marks individual tasks done with optional evidence, and `skip_task` marks tasks as skipped with a required reason. Neither stops the turn, so the agent can continue uninterrupted.
+- **Single-dialog confirmation** — `propose_goal_draft` now accepts an optional `tasks` array parameter. The confirmation dialog shows the goal objective AND the proposed task list together in a single rich TUI view with box-drawing panel (`┌─ TASKS ───┐`), section headers, and hierarchical indentation for subtasks.
+- **Atomic creation** — one confirmation (single enter press) creates the goal AND its task list together. No need for separate `propose_goal_draft` + `propose_task_list` calls.
+- **Backward compatible** — existing separate `propose_task_list` flow continues to work unchanged. Goals without tasks work as before.
+
+### Task list & sub-task system
+
+- **Structured task breakdown** — the agent can propose a task list via `propose_task_list` (standalone) or `propose_goal_draft` with `tasks` (unified). Both show a Confirm / Continue Chatting dialog. Once confirmed, tasks are displayed in prompts, the widget, serialized to disk, and included in auditor review.
+- **Recursive subtasks** — tasks can have nested sub-tasks via `subtasks?: GoalTask[]` (full recursive type). Subtask depth is controlled globally by `subtaskDepth` in `.pi/goal-settings.json` (default: 1 level). Too-deep subtrees are rejected at proposal.
+- **Lightweight subtasks** — each task has an optional `lightweightSubtasks?: boolean` flag. When true, the parent can complete regardless of subtask status. When false/absent (full subtasks), all subtasks must be individually complete before the parent can close.
+- **Per-task completion** — `complete_task` marks individual tasks done with optional evidence/verificationSummary, and `skip_task` marks tasks as skipped with a required reason. Neither stops the turn, so the agent can continue uninterrupted.
+- **Hierarchical display** — task lists with subtasks render with indentation in prompts (`taskListBlock`, `goalPrompt`, `continuationPrompt`) and in the TUI widget (recursive count, BFS next-pending).
 - **Optional `taskList`** — goals without a task list work exactly as before. The feature is entirely opt-in.
 - **Soft `complete_goal` gate** — when `blockCompletion: true` is set, `complete_goal` surfaces a warning if pending tasks remain (prompt-level only; the agent can still complete).
 
@@ -39,7 +48,7 @@ All core features of [@capyup/pi-goal](https://github.com/capyup/pi-goal) are pr
 ### E2e test infrastructure
 
 - **Deterministic fork tests using `--mode json`**: the e2e suite spawns a real `pi --fork --mode json` session, parses structured `tool_execution_start`/`tool_execution_end` JSON events for field-level assertions — no free-text AI output parsing. Uses `--append-system-prompt` + `--tools` to force deterministic tool calls.
-- **Full coverage**: 205 tests total — function-level integration tests (12), mock-pi handler tests (4), file-validity checks (6), real `pi --fork --mode json` tests (3 scenarios), propose_goal_tweak unit/integration/e2e tests (15), task list policy/round-trip/render tests (50+), and verification contract tests (14).
+- **Full coverage**: 281 tests total — function-level integration tests, mock-pi handler tests, file-validity checks, real `pi --fork --mode json` E2E tests, propose_goal_tweak unit/integration/e2e tests, task list policy/round-trip/render tests (including subtasks), and verification contract tests.
 
 ### Completion auditor
 
@@ -214,17 +223,7 @@ Before archiving the goal, `update_goal` starts a separate pi agent in an isolat
 
 The auditor is semantic, not a paperwork checklist: it should reject scaffold-only, alpha, generated-template, proxy-metric, build-only, or weakly verified completions when the real user outcome is not satisfied.
 
-By default the auditor uses the current/default pi model. Configure it interactively with `/goal-settings` -> `auditor`, then click `provider`, `model`, or `thinking_level` and type the value directly. The settings are saved to `.pi/goal-auditor.json`. You can also edit the file or override it with environment variables:
-
-```json
-{
-  "provider": "fireworks",
-  "model": "accounts/fireworks/routers/kimi-k2p6-turbo",
-  "thinking_level": "high"
-}
-```
-
-Environment variables `PI_GOAL_AUDITOR_PROVIDER`, `PI_GOAL_AUDITOR_MODEL`, and `PI_GOAL_AUDITOR_THINKING_LEVEL` take precedence over `/goal-settings`.
+By default the auditor uses the current/default pi model. Configure it via `.pi/goal-auditor.json`, interactively with `/goal-settings` → `auditor`, or environment variables (see [Settings files](#settings-files)).
 
 The completion result prints a full report into the conversation:
 
@@ -272,6 +271,52 @@ Before commands, tools, and lifecycle hooks act on a focused goal, the runtime r
 
 Goal paths are constrained to `.pi/goals/` and `.pi/goals/archived/`; absolute paths, traversal, NUL bytes, symlinks, and unsafe metadata paths are rejected.
 
+## Settings files
+
+Configuration is split across two files under `.pi/`.
+
+### `.pi/goal-settings.json`
+
+Configured interactively via `/goal-settings`, or edited directly:
+
+```json
+{
+  "disableTasks": false,
+  "disableContracts": false,
+  "subtaskDepth": 1
+}
+```
+
+| Field | Default | Purpose |
+|---|---:|---|
+| `disableTasks` | `false` | Suppress task list features entirely when `true` |
+| `disableContracts` | `false` | Suppress verification contract enforcement when `true` |
+| `subtaskDepth` | `1` | Maximum nesting depth for subtasks (`1` = tasks → subtasks, `2` = tasks → subtasks → sub-subtasks) |
+
+**Env var overrides:** `PI_GOAL_DISABLE_TASKS=1` and `PI_GOAL_DISABLE_CONTRACTS=1` take precedence over the file. Set to any truthy string to disable.
+
+### `.pi/goal-auditor.json`
+
+Configured interactively via `/goal-settings` → `auditor`, or edited directly:
+
+```json
+{
+  "provider": "fireworks",
+  "model": "accounts/fireworks/models/deepseek-v4-flash",
+  "thinkingLevel": "high",
+  "disabled": false
+}
+```
+
+| Field | Default | Purpose |
+|---|---:|---|
+| `provider` | system default | Provider name for the auditor agent (`anthropic`, `fireworks`, `google`, `groq`, etc.) |
+| `model` | system default | Model name for the auditor agent |
+| `thinkingLevel` | system default | Thinking level: `none`, `low`, `medium`, `high` |
+| `disabled` | `false` | When `true`, skip the completion audit entirely |
+
+**Env var overrides:** `PI_GOAL_AUDITOR_PROVIDER`, `PI_GOAL_AUDITOR_MODEL`, and `PI_GOAL_AUDITOR_THINKING_LEVEL` take precedence over file config. `PI_GOAL_AUDITOR_THINKING` is also accepted as an alias for the thinking level.
+
 ## Environment variables
 
 | Variable | Default | Purpose |

package/extensions/goal-auditor.ts

@@ -13,7 +13,8 @@ import {
 	type ExtensionContext,
 	type ResourceLoader,
 } from "@earendil-works/pi-coding-agent";
-import type { GoalRecord, GoalTaskList } from "./goal-record.ts";
+import type { GoalRecord, GoalTask, GoalTaskList } from "./goal-record.ts";
+import type { GoalSettings } from "./goal-settings.ts";
 
 export interface GoalAuditorConfig {
 	provider?: string;
@@ -134,18 +135,43 @@ export interface AuditorVerificationEvidence {
 	contract?: string;
 }
 
+function renderAuditorTaskTree(tasks: GoalTask[], indent: number): string[] {
+	const prefix = "  ".repeat(indent);
+	const lines: string[] = [];
+	for (const task of tasks) {
+		const marker = task.status === "complete" ? "[x]" : task.status === "skipped" ? "[~]" : "[ ]";
+		lines.push(`${prefix}${marker} ${task.id}: ${task.title}`);
+		if (task.subtasks && task.subtasks.length > 0) {
+			lines.push(...renderAuditorTaskTree(task.subtasks, indent + 1));
+		}
+	}
+	return lines;
+}
+
+function countAuditorTasks(tasks: GoalTask[]): { total: number; complete: number; skipped: number; pending: number } {
+	let total = 0;
+	let complete = 0;
+	let skipped = 0;
+	for (const t of tasks) {
+		total++;
+		if (t.status === "complete") complete++;
+		else if (t.status === "skipped") skipped++;
+		if (t.subtasks && t.subtasks.length > 0) {
+			const child = countAuditorTasks(t.subtasks);
+			total += child.total;
+			complete += child.complete;
+			skipped += child.skipped;
+		}
+	}
+	return { total, complete, skipped, pending: total - complete - skipped };
+}
+
 function taskSummaryBlock(taskList?: GoalTaskList | null): string {
 	if (!taskList || taskList.tasks.length === 0) return "";
-	const total = taskList.tasks.length;
-	const complete = taskList.tasks.filter((t) => t.status === "complete").length;
-	const skipped = taskList.tasks.filter((t) => t.status === "skipped").length;
-	const pending = taskList.tasks.filter((t) => t.status === "pending");
+	const { total, complete, skipped, pending } = countAuditorTasks(taskList.tasks);
 	const lines: string[] = [`Tasks: ${complete}/${total} complete${skipped > 0 ? `, ${skipped} skipped` : ""}`];
-	for (const task of taskList.tasks) {
-		const marker = task.status === "complete" ? "[x]" : task.status === "skipped" ? "[~]" : "[ ]";
-		lines.push(`  ${marker} ${task.id}: ${task.title}`);
-	}
-	const gate = taskList.blockCompletion && pending.length > 0 ? " | TASK GATE: pending tasks block completion" : "";
+	lines.push(...renderAuditorTaskTree(taskList.tasks, 0));
+	const gate = taskList.blockCompletion && pending > 0 ? " | TASK GATE: pending tasks block completion" : "";
 	lines[0] = lines[0]! + gate;
 	return lines.join("\n");
 }
@@ -155,6 +181,7 @@ export function buildGoalAuditorPrompt(args: {
 	completionSummary?: string | null;
 	detailedSummary: string;
 	verificationSummary?: string | null;
+	settings?: GoalSettings;
 }): string {
 	return [
 		"You are the independent completion auditor for pi-goal.",
@@ -180,7 +207,7 @@ export function buildGoalAuditorPrompt(args: {
 		"Current goal metadata:",
 		"<goal_details>",
 		args.detailedSummary,
-		...(taskSummaryBlock(args.goal.taskList) ? ["", taskSummaryBlock(args.goal.taskList)] : []),
+		...(!args.settings?.disableTasks && taskSummaryBlock(args.goal.taskList) ? ["", taskSummaryBlock(args.goal.taskList)] : []),
 		"</goal_details>",
 		...(args.verificationSummary?.trim() ? [
 			"",
@@ -189,7 +216,7 @@ export function buildGoalAuditorPrompt(args: {
 			args.verificationSummary.trim(),
 			"</verification_summary>",
 		] : []),
-		...(args.goal.verificationContract?.trim() ? [
+		...(!args.settings?.disableContracts && args.goal.verificationContract?.trim() ? [
 			"",
 			"Goal verification contract (what the executor was required to verify):",
 			"<verification_contract>",
@@ -204,7 +231,7 @@ export function buildGoalAuditorPrompt(args: {
 			...(args.verificationSummary?.trim()
 				? ["3. Check the <verification_summary> against real artifacts. If the executor claims to have run tests or searched for references, verify those claims with actual file/shell evidence. The summary is a claim, not proof — cross-check it."]
 				: []),
-			...(args.goal.verificationContract?.trim()
+			...(!args.settings?.disableContracts && args.goal.verificationContract?.trim()
 				? ["4. Verify that the executor has satisfied every item in the <verification_contract>. If any item is missing or weakly addressed, disapprove."]
 				: []),
 			"5. Explain missing or weak evidence, especially scaffold-vs-final quality gaps.",
@@ -288,6 +315,7 @@ export async function runGoalCompletionAuditor(args: {
 	completionSummary?: string | null;
 	detailedSummary: string;
 	verificationSummary?: string | null;
+	settings?: GoalSettings;
 	signal?: AbortSignal;
 	onProgress?: AuditorProgressCallback;
 	/**

package/extensions/goal-policy.ts

@@ -1,5 +1,5 @@
 import { statusLabel, type GoalDisplayRecordLike } from "./goal-core.ts";
-import type { GoalTaskList, TaskStatus } from "./goal-record.ts";
+import type { GoalTask, GoalTaskList, TaskStatus } from "./goal-record.ts";
 
 export type GoalStatusLike = "active" | "paused" | "complete";
 export type StopReasonLike = "user" | "agent";
@@ -126,10 +126,27 @@ export function abortGoalCommandMessage(args: { archived: boolean; wasDrafting:
 	return args.archived ? "Goal aborted and archived." : args.wasDrafting ? "Drafting cancelled." : "No goal is set.";
 }
 
+/** Count tasks in subtree recursively */
+function countSubtreeTasks(tasks: GoalTask[]): { total: number; complete: number; skipped: number; pending: number } {
+	let total = 0;
+	let complete = 0;
+	let skipped = 0;
+	for (const t of tasks) {
+		total++;
+		if (t.status === "complete") complete++;
+		else if (t.status === "skipped") skipped++;
+		if (t.subtasks && t.subtasks.length > 0) {
+			const child = countSubtreeTasks(t.subtasks);
+			total += child.total;
+			complete += child.complete;
+			skipped += child.skipped;
+		}
+	}
+	return { total, complete, skipped, pending: total - complete - skipped };
+}
+
 export function buildTaskSummary(taskList: GoalTaskList): string {
-	const total = taskList.tasks.length;
-	const complete = taskList.tasks.filter((t) => t.status === "complete").length;
-	const skipped = taskList.tasks.filter((t) => t.status === "skipped").length;
+	const { total, complete, skipped } = countSubtreeTasks(taskList.tasks);
 	if (total === 0) return "No tasks";
 	const parts: string[] = [`${complete}/${total} tasks complete`];
 	if (skipped > 0) parts.push(`(${skipped} skipped)`);
@@ -138,9 +155,9 @@ export function buildTaskSummary(taskList: GoalTaskList): string {
 
 export function taskCompletionBlockWarning(taskList: GoalTaskList): string | null {
 	if (!taskList.blockCompletion) return null;
-	const pending = taskList.tasks.filter((t) => t.status === "pending");
-	if (pending.length === 0) return null;
-	return `${pending.length} task${pending.length > 1 ? "s" : ""} still pending with blockCompletion enabled. Complete or skip all pending tasks before finishing the goal.`;
+	const { pending } = countSubtreeTasks(taskList.tasks);
+	if (pending === 0) return null;
+	return `${pending} task${pending > 1 ? "s" : ""} still pending with blockCompletion enabled. Complete or skip all pending tasks before finishing the goal.`;
 }
 
 /**
@@ -190,9 +207,43 @@ export function validateTaskSkip(args: {
 	return { ok: true };
 }
 
+/**
+ * Count the maximum nesting depth of a task's subtask tree.
+ * Root level = 0. Returns the deepest nesting depth found.
+ */
+export function measureSubtaskDepth(task: GoalTask): number {
+	if (!task.subtasks || task.subtasks.length === 0) return 0;
+	let maxChild = 0;
+	for (const child of task.subtasks) {
+		const childDepth = measureSubtaskDepth(child);
+		if (childDepth > maxChild) maxChild = childDepth;
+	}
+	return maxChild + 1;
+}
+
+/**
+ * Validate that a task's subtask tree does not exceed the configured max depth.
+ * maxDepth is the subtaskDepth setting (default 1) — how many levels of nesting are allowed.
+ * Returns the first violation found, or undefined if valid.
+ */
+export function findSubtaskDepthViolation(tasks: GoalTask[], maxDepth: number): string | undefined {
+	for (const task of tasks) {
+		const depth = measureSubtaskDepth(task);
+		if (depth > maxDepth) {
+			return `Task "${task.id}" has subtask nesting depth ${depth}, exceeding the configured maximum of ${maxDepth}`;
+		}
+		if (task.subtasks) {
+			const childViolation = findSubtaskDepthViolation(task.subtasks, maxDepth);
+			if (childViolation) return childViolation;
+		}
+	}
+	return undefined;
+}
+
 export function validateTaskListProposal(args: {
 	goal: GoalPolicyRecordLike | null;
-	tasks: { id: string; title: string }[];
+	tasks: GoalTask[];
+	maxSubtaskDepth?: number;
 }): PolicyValidation {
 	if (!args.goal) return { ok: false, message: "No goal is set." };
 	if (args.tasks.length > 50) return { ok: false, message: "Task list cannot exceed 50 tasks." };
@@ -203,9 +254,78 @@ export function validateTaskListProposal(args: {
 		if (ids.has(t.id)) return { ok: false, message: `Duplicate task id: "${t.id}".` };
 		ids.add(t.id);
 	}
+	// Check subtask depth limit
+	const maxDepth = args.maxSubtaskDepth ?? 1;
+	const depthViolation = findSubtaskDepthViolation(args.tasks, maxDepth);
+	if (depthViolation) return { ok: false, message: depthViolation };
 	return { ok: true };
 }
 
+/**
+ * Recursively find a task by ID in a task tree.
+ */
+export function findTaskInTree(tasks: GoalTask[], taskId: string): GoalTask | undefined {
+	for (const t of tasks) {
+		if (t.id === taskId) return t;
+		if (t.subtasks) {
+			const found = findTaskInTree(t.subtasks, taskId);
+			if (found) return found;
+		}
+	}
+	return undefined;
+}
+
+/**
+ * Recursively update a task by ID in a task tree using an updater function.
+ */
+export function updateTaskInTree(tasks: GoalTask[], taskId: string, updater: (task: GoalTask) => GoalTask): GoalTask[] {
+	return tasks.map((t) => {
+		if (t.id === taskId) return updater(t);
+		if (t.subtasks) {
+			return { ...t, subtasks: updateTaskInTree(t.subtasks, taskId, updater) };
+		}
+		return t;
+	});
+}
+
+/**
+ * Check if all subtasks of a task are complete (for full subtasks only).
+ * Returns undefined when all are complete/skipped, or an error message.
+ */
+export function checkSubtasksComplete(task: GoalTask): string | undefined {
+	if (!task.subtasks || task.subtasks.length === 0 || task.lightweightSubtasks) return undefined;
+	for (const child of task.subtasks) {
+		if (child.status === "pending") {
+			return `Task "${task.id}" has pending subtask "${child.id}". Complete or skip all subtasks first.`;
+		}
+		// Check recursively
+		const childCheck = checkSubtasksComplete(child);
+		if (childCheck) return childCheck;
+	}
+	return undefined;
+}
+
+/**
+ * Recursively skip all subtasks of a task.
+ * Returns a set of all skipped task IDs.
+ */
+export function skipAllSubtasks(task: GoalTask, now: string, reason: string): GoalTask {
+	if (!task.subtasks || task.subtasks.length === 0) return task;
+	return {
+		...task,
+		subtasks: task.subtasks.map((child) => {
+			if (child.status === "complete") return child;
+			const skipped = {
+				...child,
+				status: "skipped" as const,
+				skippedAt: now,
+				skipReason: reason,
+			};
+			return skipAllSubtasks(skipped, now, reason);
+		}),
+	};
+}
+
 export function buildCompletionReport(args: { detailedSummary: string; completionSummary?: string | null; auditorReport?: string | null; auditSkippedReason?: string | null; taskSummary?: string | null }): string {
 	const auditSkipped = args.auditSkippedReason?.trim();
 	const auditorReport = args.auditorReport?.trim();

package/extensions/goal-questionnaire.ts

@@ -92,6 +92,11 @@ export async function runGoalQuestionnaire(ctx: ExtensionContext, rawQuestions:
 	const totalTabs = questions.length + 1;
 
 	return await ctx.ui.custom<GoalQuestionnaireResult>((tui, theme, _kb, done) => {
+		// Suppress hardware cursor during dialog to reduce TUI auto-scroll
+		// (the TUI render loop runs at ~60fps and writes ANSI cursor positioning
+		// sequences every cycle, which can cause terminal viewport snapping).
+		const wasHardwareCursorShown = tui.getShowHardwareCursor();
+		tui.setShowHardwareCursor(false);
 		let currentTab = 0;
 		let optionIndex = 0;
 		let inputMode = false;
@@ -118,6 +123,8 @@ export async function runGoalQuestionnaire(ctx: ExtensionContext, rawQuestions:
 		}
 
 		function submit(cancelled: boolean) {
+			// Restore hardware cursor now that the dialog is closing
+			tui.setShowHardwareCursor(wasHardwareCursorShown);
 			const ordered = questions.map((q) => answers.get(q.id)).filter((a): a is GoalQuestionnaireAnswer => !!a);
 			done({ questions, answers: ordered, cancelled });
 		}

package/extensions/goal-record.ts

@@ -15,6 +15,8 @@ export interface GoalTask {
   evidence?: string;
   skipReason?: string;
   verificationContract?: string;
+  lightweightSubtasks?: boolean;
+  subtasks?: GoalTask[];
 }
 
 export interface GoalTaskList {
@@ -111,12 +113,19 @@ export function emptyUsage(): GoalUsage {
 	return { tokensUsed: 0, activeSeconds: 0 };
 }
 
+function cloneGoalTask(task: GoalTask): GoalTask {
+	return {
+		...task,
+		subtasks: task.subtasks ? task.subtasks.map(cloneGoalTask) : undefined,
+	};
+}
+
 export function cloneGoal(goal: GoalRecord): GoalRecord {
 	return {
 		...goal,
 		usage: { ...goal.usage },
 		taskList: goal.taskList
-			? { ...goal.taskList, tasks: goal.taskList.tasks.map(t => ({ ...t })) }
+			? { ...goal.taskList, tasks: goal.taskList.tasks.map(cloneGoalTask) }
 			: undefined,
 	};
 }
@@ -164,30 +173,41 @@ export function normalizeUsage(value: unknown): GoalUsage {
 	return { tokensUsed, activeSeconds };
 }
 
+export function normalizeTaskItem(raw: Record<string, unknown>): GoalTask | undefined {
+	const id = typeof raw.id === "string" && raw.id.trim() ? raw.id.trim() : "";
+	const title = typeof raw.title === "string" ? raw.title.trim() : "";
+	if (!id || !title) return undefined;
+	const status: TaskStatus = raw.status === "complete" ? "complete" : raw.status === "skipped" ? "skipped" : "pending";
+	const subtasksRaw = raw.subtasks;
+	let subtasks: GoalTask[] | undefined;
+	if (Array.isArray(subtasksRaw)) {
+		subtasks = subtasksRaw
+			.map((item) => (item && typeof item === "object" ? normalizeTaskItem(item as Record<string, unknown>) : undefined))
+			.filter((t): t is GoalTask => !!t);
+		if (subtasks.length === 0) subtasks = undefined;
+	}
+	return {
+		id,
+		title,
+		status,
+		completedAt: typeof raw.completedAt === "string" ? raw.completedAt : undefined,
+		skippedAt: typeof raw.skippedAt === "string" ? raw.skippedAt : undefined,
+		evidence: typeof raw.evidence === "string" ? raw.evidence : undefined,
+		skipReason: typeof raw.skipReason === "string" ? raw.skipReason : undefined,
+		verificationContract: typeof raw.verificationContract === "string" ? raw.verificationContract : undefined,
+		lightweightSubtasks: raw.lightweightSubtasks === true ? true : undefined,
+		subtasks,
+	};
+}
+
 export function normalizeTaskList(value: unknown): GoalTaskList | undefined {
 	const raw = asRecord(value);
 	if (!raw) return undefined;
 	const tasksRaw = raw.tasks;
 	if (!Array.isArray(tasksRaw)) return undefined;
-	const tasks: GoalTask[] = [];
-	for (const item of tasksRaw) {
-		if (!item || typeof item !== "object" || Array.isArray(item)) continue;
-		const t = item as Record<string, unknown>;
-		const id = typeof t.id === "string" && t.id.trim() ? t.id.trim() : "";
-		const title = typeof t.title === "string" ? t.title.trim() : "";
-		if (!id || !title) continue;
-		const status: TaskStatus = t.status === "complete" ? "complete" : t.status === "skipped" ? "skipped" : "pending";
-		tasks.push({
-			id,
-			title,
-			status,
-			completedAt: typeof t.completedAt === "string" ? t.completedAt : undefined,
-			skippedAt: typeof t.skippedAt === "string" ? t.skippedAt : undefined,
-			evidence: typeof t.evidence === "string" ? t.evidence : undefined,
-			skipReason: typeof t.skipReason === "string" ? t.skipReason : undefined,
-			verificationContract: typeof t.verificationContract === "string" ? t.verificationContract : undefined,
-		});
-	}
+	const tasks: GoalTask[] = tasksRaw
+		.map((item) => (item && typeof item !== "object" || Array.isArray(item) ? undefined : normalizeTaskItem(item as Record<string, unknown>)))
+		.filter((t): t is GoalTask => !!t);
 	if (tasks.length === 0) return undefined;
 	return {
 		tasks,

package/extensions/goal-settings.ts

@@ -0,0 +1,95 @@
+/**
+ * Global goal settings: config file + env var overrides for disabling
+ * task lists and/or verification contracts.
+ *
+ * Reads `.pi/goal-settings.json` with env var overrides:
+ *   PI_GOAL_DISABLE_TASKS     — "true" to disable, any other value = use file config
+ *   PI_GOAL_DISABLE_CONTRACTS — "true" to disable, any other value = use file config
+ *
+ * Pattern mirrors `goalAuditorConfig` in goal-auditor.ts.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export interface GoalSettings {
+	disableTasks?: boolean;
+	disableContracts?: boolean;
+	subtaskDepth?: number;
+}
+
+/**
+ * Resolve the path to the global goal-settings.json file.
+ */
+export function goalSettingsPath(cwd: string): string {
+	return path.join(cwd, ".pi", "goal-settings.json");
+}
+
+function asNonEmptyString(value: unknown): string | undefined {
+	return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+
+function asBool(value: unknown): boolean | undefined {
+	if (value === true || value === "true") return true;
+	if (value === false || value === "false") return false;
+	return undefined;
+}
+
+function asPositiveInt(value: unknown): number | undefined {
+	if (typeof value === "number" && Number.isInteger(value) && value >= 1) return value;
+	if (typeof value === "string") {
+		const n = parseInt(value, 10);
+		if (!isNaN(n) && n >= 1) return n;
+	}
+	return undefined;
+}
+
+const ALLOWED_SETTINGS_KEYS = new Set(["disableTasks", "disableContracts", "subtaskDepth"]);
+
+/**
+ * Parse raw (deserialized JSON) into a GoalSettings object.
+ * Rejects unknown keys (additionalProperties: false semantics).
+ */
+export function parseGoalSettings(raw: unknown): GoalSettings {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
+	const record = raw as Record<string, unknown>;
+	const unknownKeys = Object.keys(record).filter((k) => !ALLOWED_SETTINGS_KEYS.has(k));
+	if (unknownKeys.length > 0) {
+		throw new Error(`Unknown goal-settings.json key(s): ${unknownKeys.join(", ")}`);
+	}
+	const settings: GoalSettings = {};
+	const disableTasks = asBool(record.disableTasks);
+	const disableContracts = asBool(record.disableContracts);
+	const subtaskDepth = asPositiveInt(record.subtaskDepth);
+	if (disableTasks !== undefined) settings.disableTasks = disableTasks;
+	if (disableContracts !== undefined) settings.disableContracts = disableContracts;
+	if (subtaskDepth !== undefined) settings.subtaskDepth = subtaskDepth;
+	return settings;
+}
+
+/**
+ * Load settings from the file on disk. Returns {} if file missing or invalid.
+ */
+export function loadGoalSettingsFileConfig(cwd: string): GoalSettings {
+	try {
+		const configPath = goalSettingsPath(cwd);
+		if (fs.existsSync(configPath)) return parseGoalSettings(JSON.parse(fs.readFileSync(configPath, "utf8")));
+	} catch {
+		// file missing, malformed JSON, etc. — use defaults
+	}
+	return {};
+}
+
+/**
+ * Load settings with env var overrides.
+ * Env vars take precedence over file config.
+ * Default: both flags false (features enabled).
+ */
+export function loadGoalSettings(cwd: string, env: NodeJS.ProcessEnv = process.env): GoalSettings {
+	const fileConfig = loadGoalSettingsFileConfig(cwd);
+	return {
+		disableTasks: asBool(env.PI_GOAL_DISABLE_TASKS) ?? fileConfig.disableTasks ?? false,
+		disableContracts: asBool(env.PI_GOAL_DISABLE_CONTRACTS) ?? fileConfig.disableContracts ?? false,
+		subtaskDepth: fileConfig.subtaskDepth ?? 1,
+	};
+}

package/extensions/goal.ts

@@ -23,6 +23,7 @@ import {
 	saveGoalAuditorFileConfig,
 	type GoalAuditorConfig,
 } from "./goal-auditor.ts";
+import { loadGoalSettings, type GoalSettings } from "./goal-settings.ts";
 import {
 	proposalDialogFailureMessage,
 	registerQuestionnaireTools,
@@ -52,6 +53,7 @@ import {
 	goalFocusDetails,
 	normalizeGoalRecord,
 	normalizeGoalFocusEntry,
+	normalizeTaskItem,
 	nowIso,
 	type AssistantMessageLike,
 	type DraftingFocus,
@@ -64,6 +66,7 @@ import {
 	type GoalStateEntry,
 	type GoalStatus,
 	type StopReason,
+	type GoalTask,
 	type GoalTaskList,
 } from "./goal-record.ts";
 import {
@@ -115,6 +118,11 @@ import {
 	validateGoalAbort,
 	validateGoalCompletion,
 	validatePauseGoal,
+	checkSubtasksComplete,
+	findSubtaskDepthViolation,
+	findTaskInTree,
+	skipAllSubtasks,
+	updateTaskInTree,
 	validateResumeGoal,
 	validateTaskCompletion,
 	validateTaskListProposal,
@@ -187,12 +195,18 @@ function detailedSummary(goal: GoalRecord | null): string {
 		lines.push("Mode: Sisyphus (prompt/criteria variant; shared goal lifecycle)");
 	}
 	if (goal.taskList) {
-		const total = goal.taskList.tasks.length;
-		const pending = goal.taskList.tasks.filter((t) => t.status === "pending");
 		const taskSummary = buildTaskSummary(goal.taskList);
 		lines.push(`Tasks: ${taskSummary}`);
-		if (pending.length > 0) {
-			lines.push(`Next pending task: ${pending[0]!.id} — ${pending[0]!.title}`);
+		// Find first pending task at any depth (BFS)
+		const queue = [...(goal.taskList.tasks ?? [])];
+		let firstPending: { id: string; title: string } | undefined;
+		while (queue.length > 0 && !firstPending) {
+			const t = queue.shift()!;
+			if (t.status === "pending") firstPending = t;
+			else if (t.subtasks) queue.push(...t.subtasks);
+		}
+		if (firstPending) {
+			lines.push(`Next pending task: ${firstPending.id} — ${firstPending.title}`);
 		}
 	}
 	if (goal.activePath) lines.push(`File: ${goal.activePath}`);
@@ -785,6 +799,7 @@ export default function goalExtension(pi: ExtensionAPI): void {
 							getGoal: () => goalForDisplay() ?? state.goal,
 							getOpenGoalCount: () => openGoals().length,
 							getAuditorProgress: () => auditProgress,
+							getSettings: () => loadGoalSettings(ctx.cwd),
 						});
 						return goalWidgetComponent;
 					},
@@ -812,6 +827,7 @@ export default function goalExtension(pi: ExtensionAPI): void {
 						getGoal: () => goalForDisplay() ?? state.goal,
 						getOpenGoalCount: () => openGoals().length,
 						getAuditorProgress: () => auditProgress,
+						getSettings: () => loadGoalSettings(ctx.cwd),
 					});
 					return goalWidgetComponent;
 				},
@@ -977,10 +993,11 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			return;
 		}
 		continuationQueuedFor = goalId;
+		const settings = loadGoalSettings(ctx.cwd);
 		pi.sendMessage<GoalEventDetails>(
 			{
 				customType: GOAL_EVENT_ENTRY,
-				content: continuationPrompt(state.goal),
+				content: continuationPrompt(state.goal, settings),
 				display: false,
 				details: {
 					kind: "checkpoint",
@@ -1622,6 +1639,13 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			objective: Type.String({ description: "Full goal text. For Sisyphus goals this MUST include the user's numbered steps + per-step done criteria, taken faithfully from the user's input." }),
 			autoContinue: Type.Optional(Type.Boolean({ description: "Whether pi should keep sending continuation prompts until complete. Default true." })),
 			sisyphus: Type.Optional(Type.Boolean({ description: "Must equal true for /sisyphus discussion, false for /goals discussion. Schema-enforced via B1 gate." })),
+			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 confirm together with the goal in a single step. Each task supports recursive subtasks." })),
 			draftId: Type.Optional(Type.String({ description: "Deprecated compatibility field. It is accepted but ignored; current goal confirmation no longer depends on hidden draft ids." })),
 		}),
 		executionMode: "sequential",
@@ -1650,10 +1674,55 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			const objective = validation.objective;
 			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) {
+				tasksToCreate = params.tasks.map((t) => {
+					const task: GoalTask = {
+						id: (t as Record<string, unknown>).id as string,
+						title: (t as Record<string, unknown>).title as string,
+						status: "pending",
+						verificationContract: (t as Record<string, unknown>).verificationContract as string | undefined,
+						lightweightSubtasks: (t as Record<string, unknown>).lightweightSubtasks === true ? true : undefined,
+					};
+					const rawSubtasks = (t as Record<string, unknown>).subtasks;
+					if (Array.isArray(rawSubtasks) && rawSubtasks.length > 0) {
+						task.subtasks = rawSubtasks.map((s) => normalizeTaskItem(s as Record<string, unknown>)).filter((s): s is GoalTask => !!s);
+					}
+					return task;
+				});
+				// Validate subtask depth BEFORE showing dialog (consistent with propose_task_list)
+				const settings = loadGoalSettings(ctx.cwd);
+				const depthViolation = findSubtaskDepthViolation(tasksToCreate, settings.subtaskDepth ?? 1);
+				if (depthViolation) {
+					return {
+						content: [{ type: "text", text: depthViolation }],
+						details: goalDetails(state.goal),
+					};
+				}
+				const taskLines = renderConfirmationTasks(tasksToCreate, 0);
+				taskSummarySection = `\n\n┌─ TASKS ─────────────────────────────────────┐\n${taskLines.join("\n")}\n└──────────────────────────────────────────────┘`;
+			}
+
 			const draftSummary = buildDraftConfirmationText({
 				focus: activeIntent.focus,
 				originalTopic: activeIntent.originalTopic,
-				objective,
+				objective: objective + taskSummarySection,
 				autoContinue: autoContinueFlag,
 			});
 
@@ -1687,6 +1756,36 @@ export default function goalExtension(pi: ExtensionAPI): void {
 				};
 				confirmationIntent = null;
 				replaceGoal(config, ctx, false, verificationContract);
+
+				// Set task list if provided
+				if (tasksToCreate && tasksToCreate.length > 0 && state.goal) {
+					const now = nowIso();
+					state.goal = {
+						...state.goal,
+						taskList: {
+							tasks: tasksToCreate,
+							blockCompletion: false,
+							proposedAt: now,
+						},
+						updatedAt: now,
+					};
+					setGoal(state.goal, ctx);
+					// Append ledger event for task list
+					try {
+						appendGoalEvent(ctx, {
+							type: "task_list_set",
+							goalId: state.goal.id,
+							taskCount: tasksToCreate.length,
+							blockCompletion: false,
+							at: now,
+						});
+					} catch {
+						// Ledger failure should not block creation
+					}
+					syncGoalTools();
+					updateUI(ctx);
+				}
+
 				syncGoalTools();
 				return {
 					content: [{ type: "text", text: buildGoalCreatedReport({ objective, detailedSummary: detailedSummary(state.goal) }) }],
@@ -1902,25 +2001,30 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			if (!state.goal) throw new Error("Goal disappeared during completion validation.");
 
 			// Task gate: warn if blockCompletion is enabled and tasks remain pending
-			const taskWarning = state.goal.taskList ? taskCompletionBlockWarning(state.goal.taskList) : null;
-			const taskSummaryText = state.goal.taskList ? buildTaskSummary(state.goal.taskList) : null;
-			if (taskWarning) {
-				return {
-					content: [{ type: "text", text: taskWarning }],
-					details: goalDetails(state.goal),
-				};
+			const disableTasksSettings = loadGoalSettings(ctx.cwd).disableTasks;
+			if (!disableTasksSettings) {
+				const taskWarning = state.goal.taskList ? taskCompletionBlockWarning(state.goal.taskList) : null;
+				if (taskWarning) {
+					return {
+						content: [{ type: "text", text: taskWarning }],
+						details: goalDetails(state.goal),
+					};
+				}
 			}
 
 			// Verification contract gate: if the goal has a contract, verificationSummary must be non-empty
-			const contractGate = validateVerificationSummary({
-				verificationContract: state.goal.verificationContract,
-				verificationSummary: params.verificationSummary,
-			});
-			if (!contractGate.ok) {
-				return {
-					content: [{ type: "text", text: contractGate.message }],
-					details: goalDetails(state.goal),
-				};
+			const disableContractsSettings = loadGoalSettings(ctx.cwd).disableContracts;
+			if (!disableContractsSettings) {
+				const contractGate = validateVerificationSummary({
+					verificationContract: state.goal.verificationContract,
+					verificationSummary: params.verificationSummary,
+				});
+				if (!contractGate.ok) {
+					return {
+						content: [{ type: "text", text: contractGate.message }],
+						details: goalDetails(state.goal),
+					};
+				}
 			}
 
 			const auditTarget = mergeGoalPromptFromDisk(ctx, state.goal);
@@ -2061,6 +2165,7 @@ export default function goalExtension(pi: ExtensionAPI): void {
 				completionSummary: params.completionSummary,
 				detailedSummary: detailedSummary(auditTarget),
 				verificationSummary: params.verificationSummary,
+				settings: loadGoalSettings(ctx.cwd),
 				signal: auditAbortController.signal,
 				onProgress: (progress) => {
 					auditProgress = {
@@ -2397,7 +2502,9 @@ export default function goalExtension(pi: ExtensionAPI): void {
 				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 — what evidence is required before marking it complete." })),
-			}), { description: "Array of task objects with id and title" }),
+				lightweightSubtasks: Type.Optional(Type.Boolean({ description: "If true, subtasks are lightweight (no completion enforcement). Default false (full subtasks)." })),
+				subtasks: Type.Optional(Type.Any({ description: "Optional recursive array of sub-tasks (same shape as parent). Nested up to subtaskDepth (default 1, from .pi/goal-settings.json)." })),
+			}), { description: "Array of task objects with id, title, optional subtasks" }),
 			blockCompletion: Type.Optional(Type.Boolean({ description: "If true, warns when pending tasks remain during complete_goal. Default false." })),
 			changeSummary: Type.Optional(Type.String({ description: "Optional summary of the task list proposal" })),
 		}),
@@ -2410,7 +2517,15 @@ export default function goalExtension(pi: ExtensionAPI): void {
 					details: goalDetails(state.goal),
 				};
 			}
-			const gate = validateTaskListProposal({ goal: state.goal, tasks: params.tasks });
+			// Reject if task lists are disabled via settings
+			if (loadGoalSettings(ctx.cwd).disableTasks) {
+				return {
+					content: [{ type: "text", text: "propose_task_list is disabled by .pi/goal-settings.json (disableTasks: true)." }],
+					details: goalDetails(state.goal),
+				};
+			}
+			const settings = loadGoalSettings(ctx.cwd);
+			const gate = validateTaskListProposal({ goal: state.goal, tasks: params.tasks as GoalTask[], maxSubtaskDepth: settings.subtaskDepth });
 			if (!gate.ok) {
 				return {
 					content: [{ type: "text", text: gate.message }],
@@ -2420,25 +2535,31 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			const blockCompletion = params.blockCompletion === true;
 			const now = nowIso();
 			const existingTasks = state.goal.taskList?.tasks ?? [];
+			const existingById = new Map(existingTasks.map((t) => [t.id, t]));
 
 			// Merge: existing tasks with matching IDs preserve status/timestamps
-			const existingById = new Map(existingTasks.map((t) => [t.id, t]));
-			const mergedTasks = params.tasks.map((p) => {
-				const existing = existingById.get(p.id);
-				if (existing) {
-					return {
+			function mergeTask(input: GoalTask): GoalTask {
+				const existing = existingById.get(input.id);
+				const base: GoalTask = existing
+					? {
 						...existing,
-						title: p.title,
-						verificationContract: p.verificationContract ?? existing.verificationContract,
+						title: input.title,
+						verificationContract: input.verificationContract ?? existing.verificationContract,
+						lightweightSubtasks: input.lightweightSubtasks ?? existing.lightweightSubtasks,
+					}
+					: {
+						id: input.id,
+						title: input.title,
+						status: "pending" as const,
+						verificationContract: input.verificationContract || undefined,
+						lightweightSubtasks: input.lightweightSubtasks || undefined,
 					};
+				if (input.subtasks && input.subtasks.length > 0) {
+					base.subtasks = input.subtasks.map((child) => mergeTask(child));
 				}
-				return {
-					id: p.id,
-					title: p.title,
-					status: "pending" as const,
-					verificationContract: p.verificationContract || undefined,
-				};
-			});
+				return base;
+			}
+			const mergedTasks = params.tasks.map((p) => mergeTask(p as GoalTask));
 
 			const taskList: GoalTaskList = {
 				tasks: mergedTasks,
@@ -2446,11 +2567,21 @@ export default function goalExtension(pi: ExtensionAPI): void {
 				proposedAt: now,
 			};
 
-			// Show full proposed task list in confirmation dialog
-			const taskLines = taskList.tasks.map((t) => {
-				const marker = t.status === "complete" ? "[x]" : t.status === "skipped" ? "[~]" : "[ ]";
-				return `  ${marker} ${t.id}: ${t.title}`;
-			});
+			// Show full proposed task list in confirmation dialog (with subtasks)
+			function renderTaskLines(tasks: GoalTask[], indent = 0): string[] {
+				const prefix = "  ".repeat(indent);
+				const lines: string[] = [];
+				for (const t of tasks) {
+					const marker = t.status === "complete" ? "[x]" : t.status === "skipped" ? "[~]" : "[ ]";
+					const lw = t.lightweightSubtasks ? " (lightweight)" : "";
+					lines.push(`${prefix}${marker} ${t.id}: ${t.title}${lw}`);
+					if (t.subtasks && t.subtasks.length > 0) {
+						lines.push(...renderTaskLines(t.subtasks, indent + 1));
+					}
+				}
+				return lines;
+			}
+			const taskLines = renderTaskLines(taskList.tasks);
 			const gateLabel = blockCompletion ? " (blockCompletion enabled)" : "";
 			const proposalText = [`Proposed task list${gateLabel}:`, "", ...taskLines].join("\n");
 
@@ -2524,6 +2655,12 @@ export default function goalExtension(pi: ExtensionAPI): void {
 		executionMode: "sequential",
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
 			reconcileFocusedGoalFromDisk(ctx);
+			if (loadGoalSettings(ctx.cwd).disableTasks) {
+				return {
+					content: [{ type: "text", text: "complete_task is disabled by .pi/goal-settings.json (disableTasks: true)." }],
+					details: goalDetails(state.goal),
+				};
+			}
 			const gate = validateTaskCompletion({ goal: state.goal, taskId: params.taskId });
 			if (!gate.ok) {
 				return {
@@ -2533,24 +2670,41 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			}
 			if (!state.goal?.taskList) throw new Error("Task list disappeared during task completion.");
 
-			// Check verification contract for the task
-			const taskToComplete = state.goal.taskList.tasks.find((t) => t.id === params.taskId);
-			const contractGate = validateVerificationSummary({
-				verificationContract: taskToComplete?.verificationContract,
-				verificationSummary: params.verificationSummary,
-			});
-			if (!contractGate.ok) {
-				return {
-					content: [{ type: "text", text: contractGate.message }],
-					details: goalDetails(state.goal),
-				};
+			// Check verification contract for the task (skip if contracts disabled)
+			const settings = loadGoalSettings(ctx.cwd);
+			const taskToComplete = findTaskInTree(state.goal.taskList.tasks, params.taskId);
+			if (!settings.disableContracts) {
+				const contractGate = validateVerificationSummary({
+					verificationContract: taskToComplete?.verificationContract,
+					verificationSummary: params.verificationSummary,
+				});
+				if (!contractGate.ok) {
+					return {
+						content: [{ type: "text", text: contractGate.message }],
+						details: goalDetails(state.goal),
+					};
+				}
 			}
+
+			// Check subtask completion (full subtasks only)
+			if (taskToComplete) {
+				const subtaskGate = checkSubtasksComplete(taskToComplete);
+				if (subtaskGate) {
+					return {
+						content: [{ type: "text", text: subtaskGate }],
+						details: goalDetails(state.goal),
+					};
+				}
+			}
+
 			const now = nowIso();
 			const evidence = params.evidence?.trim().slice(0, 200) || undefined;
-			const updatedTasks = state.goal.taskList.tasks.map((t) => {
-				if (t.id !== params.taskId) return t;
-				return { ...t, status: "complete" as const, completedAt: now, evidence };
-			});
+			const updatedTasks = updateTaskInTree(state.goal.taskList.tasks, params.taskId, (t) => ({
+				...t,
+				status: "complete" as const,
+				completedAt: now,
+				evidence,
+			}));
 			state.goal = mergeGoalPromptFromDisk(ctx, state.goal);
 			if (!state.goal || !state.goal.taskList) throw new Error("Goal disappeared during task completion.");
 			state.goal = {
@@ -2606,6 +2760,12 @@ export default function goalExtension(pi: ExtensionAPI): void {
 		executionMode: "sequential",
 		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
 			reconcileFocusedGoalFromDisk(ctx);
+			if (loadGoalSettings(ctx.cwd).disableTasks) {
+				return {
+					content: [{ type: "text", text: "skip_task is disabled by .pi/goal-settings.json (disableTasks: true)." }],
+					details: goalDetails(state.goal),
+				};
+			}
 			const gate = validateTaskSkip({ goal: state.goal, taskId: params.taskId, reason: params.reason });
 			if (!gate.ok) {
 				return {
@@ -2615,9 +2775,13 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			}
 			if (!state.goal?.taskList) throw new Error("Task list disappeared during task skip.");
 			const now = nowIso();
-			const updatedTasks = state.goal.taskList.tasks.map((t) => {
-				if (t.id !== params.taskId) return t;
-				return { ...t, status: "skipped" as const, skippedAt: now, skipReason: params.reason.trim() };
+			const updatedTasks = updateTaskInTree(state.goal.taskList.tasks, params.taskId, (t) => {
+				// Cascade skip to all subtasks (full subtasks only)
+				const base = { ...t, status: "skipped" as const, skippedAt: now, skipReason: params.reason.trim() };
+				if (t.subtasks && t.subtasks.length > 0 && !t.lightweightSubtasks) {
+					return skipAllSubtasks(base, now, params.reason.trim());
+				}
+				return base;
 			});
 			state.goal = mergeGoalPromptFromDisk(ctx, state.goal);
 			if (!state.goal || !state.goal.taskList) throw new Error("Goal disappeared during task skip.");
@@ -2921,7 +3085,8 @@ export default function goalExtension(pi: ExtensionAPI): void {
 			};
 		}
 		const activeGoal = state.goal;
-		let prompt = goalPrompt(activeGoal);
+		const settings = loadGoalSettings(ctx.cwd);
+		let prompt = goalPrompt(activeGoal, settings);
 		// Inject durable auditor feedback if the latest result was a rejection
 		try {
 			const ledger = readGoalLedger(ctx);

package/extensions/prompts/goal-prompts.ts

@@ -3,7 +3,8 @@ import {
 	truncateText,
 } from "../goal-core.ts";
 import { promptSafeObjective } from "../goal-draft.ts";
-import type { GoalRecord, TaskStatus } from "../goal-record.ts";
+import type { GoalRecord, GoalTask, TaskStatus } from "../goal-record.ts";
+import type { GoalSettings } from "../goal-settings.ts";
 
 function taskMarker(status: TaskStatus): string {
 	if (status === "complete") return "[x]";
@@ -11,23 +12,55 @@ function taskMarker(status: TaskStatus): string {
 	return "[ ]";
 }
 
-export function taskListBlock(goal: GoalRecord): string {
-	if (!goal.taskList || goal.taskList.tasks.length === 0) return "";
-	const total = goal.taskList.tasks.length;
-	const complete = goal.taskList.tasks.filter((t) => t.status === "complete").length;
-	const skipped = goal.taskList.tasks.filter((t) => t.status === "skipped").length;
-	const pending = goal.taskList.tasks.filter((t) => t.status === "pending");
+/** Count tasks in subtree recursively */
+function countSubtree(tasks: GoalTask[]): { total: number; complete: number; skipped: number; pending: GoalTask[] } {
+	let total = 0;
+	let complete = 0;
+	let skipped = 0;
+	const pending: GoalTask[] = [];
+	for (const t of tasks) {
+		total++;
+		if (t.status === "complete") complete++;
+		else if (t.status === "skipped") skipped++;
+		else pending.push(t);
+		if (t.subtasks && t.subtasks.length > 0) {
+			const child = countSubtree(t.subtasks);
+			total += child.total;
+			complete += child.complete;
+			skipped += child.skipped;
+			pending.push(...child.pending);
+		}
+	}
+	return { total, complete, skipped, pending };
+}
+
+/** Render task subtree recursively */
+function renderTaskTree(tasks: GoalTask[], indent: number): string[] {
+	const prefix = "  ".repeat(indent);
 	const lines: string[] = [];
-	lines.push(`[TASK LIST — ${complete}/${total} tasks complete${skipped > 0 ? ` (${skipped} skipped)` : ""}]`);
-	for (const task of goal.taskList.tasks) {
+	for (const task of tasks) {
 		let suffix = "";
 		if (task.status === "complete" && task.evidence) suffix = ` — ${task.evidence}`;
 		if (task.status === "skipped" && task.skipReason) suffix = ` — skipped: ${task.skipReason}`;
-		lines.push(`  ${taskMarker(task.status)} ${task.id}: ${task.title}${suffix}`);
-		if ((task.status === "pending") && task.verificationContract) {
-			lines.push(`    contract: ${task.verificationContract}`);
+		const lw = task.lightweightSubtasks ? " (lightweight)" : "";
+		lines.push(`${prefix}${taskMarker(task.status)} ${task.id}: ${task.title}${lw}${suffix}`);
+		if (task.status === "pending" && task.verificationContract) {
+			lines.push(`${prefix}  contract: ${task.verificationContract}`);
+		}
+		if (task.subtasks && task.subtasks.length > 0) {
+			lines.push(...renderTaskTree(task.subtasks, indent + 1));
 		}
 	}
+	return lines;
+}
+
+export function taskListBlock(goal: GoalRecord, settings?: GoalSettings): string {
+	if (settings?.disableTasks) return "";
+	if (!goal.taskList || goal.taskList.tasks.length === 0) return "";
+	const { total, complete, skipped, pending } = countSubtree(goal.taskList.tasks);
+	const lines: string[] = [];
+	lines.push(`[TASK LIST — ${complete}/${total} tasks complete${skipped > 0 ? ` (${skipped} skipped)` : ""}]`);
+	lines.push(...renderTaskTree(goal.taskList.tasks, 0));
 	if (goal.taskList.blockCompletion && pending.length > 0) {
 		lines.push(`  TASK GATE: do not call complete_goal while tasks remain in [ ] pending state`);
 	}
@@ -41,7 +74,8 @@ export function taskListBlock(goal: GoalRecord): string {
  * Render a VERIFICATION CONTRACT section for the agent's prompts.
  * This is shown when the goal has a verificationContract defined.
  */
-export function verificationContractBlock(goal: GoalRecord): string {
+export function verificationContractBlock(goal: GoalRecord, settings?: GoalSettings): string {
+	if (settings?.disableContracts) return "";
 	if (!goal.verificationContract?.trim()) return "";
 	return [
 		"",
@@ -84,10 +118,10 @@ export function sisyphusDisciplineBlock(goal: GoalRecord): string {
 	].join("\n");
 }
 
-export function goalPrompt(goal: GoalRecord): string {
-	const taskBlock = taskListBlock(goal);
+export function goalPrompt(goal: GoalRecord, settings?: GoalSettings): string {
+	const taskBlock = taskListBlock(goal, settings);
 	const taskInjection = taskBlock ? `\n${taskBlock}` : "";
-	const contractBlock = verificationContractBlock(goal);
+	const contractBlock = verificationContractBlock(goal, settings);
 	const contractInjection = contractBlock ? `\n${contractBlock}` : "";
 	return `[PI GOAL ACTIVE goalId=${goal.id}]${taskInjection}${contractInjection}
 Status: ${statusLabel(goal)}
@@ -117,9 +151,9 @@ Do NOT silently invent workarounds, fake completion, or quietly redefine the obj
 Goal evolution: if the user gives requirements, feedback, or corrections that differ from the goal objective, the goal is stale. The goal objective is immutable — the agent must NOT modify it autonomously. Propose the updated objective concisely and ask the user to run /goal-tweak to revise it. Do NOT mark the goal complete with a stale objective.${sisyphusDisciplineBlock(goal) ? `\n${sisyphusDisciplineBlock(goal)}` : ""}`;
 }
 
-export function continuationPrompt(goal: GoalRecord): string {
-	const taskBlock = taskListBlock(goal);
-	const contractBlock = verificationContractBlock(goal);
+export function continuationPrompt(goal: GoalRecord, settings?: GoalSettings): string {
+	const taskBlock = taskListBlock(goal, settings);
+	const contractBlock = verificationContractBlock(goal, settings);
 	return [
 		// Phase 5 C1: structured outer marker (pi-codex-goal pattern).
 		`<pi_goal_continuation goal_id="${goal.id}" kind="checkpoint">`,

package/extensions/widgets/goal-widget.ts

@@ -8,7 +8,8 @@ import {
 	truncateText,
 	type GoalDisplayRecordLike,
 } from "../goal-core.ts";
-import type { GoalTaskList, TaskStatus } from "../goal-record.ts";
+import type { GoalTask, GoalTaskList, TaskStatus } from "../goal-record.ts";
+import type { GoalSettings } from "../goal-settings.ts";
 
 type GoalWidgetColor = Extract<ThemeColor, "accent" | "warning" | "success" | "error" | "dim" | "muted" | "text">;
 
@@ -17,7 +18,7 @@ export interface GoalWidgetRecord extends GoalDisplayRecordLike {
 	archivedPath?: string | null;
 	pauseReason?: string;
 	pauseSuggestedAction?: string;
-	taskList?: { tasks: Array<{ id: string; title: string; status: TaskStatus }>; blockCompletion: boolean } | null;
+	taskList?: GoalTaskList | null;
 }
 
 export interface AuditorWidgetProgress {
@@ -39,6 +40,7 @@ export interface GoalWidgetOptions {
 	getGoal: () => GoalWidgetRecord | null;
 	getOpenGoalCount?: () => number;
 	getAuditorProgress?: () => AuditorWidgetProgress | null;
+	getSettings?: () => GoalSettings;
 }
 
 function fit(value: string, width: number): string {
@@ -75,14 +77,38 @@ function displayIcon(goal: GoalWidgetRecord): { icon: string; color: GoalWidgetC
 	return goal.autoContinue ? { icon: "●", color: "accent", label: "goal running" } : { icon: "○", color: "muted", label: "goal idle" };
 }
 
-function headingMeta(goal: GoalWidgetRecord, otherOpenGoalCount = 0): string {
+function countFlatTasks(tasks: GoalTask[]): { total: number; done: number } {
+	let total = 0;
+	let done = 0;
+	for (const t of tasks) {
+		total++;
+		if (t.status === "complete" || t.status === "skipped") done++;
+		if (t.subtasks && t.subtasks.length > 0) {
+			const child = countFlatTasks(t.subtasks);
+			total += child.total;
+			done += child.done;
+		}
+	}
+	return { total, done };
+}
+
+function findFirstPending(tasks: GoalTask[]): GoalTask | undefined {
+	const queue = [...tasks];
+	while (queue.length > 0) {
+		const t = queue.shift()!;
+		if (t.status === "pending") return t;
+		if (t.subtasks) queue.push(...t.subtasks);
+	}
+	return undefined;
+}
+
+function headingMeta(goal: GoalWidgetRecord, otherOpenGoalCount = 0, disableTasks = false): string {
 	const bits: string[] = [];
 	if (goal.status === "active" && goal.autoContinue) bits.push("auto");
 	if (goal.usage.activeSeconds > 0) bits.push(formatDuration(goal.usage.activeSeconds));
 	if (goal.usage.tokensUsed > 0) bits.push(formatTokenValue(goal.usage.tokensUsed));
-	if (goal.taskList && goal.taskList.tasks.length > 0) {
-		const total = goal.taskList.tasks.length;
-		const done = goal.taskList.tasks.filter((t) => t.status === "complete" || t.status === "skipped").length;
+	if (!disableTasks && goal.taskList && goal.taskList.tasks.length > 0) {
+		const { total, done } = countFlatTasks(goal.taskList.tasks);
 		bits.push(`${done}/${total} tasks`);
 	}
 	if (otherOpenGoalCount > 0) bits.push(`+${otherOpenGoalCount} open`);
@@ -190,7 +216,7 @@ export function renderAuditorWidgetLines(progress: AuditorWidgetProgress, theme:
 	return lines;
 }
 
-export function renderGoalWidgetLines(goal: GoalWidgetRecord | null, theme: Theme, width: number, options: { openGoalCount?: number; auditorProgress?: AuditorWidgetProgress | null } = {}): string[] {
+export function renderGoalWidgetLines(goal: GoalWidgetRecord | null, theme: Theme, width: number, options: { openGoalCount?: number; auditorProgress?: AuditorWidgetProgress | null; disableTasks?: boolean } = {}): string[] {
 	// When auditor progress is active, show auditor display instead of normal goal widget
 	if (options.auditorProgress) {
 		return renderAuditorWidgetLines(options.auditorProgress, theme, width);
@@ -209,7 +235,7 @@ export function renderGoalWidgetLines(goal: GoalWidgetRecord | null, theme: Them
 	const mode = goal.sisyphus ? "Sisyphus" : "Goal";
 	const headingLeft = `${theme.fg(color, icon)} ${theme.fg(color, theme.bold(mode))} ${theme.fg("muted", label.replace(/^sisyphus |^goal /, ""))}`;
 	const otherOpenGoalCount = Math.max(0, (options.openGoalCount ?? (goal ? 1 : 0)) - 1);
-	const headingRight = theme.fg("muted", headingMeta(goal, otherOpenGoalCount));
+	const headingRight = theme.fg("muted", headingMeta(goal, otherOpenGoalCount, options.disableTasks));
 	const lines: string[] = [heading(theme, safeWidth, headingLeft, headingRight)];
 	const body: string[] = [];
 
@@ -217,14 +243,15 @@ export function renderGoalWidgetLines(goal: GoalWidgetRecord | null, theme: Them
 	const objective = truncateText(displayObjectiveTitle(goal.objective), titleWidth);
 	body.push(`${theme.fg("accent", "⟡")} ${theme.fg("text", objective)}`);
 
-	if (goal.taskList && goal.taskList.tasks.length > 0) {
-		const total = goal.taskList.tasks.length;
-		const done = goal.taskList.tasks.filter((t) => t.status === "complete" || t.status === "skipped").length;
-		const pending = goal.taskList.tasks.filter((t) => t.status === "pending");
+	if (!options.disableTasks && goal.taskList && goal.taskList.tasks.length > 0) {
+		const { total, done } = countFlatTasks(goal.taskList.tasks);
 		if (done === total) {
 			body.push(`${theme.fg("success", "✓")} ${theme.fg("muted", "All tasks complete")}`);
-		} else if (pending.length > 0) {
-			body.push(`${theme.fg("warning", "◻")} ${theme.fg("muted", `${pending[0]!.id}: ${truncateText(pending[0]!.title, Math.max(8, safeWidth - 20))} (next)`)}`);
+		} else {
+			const firstPending = findFirstPending(goal.taskList.tasks);
+			if (firstPending) {
+				body.push(`${theme.fg("warning", "◻")} ${theme.fg("muted", `${firstPending.id}: ${truncateText(firstPending.title, Math.max(8, safeWidth - 20))} (next)`)}`);
+			}
 		}
 	}
 
@@ -254,12 +281,15 @@ export class GoalWidgetComponent implements Component {
 	private getOpenGoalCount: () => number;
 	private getAuditorProgress: () => AuditorWidgetProgress | null;
 
+	private getSettings: () => GoalSettings;
+
 	constructor(options: GoalWidgetOptions) {
 		this.theme = options.theme;
 		this.tui = options.tui;
 		this.getGoal = options.getGoal;
 		this.getOpenGoalCount = options.getOpenGoalCount ?? (() => (this.getGoal() ? 1 : 0));
 		this.getAuditorProgress = options.getAuditorProgress ?? (() => null);
+		this.getSettings = options.getSettings ?? (() => ({}));
 	}
 
 	update(): void {
@@ -267,9 +297,11 @@ export class GoalWidgetComponent implements Component {
 	}
 
 	render(width: number): string[] {
+		const settings = this.getSettings();
 		return renderGoalWidgetLines(this.getGoal(), this.theme, width, {
 			openGoalCount: this.getOpenGoalCount(),
 			auditorProgress: this.getAuditorProgress(),
+			disableTasks: settings.disableTasks,
 		});
 	}
 

package/package.json

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