@oh-my-pi/pi-coding-agent 15.2.3 → 15.3.0

package/src/prompts/agents/frontmatter.md

@@ -6,5 +6,6 @@ description: {{jsonStringify description}}
 {{/if}}{{#if model}}model: {{jsonStringify model}}
 {{/if}}{{#if thinkingLevel}}thinking-level: {{jsonStringify thinkingLevel}}
 {{/if}}{{#if blocking}}blocking: true
+{{/if}}{{#if autoloadSkills}}autoloadSkills: {{jsonStringify autoloadSkills}}
 {{/if}}---
 {{body}}

package/src/prompts/tools/hashline.md

@@ -1,58 +1,36 @@
 Your patch language is a compact, line-anchored edit format.
 
-A patch contains one or more file sections. The first non-blank line of every edit section MUST be `@@ PATH`.
+A patch contains one or more file sections. The first non-blank line of every edit section MUST be `§PATH`.
 Operations reference lines in the file by their line number and hash, called "Anchors", e.g. `5th`, `123ab`.
 You MUST copy them verbatim from the latest output for the file you're editing.
 
 Purely textual format. The tool has NO awareness of language, indentation, brackets, fences, or table widths. You MUST emit valid syntax in replacements/insertions.
 
 <ops>
-@@ PATH          header: subsequent ops apply to PATH
+§PATH           header: subsequent ops apply to PATH
 Each op line is ONE of:
-+ ANCHOR         insert lines AFTER  the anchored line (or EOF); payload follows as `{{hsep}}TEXT` lines
-< ANCHOR         insert lines BEFORE the anchored line (or BOF); payload follows as `{{hsep}}TEXT` lines
-- A..B           delete the line range (inclusive).
-= A..B           replace the range with payload `{{hsep}}TEXT` lines, or with one blank line if no payload follows.
+»ANCHOR         insert lines AFTER  the anchored line (or EOF); payload follows on subsequent lines
+«ANCHOR         insert lines BEFORE the anchored line (or BOF); payload follows on subsequent lines
+≔A..B           replace the inclusive range A..B with payload; delete the range if no payload follows
+≔A              shorthand for ≔A..A
 </ops>
 
-<format-reminder>
-Op lines carry no content — payload goes on the next line.
-
-WRONG: + 5pg| some code
-WRONG: {{hsep}} some code
-RIGHT: + 5pg
-{{hsep}}some code
-
-A single `+`/`<`/`=` op accepts MANY `{{hsep}}` payload lines. To insert N consecutive lines, write ONE op followed by N payload lines — NEVER N ops with one payload each.
-
-WRONG (one op per inserted line, with fabricated anchors):
-  + 5pg
-  {{hsep}}first new line
-  + 6xx    ← FABRICATED
-  {{hsep}}second new line
-
-RIGHT (one op, many payload lines):
-  + 5pg
-  {{hsep}}first new line
-  {{hsep}}second new line
-</format-reminder>
-
 <rules>
-- Every payload line MUST start with `{{hsep}}` immediately followed by payload text. Do NOT add a readability space after `{{hsep}}`.
-- Every character after `{{hsep}}` is file content. If the target line intentionally starts with one space, write exactly one space after `{{hsep}}`; otherwise write none.
 - Payload text is verbatim — NEVER escape unicode.
+- Payload ends at the next `»`, `«`, `≔`, `§`, envelope marker, or EOF.
+- `≔A..B` with no payload deletes the range. To keep a blank line, include one explicit empty payload line.
 - **Payload is only what's NEW relative to your range:**
-  - `=` replaces inside; NEVER include lines outside.
-  - `+`/`<` adds at the anchor; NEVER repeat line A or neighbors.
+  - `≔` replaces inside; NEVER include lines outside.
+  - `»`/`«` adds at the anchor; NEVER repeat line A or neighbors.
   - Payload matching nearby content duplicates — drop it or widen.
 - **Pick a self-contained unit first.** Touching a multiline construct? Widen to the whole thing.
-- Then smallest op: add → `+`/`<`; delete → `-`; `=` ONLY when modifying inside.
+- Then smallest op: add → `»`/`«`; delete/replace → `≔`.
 </rules>
 
 <brace-shapes>
 When braces bound your edit, you SHOULD prefer these shapes:
 - **Whole block**: range spans `{` through matching `}`.
-- **Signature only**: one-line `=` on the opener; body untouched.
+- **Signature only**: one-line `≔` on the opener; body untouched.
 - **Insert inside**: anchor on `{` or last interior line; NEVER repeat the braces.
 - **End on `}`**: only when that `}` is part of the change. Otherwise extend or stop earlier.
 </brace-shapes>
@@ -61,9 +39,9 @@ When braces bound your edit, you SHOULD prefer these shapes:
 - **NEVER replay past your range.** Stop before B+1; extend B if it must go.
 - **NEVER duplicate chunks inside one payload.** Caught re-emitting? Rewrite.
 - **Anchor only inside the visible region.** B+1 truncated? Re-`read` first.
-- **You SHOULD prefer the narrowest self-contained edit.** Small `+`/`-` beats wide `=`.
+- **You SHOULD prefer the narrowest self-contained edit.** Narrow range beats wide range.
 - **Anchors reference the file as last read.** NEVER shift for prior ops.
-- **One `+`/`<` op per block, NOT per line.** N lines = ONE op, N payloads. Collapse adjacent ops.
+- **One `»`/`«` op per block, NOT per line.** N lines = ONE op, N payloads. Collapse adjacent ops.
 - **NEVER fabricate anchor hashes.** Missing? Re-`read`.
 </common-failures>
 
@@ -79,71 +57,74 @@ When braces bound your edit, you SHOULD prefer these shapes:
 
 <examples>
 # Replace one line (the payload must re-emit the original indentation)
-@@ mod.ts
-= {{hrefr 1}}..{{hrefr 1}}
-{{hsep}}const TITLE = "Mrs";
+§mod.ts
+≔{{hrefr 1}}
+const TITLE = "Mrs";
 
 # Replace a full multiline statement (widen to a self-contained boundary)
-@@ mod.ts
-= {{hrefr 3}}..{{hrefr 6}}
-{{hsep}}	return [
-{{hsep}}		"Mrs",
-{{hsep}}		name?.trim() || "guest",
-{{hsep}}	].join(" ");
+§mod.ts
+≔{{hrefr 3}}..{{hrefr 6}}
+	return [
+		"Mrs",
+		name?.trim() || "guest",
+	].join(" ");
 
 # Insert AFTER/BEFORE a line
-@@ mod.ts
-+ {{hrefr 4}}
-{{hsep}}		"Dr",
-< {{hrefr 5}}
-{{hsep}}		"Dr",
+§mod.ts
+»{{hrefr 4}}
+		"Dr",
+«{{hrefr 5}}
+		"Dr",
 
 # Append to file
-@@ mod.ts
-+ EOF
-{{hsep}}export const done = true;
+§mod.ts
+»EOF
+export const done = true;
 
 # Delete a line
-@@ mod.ts
-- {{hrefr 5}}..{{hrefr 5}}
+§mod.ts
+≔{{hrefr 5}}
+
+# Blank a line (replace with LF: the empty payload is the blank line before `»EOF`)
+§mod.ts
+≔{{hrefr 5}}
 
-# Blank a line (replace with LF)
-@@ mod.ts
-= {{hrefr 5}}..{{hrefr 5}}
+»EOF
+export const done = true;
 </examples>
 
 <anti-pattern>
 # WRONG — replaces 2 lines just to add one.
-@@ mod.ts
-= {{hrefr 1}}..{{hrefr 2}}
-{{hsep}}const TITLE = "Mr";
-{{hsep}}const DEBUG = false;
-{{hsep}}export function greet(name) {
+§mod.ts
+≔{{hrefr 1}}..{{hrefr 2}}
+const TITLE = "Mr";
+const DEBUG = false;
+export function greet(name) {
 # RIGHT — same effect, one-line insert
-@@ mod.ts
-+ {{hrefr 1}}
-{{hsep}}const DEBUG = false;
+§mod.ts
+»{{hrefr 1}}
+const DEBUG = false;
 
 # WRONG — replace from the middle of a larger statement (error-prone)
-@@ mod.ts
-= {{hrefr 4}}..{{hrefr 5}}
-{{hsep}}		"Dr",
-{{hsep}}		name?.trim() || "guest",
+§mod.ts
+≔{{hrefr 4}}..{{hrefr 5}}
+		"Dr",
+		name?.trim() || "guest",
 # RIGHT — widen to the full statement
-@@ mod.ts
-= {{hrefr 3}}..{{hrefr 6}}
-{{hsep}}	return [
-{{hsep}}		"Dr",
-{{hsep}}		name?.trim() || "guest",
-{{hsep}}	].join(" ");
+§mod.ts
+≔{{hrefr 3}}..{{hrefr 6}}
+	return [
+		"Dr",
+		name?.trim() || "guest",
+	].join(" ");
 </anti-pattern>
 
 <critical>
 - Copy anchors verbatim (line number + 2-char hash); NEVER include the `|TEXT` body.
-- Every payload line MUST start with `{{hsep}}`; raw content is invalid.
-- NEVER write unified diff syntax. Header is `@@ PATH`; ops are `<`/`+`/`-`/`=`.
-- `= A..B` deletes the range; payload is what's written. Edge line matches just outside? Widen, or it duplicates.
-- Multiple ops are cheap. SHOULD prefer two narrow ops over one wide `=`.
-  - Before `= A..B`, mentally delete A..B. Splits an unclosed bracket/brace/string from above, or orphans a closer inside? You're bisecting a construct.
+- NEVER write unified diff syntax. Headers are `§PATH`; ops are `»`/`«`/`≔`.
+- `≔A..B` deletes the range when no payload follows. To keep a blank line, include one explicit empty payload line.
+- `≔A..B` with payload writes exactly that payload. Edge line matches just outside? Widen, or it duplicates.
+- Multiple ops are cheap. SHOULD prefer two narrow ops over one wide `≔`.
+  - Before `≔A..B`, mentally delete A..B. Splits an unclosed bracket/brace/string from above, or orphans a closer inside? You're bisecting a construct.
 - NEVER use this tool to reformat code (indentation, whitespace, line wrapping, style). Run the project's formatter instead.
 </critical>

package/src/sdk.ts

@@ -4,6 +4,7 @@ import {
 	type AgentMessage,
 	type AgentTelemetryConfig,
 	type AgentTool,
+	AppendOnlyContextManager,
 	INTENT_FIELD,
 	type ThinkingLevel,
 } from "@oh-my-pi/pi-agent-core";
@@ -589,6 +590,24 @@ function registerPythonCleanup(): void {
 	postmortem.register("python-cleanup", disposeAllKernelSessions);
 }
 
+/**
+ * Resolve whether to enable append-only context mode based on the setting and provider.
+ *
+ * - `"on"` → always enable
+ * - `"off"` → never enable
+ * - `"auto"` → enable for DeepSeek (prefix-caching provider)
+ */
+function resolveAppendOnlyMode(setting: "auto" | "on" | "off" | undefined, provider: string): boolean {
+	switch (setting ?? "auto") {
+		case "on":
+			return true;
+		case "off":
+			return false;
+		default:
+			return provider === "deepseek";
+	}
+}
+
 function customToolToDefinition(tool: CustomTool): ToolDefinition {
 	const definition: ToolDefinition & { [TOOL_DEFINITION_MARKER]: true } = {
 		name: tool.name,
@@ -1897,6 +1916,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			intentTracing: !!intentField,
 			getToolChoice: () => session?.nextToolChoice(),
 			telemetry: options.telemetry,
+			appendOnlyContext: model
+				? resolveAppendOnlyMode(settings.get("provider.appendOnlyContext"), model.provider)
+					? new AppendOnlyContextManager()
+					: undefined
+				: undefined,
 		});
 
 		cursorEventEmitter = event => agent.emitExternalEvent(event);

package/src/session/agent-session.ts

@@ -26,6 +26,7 @@ import {
 	type AgentMessage,
 	type AgentState,
 	type AgentTool,
+	AppendOnlyContextManager,
 	resolveTelemetry,
 	ThinkingLevel,
 } from "@oh-my-pi/pi-agent-core";
@@ -98,6 +99,7 @@ import {
 } from "../config/model-resolver";
 import { expandPromptTemplate, type PromptTemplate } from "../config/prompt-templates";
 import type { Settings, SkillsSettings } from "../config/settings";
+import { onAppendOnlyModeChanged } from "../config/settings";
 import { RawSseDebugBuffer } from "../debug/raw-sse-buffer";
 import { loadCapability } from "../discovery";
 import { expandApplyPatchToEntries, normalizeDiff, normalizeToLF, ParseError, previewPatch, stripBom } from "../edit";
@@ -1138,6 +1140,8 @@ export class AgentSession {
 		// Always subscribe to agent events for internal handling
 		// (session persistence, hooks, auto-compaction, retry logic)
 		this.#unsubscribeAgent = this.agent.subscribe(this.#handleAgentEvent);
+		// Re-evaluate append-only context mode when the setting changes at runtime.
+		onAppendOnlyModeChanged(_value => this.#syncAppendOnlyContext(this.model));
 	}
 
 	/** Model registry for API key resolution and model discovery */
@@ -3573,6 +3577,18 @@ export class AgentSession {
 		return this.#autoCompactionAbortController !== undefined || this.#compactionAbortController !== undefined;
 	}
 
+	/**
+	 * Whether idle-flush tasks, auto-continuations, or other short-lived
+	 * post-prompt work are pending.  True in the brief window after
+	 * `session.prompt()` returns but before a scheduled background delivery
+	 * (e.g. an async-job result) has finished its own streaming turn.
+	 * Loop-mode and similar auto-submit paths should treat this as a block
+	 * to avoid racing against the delivery turn.
+	 */
+	get hasPostPromptWork(): boolean {
+		return this.#postPromptTasks.size > 0;
+	}
+
 	/** All messages including custom types like BashExecutionMessage */
 	get messages(): AgentMessage[] {
 		return this.agent.state.messages;
@@ -5947,6 +5963,9 @@ export class AgentSession {
 			this.#closeProviderSessionsForModelSwitch(currentModel, model);
 		}
 		this.agent.setModel(model);
+
+		// Re-evaluate append-only context mode — provider or setting may have changed
+		this.#syncAppendOnlyContext(model);
 	}
 
 	#closeCodexProviderSessionsForHistoryRewrite(): void {
@@ -5955,6 +5974,24 @@ export class AgentSession {
 		this.#closeProviderSessionsForModelSwitch(currentModel, currentModel);
 	}
 
+	/**
+	 * Re-evaluate append-only context mode, creating or destroying the
+	 * manager as needed. Called on model switch AND setting change.
+	 */
+	#syncAppendOnlyContext(model: Model | null | undefined): void {
+		const setting = this.settings.get("provider.appendOnlyContext") ?? "auto";
+		const enable = setting === "on" || (setting === "auto" && model?.provider === "deepseek");
+		if (enable && !this.agent.appendOnlyContext) {
+			this.agent.setAppendOnlyContext(new AppendOnlyContextManager());
+		} else if (enable && this.agent.appendOnlyContext) {
+			// Already active — invalidate prefix + log so the next turn
+			// rebuilds for the current model's normalization.
+			this.agent.appendOnlyContext.invalidateForModelChange();
+		} else if (!enable && this.agent.appendOnlyContext) {
+			this.agent.setAppendOnlyContext(undefined);
+		}
+	}
+
 	#closeProviderSessionsForModelSwitch(currentModel: Model, nextModel: Model): void {
 		const providerKeys = new Set<string>();
 		if (currentModel.api === "openai-codex-responses" || nextModel.api === "openai-codex-responses") {
@@ -7071,6 +7108,27 @@ export class AgentSession {
 			}
 		}
 
+		// Fail-fast cap: if the provider asks us to wait longer than
+		// retry.maxDelayMs and we have no fallback credential or model to
+		// switch to, surface the error instead of sleeping. Defends against
+		// 3-hour Anthropic rate-limit windows that would otherwise leave a
+		// subagent (or interactive session) silently hung. The original
+		// assistant error message is preserved in agent state so the caller
+		// can act on it.
+		const maxDelayMs = retrySettings.maxDelayMs;
+		if (maxDelayMs > 0 && delayMs > maxDelayMs && !switchedCredential && !switchedModel) {
+			const attempt = this.#retryAttempt;
+			this.#retryAttempt = 0;
+			await this.#emitSessionEvent({
+				type: "auto_retry_end",
+				success: false,
+				attempt,
+				finalError: `Provider requested ${delayMs}ms wait, exceeds retry.maxDelayMs (${maxDelayMs}ms). Original error: ${errorMessage}`,
+			});
+			this.#resolveRetry();
+			return false;
+		}
+
 		await this.#emitSessionEvent({
 			type: "auto_retry_start",
 			attempt: this.#retryAttempt,

package/src/session/session-manager.ts

@@ -18,6 +18,7 @@ import {
 	getProjectDir,
 	getSessionsDir,
 	getTerminalSessionsDir,
+	hasFsCode,
 	isEnoent,
 	logger,
 	parseJsonlLenient,
@@ -2146,7 +2147,59 @@ export class SessionManager {
 			{ ignoreError: true },
 		);
 	}
+	// Windows can reject overwrite-style rename with EPERM even after our own writer is closed.
+	// Move the old session file aside first so a failed retry can roll back to the last good file.
 
+	async #replaceSessionFileAfterEperm(tempPath: string, targetPath: string, renameError: unknown): Promise<void> {
+		const dir = path.resolve(targetPath, "..");
+		const backupPath = path.join(dir, `.${path.basename(targetPath)}.${Snowflake.next()}.bak`);
+		try {
+			await this.storage.rename(targetPath, backupPath);
+		} catch (err) {
+			if (isEnoent(err)) {
+				await this.storage.rename(tempPath, targetPath);
+				return;
+			}
+			throw toError(renameError);
+		}
+
+		try {
+			await this.storage.rename(tempPath, targetPath);
+		} catch (err) {
+			const replaceError = toError(err);
+			try {
+				await this.storage.rename(backupPath, targetPath);
+			} catch (rollbackErr) {
+				const rollbackError = toError(rollbackErr);
+				throw new Error(
+					`Failed to replace session file after EPERM (${replaceError.message}); rollback from ${backupPath} also failed: ${rollbackError.message}`,
+					{ cause: replaceError },
+				);
+			}
+			throw replaceError;
+		}
+
+		try {
+			await this.storage.unlink(backupPath);
+		} catch (err) {
+			if (!isEnoent(err)) {
+				logger.warn("Failed to remove session rewrite backup", {
+					sessionFile: targetPath,
+					backupPath,
+					error: toError(err).message,
+				});
+			}
+		}
+	}
+
+	async #replaceSessionFile(tempPath: string, targetPath: string): Promise<void> {
+		try {
+			await this.storage.rename(tempPath, targetPath);
+		} catch (err) {
+			if (!hasFsCode(err, "EPERM")) throw toError(err);
+			await this.#replaceSessionFileAfterEperm(tempPath, targetPath, err);
+		}
+	}
 	async #writeEntriesAtomically(entries: FileEntry[]): Promise<void> {
 		if (!this.#sessionFile) return;
 		const dir = path.resolve(this.#sessionFile, "..");
@@ -2159,7 +2212,7 @@ export class SessionManager {
 			await writer.flush();
 			await writer.fsync();
 			await writer.close();
-			await this.storage.rename(tempPath, this.#sessionFile);
+			await this.#replaceSessionFile(tempPath, this.#sessionFile);
 		} catch (err) {
 			try {
 				await writer.close();

package/src/slash-commands/builtin-registry.ts

@@ -72,7 +72,12 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 		inlineHint: "[prompt]",
 		allowArgs: true,
 		handleTui: async (command, runtime) => {
+			const hadArgs = !!command.args;
 			await runtime.ctx.handlePlanModeCommand(command.args || undefined);
+			if (hadArgs && runtime.ctx.planModeEnabled) {
+				// plan was already active — preserve the typed command in input history
+				runtime.ctx.editor.addToHistory(command.text);
+			}
 			runtime.ctx.editor.setText("");
 		},
 	},
@@ -90,7 +95,12 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 		inlineHint: "[objective]",
 		allowArgs: true,
 		handleTui: async (command, runtime) => {
+			const hadArgs = !!command.args;
 			await runtime.ctx.handleGoalModeCommand(command.args || undefined);
+			if (hadArgs && runtime.ctx.goalModeEnabled) {
+				// goal was already active — preserve the typed command in input history
+				runtime.ctx.editor.addToHistory(command.text);
+			}
 			runtime.ctx.editor.setText("");
 		},
 	},

package/src/task/executor.ts

@@ -17,7 +17,7 @@ import { SETTINGS_SCHEMA, type SettingPath } from "../config/settings-schema";
 import type { CustomTool } from "../extensibility/custom-tools/types";
 import { runExtensionCompact, runExtensionSetModel } from "../extensibility/extensions/compact-handler";
 import { getSessionSlashCommands } from "../extensibility/extensions/get-commands-handler";
-import type { Skill } from "../extensibility/skills";
+import { buildSkillPromptMessage, type Skill } from "../extensibility/skills";
 import type { HindsightSessionState } from "../hindsight/state";
 import type { LocalProtocolOptions } from "../internal-urls";
 import { callTool } from "../mcp/client";
@@ -29,6 +29,7 @@ import { createAgentSession, discoverAuthStorage } from "../sdk";
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
 import type { ArtifactManager } from "../session/artifacts";
 import type { AuthStorage } from "../session/auth-storage";
+import { SKILL_PROMPT_MESSAGE_TYPE } from "../session/messages";
 import { SessionManager } from "../session/session-manager";
 import { truncateTail } from "../session/streaming-output";
 import type { ContextFileEntry } from "../tools";
@@ -190,6 +191,8 @@ export interface ExecutorOptions {
 	 * transition explicitly.
 	 */
 	parentTelemetry?: AgentTelemetryConfig;
+	/** Skills to autoload via sendCustomMessage before the first prompt */
+	autoloadSkills?: Skill[];
 }
 
 function parseStringifiedJson(value: unknown): unknown {
@@ -1347,6 +1350,30 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 			const MAX_YIELD_RETRIES = 3;
 			unsubscribe = session.subscribe(event => {
+				if (event.type === "auto_retry_start") {
+					progress.retryState = {
+						attempt: event.attempt,
+						maxAttempts: event.maxAttempts,
+						delayMs: event.delayMs,
+						errorMessage: event.errorMessage,
+						startedAtMs: Date.now(),
+					};
+					progress.retryFailure = undefined;
+					scheduleProgress(true);
+					return;
+				}
+				if (event.type === "auto_retry_end") {
+					const attempt = progress.retryState?.attempt ?? event.attempt;
+					progress.retryState = undefined;
+					if (!event.success) {
+						progress.retryFailure = {
+							attempt,
+							errorMessage: event.finalError ?? "Auto-retry failed",
+						};
+					}
+					scheduleProgress(true);
+					return;
+				}
 				if (isAgentEvent(event)) {
 					try {
 						processEvent(event);
@@ -1360,6 +1387,21 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 			});
 
 			checkAbort();
+			// Autoload skills via sendCustomMessage (same mechanic as /skill:<name>)
+			if (options.autoloadSkills?.length) {
+				for (const skill of options.autoloadSkills) {
+					const { message } = await buildSkillPromptMessage(skill, "");
+					await session.sendCustomMessage(
+						{
+							customType: SKILL_PROMPT_MESSAGE_TYPE,
+							content: message,
+							display: false,
+							details: { name: skill.name, path: skill.filePath },
+						},
+						{ triggerTurn: false },
+					);
+				}
+			}
 			await awaitAbortable(session.prompt(task, { attribution: "agent" }));
 			await awaitAbortable(session.waitForIdle());
 
@@ -1367,6 +1409,12 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 			let retryCount = 0;
 			while (!yieldCalled && retryCount < MAX_YIELD_RETRIES && !abortSignal.aborted) {
+				// Skip reminders when the model returned a terminal error (e.g.
+				// rate-limit cap hit, auth failure). Re-prompting would just
+				// hit the same wall, multiplying the failure noise without
+				// any chance of producing a yield.
+				const lastBeforeReminder = session.getLastAssistantMessage();
+				if (lastBeforeReminder?.stopReason === "error") break;
 				try {
 					retryCount++;
 					const reminder = prompt.render(submitReminderTemplate, {
@@ -1566,6 +1614,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		usage: hasUsage ? accumulatedUsage : undefined,
 		outputPath,
 		extractedToolData: progress.extractedToolData,
+		retryFailure: progress.retryFailure,
 		outputMeta,
 	};
 }

package/src/task/index.ts

@@ -410,6 +410,8 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 								progress.contextWindow = singleResult?.contextWindow;
 								progress.cost = singleResult?.usage?.cost.total ?? 0;
 								progress.extractedToolData = singleResult?.extractedToolData;
+								progress.retryFailure = singleResult?.retryFailure;
+								progress.retryState = undefined;
 							}
 							completedJobs += 1;
 							if (singleResult && ((singleResult.aborted ?? false) || singleResult.exitCode !== 0)) {
@@ -830,6 +832,13 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			const tasksWithUniqueIds = tasks.map((t, i) => ({ ...t, id: uniqueIds[i] }));
 
 			const availableSkills = [...(this.session.skills ?? [])];
+			// Resolve autoload skills from agent definition against available skills
+			const resolvedAutoloadSkills =
+				agent.autoloadSkills?.length && availableSkills.length > 0
+					? agent.autoloadSkills
+							.map(name => availableSkills.find(s => s.name === name))
+							.filter((s): s is NonNullable<typeof s> => s !== undefined)
+					: [];
 			const contextFiles = this.session.contextFiles?.filter(
 				file => path.basename(file.path).toLowerCase() !== "agents.md",
 			);
@@ -894,6 +903,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						mcpManager: MCPManager.instance(),
 						contextFiles,
 						skills: availableSkills,
+						autoloadSkills: resolvedAutoloadSkills,
 						workspaceTree: this.session.workspaceTree,
 						promptTemplates,
 						localProtocolOptions,
@@ -948,6 +958,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						mcpManager: MCPManager.instance(),
 						contextFiles,
 						skills: availableSkills,
+						autoloadSkills: resolvedAutoloadSkills,
 						workspaceTree: this.session.workspaceTree,
 						promptTemplates,
 						localProtocolOptions,

package/src/task/render.ts

@@ -551,8 +551,15 @@ function renderAgentProgress(
 	const titlePart = description ? `${theme.bold(displayId)}: ${description}` : displayId;
 	let statusLine = `${prefix} ${theme.fg(iconColor, icon)} ${theme.fg("accent", titlePart)}`;
 
-	// Only show badge for non-running states (spinner already indicates running)
-	if (progress.status === "failed" || progress.status === "aborted") {
+	// Show retry-blocked badge so the parent immediately sees that a child
+	// is sleeping on a provider 429, not silently progressing. Wins over the
+	// generic running spinner because "we're waiting on a quota window" is
+	// the operationally meaningful state.
+	if (progress.retryState && progress.status === "running") {
+		statusLine += ` ${formatBadge("retrying", "warning", theme)}`;
+	} else if (progress.retryFailure && (progress.status === "failed" || progress.status === "aborted")) {
+		statusLine += ` ${formatBadge("rate-limited", "error", theme)}`;
+	} else if (progress.status === "failed" || progress.status === "aborted") {
 		const statusLabel = progress.status === "failed" ? "failed" : "aborted";
 		statusLine += ` ${formatBadge(statusLabel, iconColor, theme)}`;
 	}
@@ -598,6 +605,23 @@ function renderAgentProgress(
 		}
 	}
 
+	// Retry detail line: surface why the subagent is paused and roughly how
+	// long until the next attempt. Without this, the parent UI would just
+	// keep spinning while a child sleeps on a 3-hour provider rate-limit.
+	if (progress.retryState && progress.status === "running") {
+		const remainingMs = Math.max(0, progress.retryState.startedAtMs + progress.retryState.delayMs - Date.now());
+		const waitLabel = remainingMs > 0 ? `in ${formatDuration(remainingMs)}` : "now";
+		const summary =
+			`retrying ${progress.retryState.attempt}/${progress.retryState.maxAttempts} ${waitLabel}: ` +
+			truncateToWidth(replaceTabs(progress.retryState.errorMessage), 60);
+		lines.push(`${continuePrefix}${theme.tree.hook} ${theme.fg("warning", summary)}`);
+	} else if (progress.retryFailure && progress.status !== "running") {
+		const summary = `auto-retry gave up after ${progress.retryFailure.attempt} attempt${
+			progress.retryFailure.attempt === 1 ? "" : "s"
+		}: ${truncateToWidth(replaceTabs(progress.retryFailure.errorMessage), 80)}`;
+		lines.push(`${continuePrefix}${theme.tree.hook} ${theme.fg("error", summary)}`);
+	}
+
 	// Render extracted tool data inline (e.g., review findings)
 	if (progress.extractedToolData) {
 		// For completed tasks, check for review verdict from yield tool