pi-goal-x 0.31.8 → 0.32.0

package/README.md

@@ -6,19 +6,21 @@
   <a href="https://pi.dev/packages?type=extension" target="_blank" rel="noopener noreferrer">
     <picture>
       <source media="(prefers-color-scheme: dark)" srcset="assets/badge-dark.svg">
-      <img src="assets/badge-light.svg" alt="TOP 0.3% of Pi coding agent extensions: #7 of 3,275 by downloads · Sep 22, 2026 (best recorded rank)" width="480">
+      <img src="assets/badge-light.svg" alt="TOP 0.2% of Pi coding agent extensions: #6 of 3,258 by downloads · Oct 1, 2026 (best recorded rank)" width="480">
     </picture>
   </a>
 </div>
 
 # pi-goal-x
 
-Adds `/goal` functionality to [pi](https://github.com/earendil-works/pi-coding-agent). The agent helps you define a goal and plan, continues working on it automatically, and submits the result to an optional independent completion auditor.
+Adds `/goal` functionality to [pi](https://pi.dev). The agent helps you define a goal and plan, continues working on it automatically, and submits the result to an optional independent completion auditor.
 
 The extension saves goal objectives, tasks, and progress across sessions. You can pause, resume, revise, or switch goals as your work changes.
 
 ## Install
 
+Supports pi 0.83 through 1.x (`@earendil-works/pi-ai`, `pi-coding-agent`, and `pi-tui` `>=0.83.0 <2.0.0`), developed and verified against 1.0.0.
+
 ```bash
 pi install npm:pi-goal-x
 ```
@@ -117,6 +119,7 @@ Open `/goal-settings` to change these options. You can save defaults for all pro
 | --- | --- |
 | Explicit execution contracts (`strictExecutionContract`) | Opt-in ready/wait protocol with one missing-decision repair, then pause. Defaults to `false`: successful executions continue automatically. |
 | Autonomous run allowance (`maxAutonomousRuns`) | Positive whole number of extension-started runs per creation or `/goal-resume` period. **Unset means unlimited; zero disables automatic continuation.** Settings edits change the limit without resetting usage. |
+| Autonomous runs line (`showAutonomousRuns`) | Controls the `Autonomous runs: N/limit` line that appears for a finite allowance. Defaults to `true`. |
 | Task tracking (`disableTasks`) | Turn task lists on or off. Set to `true` to disable them. |
 | Subtask depth (`subtaskDepth`) | Limit how many levels of subtasks the agent can create. |
 | Completion requirements (`disableContracts`) | Turn explicit goal and task completion requirements on or off. Set to `true` to disable them. |

package/assets/badge-dark.svg

@@ -1,4 +1,4 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="480" height="54" viewBox="0 0 480 54" role="img" aria-label="TOP 0.3% of Pi coding agent extensions: #7 of 3,275 by downloads · Sep 22, 2026 (best recorded rank)">
+<svg xmlns="http://www.w3.org/2000/svg" width="480" height="54" viewBox="0 0 480 54" role="img" aria-label="TOP 0.2% of Pi coding agent extensions: #6 of 3,258 by downloads · Oct 1, 2026 (best recorded rank)">
   <!-- Dark mode -->
   <style>
     .frame { fill: #14181f; stroke: #2a3040; stroke-width: 1; }
@@ -10,9 +10,9 @@
   </style>
   <a class="link" href="https://pi.dev/packages?type=extension" target="_blank" rel="noopener noreferrer">
     <rect class="frame" x="0.5" y="0.5" width="479" height="53" rx="6"/>
-    <text class="rank" x="18" y="34">TOP 0.3%</text>
+    <text class="rank" x="18" y="34">TOP 0.2%</text>
     <line class="divider" x1="128" y1="13" x2="128" y2="41"/>
     <text class="label" x="143" y="25">of Pi coding agent extensions</text>
-    <text class="meta" x="143" y="41">#7 of 3,275 by downloads · Sep 22, 2026</text>
+    <text class="meta" x="143" y="41">#6 of 3,258 by downloads · Oct 1, 2026</text>
   </a>
 </svg>

package/assets/badge-light.svg

@@ -1,4 +1,4 @@
-<svg xmlns="http://www.w3.org/2000/svg" width="480" height="54" viewBox="0 0 480 54" role="img" aria-label="TOP 0.3% of Pi coding agent extensions: #7 of 3,275 by downloads · Sep 22, 2026 (best recorded rank)">
+<svg xmlns="http://www.w3.org/2000/svg" width="480" height="54" viewBox="0 0 480 54" role="img" aria-label="TOP 0.2% of Pi coding agent extensions: #6 of 3,258 by downloads · Oct 1, 2026 (best recorded rank)">
   <!-- Light mode -->
   <style>
     .frame { fill: #f6f8fa; stroke: #d0d7de; stroke-width: 1; }
@@ -10,9 +10,9 @@
   </style>
   <a class="link" href="https://pi.dev/packages?type=extension" target="_blank" rel="noopener noreferrer">
     <rect class="frame" x="0.5" y="0.5" width="479" height="53" rx="6"/>
-    <text class="rank" x="18" y="34">TOP 0.3%</text>
+    <text class="rank" x="18" y="34">TOP 0.2%</text>
     <line class="divider" x1="128" y1="13" x2="128" y2="41"/>
     <text class="label" x="143" y="25">of Pi coding agent extensions</text>
-    <text class="meta" x="143" y="41">#7 of 3,275 by downloads · Sep 22, 2026</text>
+    <text class="meta" x="143" y="41">#6 of 3,258 by downloads · Oct 1, 2026</text>
   </a>
 </svg>

package/docs/advanced-usage.md

@@ -14,12 +14,18 @@ Set an appropriate allowance in `/goal-settings`, or in `.pi/pi-goal-x-settings.
 { "maxAutonomousRuns": 20 }
 ```
 
+The `Autonomous runs: used/limit` line reports a finite allowance and is left out when
+allowance is unlimited. Set `showAutonomousRuns` to `false` to drop it for a finite
+allowance as well; it defaults to `true`.
+
 Agents may edit this setting. Changing it does not replenish consumed runs; explicit `/goal-resume` renews the period and continues now, including from a waiting goal. No configured allowance is required unless the effective limit is zero, which disables resume. Tool calls within a run are not separate runs. Existing token budgets still apply.
 
-Explicit `ready` is optional in default mode. New `wait` declarations require strict mode; otherwise they return a non-terminating error. Previously saved waits retain their deadline, checks, and repair rules when upgrading or disabling strict mode, and may be re-declared with the same identity. Mode changes never resume a paused goal or renew consumed runs.
+Explicit `ready` is optional in default mode. A goal saved before next actions were
+removed still loads, with its `nextAction` field stripped during normalization.
+New `wait` declarations require strict mode; otherwise they return a non-terminating error. Previously saved waits retain their deadline, checks, and repair rules when upgrading or disabling strict mode, and may be re-declared with the same identity. Mode changes never resume a paused goal or renew consumed runs.
 
 ```js
-update_goal({ continuation: { kind: "ready", next_action: "Verify the build artifacts" } })
+update_goal({ continuation: { kind: "ready" } })
 update_goal({ continuation: {
   kind: "wait", reason: "Await the remote build",
   deadline: "2026-09-15T12:00:00Z",

package/docs/agent-flow-design.md

@@ -302,4 +302,4 @@ per-draft auditor selection), a fully operable settings menu, `/goal-clear`
 confirmation, neutral task-confirmation labels, failure-checked completion
 commits, per-goal revision/lock serialization with typed conflicts, the
 agent-pause outcome, untrusted `completion_summary` claims, the enforced
-experiment matrix, the runner self-check, and the Pi SDK 0.83 family upgrade.
+experiment matrix, the runner self-check, and the Pi SDK 1.0 family upgrade.

package/extensions/goal-commands.ts

@@ -374,6 +374,7 @@ export function registerGoalCommands(core: GoalCore): void {
 		{ key: "disableContracts", label: "disableContracts", section: "Goal behavior", kind: "boolean" },
 		{ key: "strictExecutionContract", label: "explicit execution contracts (opt-in)", section: "Goal behavior", kind: "boolean" },
 		{ key: "maxAutonomousRuns", label: "autonomous run allowance", section: "Goal behavior", kind: "positiveInteger" },
+		{ key: "showAutonomousRuns", label: "show autonomous runs line", section: "Goal behavior", kind: "boolean" },
 		{ key: "stallTimeoutMinutes", label: "stall timeout (minutes)", section: "Goal behavior", kind: "positiveInteger" },
 		{ key: "objectiveMaxChars", label: "max objective length (0 = none)", section: "Goal behavior", kind: "positiveInteger" },
 		{ key: "disableTasks", label: "disableTasks", section: "Task tracking", kind: "boolean" },
@@ -392,7 +393,7 @@ export function registerGoalCommands(core: GoalCore): void {
 	];
 
 	function settingsValue(config: GoalSettings, key: keyof GoalSettings | string): string {
-		if (key === "strictExecutionContract" || key === "disabled" || key === "disableTasks" || key === "disableContracts" || key === "autoSelectSingleGoal" || key === "auditorProjectResources" || key === "hideUnfocusedBanner" || key === "hideUnfocusedPrompt") {
+		if (key === "strictExecutionContract" || key === "disabled" || key === "disableTasks" || key === "disableContracts" || key === "autoSelectSingleGoal" || key === "auditorProjectResources" || key === "hideUnfocusedBanner" || key === "hideUnfocusedPrompt" || key === "showAutonomousRuns") {
 			return config[key] === true ? "true" : "false";
 		}
 		if (key === "subtaskDepth") return config.subtaskDepth !== undefined ? String(config.subtaskDepth) : "1";

package/extensions/goal-core-tools.ts

@@ -87,7 +87,7 @@ pi.registerTool(defineTool({
   }
   if (params.cursor || params.task_id) return {content: [{type: "text", text: "Use section=objective, tasks, or history for detail retrieval; task_id requires tasks."}], details: goalDetails(view)};
 		if (verbose && !params.section) {
-			const lines: string[] = [`Goal ${view.id}: ${statusLabel(view)}, ${view.sisyphus ? "sisyphus" : "regular"}`, schedulerSummary(view.scheduler, loadGoalSettings(ctx.cwd).maxAutonomousRuns)];
+			const lines: string[] = [`Goal ${view.id}: ${statusLabel(view)}, ${view.sisyphus ? "sisyphus" : "regular"}`, schedulerSummary(view.scheduler, loadGoalSettings(ctx.cwd).maxAutonomousRuns, loadGoalSettings(ctx.cwd).showAutonomousRuns)];
 			lines.push(`Objective: ${view.objective}`, "");
 			lines.push(`Status: ${statusLabel(view)}`);
 			lines.push(`Mode: ${view.sisyphus ? "sisyphus" : "regular"}`);
@@ -130,7 +130,7 @@ pi.registerTool(defineTool({
 		}
 
 		// Compact state read; full requirements remain available through detail pages.
-		const lines: string[] = [`Goal ${view.id}: ${statusLabel(view)}, ${view.sisyphus ? "sisyphus" : "regular"}`, schedulerSummary(view.scheduler, loadGoalSettings(ctx.cwd).maxAutonomousRuns)];
+		const lines: string[] = [`Goal ${view.id}: ${statusLabel(view)}, ${view.sisyphus ? "sisyphus" : "regular"}`, schedulerSummary(view.scheduler, loadGoalSettings(ctx.cwd).maxAutonomousRuns, loadGoalSettings(ctx.cwd).showAutonomousRuns)];
 		lines.push(`Objective: ${truncateText(view.objective, 180)}${view.objective.length > 180 ? " (full: get_goal section=objective)" : ""}`);
 		if (view.taskList) {
 			const { findCurrentTask, firstPendingTask } = conciseTaskPointers(view);
@@ -515,7 +515,7 @@ pi.registerTool(defineTool({
 	parameters: Type.Object({
 		status: Type.Optional(StringEnum(["complete", "blocked", "paused"] as const, { description: "Exclusive with continuation." })),
 		continuation: Type.Optional(Type.Union([
-			Type.Object({ kind: Type.Literal("ready"), next_action: Type.String({ minLength: 1, maxLength: 2000 }) }, { additionalProperties: false }),
+			Type.Object({ kind: Type.Literal("ready") }, { additionalProperties: false }),
 			Type.Object({ kind: Type.Literal("wait"), reason: Type.String({ minLength: 1, maxLength: 2000 }), deadline: Type.String(), wait_id: Type.Optional(Type.String()), polling: Type.Optional(Type.Object({ interval_seconds: Type.Integer({ minimum: 1, maximum: 2147483 }), max_checks: Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER }) }, { additionalProperties: false })) }, { additionalProperties: false }),
 		])),
 		reason: Type.Optional(Type.String({ description: "Required when status is paused or blocked: describe the concrete blocker." })),

package/extensions/goal-drafting.ts

@@ -311,6 +311,7 @@ export function registerDraftingTools(core: GoalCore): void {
 		promptGuidelines: [
 			"Use only during a /goal, /sisyphus, or /goal-tweak guided draft.",
 			"Clarify ambiguity before proposing. Include tasks when the work naturally decomposes into trackable milestones; omit them for genuinely simple work.",
+			"Set token_budget only when the user explicitly asked for a token budget or a spend limit. Never invent, estimate, or infer one from the objective's size; omitting it creates a goal with no budget.",
 			"Confirmation creates or revises the goal atomically. Continue Chatting leaves drafting active for refinement.",
 		],
 		parameters: Type.Object({
@@ -490,7 +491,7 @@ export function registerDraftingTools(core: GoalCore): void {
 				// Resume glue mirrors replaceGoal: restart accounting and queue
 				// the auto-continuation so the revived goal keeps going.
 				core.beginAccounting();
-				const scheduling = core.scheduler.declare(ctx, {kind: "ready", next_action: "Continue the goal after the confirmed tweak."});
+				const scheduling = core.scheduler.declare(ctx, {kind: "ready"});
 				if (!scheduling.terminate) schedulingNote = "\n" + scheduling.content.filter(item => item.type === "text").map(item => item.text).join("\n");
 				core.queueContinuation(ctx, true);
 			}

package/extensions/goal-events.ts

@@ -317,6 +317,27 @@ export function registerGoalEvents(core: GoalCore): void {
 		core.queueContinuation(ctx, true);
 	});
 
+	type SessionCompactFailed = { reason: "manual" | "threshold" | "overflow"; errorMessage?: string; aborted: boolean; willRetry: boolean; fromExtension: boolean };
+	// session_compact_failed is new in pi 1.0.0. The supported peer range also
+	// includes 0.83 through 0.87, where this event does not exist and is never
+	// emitted, so the registration is typed loosely enough to compile against
+	// every supported host. On those hosts the handler is simply never called.
+	type CompactFailedOn = (event: "session_compact_failed", handler: (event: SessionCompactFailed, ctx: ExtensionContext) => unknown) => unknown;
+	(pi.on as unknown as CompactFailedOn)("session_compact_failed", async (event, ctx) => {
+		// `session_before_compact` already charged progress to the goal, so
+		// flush the buffered transaction and persist first. Otherwise the goal
+		// record and the ledger can disagree about a compaction that never
+		// happened.
+		core.goalService.flushTurn(ctx);
+		if (core.state.goal) core.persist(ctx);
+		if (event.aborted || !core.state.goal) return;
+		const detail = event.errorMessage ? `: ${event.errorMessage}` : "";
+		ctx.ui.notify(
+			`Goal context compaction failed (${event.reason})${detail}. The goal stays active; retry with /compact or keep working.`,
+			"warning",
+		);
+	});
+
 	pi.on("session_tree", async (_event, ctx) => {
 		core.auditMessages.clear();
 		core.goalService.flushTurn(ctx); // P1-3: persist any buffered transaction before reload

package/extensions/goal-scheduler-state.ts

@@ -17,13 +17,13 @@ export interface GoalSchedulerState {
 	generation: string;
 	used: number;
 	phase: "idle" | "ready" | "waiting" | "claimed" | "running" | "interrupted";
-	decision?: { kind: "ready"; nextAction: string; purpose: GoalDispatchKind } | { kind: "wait" };
+	decision?: { kind: "ready"; purpose: GoalDispatchKind } | { kind: "wait" };
 	wait?: GoalWait;
 	dispatch?: { id: string; kind: GoalDispatchKind; claimedAt: number };
 	repairUsed: boolean;
 }
 export type GoalContinuation =
-	| { kind: "ready"; next_action: string }
+	| { kind: "ready" }
 	| { kind: "wait"; reason: string; deadline: string; wait_id?: string; polling?: { interval_seconds: number; max_checks: number } };
 
 export function newGoalScheduler(owner: string): GoalSchedulerState {
@@ -39,7 +39,10 @@ export function normalizeGoalScheduler(raw: unknown): GoalSchedulerState | undef
 	const integer = (n: unknown) => typeof n === "number" && Number.isSafeInteger(n) && n >= 0;
 	const text = (v: unknown) => typeof v === "string" && v.length > 0 && v.length <= 2000;
 	if (s.version !== 1 || !text(s.owner) || !text(s.generation) || !integer(s.used) || typeof s.repairUsed !== "boolean" || !["idle", "ready", "waiting", "claimed", "running", "interrupted"].includes(s.phase)) return invalid();
-	if (s.decision && (s.decision.kind !== "wait" && (s.decision.kind !== "ready" || !text(s.decision.nextAction) || !["ready", "repair", "kickoff", "recovery"].includes(s.decision.purpose)))) return invalid();
+	// Goals saved before next actions were removed still carry decision.nextAction.
+	// The field is stripped after validation and never makes a goal invalid:
+	// rejecting one would strand it as interrupted with spent allowance.
+	if (s.decision && (s.decision.kind !== "wait" && (s.decision.kind !== "ready" || !["ready", "repair", "kickoff", "recovery"].includes(s.decision.purpose)))) return invalid();
 	if (s.wait) {
 		const w = s.wait;
 		if (!text(w.id) || !text(w.token) || !text(w.reason) || (!integer(w.deadline) || w.deadline > 8_640_000_000_000_000)) return invalid();
@@ -51,7 +54,9 @@ export function normalizeGoalScheduler(raw: unknown): GoalSchedulerState | undef
 	if ((s.phase === "claimed" || s.phase === "running") && !s.dispatch) return invalid();
 	if (s.phase === "ready" && s.decision?.kind !== "ready") return invalid();
 	if (s.phase === "waiting" && (!s.wait || s.decision?.kind !== "wait")) return invalid();
-	return structuredClone(s);
+	const normalized = structuredClone(s) as GoalSchedulerState;
+	if (normalized.decision && "nextAction" in normalized.decision) delete (normalized.decision as Record<string, unknown>).nextAction;
+	return normalized;
 }
 
 /**
@@ -60,11 +65,14 @@ export function normalizeGoalScheduler(raw: unknown): GoalSchedulerState | undef
  * omission, so a retained stale copy would keep issuing a cancelled order:
  * they belong with the reset-on-change state, never with retained counters.
  */
-export function schedulerSummaryParts(s: GoalSchedulerState | undefined, limit?: number): { runs: string; instructions: string } {
-	const runs = `Autonomous runs: ${s?.used ?? 0}/${limit ?? "unlimited"}${limit === 0 ? " (automatic continuation disabled)" : ""}.`;
+export function schedulerSummaryParts(s: GoalSchedulerState | undefined, limit?: number, showRuns = true): { runs: string; instructions: string } {
+	// An unlimited allowance has no limit to report, so the runs line is left
+	// empty rather than rendered as "used/unlimited". A finite allowance is
+	// reported unless showAutonomousRuns is off. Enforcement reads the limit
+	// elsewhere; this is display only.
+	const runs = limit !== undefined && showRuns ? `Autonomous runs: ${s?.used ?? 0}/${limit}${limit === 0 ? " (automatic continuation disabled)" : ""}.` : "";
 	const lines: string[] = [];
 	if (s) {
-		if (s.decision?.kind === "ready") lines.push(`Next action: ${s.decision.nextAction}`);
 		if (s.wait) {
 			lines.push(`Waiting: ${s.wait.reason}; wait_id=${s.wait.id}; deadline=${new Date(s.wait.deadline).toISOString()}.`);
 			if (s.wait.nextCheckAt !== undefined) lines.push(`Next check: ${new Date(s.wait.nextCheckAt).toISOString()}; ${s.wait.remainingChecks} checks remaining.`);
@@ -74,7 +82,7 @@ export function schedulerSummaryParts(s: GoalSchedulerState | undefined, limit?:
 	return { runs, instructions: lines.join("\n") };
 }
 
-export function schedulerSummary(s: GoalSchedulerState | undefined, limit?: number): string {
-	const { runs, instructions } = schedulerSummaryParts(s, limit);
-	return instructions ? `${runs}\n${instructions}` : runs;
+export function schedulerSummary(s: GoalSchedulerState | undefined, limit?: number, showRuns = true): string {
+	const { runs, instructions } = schedulerSummaryParts(s, limit, showRuns);
+	return [runs, instructions].filter(Boolean).join("\n");
 }

package/extensions/goal-scheduler.ts

@@ -26,7 +26,7 @@ export class GoalScheduler {
 	}
 	private implicitReady(s: GoalSchedulerState): void {
 		s.phase = "ready"; s.dispatch = undefined; s.generation = randomUUID();
-		s.decision = { kind: "ready", nextAction: "Continue pursuing the goal, then verify and complete it when satisfied.", purpose: "ready" };
+		s.decision = { kind: "ready", purpose: "ready" };
 	}
 	private available(ctx: ExtensionContext, s: GoalSchedulerState): boolean {
 		const limit = this.limit(ctx);
@@ -123,7 +123,7 @@ export class GoalScheduler {
 			this.write(ctx, g => {
 				if (g.status === "complete" || budgetReached(g)) throw new Error("A completed or token-budget-limited goal cannot resume.");
 				return { ...g, status: "active", autoContinue: true, stopReason: undefined, pauseReason: undefined, pauseSuggestedAction: undefined,
-					scheduler: { ...newGoalScheduler(this.owner(ctx)), phase: "ready", decision: { kind: "ready", nextAction: "Continue the goal at the user's request.", purpose: "kickoff" } } };
+					scheduler: { ...newGoalScheduler(this.owner(ctx)), phase: "ready", decision: { kind: "ready", purpose: "kickoff" } } };
 			});
 			// A resume during host work waits for settlement; another model turn
 			// still invalidates it through turn(), just like a declaration.
@@ -138,7 +138,7 @@ export class GoalScheduler {
 			const goal = this.core.state.goal;
 			if (!goal || goal.status !== "active" || !goal.autoContinue) return;
 			if (this.limit(ctx) === 0) { this.update(ctx, () => {}); ctx.ui.notify(this.allowanceReason(ctx), "info"); return; }
-			this.update(ctx, s => { s.phase = "ready"; s.decision = { kind: "ready", nextAction: "Begin the requested goal.", purpose: "kickoff" }; });
+			this.update(ctx, s => { s.phase = "ready"; s.decision = { kind: "ready", purpose: "kickoff" }; });
 			this.schedule(ctx);
 		});
 	}
@@ -150,8 +150,7 @@ export class GoalScheduler {
 			const goal = this.update(ctx, s => {
 				if (!this.available(ctx, s)) throw new Error(this.allowanceReason(ctx));
 				if (input.kind === "ready") {
-					if (typeof input.next_action !== "string" || !input.next_action.trim() || input.next_action.length > 2000) throw new Error("ready requires a nonempty next_action (at most 2000 characters).");
-					s.phase = "ready"; s.decision = { kind: "ready", nextAction: input.next_action.trim(), purpose: "ready" }; s.wait = undefined;
+					s.phase = "ready"; s.decision = { kind: "ready", purpose: "ready" }; s.wait = undefined;
 				} else if (input.kind === "wait") {
 					if (!this.strict(ctx, s)) throw new Error("New waits require strictExecutionContract=true in /goal-settings. This is a user preference; continue pursuing the goal without a wait unless the user opts in.");
 					if (typeof input.reason !== "string" || !input.reason.trim() || input.reason.length > 2000) throw new Error("wait requires a nonempty reason (at most 2000 characters).");
@@ -177,7 +176,7 @@ export class GoalScheduler {
 			this.declared = true;
 			this.core.runtime.markTurnStopped(goal.id);
 			const wait = goal.scheduler?.wait;
-			return { content: [{ type: "text", text: `Scheduling decision saved. Stop this execution.\n${schedulerSummary(goal.scheduler, this.limit(ctx))}${wait ? `\nWake token: ${wait.token}. Register this token with the producer before completion; adapters must retain early results.` : ""}` }], details: { goal, ...(wait ? { wait_id: wait.id, waitToken: wait.token } : {}) }, terminate: true };
+			return { content: [{ type: "text", text: `Scheduling decision saved. Stop this execution.\n${schedulerSummary(goal.scheduler, this.limit(ctx), loadGoalSettings(ctx.cwd).showAutonomousRuns)}${wait ? `\nWake token: ${wait.token}. Register this token with the producer before completion; adapters must retain early results.` : ""}` }], details: { goal, ...(wait ? { wait_id: wait.id, waitToken: wait.token } : {}) }, terminate: true };
 		} catch (error) { return { content: [{ type: "text", text: `Scheduling decision NOT saved: ${error instanceof Error ? error.message : String(error)}` }], details: { error: true }, terminate: false }; }
 	}
 
@@ -248,14 +247,14 @@ export class GoalScheduler {
 			}
 			this.update(ctx, state => {
 				state.phase = "ready"; state.dispatch = undefined;
-				state.decision = { kind: "ready", nextAction: "The prior execution did not declare a disposition. Declare ready with a concrete next action, wait with a deadline, or complete/pause/block. This is the only repair prompt.", purpose: "repair" };
+				state.decision = { kind: "ready", purpose: "repair" };
 			});
 			this.schedule(ctx);
 		});
 	}
 	recover(ctx: ExtensionContext): void {
 		this.safe(ctx, () => {
-			this.update(ctx, s => { s.phase = "ready"; s.dispatch = undefined; s.decision = { kind: "ready", nextAction: this.strict(ctx, s) ? "Retry after the provider error, then declare an execution disposition." : "Retry after the provider error and continue pursuing the goal.", purpose: "recovery" }; });
+			this.update(ctx, s => { s.phase = "ready"; s.dispatch = undefined; s.decision = { kind: "ready", purpose: "recovery" }; });
 			this.schedule(ctx);
 		});
 	}

package/extensions/goal-settings.ts

@@ -104,6 +104,12 @@ export interface GoalSettingsResolvedShape {
 	stallTimeoutMinutes?: number;
 	/** Optional extension-run limit per creation/resume; zero disables, absent inherits (default unlimited). */
 	maxAutonomousRuns?: number;
+	/**
+	 * Report the "Autonomous runs: used/limit" line for a finite run allowance
+	 * (default true). The line reports a limit, so it appears exactly when a
+	 * finite allowance exists. Display only; enforcement is unaffected.
+	 */
+	showAutonomousRuns?: boolean;
 	strictExecutionContract?: boolean;
 	/**
 	 * Maximum objective length in characters (0/unset = no limit, the
@@ -339,6 +345,7 @@ const ALLOWED_SETTINGS_KEYS = new Set([
 	"objectiveMaxChars",
 	"keybindings",
 	"hideUnfocusedBanner",
+	"showAutonomousRuns",
 	"hideUnfocusedPrompt",
 	"goalsRoot",
 	"oracle",
@@ -394,6 +401,7 @@ export function parseSettingsLayer(
 			case "autoSelectSingleGoal":
 			case "auditorProjectResources":
 			case "hideUnfocusedBanner":
+			case "showAutonomousRuns":
 			case "hideUnfocusedPrompt": {
 				const parsed = asBool(value);
 				if (parsed === undefined) {
@@ -769,6 +777,11 @@ function resolvedSettingsSnapshot(cwd: string, env: NodeJS.ProcessEnv): Settings
 		globalValue: global.layer.hideUnfocusedBanner,
 		defaultValue: false,
 	}));
+	const showAutonomousRuns = track("showAutonomousRuns", resolveLeaf<boolean>({
+		projectValue: project.layer.showAutonomousRuns,
+		globalValue: global.layer.showAutonomousRuns,
+		defaultValue: true,
+	}));
 	const hideUnfocusedPrompt = track("hideUnfocusedPrompt", resolveLeaf<boolean>({
 		projectValue: project.layer.hideUnfocusedPrompt,
 		globalValue: global.layer.hideUnfocusedPrompt,
@@ -877,6 +890,7 @@ function resolvedSettingsSnapshot(cwd: string, env: NodeJS.ProcessEnv): Settings
 		autoSelectSingleGoal,
 		auditorProjectResources,
 		hideUnfocusedBanner,
+		showAutonomousRuns,
 		hideUnfocusedPrompt,
 		goalsRoot,
 		stallTimeoutMinutes,
@@ -1213,6 +1227,7 @@ function buildPersistedLayer(settings: GoalSettings): Record<string, unknown> {
 	if (settings.autoSelectSingleGoal !== undefined) persisted.autoSelectSingleGoal = settings.autoSelectSingleGoal;
 	if (settings.auditorProjectResources !== undefined) persisted.auditorProjectResources = settings.auditorProjectResources;
 	if (settings.hideUnfocusedBanner !== undefined) persisted.hideUnfocusedBanner = settings.hideUnfocusedBanner;
+	if (settings.showAutonomousRuns !== undefined) persisted.showAutonomousRuns = settings.showAutonomousRuns;
 	if (settings.goalsRoot !== undefined) persisted.goalsRoot = settings.goalsRoot;
 	if (settings.hideUnfocusedPrompt !== undefined) persisted.hideUnfocusedPrompt = settings.hideUnfocusedPrompt;
 	if ((settings as { networkRecovery?: ResolvedGoalNetworkRecoverySettings }).networkRecovery) {
@@ -1279,6 +1294,7 @@ export function effectiveSettingsReport(cwd: string, env: NodeJS.ProcessEnv = pr
 		{ key: "thinkingLevel", label: "thinking_level", format: () => snapshot.value.thinkingLevel ?? "(default)" },
 		{ key: "auditorProjectResources", label: "auditor project resources", format: () => String(snapshot.value.auditorProjectResources) },
 		{ key: "hideUnfocusedBanner", label: "hide unfocused banner", format: () => String(snapshot.value.hideUnfocusedBanner) },
+		{ key: "showAutonomousRuns", label: "show autonomous runs line", format: () => String(snapshot.value.showAutonomousRuns) },
 		{ key: "goalsRoot", label: "goals root (reload to change)", format: () => snapshot.value.goalsRoot ?? ".pi/goals" },
 		{ key: "hideUnfocusedPrompt", label: "hide unfocused prompt", format: () => String(snapshot.value.hideUnfocusedPrompt) },
 		{ key: "strictExecutionContract", label: "explicit execution contracts (opt-in)", format: () => String(snapshot.value.strictExecutionContract) },

package/extensions/prompts/goal-prompts.ts

@@ -188,7 +188,7 @@ function lifecyclePolicyBlock(autonomous: boolean, strict: boolean): string {
   "[OUTCOMES]",
   '- Automatic runs default to unlimited. maxAutonomousRuns in .pi/pi-goal-x-settings.json caps runs; 0 disables (agents may set it). Only creation or user /goal-resume renews usage.',
   ...(autonomous && strict ? ['- End execution with update_goal: ready for runnable work, wait for an external condition, or a status below. Saved decisions terminate; further work invalidates them. Missing decisions allow one repair. Never busy-poll.'] : []),
-  ...(autonomous && !strict ? ['- Continue pursuing the goal automatically after each execution; no scheduling declaration is required. Optional ready saves a next action. New waits require user opt-in to strictExecutionContract; do not enable it merely to continue.'] : []),
+  ...(autonomous && !strict ? ['- Continue pursuing the goal automatically after each execution; no scheduling declaration is required. New waits require user opt-in to strictExecutionContract; do not enable it merely to continue.'] : []),
   '- update_goal({status: "complete"}) only when every requirement is satisfied; the independent completion auditor checks actual evidence. Approval archives; rejection requires rework.',
   '- update_goal({status: "blocked"}) only after the SAME blocker recurs on three consecutive goal turns; keep trying concrete steps before then.',
   '- update_goal({status: "paused", reason: "…"}) pauses immediately. User controls: /goal-pause, /goal-resume, /goal-clear.',
@@ -235,7 +235,7 @@ export function goalPromptParts(goal: GoalRecord, settings?: GoalSettings, conte
 	// Scheduling instructions ride with the policy block: they are cleared by
 	// omission, so a retained copy would keep issuing a cancelled order.
 	const fixed = cachedPrompt(goal, settings, "goal", () => buildGoalPrompt(goal, settings));
-	const { runs, instructions } = schedulerSummaryParts(goal.scheduler, settings?.maxAutonomousRuns);
+	const { runs, instructions } = schedulerSummaryParts(goal.scheduler, settings?.maxAutonomousRuns, settings?.showAutonomousRuns);
 	const limits = `Limits: lifetime tokens=${goal.tokenBudget ?? "none"}; runs=${settings?.maxAutonomousRuns ?? "unlimited"}.`;
 	const state = [fixed, instructions, limits, "Usage spans goal turns, not context. Latest snapshot supersedes earlier snapshots."].filter(Boolean).join("\n");
 	const counters = `Goal snapshot: ${formatUsage(goal)}\n${contextUsageLine(contextUsage)}\n${runs}`;

package/extensions/widgets/goal-dashboard-model.ts

@@ -103,6 +103,8 @@ export interface DashboardTaskNode {
 
 export interface GoalDashboardModelOptions {
 	maxAutonomousRuns?: number;
+	/** Report the runs line for a finite allowance (default on). */
+	showAutonomousRuns?: boolean;
 	focused: boolean;
 	otherOpenGoals: number;
 	ledgerEvents?: readonly GoalLedgerEvent[];
@@ -498,7 +500,7 @@ export function deriveGoalDashboardModel(
 	if (goal.usage.tokensUsed > 0) footerUsageBits.push(formatCompactTokens(goal.usage.tokensUsed));
 
 	return {
-		scheduling: schedulerSummary(goal.scheduler, options.maxAutonomousRuns).split("\n"),
+		scheduling: schedulerSummary(goal.scheduler, options.maxAutonomousRuns, options.showAutonomousRuns !== false).split("\n").filter(Boolean),
 		goalId: goal.id,
 		title: displayObjectiveTitle(goal.objective),
 		status,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-goal-x",
-  "version": "0.31.8",
+  "version": "0.32.0",
   "description": "Adds /goal to pi: conversational goal planning, flexible or ordered goals, persistent progress, and an independent completion auditor.",
   "license": "MIT",
   "author": "pi-goal-x contributors",
@@ -74,15 +74,15 @@
     "bench:gate:comprehensive": "node experiments/bench/comprehensive-gate.mjs"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": ">=0.83.0 <0.88.0",
-    "@earendil-works/pi-coding-agent": ">=0.83.0 <0.88.0",
-    "@earendil-works/pi-tui": ">=0.83.0 <0.88.0",
+    "@earendil-works/pi-ai": ">=0.83.0 <2.0.0",
+    "@earendil-works/pi-coding-agent": ">=0.83.0 <2.0.0",
+    "@earendil-works/pi-tui": ">=0.83.0 <2.0.0",
     "typebox": "^1.3.11"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "0.87.0",
-    "@earendil-works/pi-coding-agent": "0.87.0",
-    "@earendil-works/pi-tui": "0.87.0",
+    "@earendil-works/pi-ai": "1.0.0",
+    "@earendil-works/pi-coding-agent": "1.0.0",
+    "@earendil-works/pi-tui": "1.0.0",
     "@eslint/js": "^9.39.5",
     "@xterm/headless": "^6.0.0",
     "eslint": "^9.39.5",