@oh-my-pi/pi-coding-agent 15.1.9 → 15.2.1

package/src/goals/tools/goal-tool.ts

@@ -15,7 +15,7 @@ import { completionBudgetReport, remainingTokens } from "../runtime";
 import type { Goal, GoalStatus, GoalToolDetails } from "../state";
 
 const goalSchema = z.object({
-	op: z.enum(["create", "get", "complete"]).describe("goal operation"),
+	op: z.enum(["create", "get", "complete", "resume", "drop"]).describe("goal operation"),
 	objective: z.string().describe("goal objective").optional(),
 	token_budget: z.number().int().describe("token budget").optional(),
 });
@@ -86,7 +86,13 @@ export class GoalTool implements AgentTool<typeof goalSchema, GoalToolDetails> {
 			response = buildGoalToolResponse(created.goal);
 		} else if (params.op === "get") {
 			const state = this.#session.getGoalModeState?.();
-			response = buildGoalToolResponse(state?.enabled ? state.goal : null);
+			response = buildGoalToolResponse(state?.goal ?? null);
+		} else if (params.op === "resume") {
+			const resumed = await runtime.resumeGoal();
+			response = buildGoalToolResponse(resumed.goal);
+		} else if (params.op === "drop") {
+			const dropped = await runtime.dropGoal();
+			response = buildGoalToolResponse(dropped ?? null);
 		} else {
 			const completed = await runtime.completeGoalFromTool();
 			response = buildGoalToolResponse(completed, { includeCompletionReport: true });
@@ -126,6 +132,10 @@ function describeOp(op: string | undefined): string {
 			return "complete";
 		case "get":
 			return "check";
+		case "resume":
+			return "resume";
+		case "drop":
+			return "drop";
 		default:
 			return op ?? "?";
 	}

package/src/hashline/diff.ts

@@ -30,7 +30,7 @@ export async function computeHashlineSectionDiff(
 		const rawContent = await readHashlineFileText(Bun.file(absolutePath), absolutePath, section.path);
 		const { text: content } = stripBom(rawContent);
 		const normalized = normalizeToLF(content);
-		const result = applyHashlineEdits(normalized, parseHashline(section.diff), options);
+		const result = applyHashlineEdits(normalized, parseHashline(section.diff, { path: section.path }), options);
 		if (normalized === result.lines) return { error: `No changes would be made to ${section.path}.` };
 		return generateDiffString(normalized, result.lines);
 	} catch (err) {

package/src/hashline/execute.ts

@@ -106,7 +106,7 @@ async function preflightHashlineSection(options: ExecuteHashlineSingleOptions &
 	const { session, path: sectionPath, diff } = options;
 
 	const absolutePath = resolvePlanPath(session, sectionPath);
-	const { edits } = parseHashlineWithWarnings(diff);
+	const { edits } = parseHashlineWithWarnings(diff, { path: sectionPath });
 	enforcePlanModeWrite(session, sectionPath, { op: "update" });
 
 	const source = await readHashlineFile(absolutePath, sectionPath);
@@ -139,7 +139,7 @@ async function executeHashlineSection(
 	} = options;
 
 	const absolutePath = resolvePlanPath(session, sourcePath);
-	const { edits, warnings: parseWarnings } = parseHashlineWithWarnings(diff);
+	const { edits, warnings: parseWarnings } = parseHashlineWithWarnings(diff, { path: sourcePath });
 	enforcePlanModeWrite(session, sourcePath, { op: "update" });
 
 	const source = await readHashlineFile(absolutePath, sourcePath);

package/src/hashline/parser.ts

@@ -74,22 +74,86 @@ export function cloneCursor(cursor: HashlineCursor): HashlineCursor {
 	if (cursor.kind === "after_anchor") return { kind: "after_anchor", anchor: { ...cursor.anchor } };
 	return cursor;
 }
-/** Returns true when every non-empty payload line starts with `${sep} ` (sep + one space). */
+/**
+ * Returns true when every non-empty payload line looks like the `~ TEXT` readability-padding
+ * typo: exactly one leading space followed by a non-space character (or a bare single space).
+ *
+ * Indented file content (Python 4-space, YAML/JSON/Markdown 2-space, etc.) starts with two or
+ * more leading spaces, so this heuristic ignores legitimate indentation while still flagging
+ * the common `~ beta` mistake that silently corrupts file content with a stray space.
+ */
 function hasUniformSeparatorPadding(payload: string[]): boolean {
 	let any = false;
 	for (const text of payload) {
 		if (text.length === 0) continue;
-		if (!text.startsWith(" ")) return false;
+		if (text.charCodeAt(0) !== 0x20) return false;
+		// Two or more leading spaces is real indentation, not separator padding.
+		if (text.length > 1 && text.charCodeAt(1) === 0x20) return false;
 		any = true;
 	}
 	return any;
 }
 
+/**
+ * File extensions where leading single-space indentation is plausible legitimate file content
+ * (off-side-rule languages, structured-indent data formats, prose with continuation indent).
+ * For these we suppress the separator-padding warning entirely — the heuristic's false-positive
+ * cost on a real edit outweighs the rare chance it catches a `~ TEXT` typo.
+ */
+const INDENT_SENSITIVE_EXTS: Record<string, true> = {
+	".py": true,
+	".pyi": true,
+	".pyx": true,
+	".pyw": true,
+	".yml": true,
+	".yaml": true,
+	".md": true,
+	".mdx": true,
+	".markdown": true,
+	".rst": true,
+	".adoc": true,
+	".asciidoc": true,
+	".toml": true,
+	".json": true,
+	".jsonc": true,
+	".json5": true,
+	".ndjson": true,
+	".jsonl": true,
+	".tf": true,
+	".tfvars": true,
+	".hcl": true,
+	".nix": true,
+	".coffee": true,
+	".litcoffee": true,
+	".haml": true,
+	".slim": true,
+	".pug": true,
+	".jade": true,
+	".sass": true,
+	".styl": true,
+	".nim": true,
+	".cr": true,
+	".elm": true,
+	".fs": true,
+	".fsi": true,
+	".fsx": true,
+};
+
+function isIndentationSensitivePath(path: string | undefined): boolean {
+	if (!path) return false;
+	const slash = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+	const dot = path.lastIndexOf(".");
+	if (dot <= slash) return false;
+	const ext = path.slice(dot).toLowerCase();
+	return INDENT_SENSITIVE_EXTS[ext] === true;
+}
+
 function collectPayload(
 	lines: string[],
 	startIndex: number,
 	opLineNum: number,
 	requirePayload: boolean,
+	checkPadding: boolean,
 ): { payload: string[]; nextIndex: number; paddingWarning?: string } {
 	const payload: string[] = [];
 	let index = startIndex;
@@ -125,21 +189,32 @@ function collectPayload(
 	if (payload.length === 0 && requirePayload) {
 		throw new Error(`line ${opLineNum}: + and < operations require at least one ${HL_EDIT_SEP}TEXT payload line.`);
 	}
-	const paddingWarning = hasUniformSeparatorPadding(payload)
-		? `line ${opLineNum}: all payload lines start with "${HL_EDIT_SEP} " (separator + space). ` +
-			`The space becomes file content. Remove it unless the target file requires leading spaces.`
-		: undefined;
+	const paddingWarning =
+		checkPadding && hasUniformSeparatorPadding(payload)
+			? `line ${opLineNum}: every payload line begins with exactly one space before non-space content, ` +
+				`which looks like a readability gap after "${HL_EDIT_SEP}". The space becomes file content. ` +
+				`Drop it unless the file genuinely uses a one-space indent.`
+			: undefined;
 	return { payload, nextIndex: index, paddingWarning };
 }
 
-export function parseHashline(diff: string): HashlineEdit[] {
-	return parseHashlineWithWarnings(diff).edits;
+export function parseHashline(diff: string, opts: ParseHashlineOptions = {}): HashlineEdit[] {
+	return parseHashlineWithWarnings(diff, opts).edits;
+}
+
+export interface ParseHashlineOptions {
+	/** File path the diff targets. Used to suppress indent-sensitive false-positive warnings. */
+	path?: string;
 }
 
-export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]; warnings: string[] } {
+export function parseHashlineWithWarnings(
+	diff: string,
+	opts: ParseHashlineOptions = {},
+): { edits: HashlineEdit[]; warnings: string[] } {
 	const edits: HashlineEdit[] = [];
 	const warnings: string[] = [];
 	const lines = diff.split(/\r?\n/);
+	const checkPadding = !isIndentationSensitivePath(opts.path);
 	let editIndex = 0;
 
 	const pushInsert = (cursor: HashlineCursor, text: string, lineNum: number) => {
@@ -172,7 +247,7 @@ export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]
 		const insertBeforeMatch = INSERT_BEFORE_OP_RE.exec(line);
 		if (insertBeforeMatch) {
 			const cursor = parseInsertTarget(insertBeforeMatch[1], lineNum, "before");
-			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, true);
+			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, true, checkPadding);
 			if (paddingWarning) warnings.push(paddingWarning);
 			for (const text of payload) pushInsert(cursor, text, lineNum);
 			i = nextIndex;
@@ -182,7 +257,7 @@ export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]
 		const insertAfterMatch = INSERT_AFTER_OP_RE.exec(line);
 		if (insertAfterMatch) {
 			const cursor = parseInsertTarget(insertAfterMatch[1], lineNum, "after");
-			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, true);
+			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, true, checkPadding);
 			if (paddingWarning) warnings.push(paddingWarning);
 			for (const text of payload) pushInsert(cursor, text, lineNum);
 			i = nextIndex;
@@ -201,7 +276,7 @@ export function parseHashlineWithWarnings(diff: string): { edits: HashlineEdit[]
 		const replaceMatch = REPLACE_OP_RE.exec(line);
 		if (replaceMatch) {
 			const range = parseRange(replaceMatch[1], lineNum);
-			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, false);
+			const { payload, nextIndex, paddingWarning } = collectPayload(lines, i + 1, lineNum, false, checkPadding);
 			if (paddingWarning) warnings.push(paddingWarning);
 			// `= A..B` with no payload blanks the range to a single empty line.
 			const replacement = payload.length === 0 ? [""] : payload;

package/src/internal-urls/memory-protocol.ts

@@ -14,7 +14,7 @@ const MEMORY_NAMESPACE = "root";
  * Each session has its own cwd (possibly a worktree), so subagents and main
  * may see different roots.
  */
-function memoryRootsFromRegistry(): string[] {
+export function memoryRootsFromRegistry(): string[] {
 	const agentDir = getAgentDir();
 	const roots: string[] = [];
 	for (const ref of AgentRegistry.global().list()) {

package/src/modes/interactive-mode.ts

@@ -98,6 +98,7 @@ import {
 } from "./loop-limit";
 import { OAuthManualInputManager } from "./oauth-manual-input";
 import { SessionObserverRegistry } from "./session-observer-registry";
+import { type ShimmerPalette, shimmerSegments, shimmerText } from "./theme/shimmer";
 import type { Theme } from "./theme/theme";
 import {
 	getEditorTheme,
@@ -110,6 +111,20 @@ import {
 import type { CompactionQueuedMessage, InteractiveModeContext, SubmittedUserInput, TodoItem, TodoPhase } from "./types";
 import { UiHelpers } from "./utils/ui-helpers";
 
+const WORKING_INTERRUPT_HINT = " (esc to interrupt)";
+
+const HINT_SHIMMER_PALETTE: ShimmerPalette = {
+	low: "dim",
+	mid: "muted",
+	high: "borderAccent",
+};
+
+function renderWorkingMessage(message: string): string {
+	if (!message.endsWith(WORKING_INTERRUPT_HINT)) return shimmerText(message, theme);
+	const header = message.slice(0, -WORKING_INTERRUPT_HINT.length);
+	return shimmerSegments([{ text: header }, { text: WORKING_INTERRUPT_HINT, palette: HINT_SHIMMER_PALETTE }], theme);
+}
+
 const EDITOR_MAX_HEIGHT_MIN = 6;
 const EDITOR_MAX_HEIGHT_MAX = 18;
 const EDITOR_RESERVED_ROWS = 12;
@@ -1063,6 +1078,12 @@ export class InteractiveMode implements InteractiveModeContext {
 			return;
 		}
 		if (event.type === "goal_updated") {
+			// Handle drop before clearing goalModeEnabled so #exitGoalMode can
+			// still restore the previous tool set while the flag is true.
+			if (event.state?.goal?.status === "dropped") {
+				await this.#exitGoalMode({ reason: "dropped", silent: true });
+				return;
+			}
 			this.goalModeEnabled = event.state?.enabled === true;
 			this.goalModePaused = event.state?.enabled !== true && event.state?.goal?.status === "paused";
 			if (!event.state?.enabled) {
@@ -1150,6 +1171,13 @@ export class InteractiveMode implements InteractiveModeContext {
 			const restored = await this.session.goalRuntime.onThreadResumed();
 			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.
+			// Re-add it now so the agent can call resume, complete, or drop on this goal.
+			if (restored?.goal) {
+				const previousTools = this.session.getActiveToolNames().filter(name => name !== "goal");
+				this.#goalModePreviousTools = previousTools;
+				await this.session.setActiveToolsByName([...new Set([...previousTools, "goal"])]);
+			}
 			this.#updateGoalModeStatus();
 			return;
 		}
@@ -2167,7 +2195,7 @@ export class InteractiveMode implements InteractiveModeContext {
 			this.loadingAnimation = new Loader(
 				this.ui,
 				spinner => theme.fg("accent", spinner),
-				text => theme.fg("muted", text),
+				renderWorkingMessage,
 				this.#defaultWorkingMessage,
 				getSymbolTheme().spinnerFrames,
 			);

package/src/modes/theme/shimmer.ts

@@ -0,0 +1,79 @@
+import type { Theme, ThemeColor } from "./theme";
+
+const SHIMMER_PADDING = 10;
+const SHIMMER_SWEEP_MS = 2000;
+const SHIMMER_BAND_HALF_WIDTH = 5;
+
+type ShimmerTheme = Pick<Theme, "bold" | "fg">;
+
+/** Three-tier color stack a shimmer character cycles through as the band sweeps. */
+export interface ShimmerPalette {
+	/** Color for chars outside / at the edge of the band (intensity < 0.2). */
+	low: ThemeColor;
+	/** Color for chars approaching the crest (0.2 <= intensity < 0.6). */
+	mid: ThemeColor;
+	/** Color at the band's crest (intensity >= 0.6). */
+	high: ThemeColor;
+	/** Whether to bold the crest tier. Default `false`. */
+	bold?: boolean;
+}
+
+/** One run of text that shares a palette inside a larger shimmer sweep. */
+export interface ShimmerSegment {
+	text: string;
+	palette?: ShimmerPalette;
+}
+
+export const DEFAULT_SHIMMER_PALETTE: ShimmerPalette = {
+	low: "dim",
+	mid: "muted",
+	high: "accent",
+	bold: true,
+};
+
+function shimmerIntensity(index: number, length: number): number {
+	const period = length + SHIMMER_PADDING * 2;
+	const pos = Math.floor(((Date.now() % SHIMMER_SWEEP_MS) / SHIMMER_SWEEP_MS) * period);
+	const dist = Math.abs(index + SHIMMER_PADDING - pos);
+	if (dist > SHIMMER_BAND_HALF_WIDTH) return 0;
+
+	const x = Math.PI * (dist / SHIMMER_BAND_HALF_WIDTH);
+	return 0.5 * (1 + Math.cos(x));
+}
+
+function styleShimmerChar(ch: string, intensity: number, theme: ShimmerTheme, palette: ShimmerPalette): string {
+	if (intensity < 0.2) return theme.fg(palette.low, ch);
+	if (intensity < 0.6) return theme.fg(palette.mid, ch);
+	const styled = theme.fg(palette.high, ch);
+	return palette.bold ? theme.bold(styled) : styled;
+}
+
+/**
+ * Apply a shimmer sweep across one or more segments, treating them as a single
+ * continuous string for band positioning. Each segment can supply its own
+ * palette so the gradient stays in lockstep while the colors differ.
+ */
+export function shimmerSegments(segments: readonly ShimmerSegment[], theme: ShimmerTheme): string {
+	let total = 0;
+	const expanded: Array<{ chars: string[]; palette: ShimmerPalette }> = [];
+	for (const seg of segments) {
+		const chars = [...seg.text];
+		total += chars.length;
+		expanded.push({ chars, palette: seg.palette ?? DEFAULT_SHIMMER_PALETTE });
+	}
+	if (total === 0) return "";
+
+	const out: string[] = [];
+	let index = 0;
+	for (const { chars, palette } of expanded) {
+		for (const ch of chars) {
+			out.push(styleShimmerChar(ch, shimmerIntensity(index, total), theme, palette));
+			index++;
+		}
+	}
+	return out.join("");
+}
+
+export function shimmerText(text: string, theme: ShimmerTheme, palette?: ShimmerPalette): string {
+	return shimmerSegments([{ text, palette }], theme);
+}

package/src/prompts/tools/goal.md

@@ -1,13 +1,18 @@
 Manage the active goal-mode objective.
 
 Use a single `op` field:
-- `create` starts a goal. Requires `objective`; optional `token_budget` must be positive. Use only when no goal exists.
-- `get` returns the current goal and remaining token budget.
+- `create` starts a goal. Requires `objective`; optional `token_budget` must be positive. Use only when no goal exists and no goal is paused.
+- `get` returns the current goal (active or paused) and remaining token budget.
+- `resume` re-activates a paused goal so work can continue.
 - `complete` marks the goal complete after you have verified every deliverable against current evidence.
+- `drop` discards the current goal without completing it.
 
 Examples:
 - `goal({"op":"create","objective":"Implement feature X","token_budget":50000})`
 - `goal({"op":"get"})`
+- `goal({"op":"resume"})`
 - `goal({"op":"complete"})`
+- `goal({"op":"drop"})`
 
 Do not call `complete` because a budget is low or a turn is ending. Call it only when the goal is actually done and verified.
+If `get` shows a paused goal, call `resume` before continuing work on it.

package/src/session/agent-session.ts

@@ -440,11 +440,6 @@ function formatRetryFallbackBaseSelector(selector: RetryFallbackSelector): strin
 	return `${selector.provider}/${selector.id}`;
 }
 
-/** Composite key for auto-clear timers, keyed by phase name + task content. */
-function todoClearKey(phaseName: string, taskContent: string): string {
-	return `${phaseName}\u0000${taskContent}`;
-}
-
 const IRC_REPLY_MAX_BYTES = 4096;
 
 /**
@@ -796,7 +791,6 @@ export class AgentSession {
 	// Todo completion reminder state
 	#todoReminderCount = 0;
 	#todoPhases: TodoPhase[] = [];
-	#todoClearTimers = new Map<string, Timer>();
 	#toolChoiceQueue = new ToolChoiceQueue();
 
 	// Bash execution state
@@ -2734,7 +2728,6 @@ export class AgentSession {
 			logger.warn("Failed to emit session_shutdown event", { error: String(error) });
 		}
 		await this.#cancelPostPromptTasks();
-		this.#clearTodoClearTimers();
 		// Cancel jobs this agent registered so a subagent's teardown doesn't
 		// leak its background bash/task work into the parent's manager. Only
 		// the session that owns the manager goes on to dispose it (which itself
@@ -4628,13 +4621,12 @@ export class AgentSession {
 
 	setTodoPhases(phases: TodoPhase[]): void {
 		this.#todoPhases = this.#cloneTodoPhases(phases);
-		this.#scheduleTodoAutoClear(phases);
 	}
 
 	#syncTodoPhasesFromBranch(): void {
 		const phases = getLatestTodoPhasesFromEntries(this.sessionManager.getBranch());
 		// Strip completed/abandoned tasks — they were done in a previous run,
-		// so the auto-clear grace period has already elapsed.
+		// so they have no bearing on progress tracking for the new turn.
 		for (const phase of phases) {
 			phase.tasks = phase.tasks.filter(t => t.status !== "completed" && t.status !== "abandoned");
 		}
@@ -4652,72 +4644,11 @@ export class AgentSession {
 		}));
 	}
 
-	/** Schedule auto-removal of completed/abandoned tasks after a delay. */
-	#scheduleTodoAutoClear(phases: TodoPhase[]): void {
-		// Default bumped from 60s to 30 min: the prior 60s splice mutated canonical
-		// state mid-turn, so the model observed phase totals shrinking ("6 → 5")
-		// between tool calls. Surviving the turn matches user expectations; a
-		// render-time filter in the UI consumer would be cleaner but lives in a
-		// different package and is out of scope for this fix.
-		const delaySec = this.settings.get("tasks.todoClearDelay") ?? 1800;
-		if (delaySec < 0) return; // "Never" — no auto-clear
-		const delayMs = delaySec * 1000;
-		const doneKeys = new Set<string>();
-		for (const phase of phases) {
-			for (const task of phase.tasks) {
-				if (task.status === "completed" || task.status === "abandoned") {
-					doneKeys.add(todoClearKey(phase.name, task.content));
-				}
-			}
-		}
-
-		// Cancel timers for tasks that are no longer done (e.g. status was reverted)
-		for (const [key, timer] of this.#todoClearTimers) {
-			if (!doneKeys.has(key)) {
-				clearTimeout(timer);
-				this.#todoClearTimers.delete(key);
-			}
-		}
-
-		// Schedule new timers for newly-done tasks
-		for (const key of doneKeys) {
-			if (this.#todoClearTimers.has(key)) continue;
-			if (delayMs === 0) {
-				// Instant — run synchronously on next microtask to batch removals
-				const timer = setTimeout(() => this.#runTodoAutoClear(key), 0);
-				this.#todoClearTimers.set(key, timer);
-			} else {
-				const timer = setTimeout(() => this.#runTodoAutoClear(key), delayMs);
-				this.#todoClearTimers.set(key, timer);
-			}
-		}
-	}
-
-	/** Remove a single completed task and notify the UI. */
-	#runTodoAutoClear(key: string): void {
-		this.#todoClearTimers.delete(key);
-		let removed = false;
-		for (const phase of this.#todoPhases) {
-			const idx = phase.tasks.findIndex(t => todoClearKey(phase.name, t.content) === key);
-			if (idx !== -1 && (phase.tasks[idx].status === "completed" || phase.tasks[idx].status === "abandoned")) {
-				phase.tasks.splice(idx, 1);
-				removed = true;
-				break;
-			}
-		}
-		if (!removed) return;
-
-		// Remove empty phases
-		this.#todoPhases = this.#todoPhases.filter(p => p.tasks.length > 0);
-		this.#emit({ type: "todo_auto_clear" });
-	}
-
-	#clearTodoClearTimers(): void {
-		for (const timer of this.#todoClearTimers.values()) {
-			clearTimeout(timer);
-		}
-		this.#todoClearTimers.clear();
-	}
+	// Auto-clear of completed/abandoned tasks was removed: the timer-driven
+	// splice mutated canonical `#todoPhases` between tool calls, so the model
+	// observed phase totals shrinking ("5 → 4") after marking tasks done. The
+	// `tasks.todoClearDelay` setting is now inert; completed tasks survive
+	// until the next explicit `todo_write` call removes them via `rm`/`drop`.
 
 	/**
 	 * Abort current operation and wait for agent to become idle.
@@ -6240,6 +6171,12 @@ export class AgentSession {
 		};
 
 		const currentModel = this.model;
+		// Prefer the active session's model: it's what the user is actively using,
+		// and routing compaction to a different provider (e.g. an OpenAI default
+		// model while the chat is on Anthropic) changes provider-specific behavior
+		// like remote compaction endpoints. Role-based candidates only kick in
+		// as auth fallbacks when the current model has no usable credentials.
+		addCandidate(currentModel);
 		for (const role of MODEL_ROLE_IDS) {
 			addCandidate(this.#resolveRoleModelFull(role, availableModels, currentModel).model);
 		}

package/src/slash-commands/helpers/format.ts

@@ -1,3 +1,6 @@
+import { shimmerText } from "../../modes/theme/shimmer";
+import { theme as currentTheme, type Theme } from "../../modes/theme/theme";
+
 /** Format a millisecond duration as a coarse-grained human label. */
 export function formatDuration(ms: number): string {
 	const seconds = Math.max(0, Math.round(ms / 1000));
@@ -10,14 +13,31 @@ export function formatDuration(ms: number): string {
 	return `${days}d`;
 }
 
+type ProgressBarTheme = Pick<Theme, "bold" | "fg">;
+
+const unstyledProgressBarTheme: ProgressBarTheme = {
+	fg(_color, text) {
+		return text;
+	},
+	bold(text) {
+		return text;
+	},
+};
+
+function resolveProgressBarTheme(uiTheme: ProgressBarTheme | undefined): ProgressBarTheme {
+	return uiTheme ?? currentTheme ?? unstyledProgressBarTheme;
+}
+
 /**
  * Render an ASCII progress bar with a trailing percent label.
  * `fraction` is clamped to `[0, 1]`. `undefined` renders a dotted placeholder.
  */
-export function renderAsciiBar(fraction: number | undefined, width = 24): string {
-	if (fraction === undefined) return `[${"·".repeat(width)}]`;
+export function renderAsciiBar(fraction: number | undefined, width = 24, uiTheme?: ProgressBarTheme): string {
+	const progressBarTheme = resolveProgressBarTheme(uiTheme);
+	if (fraction === undefined) return `[${shimmerText("·".repeat(width), progressBarTheme)}]`;
 	const clamped = Math.min(Math.max(fraction, 0), 1);
 	const filled = Math.round(clamped * width);
 	const pct = Math.round(clamped * 100);
-	return `[${"█".repeat(filled)}${"░".repeat(Math.max(0, width - filled))}] ${pct}%`;
+	const bar = `${"█".repeat(filled)}${"░".repeat(Math.max(0, width - filled))}`;
+	return `[${shimmerText(bar, progressBarTheme)}] ${pct}%`;
 }