npm - @oh-my-pi/pi-coding-agent - Versions diffs - 15.0.0 → 15.0.2 - Mend

@oh-my-pi/pi-coding-agent 15.0.0 → 15.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (165) hide show

package/CHANGELOG.md +79 -0
package/examples/extensions/plan-mode.ts +0 -1
package/package.json +10 -10
package/scripts/build-binary.ts +5 -0
package/src/autoresearch/helpers.ts +17 -0
package/src/autoresearch/tools/log-experiment.ts +9 -17
package/src/autoresearch/tools/run-experiment.ts +2 -17
package/src/capability/skill.ts +7 -0
package/src/cli/list-models.ts +1 -1
package/src/cli/shell-cli.ts +3 -13
package/src/cli/update-cli.ts +1 -1
package/src/cli.ts +10 -29
package/src/commands/commit.ts +10 -0
package/src/commit/agentic/tools/propose-changelog.ts +8 -1
package/src/commit/analysis/conventional.ts +8 -66
package/src/commit/map-reduce/reduce-phase.ts +6 -65
package/src/commit/pipeline.ts +2 -2
package/src/commit/shared-llm.ts +89 -0
package/src/config/config-file.ts +210 -0
package/src/config/model-equivalence.ts +8 -11
package/src/config/model-registry.ts +44 -3
package/src/config/model-resolver.ts +1 -4
package/src/config/settings-schema.ts +82 -1
package/src/config/settings.ts +1 -1
package/src/config.ts +3 -219
package/src/discovery/claude-plugins.ts +19 -7
package/src/edit/renderer.ts +7 -1
package/src/eval/js/executor.ts +3 -0
package/src/eval/js/shared/rewrite-imports.ts +2 -2
package/src/eval/py/executor.ts +5 -0
package/src/eval/py/runner.py +42 -11
package/src/eval/py/runtime.ts +1 -0
package/src/exa/factory.ts +2 -2
package/src/exa/mcp-client.ts +74 -1
package/src/exec/bash-executor.ts +5 -1
package/src/export/html/template.generated.ts +1 -1
package/src/export/html/template.js +0 -11
package/src/extensibility/extensions/get-commands-handler.ts +77 -0
package/src/extensibility/extensions/runner.ts +1 -1
package/src/extensibility/extensions/types.ts +89 -223
package/src/extensibility/hooks/types.ts +89 -314
package/src/extensibility/plugins/legacy-pi-compat.ts +48 -31
package/src/extensibility/shared-events.ts +343 -0
package/src/extensibility/skills.ts +9 -0
package/src/goals/index.ts +3 -0
package/src/goals/runtime.ts +500 -0
package/src/goals/state.ts +37 -0
package/src/goals/tools/goal-tool.ts +237 -0
package/src/hashline/anchors.ts +2 -2
package/src/hashline/input.ts +2 -1
package/src/hashline/parser.ts +27 -3
package/src/hindsight/mental-models.ts +1 -1
package/src/internal-urls/agent-protocol.ts +1 -20
package/src/internal-urls/artifact-protocol.ts +1 -19
package/src/internal-urls/docs-index.generated.ts +11 -12
package/src/internal-urls/registry-helpers.ts +25 -0
package/src/internal-urls/router.ts +8 -0
package/src/internal-urls/types.ts +21 -0
package/src/lsp/config.ts +15 -6
package/src/lsp/defaults.json +6 -2
package/src/main.ts +11 -2
package/src/mcp/oauth-flow.ts +20 -0
package/src/modes/acp/acp-agent.ts +327 -95
package/src/modes/components/assistant-message.ts +14 -8
package/src/modes/components/bash-execution.ts +24 -63
package/src/modes/components/custom-message.ts +14 -40
package/src/modes/components/eval-execution.ts +27 -57
package/src/modes/components/execution-shared.ts +102 -0
package/src/modes/components/hook-message.ts +17 -49
package/src/modes/components/mcp-add-wizard.ts +26 -5
package/src/modes/components/message-frame.ts +88 -0
package/src/modes/components/model-selector.ts +1 -1
package/src/modes/components/session-observer-overlay.ts +6 -2
package/src/modes/components/session-selector.ts +1 -1
package/src/modes/components/status-line/segments.ts +93 -8
package/src/modes/components/status-line/types.ts +4 -0
package/src/modes/components/status-line.ts +28 -10
package/src/modes/components/tool-execution.ts +7 -8
package/src/modes/controllers/command-controller-shared.ts +108 -0
package/src/modes/controllers/command-controller.ts +13 -4
package/src/modes/controllers/event-controller.ts +36 -7
package/src/modes/controllers/extension-ui-controller.ts +3 -2
package/src/modes/controllers/input-controller.ts +13 -0
package/src/modes/controllers/mcp-command-controller.ts +56 -61
package/src/modes/controllers/ssh-command-controller.ts +18 -57
package/src/modes/interactive-mode.ts +624 -52
package/src/modes/print-mode.ts +16 -86
package/src/modes/rpc/host-uris.ts +235 -0
package/src/modes/rpc/rpc-mode.ts +41 -88
package/src/modes/rpc/rpc-types.ts +57 -0
package/src/modes/runtime-init.ts +116 -0
package/src/modes/theme/defaults/dark-poimandres.json +3 -0
package/src/modes/theme/defaults/light-poimandres.json +3 -0
package/src/modes/theme/theme.ts +24 -6
package/src/modes/types.ts +14 -3
package/src/modes/utils/context-usage.ts +13 -13
package/src/modes/utils/ui-helpers.ts +10 -3
package/src/plan-mode/approved-plan.ts +35 -1
package/src/prompts/goals/goal-budget-limit.md +16 -0
package/src/prompts/goals/goal-continuation.md +28 -0
package/src/prompts/goals/goal-mode-active.md +23 -0
package/src/prompts/system/plan-mode-active.md +5 -5
package/src/prompts/system/plan-mode-tool-decision-reminder.md +1 -1
package/src/prompts/tools/bash.md +6 -0
package/src/prompts/tools/github.md +4 -4
package/src/prompts/tools/goal.md +13 -0
package/src/prompts/tools/hashline.md +101 -117
package/src/prompts/tools/read.md +55 -36
package/src/prompts/tools/resolve.md +6 -5
package/src/sdk.ts +12 -5
package/src/session/agent-session.ts +428 -106
package/src/session/blob-store.ts +36 -3
package/src/session/messages.ts +67 -2
package/src/session/session-manager.ts +131 -12
package/src/session/session-storage.ts +33 -15
package/src/session/streaming-output.ts +309 -13
package/src/slash-commands/builtin-registry.ts +18 -0
package/src/ssh/ssh-executor.ts +5 -0
package/src/system-prompt.ts +4 -2
package/src/task/discovery.ts +5 -2
package/src/task/executor.ts +19 -8
package/src/task/index.ts +3 -0
package/src/task/render.ts +21 -15
package/src/task/types.ts +4 -0
package/src/tools/ast-edit.ts +21 -120
package/src/tools/ast-grep.ts +21 -119
package/src/tools/bash-command-fixup.ts +47 -0
package/src/tools/bash-interactive.ts +9 -1
package/src/tools/bash.ts +66 -19
package/src/tools/browser/attach.ts +3 -3
package/src/tools/browser/launch.ts +81 -18
package/src/tools/browser/registry.ts +1 -5
package/src/tools/browser/render.ts +2 -2
package/src/tools/browser/tab-supervisor.ts +51 -14
package/src/tools/conflict-detect.ts +15 -4
package/src/tools/eval.ts +12 -2
package/src/tools/find.ts +20 -38
package/src/tools/gh.ts +44 -10
package/src/tools/index.ts +22 -11
package/src/tools/inspect-image.ts +3 -10
package/src/tools/job.ts +16 -7
package/src/tools/output-meta.ts +202 -37
package/src/tools/path-utils.ts +125 -2
package/src/tools/read.ts +548 -237
package/src/tools/render-utils.ts +92 -0
package/src/tools/renderers.ts +2 -0
package/src/tools/resolve.ts +72 -44
package/src/tools/search.ts +120 -186
package/src/tools/ssh.ts +3 -2
package/src/tools/write.ts +64 -9
package/src/utils/file-mentions.ts +1 -1
package/src/utils/image-loading.ts +7 -3
package/src/utils/image-resize.ts +32 -43
package/src/vim/parser.ts +0 -17
package/src/vim/render.ts +1 -1
package/src/vim/types.ts +1 -1
package/src/web/search/providers/anthropic.ts +5 -0
package/src/web/search/providers/exa.ts +3 -0
package/src/web/search/providers/gemini.ts +40 -95
package/src/web/search/providers/jina.ts +5 -2
package/src/web/search/providers/zai.ts +5 -2
package/src/prompts/tools/exit-plan-mode.md +0 -6
package/src/tools/exit-plan-mode.ts +0 -97
package/src/utils/fuzzy.ts +0 -108
package/src/utils/image-convert.ts +0 -27

