@oh-my-pi/pi-coding-agent 16.0.8 → 16.0.9

package/dist/types/cli/args.d.ts

@@ -42,6 +42,7 @@ export interface Args {
     noExtensions?: boolean;
     pluginDirs?: string[];
     print?: boolean;
+    printThoughts?: boolean;
     export?: string;
     noSkills?: boolean;
     skills?: string[];

package/dist/types/commands/launch.d.ts

@@ -127,6 +127,9 @@ export default class Index extends Command {
         "no-title": import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
             description: string;
         };
+        "print-thoughts": import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"boolean"> & {
+            description: string;
+        };
         "max-time": import("@oh-my-pi/pi-utils/cli").FlagDescriptor<"string"> & {
             description: string;
         };

package/dist/types/goals/runtime.d.ts

@@ -36,6 +36,7 @@ export declare class GoalRuntime {
     #private;
     constructor(host: GoalRuntimeHost);
     get snapshot(): GoalRuntimeSnapshot;
+    clearAccounting(): void;
     onTurnStart(turnId: string, baselineUsage: GoalTokenUsage): void;
     onToolCompleted(toolName: string): Promise<void>;
     onGoalToolCompleted(): Promise<void>;
@@ -46,7 +47,9 @@ export declare class GoalRuntime {
     onTaskAborted(options?: {
         reason?: "interrupted" | "internal";
     }): Promise<void>;
-    onThreadResumed(): Promise<GoalModeState | undefined>;
+    onThreadResumed(options?: {
+        preserveActiveGoal?: boolean;
+    }): Promise<GoalModeState | undefined>;
     onBudgetMutated(newBudget: number | undefined): Promise<GoalModeState | undefined>;
     flushUsage(steering: GoalBudgetSteering, currentUsage?: GoalTokenUsage): Promise<void>;
     createGoal(input: {

package/dist/types/modes/print-mode.d.ts

@@ -19,6 +19,8 @@ export interface PrintModeOptions {
     initialMessage?: string;
     /** Images to attach to the initial message */
     initialImages?: ImageContent[];
+    /** If true, include thinking blocks in text output */
+    printThoughts?: boolean;
 }
 /**
  * Run in print (single-shot) mode.

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.0.8",
+	"version": "16.0.9",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -48,17 +48,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.0.8",
-		"@oh-my-pi/omp-stats": "16.0.8",
-		"@oh-my-pi/pi-agent-core": "16.0.8",
-		"@oh-my-pi/pi-ai": "16.0.8",
-		"@oh-my-pi/pi-catalog": "16.0.8",
-		"@oh-my-pi/pi-mnemopi": "16.0.8",
-		"@oh-my-pi/pi-natives": "16.0.8",
-		"@oh-my-pi/pi-tui": "16.0.8",
-		"@oh-my-pi/pi-utils": "16.0.8",
-		"@oh-my-pi/pi-wire": "16.0.8",
-		"@oh-my-pi/snapcompact": "16.0.8",
+		"@oh-my-pi/hashline": "16.0.9",
+		"@oh-my-pi/omp-stats": "16.0.9",
+		"@oh-my-pi/pi-agent-core": "16.0.9",
+		"@oh-my-pi/pi-ai": "16.0.9",
+		"@oh-my-pi/pi-catalog": "16.0.9",
+		"@oh-my-pi/pi-mnemopi": "16.0.9",
+		"@oh-my-pi/pi-natives": "16.0.9",
+		"@oh-my-pi/pi-tui": "16.0.9",
+		"@oh-my-pi/pi-utils": "16.0.9",
+		"@oh-my-pi/pi-wire": "16.0.9",
+		"@oh-my-pi/snapcompact": "16.0.9",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/cli/args.ts

@@ -56,6 +56,7 @@ export interface Args {
 	noExtensions?: boolean;
 	pluginDirs?: string[];
 	print?: boolean;
+	printThoughts?: boolean;
 	export?: string;
 	noSkills?: boolean;
 	skills?: string[];
@@ -200,6 +201,8 @@ export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { ty
 			result.advisor = true;
 		} else if (arg === "--print" || arg === "-p") {
 			result.print = true;
+		} else if (arg === "--print-thoughts") {
+			result.printThoughts = true;
 		} else if (arg === "--no-extensions") {
 			result.noExtensions = true;
 		} else if (arg === "--no-skills") {

package/src/cli/flag-tables.ts

@@ -270,6 +270,7 @@ export const VALUELESS_FLAGS: ReadonlySet<string> = new Set([
 	"--hide-thinking",
 	"--advisor",
 	"--print",
+	"--print-thoughts",
 	"--no-extensions",
 	"--no-skills",
 	"--no-rules",

package/src/commands/launch.ts

@@ -136,6 +136,9 @@ export default class Index extends Command {
 		"no-title": Flags.boolean({
 			description: "Disable title auto-generation",
 		}),
+		"print-thoughts": Flags.boolean({
+			description: "Include thinking blocks in print mode text output",
+		}),
 		"max-time": Flags.string({
 			description: "Stop the session after this many seconds",
 		}),

package/src/goals/runtime.ts

@@ -178,8 +178,8 @@ export class GoalRuntime {
 		}
 	}
 
-	#markActiveAccounting(goal: Goal): void {
-		if (this.#wallClock.activeGoalId !== goal.id) {
+	#markActiveAccounting(goal: Goal, resetWallClock = false): void {
+		if (resetWallClock || this.#wallClock.activeGoalId !== goal.id) {
 			this.#wallClock = { lastAccountedAt: this.#now(), activeGoalId: goal.id };
 		}
 		if (this.#turnSnapshot) {
@@ -195,6 +195,12 @@ export class GoalRuntime {
 		}
 	}
 
+	clearAccounting(): void {
+		this.#turnSnapshot = undefined;
+		this.#clearActiveAccounting();
+		this.#budgetReportedFor = undefined;
+	}
+
 	onTurnStart(turnId: string, baselineUsage: GoalTokenUsage): void {
 		this.#turnSnapshot = { turnId, baselineUsage: { ...baselineUsage } };
 		const state = this.#host.getState();
@@ -235,7 +241,7 @@ export class GoalRuntime {
 			return;
 		}
 		await this.#withAccounting(async () => {
-			await this.#flushUsageLocked("suppressed");
+			await this.#flushUsageLocked("suppressed", undefined, options?.reason === "internal");
 			this.#turnSnapshot = undefined;
 			if (options?.reason !== "interrupted") return;
 			const cloned = this.#getStateClone();
@@ -249,9 +255,14 @@ export class GoalRuntime {
 		});
 	}
 
-	async onThreadResumed(): Promise<GoalModeState | undefined> {
+	async onThreadResumed(options?: { preserveActiveGoal?: boolean }): Promise<GoalModeState | undefined> {
 		const state = this.#getStateClone();
 		if (!state) return undefined;
+		if (options?.preserveActiveGoal && state.enabled && state.goal.status === "active") {
+			this.#markActiveAccounting(state.goal, true);
+			await this.#commitState(state, { emit: true });
+			return state;
+		}
 		if (state.goal.status === "active") {
 			state.enabled = false;
 			state.goal.status = "paused";
@@ -301,6 +312,7 @@ export class GoalRuntime {
 	async #flushUsageLocked(
 		steering: GoalBudgetSteering,
 		currentUsage: GoalTokenUsage = this.#host.getCurrentUsage(),
+		persistWallClock = false,
 	): Promise<void> {
 		const state = this.#getStateClone();
 		if (!state?.enabled || !isAccountingStatus(state.goal)) return;
@@ -333,10 +345,10 @@ export class GoalRuntime {
 		if (this.#wallClock.activeGoalId === state.goal.id && wallSeconds > 0) {
 			this.#wallClock.lastAccountedAt += wallSeconds * 1000;
 		}
-
 		// Persisting wall-clock-only accounting on every tool event bloats /goal sessions with full
-		// objective snapshots. Keep the in-memory/UI state fresh, but persist only token/budget changes.
-		const shouldPersistUsage = tokenDelta > 0 || flippedToBudgetLimited;
+		// objective snapshots. Keep normal tool flushes in memory/UI only, but make wall-clock
+		// usage durable before internal session switches because the active runtime is leaving.
+		const shouldPersistUsage = tokenDelta > 0 || flippedToBudgetLimited || (persistWallClock && wallSeconds > 0);
 		await this.#commitState(state, { persist: shouldPersistUsage ? "goal" : undefined });
 
 		if (state.goal.status !== "budget-limited") {

package/src/main.ts

@@ -1039,6 +1039,13 @@ export async function runRootCommand(
 		});
 	}
 
+	// --print-thoughts (single-shot print mode) must surface reasoning, so un-hide
+	// thinking before the session is built — otherwise a passive hideThinkingBlock
+	// setting makes the provider omit summaries and the flag prints nothing. An
+	// explicit --hide-thinking below still wins.
+	if (parsedArgs.printThoughts && !isProtocolMode && !isInteractive) {
+		settingsInstance.override("hideThinkingBlock", false);
+	}
 	// Apply --hide-thinking CLI flag (ephemeral, not persisted)
 	if (parsedArgs.hideThinking) {
 		settingsInstance.override("hideThinkingBlock", true);
@@ -1373,6 +1380,7 @@ export async function runRootCommand(
 				messages: initialArgs.messages,
 				initialMessage,
 				initialImages,
+				printThoughts: initialArgs.printThoughts,
 			});
 			if ($env.PI_TIMING) {
 				logger.printTimings();

package/src/modes/interactive-mode.ts

@@ -797,7 +797,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		await this.initHooksAndCustomTools();
 
 		// Restore mode from session (e.g. plan mode on resume)
-		this.session.setSessionSwitchReconciler?.(() => this.#reconcileModeFromSession());
+		this.session.setSessionSwitchReconciler?.(() => this.#reconcileModeFromSession({ preserveActiveGoal: true }));
 		await this.#reconcileModeFromSession();
 
 		// Brand-new sessions optionally start in plan mode when the user has made it
@@ -1783,11 +1783,12 @@ export class InteractiveMode implements InteractiveModeContext {
 	}
 
 	/** Reconcile mode state from session entries on resume/switch. */
-	async #reconcileModeFromSession(): Promise<void> {
+	async #reconcileModeFromSession(options?: { preserveActiveGoal?: boolean }): Promise<void> {
 		await this.#clearTransientModeState();
 		const sessionContext = this.sessionManager.buildSessionContext();
 		const goalEnabled = this.session.settings.get("goal.enabled");
 		if (!goalEnabled && (sessionContext.mode === "goal" || sessionContext.mode === "goal_paused")) {
+			this.session.goalRuntime.clearAccounting();
 			this.sessionManager.appendModeChange("none");
 			return;
 		}
@@ -1802,7 +1803,9 @@ export class InteractiveMode implements InteractiveModeContext {
 				mode: "active",
 				goal,
 			});
-			const restored = await this.session.goalRuntime.onThreadResumed();
+			const restored = await this.session.goalRuntime.onThreadResumed({
+				preserveActiveGoal: options?.preserveActiveGoal,
+			});
 			this.goalModeEnabled = restored?.enabled === true;
 			this.goalModePaused = restored?.enabled !== true && restored?.goal.status === "paused";
 			// sdk.ts excludes "goal" from the initial active tool set unconditionally.
@@ -1815,6 +1818,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.#updateGoalModeStatus();
 			return;
 		}
+		this.session.goalRuntime.clearAccounting();
 		if (!this.session.settings.get("plan.enabled")) {
 			// Clear stale plan/plan_paused mode so re-enabling the setting
 			// later doesn't unexpectedly restore an old plan session.

package/src/modes/print-mode.ts

@@ -24,6 +24,8 @@ export interface PrintModeOptions {
 	initialMessage?: string;
 	/** Images to attach to the initial message */
 	initialImages?: ImageContent[];
+	/** If true, include thinking blocks in text output */
+	printThoughts?: boolean;
 }
 
 /**
@@ -31,7 +33,7 @@ export interface PrintModeOptions {
  * Sends prompts to the agent and outputs the result.
  */
 export async function runPrintMode(session: AgentSession, options: PrintModeOptions): Promise<void> {
-	const { mode, messages = [], initialMessage, initialImages } = options;
+	const { mode, messages = [], initialMessage, initialImages, printThoughts } = options;
 
 	// Emit session header for JSON mode
 	if (mode === "json") {
@@ -108,6 +110,8 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 			for (const content of assistantMsg.content) {
 				if (content.type === "text") {
 					process.stdout.write(`${sanitizeText(content.text)}\n`);
+				} else if (printThoughts && content.type === "thinking" && content.thinking.trim().length > 0) {
+					process.stdout.write(`${sanitizeText(content.thinking)}\n`);
 				}
 			}
 		}

package/src/prompts/advisor/advise-tool.md

@@ -1 +1,3 @@
-Send one concrete, terse piece of advice to the agent you are watching. Use sparingly; stay silent when nothing matters.
+Send one concrete, terse piece of advice to the agent you are watching.
+- Use sparingly; stay silent when nothing matters.
+- Call it to head off likely-wrong or materially wasteful work.

package/src/prompts/advisor/system.md

@@ -1,32 +1,75 @@
 <system-conventions>
 RFC 2119 applies to MUST, REQUIRED, SHOULD, RECOMMENDED, MAY, OPTIONAL. `NEVER` and `AVOID` are aliases for `MUST NOT` and `SHOULD NOT`.
-You can explore the workspace; budget is 2–3 tool calls per advise (exception: critical bugs warrant deeper verification before raising a blocker).
 </system-conventions>
 
-You bring a different angle.
-The agent might not have thought about an edge case, spotted a hallucinated API, or realized a simpler approach exists.
+You bring a different angle, and advocate for the user and the code-quality & robustness.
+You're watching over the main agent as a peer-programmer:
+- They might not have thought about an edge case, or realized a more elegant approach exists.
+- They might be sinking deeper into a hole that will not get the user's request accomplished.
+
 Your job is to offer that view before they sink work into the wrong direction.
 
 <workflow>
-You receive the agent's transcript incrementally, including private thinking.
+You receive the agent's transcript incrementally, including their thoughts.
 You have read-only access through `read`, `search`, `find` to verify your suspicions.
-Keep exploration lean — 2–3 calls per advise unless you've spotted a critical bug and need to be absolutely certain before raising a blocker.
+Keep exploration lean:
+- 2–3 tool calls per advise.
+- Exception: critical bugs may need deeper verification before raising a blocker.
 </workflow>
 
 <communication>
-At most one `advise` per update. Prefer silence when the agent is on track. Address the agent directly. Offer alternatives, not lectures. Never restate what they know; never explain how to use the advisor.
-Do not comment merely to add insight, context, or a second opinion. NEVER restate information the agent already has, including tool or CLI errors returned directly to it. NEVER flag a problem that will surface on its own — type errors, LSP diagnostics, failed builds, failing tests, lint — the agent's own tooling catches those. NEVER repeat advice you already gave.
+- You call `advise` to surface your commentary to the driving agent; at most one `advise` per update.
+- Prefer silence when the agent is on track.
+- Address the agent directly.
+- Offer alternatives, not lectures.
+- NEVER restate information the agent already has, including errors they have seen.
+- Examples: type errors, LSP diagnostics, failed builds, failing tests, lint.
+- NEVER repeat advice you already gave.
+- NEVER nitpick about things user stated they are okay with. You are the advocate for the user.
 </communication>
 
 <critical>
-You SHOULD call `advise` when: agent might be heading the wrong way, missed an edge case, about to call a hallucinated API, going in circles, picking brittle approach over better one. Low confidence bar — "this might be wrong" is worth noting if they didn't think about it.
+A low-confidence bar applies ONLY to concrete technical risk:
+- Generic uncertainty, vague unease, or user-intent ambiguity → stay SILENT.
+
 NEVER advise just to second-guess decisions the agent understands and is committed to, if you are not certain.
+
+NEVER advise on intent or process:
+- Do not push the agent to ask for clarification, confirm scope, or summarize input before acting.
+- Do not question whether the user's ask is clear enough.
+- Intent is the agent's domain; it defaults to informed action.
+- Your lane: correctness, edge cases, design, process.
+
+Cite the exact instruction or risk.
 </critical>
 
 <completeness>
-**`nit`** — Non-urgent cleanup, refactor, style, missed opportunity. Folded at next step boundary; agent keeps working. Examples: edge cases that don't break correctness, simplifications, better approach the agent can consider.
-**`concern`** — Agent might be heading wrong or missed something material. Offers your view; agent decides. Use when: exploring wrong code path, picking fragile approach when better exists, missing constraint, hallucinated API, going in circles, edge case about to be baked in.
-**`blocker`** — Stop and reconsider. Use ONLY when: continuing will clearly waste the turn, produce broken output, or the path is fundamentally unsound. Verify thoroughly before raising.
+**`nit`**
+- Non-urgent cleanup, refactor, style, missed opportunity.
+- Folded at next step boundary; agent keeps working.
+- Examples:
+  - Edge cases that don't break correctness.
+  - Simplifications.
+  - Better approach the agent can consider.
+
+**`concern`**
+- Agent might be heading wrong or missed something material.
+- Offers your view; agent decides.
+- Use when:
+  - Exploring wrong code path.
+  - Picking fragile approach when better exists.
+  - Not parallelizing when user request is obviously parallelizable.
+  - Missing constraint.
+  - Edge case about to be baked in.
+
+**`blocker`**
+- Stop and reconsider.
+- Use ONLY when the agent making progress will clearly:
+  - Waste the users time with a larger refactor.
+  - Will require the user to interrupt the agent later on, due to them going in circles without a solution.
+  - Be fundamentally unsound.
+- Verify thoroughly before raising.
 </completeness>
 
-You MAY suggest an approach or fix if you've explored enough to be confident. Your job is pair programming, not just bugs — offer the better designs, not just the warning.
+You MAY suggest an approach or fix if you've explored enough to be confident.
+Offer the better designs, not just the warning.

package/src/session/agent-session.ts

@@ -7375,7 +7375,7 @@ export class AgentSession {
 			throw new Error("Compaction already in progress");
 		}
 		this.#disconnectFromAgent();
-		await this.abort();
+		await this.abort({ goalReason: "internal" });
 		const compactionAbortController = new AbortController();
 		this.#compactionAbortController = compactionAbortController;
 
@@ -7543,6 +7543,10 @@ export class AgentSession {
 			const newEntries = this.sessionManager.getEntries();
 			const sessionContext = this.buildDisplaySessionContext();
 			this.agent.replaceMessages(sessionContext.messages);
+			// Compaction discarded the conversation history that carried the approved
+			// plan reference. Clear the sent-flag so #buildPlanReferenceMessage re-reads
+			// the plan from disk and re-injects it on the next turn (issue #1246).
+			this.#planReferenceSent = false;
 			this.#advisorRuntime?.reset();
 			this.#syncTodoPhasesFromBranch();
 			this.#closeCodexProviderSessionsForHistoryRewrite();
@@ -9409,6 +9413,10 @@ export class AgentSession {
 			const newEntries = this.sessionManager.getEntries();
 			const sessionContext = this.buildDisplaySessionContext();
 			this.agent.replaceMessages(sessionContext.messages);
+			// Compaction discarded the conversation history that carried the approved
+			// plan reference. Clear the sent-flag so #buildPlanReferenceMessage re-reads
+			// the plan from disk and re-injects it on the next turn (issue #1246).
+			this.#planReferenceSent = false;
 			this.#advisorRuntime?.reset();
 			this.#syncTodoPhasesFromBranch();
 			this.#closeCodexProviderSessionsForHistoryRewrite();
@@ -10960,7 +10968,7 @@ export class AgentSession {
 		}
 
 		this.#disconnectFromAgent();
-		await this.abort();
+		await this.abort({ goalReason: "internal" });
 
 		// Flush pending writes before switching so restore snapshots reflect committed state.
 		await this.sessionManager.flush();