package/src/session/streaming-output.ts CHANGED Viewed

@@ -12,6 +12,7 @@ export const DEFAULT_MAX_BYTES = 50 * 1024; // 50KB
 export const DEFAULT_MAX_COLUMN = 1024; // Max chars per grep match line
 const NL = "\n";
+const ELLIPSIS = "…";
 // =============================================================================
 // Interfaces
@@ -24,6 +25,14 @@ export interface OutputSummary {
 	totalBytes: number;
 	outputLines: number;
 	outputBytes: number;
+	/** Bytes elided from the middle when head-retain mode is active. */
+	elidedBytes?: number;
+	/** Lines elided from the middle when head-retain mode is active. */
+	elidedLines?: number;
+	/** Bytes dropped by the per-line column cap (sum across all lines). */
+	columnDroppedBytes?: number;
+	/** Number of distinct lines that hit the per-line column cap. */
+	columnTruncatedLines?: number;
 	/** Artifact ID for internal URL access (artifact://<id>) when truncated */
 	artifactId?: string;
 }
@@ -31,7 +40,21 @@ export interface OutputSummary {
 export interface OutputSinkOptions {
 	artifactPath?: string;
 	artifactId?: string;
+	/** Tail buffer budget (bytes). Default DEFAULT_MAX_BYTES. */
 	spillThreshold?: number;
+	/**
+	 * When > 0, the sink keeps the first `headBytes` of output in addition to
+	 * the rolling tail window. Output between the two windows is elided
+	 * (middle elision). Default 0 = tail-only behavior.
+	 */
+	headBytes?: number;
+	/**
+	 * Per-line byte cap. When > 0, lines wider than `maxColumns` bytes are
+	 * truncated with an ellipsis at write time; remaining bytes up to the next
+	 * `\n` are dropped. Cap state persists across chunks so split-mid-line
+	 * writes still respect the budget. Default 0 = no per-line cap.
+	 */
+	maxColumns?: number;
 	onChunk?: (chunk: string) => void;
 	/** Minimum ms between onChunk calls. 0 = every chunk (default). */
 	chunkThrottleMs?: number;
@@ -40,11 +63,15 @@ export interface OutputSinkOptions {
 export interface TruncationResult {
 	content: string;
 	truncated?: boolean;
-	truncatedBy?: "lines" | "bytes";
+	truncatedBy?: "lines" | "bytes" | "middle";
 	totalLines: number;
 	totalBytes: number;
 	outputLines?: number;
 	outputBytes?: number;
+	/** Bytes elided from the middle (truncateMiddle only). */
+	elidedBytes?: number;
+	/** Lines elided from the middle (truncateMiddle only). */
+	elidedLines?: number;
 	lastLinePartial?: boolean;
 	firstLineExceedsLimit?: boolean;
 }
@@ -54,6 +81,16 @@ export interface TruncationOptions {
 	maxLines?: number;
 	/** Maximum number of bytes (default: 50KB) */
 	maxBytes?: number;
+	/**
+	 * For `truncateMiddle`: bytes reserved for the head window. The tail
+	 * window receives `maxBytes - maxHeadBytes`. Default `floor(maxBytes/2)`.
+	 */
+	maxHeadBytes?: number;
+	/**
+	 * For `truncateMiddle`: lines reserved for the head window. The tail
+	 * window receives `maxLines - maxHeadLines`. Default `floor(maxLines/2)`.
+	 */
+	maxHeadLines?: number;
 }
 /** Result from byte-level truncation helpers. */
@@ -425,6 +462,90 @@ export function truncateTail(content: string, options: TruncationOptions = {}):
 	};
 }
+// =============================================================================
+// Middle elision (keep head + tail, drop middle)
+// =============================================================================
+/**
+ * Format the inline marker substituted for the elided middle region.
+ * Returned without surrounding newlines so callers can position it freely.
+ */
+export function formatMiddleElisionMarker(elidedLines: number, elidedBytes: number): string {
+	const linesPart = `${elidedLines.toLocaleString()} line${elidedLines === 1 ? "" : "s"}`;
+	return `[… ${linesPart} elided (${formatBytes(elidedBytes)}) …]`;
+}
+/**
+ * Truncate content keeping a head window and a tail window, eliding the middle.
+ *
+ * The combined output is `<head>\n<marker>\n<tail>` when truncation is needed.
+ * `maxHeadBytes` defaults to `floor(maxBytes / 2)`; the tail receives the
+ * remainder. Falls back to `truncateTail` / `truncateHead` if either side's
+ * budget is empty or the content already fits.
+ */
+export function truncateMiddle(content: string, options: TruncationOptions = {}): TruncationResult {
+	const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+	const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+	const headBytes = options.maxHeadBytes ?? Math.floor(maxBytes / 2);
+	const tailBytes = Math.max(0, maxBytes - headBytes);
+	const headLines = options.maxHeadLines ?? Math.max(1, Math.floor(maxLines / 2));
+	const tailLines = Math.max(0, maxLines - headLines);
+	const totalBytes = Buffer.byteLength(content, "utf-8");
+	const totalLines = countNewlines(content) + 1;
+	if (totalBytes <= maxBytes && totalLines <= maxLines) {
+		return noTruncResult(content, totalLines, totalBytes);
+	}
+	// Degenerate budgets → fall back to one-sided truncation.
+	if (headBytes <= 0 || headLines <= 0) {
+		return truncateTail(content, { maxBytes: tailBytes || maxBytes, maxLines: tailLines || maxLines });
+	}
+	if (tailBytes <= 0 || tailLines <= 0) {
+		return truncateHead(content, { maxBytes: headBytes, maxLines: headLines });
+	}
+	const head = truncateHead(content, { maxBytes: headBytes, maxLines: headLines });
+	const tail = truncateTail(content, { maxBytes: tailBytes, maxLines: tailLines });
+	const headLinesKept = head.outputLines ?? 0;
+	const tailLinesKept = tail.outputLines ?? 0;
+	const headBytesKept = head.outputBytes ?? Buffer.byteLength(head.content, "utf-8");
+	const tailBytesKept = tail.outputBytes ?? Buffer.byteLength(tail.content, "utf-8");
+	// Head unusable (first line exceeds budget) → tail-only.
+	if (headLinesKept === 0 || head.firstLineExceedsLimit) return tail;
+	// Tail unusable → head-only.
+	if (tailLinesKept === 0) return head;
+	// Windows overlap → no meaningful elision; return content untruncated.
+	if (headLinesKept + tailLinesKept >= totalLines) {
+		return noTruncResult(content, totalLines, totalBytes);
+	}
+	const elidedLines = totalLines - headLinesKept - tailLinesKept;
+	// `totalBytes - headBytesKept - tailBytesKept` includes newline separators
+	// between the kept windows and the elided region; close enough for a notice.
+	const elidedBytes = Math.max(0, totalBytes - headBytesKept - tailBytesKept);
+	const marker = formatMiddleElisionMarker(elidedLines, elidedBytes);
+	const composed = `${head.content}\n${marker}\n${tail.content}`;
+	const markerBytes = Buffer.byteLength(marker, "utf-8");
+	return {
+		content: composed,
+		truncated: true,
+		truncatedBy: "middle",
+		totalLines,
+		totalBytes,
+		outputLines: headLinesKept + tailLinesKept + 1,
+		outputBytes: headBytesKept + tailBytesKept + markerBytes + 2,
+		elidedLines,
+		elidedBytes,
+		lastLinePartial: tail.lastLinePartial,
+		firstLineExceedsLimit: false,
+	};
+}
 // =============================================================================
 // TailBuffer — ring-style tail buffer with lazy joining
 // =============================================================================
@@ -520,12 +641,21 @@ export class TailBuffer {
 export class OutputSink {
 	#buffer = "";
 	#bufferBytes = 0;
+	#head = "";
+	#headBytes = 0;
+	#headLines = 0; // newline count inside #head
 	#totalLines = 0; // newline count
 	#totalBytes = 0;
 	#sawData = false;
 	#truncated = false;
 	#lastChunkTime = 0;
+	// Per-line column cap streaming state (persists across `push` calls so a
+	// long line split across chunks still trips the same trigger).
+	#currentLineBytes = 0;
+	#columnEllipsisAdded = false;
+	#columnDroppedBytes = 0;
+	#columnTruncatedLines = 0;
 	#file?: {
 		path: string;
 		artifactId?: string;
@@ -539,20 +669,26 @@ export class OutputSink {
 	readonly #artifactPath?: string;
 	readonly #artifactId?: string;
 	readonly #spillThreshold: number;
+	readonly #headLimit: number;
 	readonly #onChunk?: (chunk: string) => void;
 	readonly #chunkThrottleMs: number;
+	readonly #maxColumns: number;
 	constructor(options?: OutputSinkOptions) {
 		const {
 			artifactPath,
 			artifactId,
 			spillThreshold = DEFAULT_MAX_BYTES,
+			headBytes = 0,
+			maxColumns = 0,
 			onChunk,
 			chunkThrottleMs = 0,
 		} = options ?? {};
 		this.#artifactPath = artifactPath;
 		this.#artifactId = artifactId;
 		this.#spillThreshold = spillThreshold;
+		this.#headLimit = Math.max(0, headBytes);
+		this.#maxColumns = Math.max(0, maxColumns);
 		this.#onChunk = onChunk;
 		this.#chunkThrottleMs = chunkThrottleMs;
 	}
@@ -565,6 +701,8 @@ export class OutputSink {
 		chunk = sanitizeWithOptionalSixelPassthrough(chunk, sanitizeText);
 		// Throttled onChunk: only call the callback when enough time has passed.
+		// Live preview gets the raw (pre-cap) chunk so the TUI never lags behind
+		// what reached the sink — the column cap is for the persisted LLM view.
 		if (this.#onChunk) {
 			const now = Date.now();
 			if (now - this.#lastChunkTime >= this.#chunkThrottleMs) {
@@ -573,22 +711,124 @@ export class OutputSink {
 			}
 		}
-		const dataBytes = Buffer.byteLength(chunk, "utf-8");
-		this.#totalBytes += dataBytes;
+		const rawBytes = Buffer.byteLength(chunk, "utf-8");
+		this.#totalBytes += rawBytes;
 		if (chunk.length > 0) {
 			this.#sawData = true;
 			this.#totalLines += countNewlines(chunk);
 		}
-		const threshold = this.#spillThreshold;
-		const willOverflow = this.#bufferBytes + dataBytes > threshold;
-		// Write to artifact file if configured and past the threshold
-		if (this.#artifactPath && (this.#file != null || willOverflow)) {
+		// Per-line column cap. State persists across chunks so a mid-line split
+		// still respects the budget. Operates on the sanitized chunk; the cap is
+		// applied before head/tail accounting but after artifact mirroring decides.
+		const capped = this.#maxColumns > 0 ? this.#applyColumnCap(chunk) : chunk;
+		const cappedBytes = capped === chunk ? rawBytes : Buffer.byteLength(capped, "utf-8");
+		const cappedThisChunk = cappedBytes < rawBytes;
+		if (cappedThisChunk) this.#truncated = true;
+		// Mirror RAW chunk to the artifact file so the on-disk record is the full
+		// uncapped stream. Mirror triggers on: in-memory overflow OR this chunk's
+		// column cap dropped bytes (otherwise we'd lose data) OR file already open.
+		if (this.#artifactPath && (this.#file != null || cappedThisChunk || this.#willOverflow(cappedBytes))) {
 			this.#writeToFile(chunk);
 		}
+		if (cappedBytes === 0) return;
+		// Head retention: drain the (capped) chunk into #head until the budget is
+		// exhausted, then forward any leftover to the tail buffer.
+		let tailChunk = capped;
+		let tailBytes = cappedBytes;
+		if (this.#headLimit > 0 && this.#headBytes < this.#headLimit) {
+			const room = this.#headLimit - this.#headBytes;
+			if (cappedBytes <= room) {
+				this.#head += capped;
+				this.#headBytes += cappedBytes;
+				this.#headLines += countNewlines(capped);
+				return;
+			}
+			// Split: head takes a UTF-8-safe prefix; remainder flows to tail.
+			const headSlice = truncateHeadBytes(capped, room);
+			if (headSlice.bytes > 0) {
+				this.#head += headSlice.text;
+				this.#headBytes += headSlice.bytes;
+				this.#headLines += countNewlines(headSlice.text);
+				tailChunk = capped.substring(headSlice.text.length);
+				tailBytes = cappedBytes - headSlice.bytes;
+			}
+		}
+		this.#pushTail(tailChunk, tailBytes);
+	}
+	/**
+	 * Apply the per-line byte cap to `chunk`, dropping bytes that would push the
+	 * current line beyond `#maxColumns`. Emits a single `…` once a line trips the
+	 * cap; subsequent bytes are skipped until the next `\n`. State persists
+	 * across calls so a long line split across chunks still produces one marker.
+	 */
+	#applyColumnCap(chunk: string): string {
+		if (chunk.length === 0) return chunk;
+		const max = this.#maxColumns;
+		const parts: string[] = [];
+		let cursor = 0;
+		while (cursor < chunk.length) {
+			const nlIdx = chunk.indexOf(NL, cursor);
+			const segEnd = nlIdx === -1 ? chunk.length : nlIdx;
+			if (segEnd > cursor) {
+				const segment = chunk.substring(cursor, segEnd);
+				if (this.#columnEllipsisAdded) {
+					// Past the cap; drop until newline.
+					this.#columnDroppedBytes += Buffer.byteLength(segment, "utf-8");
+				} else {
+					const segBytes = Buffer.byteLength(segment, "utf-8");
+					const remaining = max - this.#currentLineBytes;
+					if (segBytes <= remaining) {
+						parts.push(segment);
+						this.#currentLineBytes += segBytes;
+					} else {
+						// First overflow on this line: keep what fits, append ellipsis,
+						// arm the skip-until-newline flag.
+						const ellipsisBytes = 3; // "…" in UTF-8
+						const headRoom = Math.max(0, remaining - ellipsisBytes);
+						let kept = "";
+						let keptBytes = 0;
+						if (headRoom > 0) {
+							const sliced = truncateHeadBytes(segment, headRoom);
+							kept = sliced.text;
+							keptBytes = sliced.bytes;
+							parts.push(kept);
+						}
+						parts.push(ELLIPSIS);
+						this.#columnDroppedBytes += segBytes - keptBytes;
+						this.#columnTruncatedLines++;
+						this.#currentLineBytes += keptBytes + ellipsisBytes;
+						this.#columnEllipsisAdded = true;
+					}
+				}
+			}
+			if (nlIdx === -1) break;
+			parts.push(NL);
+			this.#currentLineBytes = 0;
+			this.#columnEllipsisAdded = false;
+			cursor = nlIdx + 1;
+		}
+		return parts.join("");
+	}
+	#willOverflow(dataBytes: number): boolean {
+		// Triggers file mirroring as soon as the next chunk would push us over
+		// the tail budget (head retention does not change spill-to-artifact).
+		return this.#bufferBytes + dataBytes > this.#spillThreshold;
+	}
+	#pushTail(chunk: string, dataBytes: number): void {
+		if (dataBytes === 0) return;
+		const threshold = this.#spillThreshold;
+		const willOverflow = this.#bufferBytes + dataBytes > threshold;
 		if (!willOverflow) {
 			this.#buffer += chunk;
 			this.#bufferBytes += dataBytes;
@@ -612,8 +852,6 @@ export class OutputSink {
 			this.#buffer = text;
 			this.#bufferBytes = bytes;
 		}
-		if (this.#file) this.#truncated = true;
 	}
 	/**
@@ -685,26 +923,84 @@ export class OutputSink {
 	 * streaming counters (totalLines/totalBytes reflect the raw chunks that
 	 * already reached the sink). Used when an upstream minimizer rewrites the
 	 * captured output after the raw bytes have already been streamed.
+	 *
+	 * Clears any retained head window — the minimized text is authoritative.
 	 */
 	replace(text: string): void {
 		this.#buffer = text;
 		this.#bufferBytes = Buffer.byteLength(text, "utf-8");
+		this.#head = "";
+		this.#headBytes = 0;
+		this.#headLines = 0;
+		this.#currentLineBytes = 0;
+		this.#columnEllipsisAdded = false;
+		this.#columnDroppedBytes = 0;
+		this.#columnTruncatedLines = 0;
 	}
 	async dump(notice?: string): Promise<OutputSummary> {
 		const noticeLine = notice ? `[${notice}]\n` : "";
-		const outputLines = this.#buffer.length > 0 ? countNewlines(this.#buffer) + 1 : 0;
 		const totalLines = this.#sawData ? this.#totalLines + 1 : 0;
 		if (this.#file) await this.#file.sink.end();
+		// Compose the visible output. With head retention, splice head + marker
+		// + tail when content was elided. Otherwise return the rolling buffer.
+		const headBytes = this.#headBytes;
+		const tailBuf = this.#buffer;
+		const tailBytes = this.#bufferBytes;
+		const headLines = this.#headLines + (headBytes > 0 && !this.#head.endsWith("\n") ? 1 : 0);
+		const tailLines = tailBuf.length > 0 ? countNewlines(tailBuf) + 1 : 0;
+		// Bytes that survived the column cap. Middle elision operates on these,
+		// so column-dropped bytes don't inflate the "elided from middle" count.
+		const effectiveTotalBytes = Math.max(0, this.#totalBytes - this.#columnDroppedBytes);
+		let body: string;
+		let outputBytes: number;
+		let outputLines: number;
+		let elidedBytes: number | undefined;
+		let elidedLines: number | undefined;
+		if (headBytes > 0 && effectiveTotalBytes > headBytes + tailBytes) {
+			// Middle was elided. Emit head + marker + tail.
+			elidedBytes = Math.max(0, effectiveTotalBytes - headBytes - tailBytes);
+			elidedLines = Math.max(0, totalLines - headLines - tailLines);
+			const marker = formatMiddleElisionMarker(elidedLines, elidedBytes);
+			const markerBytes = Buffer.byteLength(marker, "utf-8");
+			const headSep = this.#head.endsWith("\n") ? "" : "\n";
+			const tailSep = tailBuf.startsWith("\n") ? "" : "\n";
+			body = `${this.#head}${headSep}${marker}${tailSep}${tailBuf}`;
+			outputBytes =
+				headBytes +
+				markerBytes +
+				tailBytes +
+				Buffer.byteLength(headSep, "utf-8") +
+				Buffer.byteLength(tailSep, "utf-8");
+			outputLines = headLines + 1 + tailLines;
+			this.#truncated = true;
+		} else if (headBytes > 0) {
+			// Head + tail combine into the full buffered output (no overlap or elision).
+			body = `${this.#head}${tailBuf}`;
+			outputBytes = headBytes + tailBytes;
+			outputLines = body.length > 0 ? countNewlines(body) + 1 : 0;
+		} else {
+			body = tailBuf;
+			outputBytes = tailBytes;
+			outputLines = tailLines;
+		}
 		return {
-			output: `${noticeLine}${this.#buffer}`,
+			output: `${noticeLine}${body}`,
 			truncated: this.#truncated,
 			totalLines,
 			totalBytes: this.#totalBytes,
 			outputLines,
-			outputBytes: this.#bufferBytes,
+			outputBytes,
+			elidedBytes,
+			elidedLines,
+			columnDroppedBytes: this.#columnDroppedBytes > 0 ? this.#columnDroppedBytes : undefined,
+			columnTruncatedLines: this.#columnTruncatedLines > 0 ? this.#columnTruncatedLines : undefined,
 			artifactId: this.#file?.artifactId,
 		};
 	}

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

@@ -76,6 +76,24 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "goal",
+		description: "Toggle goal mode (persistent autonomous objective for this session)",
+		subcommands: [
+			{ name: "set", description: "Set or replace the goal", usage: "<objective>" },
+			{ name: "show", description: "Show current goal details" },
+			{ name: "pause", description: "Pause the current goal" },
+			{ name: "resume", description: "Resume a paused goal" },
+			{ name: "drop", description: "Drop the current goal" },
+			{ name: "budget", description: "Adjust the token budget", usage: "<N|off>" },
+		],
+		inlineHint: "[objective]",
+		allowArgs: true,
+		handleTui: async (command, runtime) => {
+			await runtime.ctx.handleGoalModeCommand(command.args || undefined);
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "loop",
 		description:

package/src/ssh/ssh-executor.ts CHANGED Viewed

@@ -1,5 +1,7 @@
 import { logger, ptree } from "@oh-my-pi/pi-utils";
+import { Settings } from "../config/settings";
 import { OutputSink } from "../session/streaming-output";
+import { resolveOutputMaxColumns, resolveOutputSinkHeadBytes } from "../tools/output-meta";
 import { buildRemoteCommand, ensureConnection, ensureHostInfo, type SSHConnectionTarget } from "./connection-manager";
 import { hasSshfs, mountRemote } from "./sshfs-mount";
@@ -83,10 +85,13 @@ export async function executeSSH(
 		stderr: "full",
 	});
+	const settings = await Settings.init();
 	const sink = new OutputSink({
 		onChunk: options?.onChunk,
 		artifactPath: options?.artifactPath,
 		artifactId: options?.artifactId,
+		headBytes: resolveOutputSinkHeadBytes(settings),
+		maxColumns: resolveOutputMaxColumns(settings),
 	});
 	const streams = [child.stdout.pipeTo(sink.createInput())];

package/src/system-prompt.ts CHANGED Viewed

@@ -530,9 +530,11 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		description: tools?.get(name)?.description ?? "",
 	}));
-	// Filter skills to only include those with read tool.
+	// Filter skills for the rendered system prompt:
+	// - require the `read` tool so the model can actually fetch skill content;
+	// - drop skills with frontmatter `hide: true` (still loadable via skill:// and /skill:<name>).
 	const hasRead = tools?.has("read");
-	const filteredSkills = hasRead ? skills : [];
+	const filteredSkills = hasRead ? skills.filter(skill => skill.hide !== true) : [];
 	const effectiveSystemPromptCustomization = dedupePromptSource(systemPromptCustomization, [
 		resolvedCustomPrompt,

package/src/task/discovery.ts CHANGED Viewed

@@ -15,6 +15,7 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import { logger } from "@oh-my-pi/pi-utils";
+import { isProviderEnabled } from "../capability";
 import { findAllNearestProjectConfigDirs, getConfigDirs } from "../config";
 import { listClaudePluginRoots } from "../discovery/helpers";
 import { loadBundledAgents, parseAgent } from "./agents";
@@ -87,8 +88,10 @@ export async function discoverAgents(cwd: string, home: string = os.homedir()):
 		if (user) orderedDirs.push({ dir: user.path, source: "user" });
 	}
-	// Load agents from Claude Code marketplace plugins
-	const { roots: pluginRoots } = await listClaudePluginRoots(home, resolvedCwd);
+	// Load agents from Claude Code marketplace plugins (respects disabledProviders)
+	const { roots: pluginRoots } = isProviderEnabled("claude-plugins")
+		? await listClaudePluginRoots(home, resolvedCwd)
+		: { roots: [] };
 	const sortedPluginRoots = [...pluginRoots].sort((a, b) => {
 		if (a.scope === b.scope) return 0;
 		return a.scope === "project" ? -1 : 1;

package/src/task/executor.ts CHANGED Viewed

@@ -16,6 +16,7 @@ import { Settings } from "../config/settings";
 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 type { HindsightSessionState } from "../hindsight/state";
 import type { LocalProtocolOptions } from "../internal-urls";
@@ -379,21 +380,29 @@ function firstNumberField(record: Record<string, unknown>, keys: string[]): numb
 }
 /**
- * Normalize usage objects from different event formats.
+ * Tokens for progress display: input + output + cacheWrite per turn.
+ *
+ * Deliberately excludes cacheRead. With prompt caching, cacheRead in each turn
+ * equals the full cached context (potentially hundreds of KB), so summing it
+ * across all turns produces a cumulative total that is N×context_size — far
+ * larger than the context window and misleading as a "work done" metric.
+ * cacheWrite is kept because each byte is written once, not repeated per turn.
+ * The cost segment handles billing; dedicated cache_read/cache_write segments
+ * handle cache-specific monitoring.
  */
 function getUsageTokens(usage: unknown): number {
 	if (!usage || typeof usage !== "object") return 0;
 	const record = usage as Record<string, unknown>;
-	const totalTokens = firstNumberField(record, ["totalTokens", "total_tokens"]);
-	if (totalTokens !== undefined && totalTokens > 0) return totalTokens;
 	const input = firstNumberField(record, ["input", "input_tokens", "inputTokens"]) ?? 0;
 	const output = firstNumberField(record, ["output", "output_tokens", "outputTokens"]) ?? 0;
-	const cacheRead = firstNumberField(record, ["cacheRead", "cache_read", "cacheReadTokens"]) ?? 0;
 	const cacheWrite = firstNumberField(record, ["cacheWrite", "cache_write", "cacheWriteTokens"]) ?? 0;
-	return input + output + cacheRead + cacheWrite;
+	const computed = input + output + cacheWrite;
+	if (computed > 0) return computed;
+	// Fallback for providers that only surface a pre-summed total without individual
+	// field breakdown. This total includes cacheRead, but returning it is still better
+	// than silently showing 0 for those providers.
+	return firstNumberField(record, ["totalTokens", "total_tokens"]) ?? 0;
 }
 /**
@@ -497,6 +506,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		recentOutput: [],
 		toolCount: 0,
 		tokens: 0,
+		cost: 0,
 		durationMs: 0,
 		modelOverride,
 	};
@@ -892,6 +902,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 							accumulatedUsage.cost.cacheRead += getNumberField(costRecord, "cacheRead") ?? 0;
 							accumulatedUsage.cost.cacheWrite += getNumberField(costRecord, "cacheWrite") ?? 0;
 							accumulatedUsage.cost.total += getNumberField(costRecord, "total") ?? 0;
+							progress.cost = accumulatedUsage.cost.total;
 						}
 					}
 					// Accumulate tokens for progress display
@@ -1109,7 +1120,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 						getAllTools: () => session.getAllToolNames(),
 						setActiveTools: (toolNames: string[]) =>
 							session.setActiveToolsByName(toolNames.filter(name => !parentOwnedToolNames.has(name))),
-						getCommands: () => [],
+						getCommands: () => getSessionSlashCommands(session),
 						setModel: model => runExtensionSetModel(session, model),
 						getThinkingLevel: () => session.thinkingLevel,
 						setThinkingLevel: level => session.setThinkingLevel(level),

package/src/task/index.ts CHANGED Viewed

@@ -306,6 +306,7 @@ export class TaskTool implements AgentTool<TSchema, TaskToolDetails, Theme> {
 				recentOutput: [],
 				toolCount: 0,
 				tokens: 0,
+				cost: 0,
 				durationMs: 0,
 			});
 		}
@@ -390,6 +391,7 @@ export class TaskTool implements AgentTool<TSchema, TaskToolDetails, Theme> {
 										: "failed";
 								progress.durationMs = singleResult?.durationMs ?? Math.max(0, Date.now() - startedAt);
 								progress.tokens = singleResult?.tokens ?? 0;
+								progress.cost = singleResult?.usage?.cost.total ?? 0;
 								progress.extractedToolData = singleResult?.extractedToolData;
 							}
 							completedJobs += 1;
@@ -831,6 +833,7 @@ export class TaskTool implements AgentTool<TSchema, TaskToolDetails, Theme> {
 					recentOutput: [],
 					toolCount: 0,
 					tokens: 0,
+					cost: 0,
 					durationMs: 0,
 					modelOverride,
 					description: taskItem.description,